style changes

Signed-off-by: Wojciech Jabłoński <wj359634@students.mimuw.edu.pl>

Author: Wojciech Jabłoński

uast/diff/apply.go

@@ -2,9 +2,12 @@ package diff
 
 import (
 	"fmt"
+
 	"gopkg.in/bblfsh/sdk.v2/uast/nodes"
 )
 
+// Apply is a method that takes a tree (nodes.Node) and applies the current changelist to that
+// tree.
 func (changelist Changelist) Apply(root nodes.Node) nodes.Node {
 	nodeDict := make(map[ID]nodes.Node)
 	nodes.WalkPreOrder(root, func(node nodes.Node) bool {

uast/diff/changelist.go

@@ -4,8 +4,11 @@ import (
 	"gopkg.in/bblfsh/sdk.v2/uast/nodes"
 )
 
+// Changelist is a list of changes, a result of tree difference. Applying all changes from a
+// changelist on a source tree will result in it being transformed into the destination tree.
 type Changelist []Change
 
+// Change is a single operation performed
 type Change interface {
 	isChange()
 	TransactionID() uint64
@@ -18,12 +21,16 @@ type changeBase struct {
 func (changeBase) isChange()                {}
 func (ch changeBase) TransactionID() uint64 { return ch.txID }
 
+// ID is a type representing node unique ID that can be compared in O(1)
 type ID nodes.Comparable
 
-// key in a node, string for nodes.Object and int for nodes.Array
+// Key in a node, string for nodes.Object and int for nodes.Array
 type Key interface{ isKey() }
 
+// String is a wrapped string type for the Key interface.
 type String string
+
+// Int is a wrapped int type for the Key interface.
 type Int int
 
 func (Int) isKey()    {}
@@ -37,24 +44,24 @@ type Create struct {
 	Node nodes.Node
 }
 
-// delete a node by ID
+// Delete a node by ID
 type Delete struct {
 	changeBase
 	NodeID ID
 }
 
-// attach a node as a child of another node with a given key
+// Attach a node as a child of another node with a given key
 type Attach struct {
 	changeBase
 	Parent ID
 	Key    Key
 	Child  ID
 }
 
-// deatach a child from a node
+// Deatach a child from a node
 type Deatach struct {
 	changeBase
 	Parent ID
-	Key    Key 	// Currently deatach semantics are only defined for nodes.Object so the Key is
-				// practically always a string
+	Key    Key // Currently deatach semantics are only defined for nodes.Object so the Key is
+	// practically always a string
 }

uast/diff/changelist_test.go

@@ -1,48 +1,48 @@
 package diff
 
 import (
-    "strings"
-    "os"
-    "path/filepath"
-    "io/ioutil"
-    "testing"
-    "gopkg.in/bblfsh/sdk.v2/uast/yaml"
-    "gopkg.in/bblfsh/sdk.v2/uast/nodes"
-    "github.com/stretchr/testify/require"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"gopkg.in/bblfsh/sdk.v2/uast/nodes"
+	uastyml "gopkg.in/bblfsh/sdk.v2/uast/yaml"
 )
 
-
 const dataDir = "./testdata"
 
 func readUAST(t testing.TB, path string) nodes.Node {
-    data, err := ioutil.ReadFile(path)
-    require.NoError(t, err)
-    nd, err := uastyml.Unmarshal(data)
-    require.NoError(t, err)
-    return nd
+	data, err := ioutil.ReadFile(path)
+	require.NoError(t, err)
+	nd, err := uastyml.Unmarshal(data)
+	require.NoError(t, err)
+	return nd
 }
 
 func TestChangelist(t *testing.T) {
-    dir, err := os.Open(dataDir)
-    require.NoError(t, err)
-    defer dir.Close()
-    names, err := dir.Readdirnames(-1)
-    require.NoError(t, err)
-
-    for _, fname := range names {
-        if strings.HasSuffix(fname, "_src.uast") {
-            name := fname[:len(fname)-len("_src.uast")]
-
-            t.Run(name, func(t *testing.T) {
-                src_name := filepath.Join(dataDir, name + "_src.uast")
-                dst_name := filepath.Join(dataDir, name + "_dst.uast")
-                src := readUAST(t, src_name)
-                dst := readUAST(t, dst_name)
-
-                changes := Changes(src, dst)
-                newsrc := changes.Apply(src)
-                require.True(t, nodes.Equal(newsrc, dst))
-            })
-        }
-    }
+	dir, err := os.Open(dataDir)
+	require.NoError(t, err)
+	defer dir.Close()
+	names, err := dir.Readdirnames(-1)
+	require.NoError(t, err)
+
+	for _, fname := range names {
+		if strings.HasSuffix(fname, "_src.uast") {
+			name := fname[:len(fname)-len("_src.uast")]
+
+			t.Run(name, func(t *testing.T) {
+				srcName := filepath.Join(dataDir, name+"_src.uast")
+				dstName := filepath.Join(dataDir, name+"_dst.uast")
+				src := readUAST(t, srcName)
+				dst := readUAST(t, dstName)
+
+				changes := Changes(src, dst)
+				newsrc := changes.Apply(src)
+				require.True(t, nodes.Equal(newsrc, dst))
+			})
+		}
+	}
 }

uast/diff/diff.go

@@ -2,6 +2,7 @@ package diff
 
 import (
 	"fmt"
+
 	"github.com/heetch/lapjv"
 	"gopkg.in/bblfsh/sdk.v2/uast/nodes"
 )
@@ -19,18 +20,17 @@ type permuteDecision struct {
 	permutation []int
 }
 
-func (d sameDecision) 		cost() int { return d.privateCost }
-func (d replaceDecision) 	cost() int { return d.privateCost }
-func (d matchDecision) 		cost() int { return d.privateCost }
-func (d permuteDecision) 	cost() int { return d.privateCost }
+func (d sameDecision) cost() int    { return d.privateCost }
+func (d replaceDecision) cost() int { return d.privateCost }
+func (d matchDecision) cost() int   { return d.privateCost }
+func (d permuteDecision) cost() int { return d.privateCost }
 
 // min is a convinience method for choosing the cheapest decision
 func min(self, candidate decisionType) decisionType {
 	if self.cost() > candidate.cost() {
 		return candidate
-	} else {
-		return self
 	}
+	return self
 }
 
 // type for cache
@@ -39,14 +39,14 @@ type keyType struct{ k1, k2 ID }
 // cache for diff computation
 type cacheStorage struct {
 	decisions map[keyType]decisionType
-	counts     map[ID]int
+	counts    map[ID]int
 	changes   Changelist
 }
 
 func makeCacheStorage() *cacheStorage {
 	return &cacheStorage{
 		decisions: make(map[keyType]decisionType),
-		counts: make(map[ID]int),
+		counts:    make(map[ID]int),
 	}
 }
 
@@ -221,12 +221,12 @@ func (ds *cacheStorage) generateDifference(src, dst nodes.Node, parentID ID, par
 				keys[key] = true
 				if _, ok := dst[key]; !ok {
 					ds.push(Deatach{Parent: nodes.UniqueKey(src), Key: String(key)})
-				} else  if _, ok := src[key]; !ok {
+				} else if _, ok := src[key]; !ok {
 					ds.createRec(dst[key])
 					ds.push(Attach{
 						Parent: nodes.UniqueKey(src),
-						Key: String(key),
-						Child: nodes.UniqueKey(dst[key]),
+						Key:    String(key),
+						Child:  nodes.UniqueKey(dst[key]),
 					})
 				} else {
 					ds.generateDifference(
@@ -273,11 +273,15 @@ func (ds *cacheStorage) generateDifference(src, dst nodes.Node, parentID ID, par
 	}
 }
 
+// Cost is a function that takes two trees: src and dst and returns number of operations needed to
+// convert the former into the latter.
 func Cost(src, dst nodes.Node) int {
 	ds := makeCacheStorage()
 	return ds.decideAction(src, dst).cost()
 }
 
+// Changes is a function that takes two trees: src and dst and returns a changelist containing
+// all operations required to convert the former into the latter.
 func Changes(src, dst nodes.Node) Changelist {
 	ds := makeCacheStorage()
 	ds.generateDifference(src, dst, nil, Int(0))