feat: Moving dag graph to list

Author: yhakbar

cli/commands/dag/graph/cli.go

@@ -1,14 +1,13 @@
 // Package graph implements the terragrunt dag graph command which generates a visual
 // representation of the Terragrunt dependency graph in DOT language format.
+//
+// Alias for 'list --format=dot --dag --dependencies --external'.
 package graph
 
 import (
-	"github.com/gruntwork-io/terragrunt/cli/commands/common/graph"
-	"github.com/gruntwork-io/terragrunt/cli/commands/common/runall"
-	"github.com/gruntwork-io/terragrunt/cli/commands/run"
+	"github.com/gruntwork-io/terragrunt/cli/commands/list"
 	"github.com/gruntwork-io/terragrunt/cli/flags"
 	"github.com/gruntwork-io/terragrunt/internal/cli"
-	"github.com/gruntwork-io/terragrunt/internal/runner"
 	"github.com/gruntwork-io/terragrunt/options"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 )
@@ -18,31 +17,23 @@ const (
 )
 
 func NewCommand(l log.Logger, opts *options.TerragruntOptions, _ flags.Prefix) *cli.Command {
-	cmd := &cli.Command{
+	return &cli.Command{
 		Name:      CommandName,
-		Usage:     "Graph the Directed Acyclic Graph (DAG) in DOT language.",
+		Usage:     "Graph the Directed Acyclic Graph (DAG) in DOT language. Alias for 'list --format=dot --dag --dependencies --external'.",
 		UsageText: "terragrunt dag graph",
 		Action: func(ctx *cli.Context) error {
 			return Run(ctx, l, opts)
 		},
-		Flags: run.NewFlags(l, opts, nil),
 	}
-
-	cmd = runall.WrapCommand(l, opts, cmd, run.Run, true)
-	cmd = graph.WrapCommand(l, opts, cmd, run.Run, true)
-
-	return cmd
 }
 
 func Run(ctx *cli.Context, l log.Logger, opts *options.TerragruntOptions) error {
-	stack, err := runner.FindStackInSubfolders(ctx, l, opts)
-	if err != nil {
-		return err
-	}
-
-	if err := stack.GetStack().Units.WriteDot(l, opts.Writer, opts); err != nil {
-		l.Warnf("Failed to graph dot: %v", err)
-	}
-
-	return nil
+	listOpts := list.NewOptions(opts)
+	listOpts.Format = list.FormatDot
+	listOpts.Mode = list.ModeDAG
+	listOpts.Dependencies = true
+	listOpts.External = true
+	listOpts.Hidden = true
+
+	return list.Run(ctx, l, listOpts)
 }

cli/commands/list/cli.go

@@ -41,7 +41,7 @@ func NewFlags(opts *Options, prefix flags.Prefix) cli.Flags {
 			Name:        FormatFlagName,
 			EnvVars:     tgPrefix.EnvVars(FormatFlagName),
 			Destination: &opts.Format,
-			Usage:       "Output format for list results. Valid values: text, tree, long.",
+			Usage:       "Output format for list results. Valid values: text, tree, long, dot.",
 			DefaultText: FormatText,
 		}),
 		flags.NewFlag(&cli.BoolFlag{

cli/commands/list/list.go

@@ -2,6 +2,7 @@ package list
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"path/filepath"
 	"sort"
@@ -104,6 +105,8 @@ func Run(ctx context.Context, l log.Logger, opts *Options) error {
 		return outputTree(l, opts, listedComponents, opts.Mode)
 	case FormatLong:
 		return outputLong(l, opts, listedComponents)
+	case FormatDot:
+		return outputDot(l, opts, listedComponents)
 	default:
 		// This should never happen, because of validation in the command.
 		// If it happens, we want to throw so we can fix the validation.
@@ -131,10 +134,10 @@ func shouldDiscoverDependencies(opts *Options) bool {
 type ListedComponents []*ListedComponent
 
 type ListedComponent struct {
-	Type component.Kind
-	Path string
-
+	Type         component.Kind
+	Path         string
 	Dependencies []*ListedComponent
+	Excluded     bool
 }
 
 // Contains checks to see if the given path is in the listed components.
@@ -168,11 +171,17 @@ func discoveredToListed(components component.Components, opts *Options) (ListedC
 			continue
 		}
 
+		excluded := false
+
 		if opts.QueueConstructAs != "" {
 			if unit, ok := c.(*component.Unit); ok {
 				if cfg := unit.Config(); cfg != nil && cfg.Exclude != nil {
 					if cfg.Exclude.IsActionListed(opts.QueueConstructAs) {
-						continue
+						if opts.Format != FormatDot {
+							continue
+						}
+
+						excluded = true
 					}
 				}
 			}
@@ -186,8 +195,9 @@ func discoveredToListed(components component.Components, opts *Options) (ListedC
 		}
 
 		listedCfg := &ListedComponent{
-			Type: c.Kind(),
-			Path: relPath,
+			Type:     c.Kind(),
+			Path:     relPath,
+			Excluded: excluded,
 		}
 
 		if len(c.Dependencies()) == 0 {
@@ -206,9 +216,22 @@ func discoveredToListed(components component.Components, opts *Options) (ListedC
 				continue
 			}
 
+			depExcluded := false
+
+			if opts.QueueConstructAs != "" {
+				if depUnit, ok := dep.(*component.Unit); ok {
+					if depCfg := depUnit.Config(); depCfg != nil && depCfg.Exclude != nil {
+						if depCfg.Exclude.IsActionListed(opts.QueueConstructAs) {
+							depExcluded = true
+						}
+					}
+				}
+			}
+
 			listedCfg.Dependencies[i] = &ListedComponent{
-				Type: dep.Kind(),
-				Path: relDepPath,
+				Type:     dep.Kind(),
+				Path:     relDepPath,
+				Excluded: depExcluded,
 			}
 		}
 
@@ -442,6 +465,11 @@ func outputTree(l log.Logger, opts *Options, components ListedComponents, sort s
 	return renderTree(opts, components, s, sort)
 }
 
+// outputDot outputs the discovered components in GraphViz DOT format.
+func outputDot(_ log.Logger, opts *Options, components ListedComponents) error {
+	return renderDot(opts, components)
+}
+
 type TreeStyler struct {
 	entryStyle  lipgloss.Style
 	rootStyle   lipgloss.Style
@@ -674,3 +702,73 @@ func getLongestPathLen(components ListedComponents) int {
 
 	return longest
 }
+
+// renderDot renders the components in GraphViz DOT format.
+func renderDot(opts *Options, components ListedComponents) error {
+	if _, err := opts.Writer.Write([]byte("digraph {\n")); err != nil {
+		return errors.New(err)
+	}
+
+	writtenNodes := make(map[string]bool, len(components))
+
+	for _, component := range components {
+		if !writtenNodes[component.Path] {
+			style := ""
+			if component.Excluded {
+				style = "[color=red]"
+			}
+
+			if _, writeErr := opts.Writer.Write(
+				fmt.Appendf(
+					nil,
+					"\t\"%s\" %s;\n",
+					component.Path,
+					style,
+				),
+			); writeErr != nil {
+				return errors.New(writeErr)
+			}
+
+			writtenNodes[component.Path] = true
+		}
+
+		for _, dep := range component.Dependencies {
+			if !writtenNodes[dep.Path] {
+				style := ""
+				if dep.Excluded {
+					style = "[color=red]"
+				}
+
+				if _, writeErr := opts.Writer.Write(
+					fmt.Appendf(
+						nil,
+						"\t\"%s\" %s;\n",
+						dep.Path,
+						style,
+					),
+				); writeErr != nil {
+					return errors.New(writeErr)
+				}
+
+				writtenNodes[dep.Path] = true
+			}
+
+			if _, writeErr := opts.Writer.Write(
+				fmt.Appendf(
+					nil,
+					"\t\"%s\" -> \"%s\";\n",
+					component.Path,
+					dep.Path,
+				),
+			); writeErr != nil {
+				return errors.New(writeErr)
+			}
+		}
+	}
+
+	if _, err := opts.Writer.Write([]byte("}\n")); err != nil {
+		return errors.New(err)
+	}
+
+	return nil
+}