add support for analyzing imports, dependency graph

Author: nedpals

depgraph.go

@@ -0,0 +1,111 @@
+package errgoengine
+
+import "fmt"
+
+type DepGraph map[string]*DepNode
+
+type DepNode struct {
+	Graph        DepGraph
+	Path         string            // path where the module/library/package is located
+	Dependencies map[string]string // mapped as map[label]depPath
+}
+
+func (node *DepNode) GetDependencies() []*DepNode {
+	deps := make([]*DepNode, len(node.Dependencies))
+
+	i := 0
+	for _, path := range node.Dependencies {
+		deps[i] = node.Graph[path]
+		i++
+	}
+
+	return deps
+}
+
+func (node *DepNode) Dependents() []*DepNode {
+	deps := []*DepNode{}
+
+	for _, cnode := range node.Graph {
+		if cnode.HasDependency(node.Path) {
+			deps = append(deps, cnode)
+		}
+	}
+
+	return deps
+}
+
+func (node *DepNode) DependentPaths() []string {
+	deps := node.Dependents()
+	depPaths := make([]string, len(deps))
+	for i, dep := range deps {
+		depPaths[i] = dep.Path
+	}
+	return depPaths
+}
+
+func (node *DepNode) HasDependency(path string) bool {
+	for _, depPath := range node.Dependencies {
+		if depPath == path {
+			return true
+		}
+	}
+	return false
+}
+
+func (node *DepNode) Detach(path string) error {
+	if !node.HasDependency(path) {
+		return fmt.Errorf(
+			"dependency '%s' not found in %s's dependencies",
+			path,
+			node.Path,
+		)
+	}
+
+	for k, v := range node.Dependencies {
+		if v == path {
+			delete(node.Dependencies, k)
+			node.Graph.Delete(path)
+			break
+		}
+	}
+
+	return nil
+}
+
+func (graph DepGraph) Add(path string, deps map[string]string) {
+	if node, ok := graph[path]; ok {
+		for label, depPath := range deps {
+			if !graph.Has(depPath) {
+				graph.Add(depPath, map[string]string{})
+			}
+
+			node.Dependencies[label] = depPath
+		}
+	} else {
+		graph[path] = &DepNode{
+			Graph:        graph,
+			Path:         path,
+			Dependencies: map[string]string{},
+		}
+
+		graph.Add(path, deps)
+	}
+}
+
+func (graph DepGraph) Has(path string) bool {
+	_, hasDep := graph[path]
+	return hasDep
+}
+
+func (graph DepGraph) Delete(path string) {
+	if node, ok := graph[path]; !ok {
+		return
+	} else if len(node.Dependents()) > 0 {
+		return
+	}
+	delete(graph, path)
+}
+
+func (graph DepGraph) Detach(path string, dep string) error {
+	return graph[path].Detach(dep)
+}

depgraph_test.go

@@ -0,0 +1,38 @@
+package errgoengine
+
+import (
+	"testing"
+
+	testutils "github.com/nedpals/errgoengine/test_utils"
+)
+
+func TestDepGraph(t *testing.T) {
+	graph := DepGraph{}
+
+	// Adding
+	graph.Add("a", map[string]string{"b": "c"})
+	graph.Add("d", map[string]string{"e": "c"})
+
+	testutils.Equals(t, graph.Has("a"), true)
+	testutils.Equals(t, graph.Has("c"), true)
+
+	testutils.Equals(t, graph["a"].Path, "a")
+	testutils.EqualsMap(t, graph["a"].Graph, graph)
+	testutils.EqualsMap(t, graph["a"].Dependencies, map[string]string{"b": "c"})
+
+	testutils.Equals(t, graph["d"].Path, "d")
+	testutils.EqualsMap(t, graph["d"].Graph, graph)
+	testutils.EqualsMap(t, graph["d"].Dependencies, map[string]string{"e": "c"})
+
+	testutils.EqualsList(t, graph["c"].DependentPaths(), []string{"a", "d"})
+
+	// Deleting
+	testutils.ExpectNoError(t, graph.Detach("d", "c"))
+	testutils.Equals(t, graph.Has("d"), true)
+	testutils.Equals(t, graph.Has("c"), true)
+	testutils.EqualsList(t, graph["c"].DependentPaths(), []string{"a"})
+
+	testutils.ExpectNoError(t, graph.Detach("a", "c"))
+	testutils.Equals(t, graph.Has("a"), true)
+	testutils.Equals(t, graph.Has("c"), false)
+}

