From bae9f6d2fd5eb5bc80929bd393932b23f14d7c93 Mon Sep 17 00:00:00 2001
From: Jake Champlin <jake.champlin.27@gmail.com>
Date: Tue, 6 Jun 2017 12:40:07 -0400
Subject: Initial transfer of provider code

---
 .../hashicorp/terraform/config/import_tree.go      | 113 +++++++++++++++++++++
 1 file changed, 113 insertions(+)
 create mode 100644 vendor/github.com/hashicorp/terraform/config/import_tree.go

(limited to 'vendor/github.com/hashicorp/terraform/config/import_tree.go')

diff --git a/vendor/github.com/hashicorp/terraform/config/import_tree.go b/vendor/github.com/hashicorp/terraform/config/import_tree.go
new file mode 100644
index 0000000..37ec11a
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/import_tree.go
@@ -0,0 +1,113 @@
+package config
+
+import (
+	"fmt"
+	"io"
+)
+
+// configurable is an interface that must be implemented by any configuration
+// formats of Terraform in order to return a *Config.
+type configurable interface {
+	Config() (*Config, error)
+}
+
+// importTree is the result of the first-pass load of the configuration
+// files. It is a tree of raw configurables and then any children (their
+// imports).
+//
+// An importTree can be turned into a configTree.
+type importTree struct {
+	Path     string
+	Raw      configurable
+	Children []*importTree
+}
+
+// This is the function type that must be implemented by the configuration
+// file loader to turn a single file into a configurable and any additional
+// imports.
+type fileLoaderFunc func(path string) (configurable, []string, error)
+
+// loadTree takes a single file and loads the entire importTree for that
+// file. This function detects what kind of configuration file it is an
+// executes the proper fileLoaderFunc.
+func loadTree(root string) (*importTree, error) {
+	var f fileLoaderFunc
+	switch ext(root) {
+	case ".tf", ".tf.json":
+		f = loadFileHcl
+	default:
+	}
+
+	if f == nil {
+		return nil, fmt.Errorf(
+			"%s: unknown configuration format. Use '.tf' or '.tf.json' extension",
+			root)
+	}
+
+	c, imps, err := f(root)
+	if err != nil {
+		return nil, err
+	}
+
+	children := make([]*importTree, len(imps))
+	for i, imp := range imps {
+		t, err := loadTree(imp)
+		if err != nil {
+			return nil, err
+		}
+
+		children[i] = t
+	}
+
+	return &importTree{
+		Path:     root,
+		Raw:      c,
+		Children: children,
+	}, nil
+}
+
+// Close releases any resources we might be holding open for the importTree.
+//
+// This can safely be called even while ConfigTree results are alive. The
+// importTree is not bound to these.
+func (t *importTree) Close() error {
+	if c, ok := t.Raw.(io.Closer); ok {
+		c.Close()
+	}
+	for _, ct := range t.Children {
+		ct.Close()
+	}
+
+	return nil
+}
+
+// ConfigTree traverses the importTree and turns each node into a *Config
+// object, ultimately returning a *configTree.
+func (t *importTree) ConfigTree() (*configTree, error) {
+	config, err := t.Raw.Config()
+	if err != nil {
+		return nil, fmt.Errorf(
+			"Error loading %s: %s",
+			t.Path,
+			err)
+	}
+
+	// Build our result
+	result := &configTree{
+		Path:   t.Path,
+		Config: config,
+	}
+
+	// Build the config trees for the children
+	result.Children = make([]*configTree, len(t.Children))
+	for i, ct := range t.Children {
+		t, err := ct.ConfigTree()
+		if err != nil {
+			return nil, err
+		}
+
+		result.Children[i] = t
+	}
+
+	return result, nil
+}
-- 
cgit v1.2.3