Add Analyzer framework (#99)

## Summary
Adds an `Analyzer` to the `plansdk`. Analyzers can be initialized on a
root directory, and provide lots of utility functions to then understand
(or analyze) the source code present in that root directory. Analyzer
implements several functions that are really handy when implementing all
sorts of planners.

This PR just introduces the library; future PRs would start using the
library in the implementation of planners.

## How was it tested?
`go test -v ./...`

Author: loreto

config.go

@@ -27,7 +27,7 @@ type Config struct {
 // ReadConfig reads a devbox config file.
 func ReadConfig(path string) (*Config, error) {
 	cfg := &Config{}
-	err := cuecfg.ReadFile(path, cfg)
+	err := cuecfg.ParseFile(path, cfg)
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}

cuecfg/cuecfg.go

@@ -13,39 +13,39 @@ import (
 
 // TODO: add support for .cue
 
-func Marshal(value any, extension string) ([]byte, error) {
-	err := cuego.Complete(value)
+func Marshal(valuePtr any, extension string) ([]byte, error) {
+	err := cuego.Complete(valuePtr)
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
 
 	switch extension {
 	case ".json":
-		return MarshalJSON(value)
+		return MarshalJSON(valuePtr)
 	case ".yml", ".yaml":
-		return MarshalYaml(value)
+		return MarshalYaml(valuePtr)
 	case ".toml":
-		return MarshalToml(value)
+		return MarshalToml(valuePtr)
 	}
 	return nil, errors.Errorf("Unsupported file format '%s' for config file", extension)
 }
 
-func Unmarshal(data []byte, extension string, value any) error {
+func Unmarshal(data []byte, extension string, valuePtr any) error {
 	switch extension {
 	case ".json":
-		err := UnmarshalJSON(data, value)
+		err := UnmarshalJSON(data, valuePtr)
 		if err != nil {
 			return errors.WithStack(err)
 		}
 		return nil
 	case ".yml", ".yaml":
-		err := UnmarshalYaml(data, value)
+		err := UnmarshalYaml(data, valuePtr)
 		if err != nil {
 			return errors.WithStack(err)
 		}
 		return nil
 	case ".toml":
-		err := UnmarshalToml(data, value)
+		err := UnmarshalToml(data, valuePtr)
 		if err != nil {
 			return errors.WithStack(err)
 		}
@@ -54,28 +54,28 @@ func Unmarshal(data []byte, extension string, value any) error {
 	return errors.Errorf("Unsupported file format '%s' for config file", extension)
 }
 
-func InitFile(path string, value any) (bool, error) {
+func InitFile(path string, valuePtr any) (bool, error) {
 	if _, err := os.Stat(path); err == nil {
 		// File already exists, don't create a new one.
 		// TODO: should we read and write again, in case the schema needs updating?
 		return false, nil
 	} else if errors.Is(err, os.ErrNotExist) {
 		// File does not exist, create a new one:
-		return true, WriteFile(path, value)
+		return true, WriteFile(path, valuePtr)
 	} else {
 		// Error case:
 		return false, errors.WithStack(err)
 	}
 
 }
 
-func ReadFile(path string, value any) error {
+func ParseFile(path string, valuePtr any) error {
 	data, err := os.ReadFile(path)
 	if err != nil {
 		return errors.WithStack(err)
 	}
 
-	return Unmarshal(data, filepath.Ext(path), value)
+	return Unmarshal(data, filepath.Ext(path), valuePtr)
 }
 
 func WriteFile(path string, value any) error {

planner/languages/javascript/nodejs_planner.go

@@ -157,7 +157,7 @@ func (p *Planner) startCommand(pkgManager string, project *nodeProject) string {
 func (p *Planner) nodeProject(srcDir string) *nodeProject {
 	packageJSONPath := filepath.Join(srcDir, "package.json")
 	project := &nodeProject{}
-	_ = cuecfg.ReadFile(packageJSONPath, project)
+	_ = cuecfg.ParseFile(packageJSONPath, project)
 
 	return project
 }

planner/plansdk/analyzer.go

@@ -0,0 +1,73 @@
+// Copyright 2022 Jetpack Technologies Inc and contributors. All rights reserved.
+// Use of this source code is governed by the license in the LICENSE file.
+
+package plansdk
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/bmatcuk/doublestar/v4"
+	"go.jetpack.io/devbox/cuecfg"
+)
+
+// Analyzers help understand the source code present in a given directory
+// Handy when implementing new Planners that need to analyze files in order
+// to determine what to do.
+type Analyzer struct {
+	rootDir string
+}
+
+func NewAnalyzer(rootDir string) (*Analyzer, error) {
+	abs, err := filepath.Abs(rootDir)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Analyzer{
+		rootDir: abs,
+	}, nil
+}
+
+// AbsPath resolves the given path and turns it into an absolute path relative
+// to the root directory of the analyzer. If the given path is already absolute
+// it leaves it as is.
+func (a *Analyzer) absPath(path string) string {
+	if filepath.IsAbs(path) {
+		return path
+	}
+
+	return filepath.Join(a.rootDir, path)
+}
+
+// GlobFiles returns all the files matching the given glob patterns.
+// Patterns can be relative to the analyzer's root directory. Glob patterns
+// support "double star" matches.
+func (a *Analyzer) GlobFiles(patterns ...string) []string {
+	results := []string{}
+
+	for _, p := range patterns {
+		pattern := a.absPath(p)
+		matches, err := doublestar.FilepathGlob(pattern)
+		if err != nil {
+			continue
+		}
+		results = append(results, matches...)
+	}
+	return results
+}
+
+func (a *Analyzer) FileExists(relPath string) bool {
+	_, err := os.Stat(a.absPath(relPath))
+	return err == nil
+}
+
+func (a *Analyzer) HasAnyFile(patterns ...string) bool {
+	matches := a.GlobFiles(patterns...)
+	return len(matches) > 0
+}
+
+func (a *Analyzer) ParseFile(relPath string, ptr any) error {
+	abs := a.absPath(relPath)
+	return cuecfg.ParseFile(abs, ptr)
+}