errgoengine.go

@@ -19,6 +19,7 @@ type ErrgoEngine struct {
 func New() *ErrgoEngine {
 	return &ErrgoEngine{
 		SharedStore: &Store{
+			DepGraph:  DepGraph{},
 			Documents: map[string]*Document{},
 			Symbols:   map[string]*SymbolTree{},
 		},

imports.go

@@ -0,0 +1,12 @@
+package errgoengine
+
+type ImportParams struct {
+	Node       Node
+	CurrentDir string
+}
+
+type ResolvedImport struct {
+	Path    string
+	Name    string
+	Symbols []string
+}

language.go

@@ -19,6 +19,7 @@ type Language struct {
 	SymbolsToCapture  ISymbolCaptureList
 	LocationConverter func(path, pos string) Location
 	ValueAnalyzer     func(NodeValueAnalyzer, Node) Symbol
+	ImportResolver    func(NodeValueAnalyzer, ImportParams) ResolvedImport
 }
 
 func (lang *Language) MatchPath(path string) bool {
@@ -43,6 +44,10 @@ func (lang *Language) Compile() {
 		lang.stackTraceRegex = regexp.MustCompile("(?m)" + lang.StackTracePattern)
 	}
 
+	if lang.ImportResolver == nil {
+		panic(fmt.Sprintf("[Language -> %s] ImportResolver must not be nil", lang.Name))
+	}
+
 	lang.isCompiled = true
 }
 

store.go

@@ -3,6 +3,7 @@ package errgoengine
 import sitter "github.com/smacker/go-tree-sitter"
 
 type Store struct {
+	DepGraph  DepGraph
 	Documents map[string]*Document
 	Symbols   map[string]*SymbolTree
 }

symbol_analyzer.go

@@ -80,7 +80,35 @@ func (an *SymbolAnalyzer) captureAndAnalyze(parent *SymbolTree, rootNode *sitter
 		// - content
 		// - position
 		// - item name (sym.children.0.name for example)
-		if body, ok := captured["body"]; ok {
+		if identifiedKind == SymbolKindImport {
+			name, ok := captured["name"]
+			if !ok {
+				// TODO: error
+				continue
+			}
+
+			resolvedImport := an.doc.Language.ImportResolver(an.contextData, ImportParams{
+				Node:       name,
+				CurrentDir: an.contextData.WorkingPath,
+			})
+
+			if len(resolvedImport.Path) == 0 {
+				// TODO: error
+				continue
+			}
+
+			an.contextData.DepGraph.Add(
+				an.contextData.CurrentDocumentPath,
+				map[string]string{
+					resolvedImport.Name: resolvedImport.Path,
+				})
+
+			parent.Add(&ImportSymbol{
+				Alias:           resolvedImport.Name,
+				Node:            an.contextData.DepGraph[resolvedImport.Path],
+				ImportedSymbols: resolvedImport.Symbols,
+			})
+		} else if body, ok := captured["body"]; ok {
 			// returnSym = an.contextData.AnalyzeValue(body)
 			childTree := parent.CreateChildFromNode(body)
 

symbols.go

@@ -9,6 +9,7 @@ const (
 	SymbolKindFunction SymbolKind = iota
 	SymbolKindVariable SymbolKind = iota
 	SymbolKindArray    SymbolKind = iota
+	SymbolKindImport   SymbolKind = iota
 )
 
 type Symbol interface {
@@ -116,3 +117,34 @@ func (sym BuiltinSymbol) Location() Location {
 func Builtin(name string) Symbol {
 	return BuiltinSymbol{Name_: name}
 }
+
+type ImportSymbol struct {
+	Alias           string
+	Node            *DepNode
+	ImportedSymbols []string
+}
+
+func (sym ImportSymbol) Name() string {
+	return sym.Alias
+}
+
+func (sym ImportSymbol) Kind() SymbolKind {
+	return SymbolKindImport
+}
+
+func (sym ImportSymbol) Location() Location {
+	return Location{
+		DocumentPath: sym.Node.Path,
+		Position: Position{
+			Line:   0,
+			Column: 0,
+			Index:  0,
+		},
+	}
+}
+
+// TODO:
+// func (sym ImportSymbol) Children() *SymbolTree {
+// 	// TODO:
+// 	return nil
+// }