Merge pull request #32 from ivanilves/GH-23

Add plain Terraform support via "plugable" IncludeFn()

.goreleaser.yml

@@ -45,3 +45,4 @@ changelog:
     - '^test'
     - '^style'
     - '^docs'
+    - '^Merge pull request'

Makefile

@@ -1,5 +1,5 @@
 APP_NAME    := travelgrunt
-API_VERSION := 0.2
+API_VERSION := 0.3
 BUILD_PATH  := ./cmd/${APP_NAME}
 
 CURRENT_PATCH = $(shell (git fetch --tags && git tag --sort=creatordate | grep -F "v${API_VERSION}." || echo -1) | tail -n1 | sed -r "s/^v([0-9]+\.){2}//")

README.md

@@ -4,14 +4,34 @@
 
 # travelgrunt
 
-Travel **[Terragrunt](https://terragrunt.gruntwork.io/)** directory tree as a first class passenger! :airplane:
+Travel **[Terragrunt](https://terragrunt.gruntwork.io/)** or **[Terraform](https://www.terraform.io/)** directory tree as a first class passenger! :airplane:
 
 ## How to use?
 
 * `cd` to the directory of your [locally cloned] Terragrunt/Terraform Git repo;
 * run **tg** [alias](#shell-aliases) there :rocket: ([optional] arguments are "path filter" matches);
 * use arrow keys to navigate the list and `/` key to search for specific items;
 
+## Configuration
+:bulb: `travelgrunt` doesn't need a configuration file, but can take advantage from having one :ok_hand:
+
+Create `.travelgrunt.yml` file in the root path of your repository. Set it content to either:
+
+```
+mode: terragrunt
+```
+:arrow_up: this will follow the **default behavior** to travel across Terragrunt projects (you don't even need a config for this!).
+
+```
+mode: terraform
+```
+:arrow_up: this will navigate through Terraform projects/modules instead of Terragrunt ones. Use case: Terraform module [mono]repo.
+
+```
+mode: terraform_or_terragrunt
+```
+:arrow_up: this will navigate through **both** Terraform and Terragrunt projects inside the repo.
+
 ## Shell aliases
 
 It is **absolutely required** to use `bash` (or `zsh`) aliases. Start from something like this:

cmd/travelgrunt/main.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"os"
 
+	"github.com/ivanilves/travelgrunt/pkg/config"
 	"github.com/ivanilves/travelgrunt/pkg/directory"
 	"github.com/ivanilves/travelgrunt/pkg/directory/tree"
 	"github.com/ivanilves/travelgrunt/pkg/file"
@@ -88,7 +89,13 @@ func main() {
 		writeFileAndExit(outFile, rootPath)
 	}
 
-	entries, paths, err := directory.Collect(rootPath)
+	cfg, err := config.NewConfig(rootPath)
+
+	if err != nil {
+		log.Fatalf("failed to load travelgrunt config: %s", err.Error())
+	}
+
+	entries, paths, err := directory.Collect(rootPath, cfg.IncludeFn())
 
 	if err != nil {
 		log.Fatalf("failed to collect Terragrunt project directories: %s", err.Error())

fixtures/config/include/nothing/foo.bar

@@ -0,0 +1 @@
+baz

fixtures/config/include/terraform/main.tf

@@ -0,0 +1,9 @@
+resource "aws_vpc" "default" {
+  cidr_block = var.vpc_cidr
+  tags = merge(
+    local.common-tags,
+    map(
+      "Description", "VPC for creating resources",
+    )
+  )
+}

fixtures/config/include/terragrunt/terragrunt.hcl

@@ -0,0 +1,14 @@
+terraform {
+  source = "my-terraform-module"
+}
+
+include "root" {
+  path = find_in_parent_folders()
+}
+
+inputs = {
+  instance_type = "t2.medium"
+
+  min_size = 3
+  max_size = 3
+}

fixtures/config/travelgrunt.yml.illegal

@@ -0,0 +1 @@
+mode: bogus

fixtures/config/travelgrunt.yml.invalid

@@ -0,0 +1,2 @@
+8�HMԧ��:q
+{�

fixtures/config/travelgrunt.yml.terraform

@@ -0,0 +1 @@
+mode: terraform

fixtures/config/travelgrunt.yml.terraform_or_terragrunt

@@ -0,0 +1 @@
+mode: terraform_or_terragrunt

fixtures/config/travelgrunt.yml.terragrunt

@@ -0,0 +1 @@
+mode: terragrunt

pkg/config/config.go

@@ -0,0 +1,70 @@
+package config
+
+import (
+	"fmt"
+	"os"
+
+	"gopkg.in/yaml.v3"
+
+	"github.com/ivanilves/travelgrunt/pkg/config/include"
+)
+
+var configFile = ".travelgrunt.yml"
+
+// Config is a travelgrunt repo-level configuration
+type Config struct {
+	Mode string `yaml:"mode"`
+
+	IsDefault bool
+}
+
+// NewConfig creates new travelgrunt repo-level configuration
+func NewConfig(path string) (cfg Config, err error) {
+	var data []byte
+
+	data, err = os.ReadFile(path + "/" + configFile)
+	// We don't care about config file not being read,
+	// it's a common case and we just return default config.
+	if err != nil {
+		return DefaultConfig(), nil
+	}
+	// If we have a file, it should be a correct one though!
+	if err := yaml.Unmarshal(data, &cfg); err != nil {
+		return cfg, err
+	}
+
+	return cfg, validate(cfg)
+}
+
+func validate(cfg Config) error {
+	allowedModes := []string{"terragrunt", "terraform", "terraform_or_terragrunt"}
+
+	for _, mode := range allowedModes {
+		if cfg.Mode == mode {
+			return nil
+		}
+	}
+
+	return fmt.Errorf("illegal mode: %s", cfg.Mode)
+}
+
+// DefaultConfig returns default travelgrunt repo-level configuration
+func DefaultConfig() Config {
+	return Config{Mode: "terragrunt", IsDefault: true}
+}
+
+// IncludeFn returns the "include" function used to select relevant directories
+func (cfg Config) IncludeFn() (fn func(os.DirEntry) bool) {
+	switch cfg.Mode {
+	case "terragrunt":
+		fn = include.IsTerragrunt
+	case "terraform":
+		fn = include.IsTerraform
+	case "terraform_or_terragrunt":
+		fn = include.IsTerraformOrTerragrunt
+	default:
+		fn = nil
+	}
+
+	return fn
+}

pkg/config/config_test.go

@@ -0,0 +1,58 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"os"
+	"reflect"
+	"runtime"
+
+	"github.com/ivanilves/travelgrunt/pkg/config/include"
+)
+
+const (
+	fixturePath = "../../fixtures/config"
+)
+
+func getConfig(mode string, isDefault bool) Config {
+	return Config{Mode: mode, IsDefault: isDefault}
+}
+
+func TestNewConfig(t *testing.T) {
+	assert := assert.New(t)
+
+	testCases := map[string]struct {
+		cfg       Config
+		success   bool
+		includeFn func(os.DirEntry) bool
+	}{
+		"travelgrunt.yml.terragrunt":              {cfg: getConfig("terragrunt", false), success: true, includeFn: include.IsTerragrunt},
+		"travelgrunt.yml.terraform":               {cfg: getConfig("terraform", false), success: true, includeFn: include.IsTerraform},
+		"travelgrunt.yml.terraform_or_terragrunt": {cfg: getConfig("terraform_or_terragrunt", false), success: true, includeFn: include.IsTerraformOrTerragrunt},
+		"travelgrunt.yml.invalid":                 {cfg: getConfig("", false), success: false, includeFn: nil},
+		"travelgrunt.yml.illegal":                 {cfg: getConfig("bogus", false), success: false, includeFn: nil},
+		"travelgrunt.yml.nonexistent":             {cfg: getConfig("terragrunt", true), success: true, includeFn: include.IsTerragrunt},
+	}
+
+	for cfgFile, expected := range testCases {
+		configFile = cfgFile
+
+		cfg, err := NewConfig(fixturePath)
+
+		assert.Equal(expected.cfg, cfg)
+
+		assert.Equalf(
+			runtime.FuncForPC(reflect.ValueOf(expected.includeFn).Pointer()).Name(),
+			runtime.FuncForPC(reflect.ValueOf(cfg.IncludeFn()).Pointer()).Name(),
+			"got unexpected include function while loading config file: %s", configFile,
+		)
+
+		if expected.success {
+			assert.Nil(err)
+		} else {
+			assert.NotNil(err)
+		}
+	}
+}

pkg/config/include/include.go

@@ -0,0 +1,25 @@
+package include
+
+import (
+	"os"
+	"strings"
+)
+
+func fileOrSymlink(d os.DirEntry) bool {
+	return d.Type().IsRegular() || d.Type() == os.ModeSymlink
+}
+
+// IsTerragrunt tells us if we operate on Terragrunt config file
+func IsTerragrunt(d os.DirEntry) bool {
+	return fileOrSymlink(d) && d.Name() == "terragrunt.hcl"
+}
+
+// IsTerraform tells us if we operate on Terraform file(s)
+func IsTerraform(d os.DirEntry) bool {
+	return fileOrSymlink(d) && strings.HasSuffix(d.Name(), ".tf")
+}
+
+// IsTerraformOrTerragrunt tells us if we operate on Terraform or Terragrunt file(s)
+func IsTerraformOrTerragrunt(d os.DirEntry) bool {
+	return IsTerraform(d) || IsTerragrunt(d)
+}

pkg/config/include/include_test.go

@@ -0,0 +1,47 @@
+package include
+
+import (
+	"os"
+	"path/filepath"
+
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	fixturePath = "../../../fixtures/config/include"
+)
+
+func TestIncludeFn(t *testing.T) {
+	assert := assert.New(t)
+
+	type testCase struct {
+		IsTerragrunt            bool
+		IsTerraform             bool
+		IsTerraformOrTerragrunt bool
+	}
+
+	testCases := map[string]testCase{
+		"../../../fixtures/config/include/terragrunt/terragrunt.hcl": testCase{true, false, true},
+		"../../../fixtures/config/include/terraform/main.tf":         testCase{false, true, true},
+		"../../../fixtures/config/include/nothing/foo.bar":           testCase{false, false, false},
+	}
+
+	err := filepath.WalkDir(fixturePath,
+		func(path string, d os.DirEntry, err error) error {
+			assert.Nil(err)
+
+			for p, expected := range testCases {
+				if p == path {
+					assert.Equal(expected.IsTerragrunt, IsTerragrunt(d))
+					assert.Equal(expected.IsTerraform, IsTerraform(d))
+					assert.Equal(expected.IsTerraformOrTerragrunt, IsTerraformOrTerragrunt(d))
+				}
+			}
+
+			return nil
+		})
+
+	assert.Nil(err)
+}

pkg/directory/directory.go

@@ -2,21 +2,16 @@ package directory
 
 import (
 	"os"
-	"strings"
-
 	"path/filepath"
+	"strings"
 )
 
 func isHidden(d os.DirEntry) bool {
 	return d.IsDir() && string(d.Name()[0]) == "."
 }
 
-func isTerragruntConfig(d os.DirEntry) bool {
-	return (d.Type().IsRegular() || d.Type() == os.ModeSymlink) && d.Name() == "terragrunt.hcl"
-}
-
 // Collect gets a list of directory path entries containing file "terragrunt.hcl"
-func Collect(rootPath string) (entries map[string]string, paths []string, err error) {
+func Collect(rootPath string, includeFn func(os.DirEntry) bool) (entries map[string]string, paths []string, err error) {
 	entries = make(map[string]string, 0)
 	paths = make([]string, 0)
 
@@ -30,7 +25,7 @@ func Collect(rootPath string) (entries map[string]string, paths []string, err er
 				return filepath.SkipDir
 			}
 
-			if isTerragruntConfig(d) {
+			if includeFn(d) {
 				abs := filepath.Dir(path)
 				rel := strings.TrimPrefix(abs, rootPath+"/")
 
@@ -41,9 +36,5 @@ func Collect(rootPath string) (entries map[string]string, paths []string, err er
 			return nil
 		})
 
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return entries, paths, nil
+	return entries, paths, err
 }

pkg/directory/directory_test.go

@@ -4,6 +4,8 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+
+	"github.com/ivanilves/travelgrunt/pkg/config"
 )
 
 const (
@@ -14,13 +16,15 @@ const (
 func TestCollect(t *testing.T) {
 	assert := assert.New(t)
 
+	cfg := config.DefaultConfig()
+
 	testCases := map[string]bool{
 		fixturePath: true,
 		invalidPath: false,
 	}
 
 	for path, expectedSuccess := range testCases {
-		entries, paths, err := Collect(path)
+		entries, paths, err := Collect(path, cfg.IncludeFn())
 
 		if expectedSuccess {
 			assert.Greater(len(entries), 0)