codeclimate feedback

Author: Matt Kulka

Diff for: cli/grep.go

@@ -99,7 +99,7 @@ func (cmd *GrepCommand) Run() int {
 		return 1
 	}
 
-	matches, err := cmd.grepPaths(cmd.args.Search, filePaths)
+	matches, err := cmd.searcher.grepPaths(cmd.client, cmd.args.Search, filePaths)
 	if err != nil {
 		return 1
 	}
@@ -117,12 +117,3 @@ func (cmd *GrepCommand) GetSearchParams() SearchParameters {
 		IsRegexp: cmd.args.Regexp,
 	}
 }
-
-func (cmd *GrepCommand) grepPaths(search string, paths []string) (matches []*Match, err error) {
-	return funcOnPaths(cmd.client, paths, func(s *client.Secret) []*Match {
-		for k, v := range s.GetData() {
-			matches = append(matches, cmd.searcher.DoSearch(s.Path, k, fmt.Sprintf("%v", v))...)
-		}
-		return matches
-	})
-}

Diff for: cli/replace.go

@@ -128,18 +128,9 @@ func (cmd *ReplaceCommand) Run() int {
 	return cmd.commitMatches(allMatches)
 }
 
-func (cmd *ReplaceCommand) grepPaths(search string, paths []string) (matches []*Match, err error) {
-	return funcOnPaths(cmd.client, paths, func(s *client.Secret) []*Match {
-		for k, v := range s.GetData() {
-			matches = append(matches, cmd.searcher.DoSearch(s.Path, k, fmt.Sprintf("%v", v))...)
-		}
-		return matches
-	})
-}
-
 // FindMatches will return a map of files sorted by path in which the search occurs
 func (cmd *ReplaceCommand) FindMatches(filePaths []string) (matchesByPath map[string][]*Match, err error) {
-	matches, err := cmd.grepPaths(cmd.args.Search, filePaths)
+	matches, err := cmd.searcher.grepPaths(cmd.client, cmd.args.Search, filePaths)
 	if err != nil {
 		return matchesByPath, err
 	}
@@ -187,7 +178,7 @@ func (cmd *ReplaceCommand) commitMatches(matchesByPath map[string][]*Match) int
 func (cmd *ReplaceCommand) WriteReplacements(groupedMatches map[string][]*Match) error {
 	// Re-read paths because they could've gone stale
 	paths := make([]string, 0)
-	for path, _ := range groupedMatches {
+	for path := range groupedMatches {
 		paths = append(paths, path)
 	}
 	secrets, err := cmd.client.BatchRead(paths)

Diff for: cli/search.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/andreyvit/diff"
 	"github.com/fatih/color"
+	"github.com/fishi0x01/vsh/client"
 )
 
 // SearchingCommand interface to describe a command that performs a search operation
@@ -258,3 +259,12 @@ func (s *Searcher) matchData(subject string) (matchPairs [][]int, replaced strin
 
 	return matchPairs, replaced
 }
+
+func (s *Searcher) grepPaths(c *client.Client, search string, paths []string) (matches []*Match, err error) {
+	return funcOnPaths(c, paths, func(secret *client.Secret) []*Match {
+		for k, v := range secret.GetData() {
+			matches = append(matches, s.DoSearch(secret.Path, k, fmt.Sprintf("%v", v))...)
+		}
+		return matches
+	})
+}

Diff for: client/batch.go

@@ -9,43 +9,43 @@ type BatchOperation int
 
 // types of operations
 const (
-	OP_READ  BatchOperation = 0
-	OP_WRITE BatchOperation = 1
+	OpRead  BatchOperation = 0
+	OpWrite BatchOperation = 1
 )
 
 // how many worker threads to use for batch operations
 const (
-	VAULT_CONCURENCY = 5
+	VaultConcurency = 5
 )
 
 // BatchOperation can perform reads or writes with concurrency
 func (client *Client) BatchOperation(absolutePaths []string, op BatchOperation, secretsIn []*Secret) (secrets []*Secret, err error) {
-	read_queue := make(chan string, len(absolutePaths))
-	write_queue := make(chan *Secret, len(absolutePaths))
+	readQueue := make(chan string, len(absolutePaths))
+	writeQueue := make(chan *Secret, len(absolutePaths))
 	results := make(chan *secretOperation, len(absolutePaths))
 
 	// load up queue for operation
 	switch op {
-	case OP_READ:
+	case OpRead:
 		for _, path := range absolutePaths {
-			read_queue <- path
+			readQueue <- path
 		}
-	case OP_WRITE:
+	case OpWrite:
 		for _, secret := range secretsIn {
-			write_queue <- secret
+			writeQueue <- secret
 		}
 	default:
 		return nil, fmt.Errorf("invalid batch operation")
 	}
 
 	// fire off goroutines for operation
-	for i := 0; i < VAULT_CONCURENCY; i++ {
+	for i := 0; i < VaultConcurency; i++ {
 		client.waitGroup.Add(1)
 		switch op {
-		case OP_READ:
-			go client.readWorker(read_queue, results)
-		case OP_WRITE:
-			go client.writeWorker(write_queue, results)
+		case OpRead:
+			go client.readWorker(readQueue, results)
+		case OpWrite:
+			go client.writeWorker(writeQueue, results)
 		}
 	}
 	client.waitGroup.Wait()

Diff for: client/client.go

@@ -120,7 +120,7 @@ func (client *Client) Read(absolutePath string) (secret *Secret, err error) {
 
 // BatchRead returns secrets for given paths
 func (client *Client) BatchRead(absolutePaths []string) (secrets []*Secret, err error) {
-	return client.BatchOperation(absolutePaths, OP_READ, make([]*Secret, 0))
+	return client.BatchOperation(absolutePaths, OpRead, make([]*Secret, 0))
 }
 
 // Write writes secret to given path, using given Client
@@ -136,7 +136,7 @@ func (client *Client) Write(absolutePath string, secret *Secret) (err error) {
 
 // BatchWrite writes provided secrets to Vault
 func (client *Client) BatchWrite(absolutePaths []string, secrets []*Secret) (err error) {
-	_, err = client.BatchOperation(absolutePaths, OP_WRITE, secrets)
+	_, err = client.BatchOperation(absolutePaths, OpWrite, secrets)
 	return err
 }
 

Diff for: client/type.go

@@ -26,6 +26,7 @@ func (client *Client) topLevelType(path string) PathKind {
 	}
 }
 
+// FilterPaths reduces an array of paths to only include the specified type (leaf vs node)
 func (client *Client) FilterPaths(paths []string, kind PathKind) (filtered []string) {
 	for _, path := range paths {
 		if client.GetType(path) == kind {