Merge pull request #8423 from unclejack/lint_changes

lint changes part 1

graphdb/graphdb.go

@@ -131,8 +131,8 @@ func (db *Database) Set(fullPath, id string) (*Entity, error) {
 	if _, err := db.conn.Exec("BEGIN EXCLUSIVE"); err != nil {
 		return nil, err
 	}
-	var entityId string
+	var entityID string
-	if err := db.conn.QueryRow("SELECT id FROM entity WHERE id = ?;", id).Scan(&entityId); err != nil {
+	if err := db.conn.QueryRow("SELECT id FROM entity WHERE id = ?;", id).Scan(&entityID); err != nil {
 		if err == sql.ErrNoRows {
 			if _, err := db.conn.Exec("INSERT INTO entity (id) VALUES(?);", id); err != nil {
 				rollback()
@@ -320,14 +320,14 @@ func (db *Database) RefPaths(id string) Edges {
 
 	for rows.Next() {
 		var name string
-		var parentId string
+		var parentID string
-		if err := rows.Scan(&name, &parentId); err != nil {
+		if err := rows.Scan(&name, &parentID); err != nil {
 			return refs
 		}
 		refs = append(refs, &Edge{
 			EntityID: id,
 			Name:     name,
-			ParentID: parentId,
+			ParentID: parentID,
 		})
 	}
 	return refs
@@ -443,11 +443,11 @@ func (db *Database) children(e *Entity, name string, depth int, entities []WalkM
 	defer rows.Close()
 
 	for rows.Next() {
-		var entityId, entityName string
+		var entityID, entityName string
-		if err := rows.Scan(&entityId, &entityName); err != nil {
+		if err := rows.Scan(&entityID, &entityName); err != nil {
 			return nil, err
 		}
-		child := &Entity{entityId}
+		child := &Entity{entityID}
 		edge := &Edge{
 			ParentID: e.id,
 			Name:     entityName,
@@ -490,11 +490,11 @@ func (db *Database) parents(e *Entity) (parents []string, err error) {
 	defer rows.Close()
 
 	for rows.Next() {
-		var parentId string
+		var parentID string
-		if err := rows.Scan(&parentId); err != nil {
+		if err := rows.Scan(&parentID); err != nil {
 			return nil, err
 		}
-		parents = append(parents, parentId)
+		parents = append(parents, parentID)
 	}
 
 	return parents, nil

timeutils/json.go

@@ -6,18 +6,21 @@ import (
 )
 
 const (
-	// Define our own version of RFC339Nano because we want one
+	// RFC3339NanoFixed is our own version of RFC339Nano because we want one
 	// that pads the nano seconds part with zeros to ensure
 	// the timestamps are aligned in the logs.
 	RFC3339NanoFixed = "2006-01-02T15:04:05.000000000Z07:00"
-	JSONFormat       = `"` + time.RFC3339Nano + `"`
+	// JSONFormat is the format used by FastMarshalJSON
+	JSONFormat = `"` + time.RFC3339Nano + `"`
 )
 
+// FastMarshalJSON avoids one of the extra allocations that
+// time.MarshalJSON is making.
 func FastMarshalJSON(t time.Time) (string, error) {
 	if y := t.Year(); y < 0 || y >= 10000 {
 		// RFC 3339 is clear that years are 4 digits exactly.
 		// See golang.org/issue/4556#c15 for more discussion.
-		return "", errors.New("Time.MarshalJSON: year outside of range [0,9999]")
+		return "", errors.New("time.MarshalJSON: year outside of range [0,9999]")
 	}
 	return t.Format(JSONFormat), nil
 }

truncindex/truncindex.go

@@ -10,7 +10,9 @@ import (
 )
 
 var (
-	ErrNoID = errors.New("prefix can't be empty")
+	// ErrNoID is thrown when attempting to use empty prefixes
+	ErrNoID        = errors.New("prefix can't be empty")
+	errDuplicateID = errors.New("multiple IDs were found")
 )
 
 func init() {
@@ -27,56 +29,62 @@ type TruncIndex struct {
 	ids  map[string]struct{}
 }
 
+// NewTruncIndex creates a new TruncIndex and initializes with a list of IDs
 func NewTruncIndex(ids []string) (idx *TruncIndex) {
 	idx = &TruncIndex{
 		ids:  make(map[string]struct{}),
 		trie: patricia.NewTrie(),
 	}
 	for _, id := range ids {
-		idx.addId(id)
+		idx.addID(id)
 	}
 	return
 }
 
-func (idx *TruncIndex) addId(id string) error {
+func (idx *TruncIndex) addID(id string) error {
 	if strings.Contains(id, " ") {
-		return fmt.Errorf("Illegal character: ' '")
+		return fmt.Errorf("illegal character: ' '")
 	}
 	if id == "" {
 		return ErrNoID
 	}
 	if _, exists := idx.ids[id]; exists {
-		return fmt.Errorf("Id already exists: '%s'", id)
+		return fmt.Errorf("id already exists: '%s'", id)
 	}
 	idx.ids[id] = struct{}{}
 	if inserted := idx.trie.Insert(patricia.Prefix(id), struct{}{}); !inserted {
-		return fmt.Errorf("Failed to insert id: %s", id)
+		return fmt.Errorf("failed to insert id: %s", id)
 	}
 	return nil
 }
 
+// Add adds a new ID to the TruncIndex
 func (idx *TruncIndex) Add(id string) error {
 	idx.Lock()
 	defer idx.Unlock()
-	if err := idx.addId(id); err != nil {
+	if err := idx.addID(id); err != nil {
 		return err
 	}
 	return nil
 }
 
+// Delete removes an ID from the TruncIndex. If there are multiple IDs
+// with the given prefix, an error is thrown.
 func (idx *TruncIndex) Delete(id string) error {
 	idx.Lock()
 	defer idx.Unlock()
 	if _, exists := idx.ids[id]; !exists || id == "" {
-		return fmt.Errorf("No such id: '%s'", id)
+		return fmt.Errorf("no such id: '%s'", id)
 	}
 	delete(idx.ids, id)
 	if deleted := idx.trie.Delete(patricia.Prefix(id)); !deleted {
-		return fmt.Errorf("No such id: '%s'", id)
+		return fmt.Errorf("no such id: '%s'", id)
 	}
 	return nil
 }
 
+// Get retrieves an ID from the TruncIndex. If there are multiple IDs
+// with the given prefix, an error is thrown.
 func (idx *TruncIndex) Get(s string) (string, error) {
 	idx.RLock()
 	defer idx.RUnlock()
@@ -90,17 +98,17 @@ func (idx *TruncIndex) Get(s string) (string, error) {
 		if id != "" {
 			// we haven't found the ID if there are two or more IDs
 			id = ""
-			return fmt.Errorf("we've found two entries")
+			return errDuplicateID
 		}
 		id = string(prefix)
 		return nil
 	}
 
 	if err := idx.trie.VisitSubtree(patricia.Prefix(s), subTreeVisitFunc); err != nil {
-		return "", fmt.Errorf("No such id: %s", s)
+		return "", fmt.Errorf("no such id: %s", s)
 	}
 	if id != "" {
 		return id, nil
 	}
-	return "", fmt.Errorf("No such id: %s", s)
+	return "", fmt.Errorf("no such id: %s", s)
 }

units/size.go

@@ -10,6 +10,7 @@ import (
 // See: http://en.wikipedia.org/wiki/Binary_prefix
 const (
 	// Decimal
+
 	KB = 1000
 	MB = 1000 * KB
 	GB = 1000 * MB
@@ -17,6 +18,7 @@ const (
 	PB = 1000 * TB
 
 	// Binary
+
 	KiB = 1024
 	MiB = 1024 * KiB
 	GiB = 1024 * MiB
@@ -60,7 +62,7 @@ func FromHumanSize(size string) (int64, error) {
 	return parseSize(size, decimalMap)
 }
 
-// Parses a human-readable string representing an amount of RAM
+// RAMInBytes parses a human-readable string representing an amount of RAM
 // in bytes, kibibytes, mebibytes, gibibytes, or tebibytes and
 // returns the number of bytes, or -1 if the string is unparseable.
 // Units are case-insensitive, and the 'b' suffix is optional.
@@ -72,7 +74,7 @@ func RAMInBytes(size string) (int64, error) {
 func parseSize(sizeStr string, uMap unitMap) (int64, error) {
 	matches := sizeRegex.FindStringSubmatch(sizeStr)
 	if len(matches) != 3 {
-		return -1, fmt.Errorf("Invalid size: '%s'", sizeStr)
+		return -1, fmt.Errorf("invalid size: '%s'", sizeStr)
 	}
 
 	size, err := strconv.ParseInt(matches[1], 10, 0)

version/version.go

@@ -5,53 +5,59 @@ import (
 	"strings"
 )
 
+// Version provides utility methods for comparing versions.
 type Version string
 
-func (me Version) compareTo(other Version) int {
+func (v Version) compareTo(other Version) int {
 	var (
-		meTab    = strings.Split(string(me), ".")
+		currTab  = strings.Split(string(v), ".")
 		otherTab = strings.Split(string(other), ".")
 	)
 
-	max := len(meTab)
+	max := len(currTab)
 	if len(otherTab) > max {
 		max = len(otherTab)
 	}
 	for i := 0; i < max; i++ {
-		var meInt, otherInt int
+		var currInt, otherInt int
 
-		if len(meTab) > i {
+		if len(currTab) > i {
-			meInt, _ = strconv.Atoi(meTab[i])
+			currInt, _ = strconv.Atoi(currTab[i])
 		}
 		if len(otherTab) > i {
 			otherInt, _ = strconv.Atoi(otherTab[i])
 		}
-		if meInt > otherInt {
+		if currInt > otherInt {
 			return 1
 		}
-		if otherInt > meInt {
+		if otherInt > currInt {
 			return -1
 		}
 	}
 	return 0
 }
 
-func (me Version) LessThan(other Version) bool {
+// LessThan checks if a version is less than another version
-	return me.compareTo(other) == -1
+func (v Version) LessThan(other Version) bool {
+	return v.compareTo(other) == -1
 }
 
-func (me Version) LessThanOrEqualTo(other Version) bool {
+// LessThanOrEqualTo checks if a version is less than or equal to another
-	return me.compareTo(other) <= 0
+func (v Version) LessThanOrEqualTo(other Version) bool {
+	return v.compareTo(other) <= 0
 }
 
-func (me Version) GreaterThan(other Version) bool {
+// GreaterThan checks if a version is greater than another one
-	return me.compareTo(other) == 1
+func (v Version) GreaterThan(other Version) bool {
+	return v.compareTo(other) == 1
 }
 
-func (me Version) GreaterThanOrEqualTo(other Version) bool {
+// GreaterThanOrEqualTo checks ia version is greater than or equal to another
-	return me.compareTo(other) >= 0
+func (v Version) GreaterThanOrEqualTo(other Version) bool {
+	return v.compareTo(other) >= 0
 }
 
-func (me Version) Equal(other Version) bool {
+// Equal checks if a version is equal to another
-	return me.compareTo(other) == 0
+func (v Version) Equal(other Version) bool {
+	return v.compareTo(other) == 0
 }