feat: add a new providers bundled command (#164)

Signed-off-by: Diogenes Fernandes <diofeher@gmail.com>

Author: diofeher

internal/cmd/providers_command.go

@@ -0,0 +1,82 @@
+// Copyright (c) The OpenTofu Authors
+// SPDX-License-Identifier: MPL-2.0
+// Copyright (c) 2024 HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package cmd
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io/fs"
+	"strings"
+
+	"github.com/mitchellh/cli"
+
+	"github.com/opentofu/tofu-ls/internal/schemas"
+)
+
+type ProvidersBundledCommand struct {
+	Ui cli.Ui
+	FS fs.ReadDirFS
+
+	jsonOutput bool
+}
+
+func (c *ProvidersBundledCommand) flags() *flag.FlagSet {
+	fs := defaultFlagSet("providers bundled")
+
+	fs.BoolVar(&c.jsonOutput, "json", false, "output the provider list as JSON")
+
+	fs.Usage = func() { c.Ui.Error(c.Help()) }
+
+	return fs
+}
+
+func (c *ProvidersBundledCommand) Run(args []string) int {
+	f := c.flags()
+	if err := f.Parse(args); err != nil {
+		c.Ui.Error(fmt.Sprintf("Error parsing command-line flags: %s", err))
+		return 1
+	}
+
+	providers, err := schemas.ListBundledProviders(c.FS)
+	if err != nil {
+		c.Ui.Error(fmt.Sprintf("Error listing bundled providers: %s", err))
+		return 1
+	}
+
+	if len(providers) == 0 {
+		c.Ui.Output("No bundled providers found.")
+		return 0
+	}
+
+	if c.jsonOutput {
+		jsonOutput, err := json.MarshalIndent(providers, "", "  ")
+		if err != nil {
+			c.Ui.Error(fmt.Sprintf("Error marshalling JSON: %s", err))
+			return 1
+		}
+		c.Ui.Output(string(jsonOutput))
+		return 0
+	}
+
+	for _, p := range providers {
+		c.Ui.Output(fmt.Sprintf("%s %s", p.Addr.ForDisplay(), p.Version))
+	}
+	return 0
+}
+
+func (c *ProvidersBundledCommand) Help() string {
+	helpText := `
+Usage: tofu-ls providers bundled [-json]
+
+` + c.Synopsis() + "\n\n" + helpForFlags(c.flags())
+
+	return strings.TrimSpace(helpText)
+}
+
+func (c *ProvidersBundledCommand) Synopsis() string {
+	return "Lists the provider schemas bundled into tofu-ls binary"
+}

internal/schemas/schemas.go

@@ -34,6 +34,66 @@ func (e SchemaNotAvailable) Error() string {
 	return fmt.Sprintf("embedded schema not available for %s", e.Addr)
 }
 
+type BundledProvider struct {
+	Addr    tfaddr.Provider
+	Version *version.Version
+}
+
+// ListBundledProviders returns a list of all bundled providers to the binary on the `data` folder.
+func ListBundledProviders(filesystem fs.ReadDirFS) ([]BundledProvider, error) {
+	var providers []BundledProvider
+
+	// We only bundle the latest version of each provider, so we expect exactly one
+	// version directory per provider. If there are more than one, that's an error
+	// If there are zero, then that provider is not bundled and we skip it.
+	hostname := tfaddr.DefaultProviderRegistryHost
+	namespacePath := path.Join("data", hostname.String())
+	namespaces, err := fs.ReadDir(filesystem, namespacePath)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, namespace := range namespaces {
+		if !namespace.IsDir() {
+			continue
+		}
+
+		typePath := path.Join(namespacePath, namespace.Name())
+		types, err := fs.ReadDir(filesystem, typePath)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, providerType := range types {
+			if !providerType.IsDir() {
+				continue
+			}
+
+			versionPath := path.Join(typePath, providerType.Name())
+			entries, err := fs.ReadDir(filesystem, versionPath)
+			if err != nil {
+				return nil, err
+			}
+
+			if len(entries) != 1 {
+				return nil, fmt.Errorf("%s/%s: expected one version, found %d", namespace.Name(), providerType.Name(), len(entries))
+			}
+
+			v, err := version.NewVersion(entries[0].Name())
+			if err != nil {
+				return nil, err
+			}
+
+			providers = append(providers, BundledProvider{
+				Addr:    tfaddr.NewProvider(hostname, namespace.Name(), providerType.Name()),
+				Version: v,
+			})
+		}
+	}
+
+	return providers, nil
+}
+
 func FindProviderSchemaFile(filesystem fs.ReadDirFS, pAddr tfaddr.Provider) (*ProviderSchema, error) {
 	providerPath := path.Join("data", pAddr.Hostname.String(), pAddr.Namespace, pAddr.Type)
 

main.go

@@ -11,6 +11,7 @@ import (
 	"github.com/mitchellh/cli"
 
 	"github.com/opentofu/tofu-ls/internal/cmd"
+	"github.com/opentofu/tofu-ls/internal/schemas"
 )
 
 func main() {
@@ -44,6 +45,12 @@ func main() {
 				Version: version,
 			}, nil
 		},
+		"providers bundled": func() (cli.Command, error) {
+			return &cmd.ProvidersBundledCommand{
+				Ui: ui,
+				FS: schemas.FS,
+			}, nil
+		},
 	}
 
 	exitStatus, err := c.Run()