update vendor and go.mod

[github/fretlink/terraform-provider-statuscake.git] / vendor / github.com / hashicorp / terraform / config / loader.go

package config

import (
        "encoding/json"
        "fmt"
        "io"
        "os"
        "path/filepath"
        "sort"
        "strings"

        "github.com/hashicorp/hcl"
)

// ErrNoConfigsFound is the error returned by LoadDir if no
// Terraform configuration files were found in the given directory.
type ErrNoConfigsFound struct {
        Dir string
}

func (e ErrNoConfigsFound) Error() string {
        return fmt.Sprintf(
                "No Terraform configuration files found in directory: %s",
                e.Dir)
}

// LoadJSON loads a single Terraform configuration from a given JSON document.
//
// The document must be a complete Terraform configuration. This function will
// NOT try to load any additional modules so only the given document is loaded.
func LoadJSON(raw json.RawMessage) (*Config, error) {
        obj, err := hcl.Parse(string(raw))
        if err != nil {
                return nil, fmt.Errorf(
                        "Error parsing JSON document as HCL: %s", err)
        }

        // Start building the result
        hclConfig := &hclConfigurable{
                Root: obj,
        }

        return hclConfig.Config()
}

// LoadFile loads the Terraform configuration from a given file.
//
// This file can be any format that Terraform recognizes, and import any
// other format that Terraform recognizes.
func LoadFile(path string) (*Config, error) {
        importTree, err := loadTree(path)
        if err != nil {
                return nil, err
        }

        configTree, err := importTree.ConfigTree()

        // Close the importTree now so that we can clear resources as quickly
        // as possible.
        importTree.Close()

        if err != nil {
                return nil, err
        }

        return configTree.Flatten()
}

// LoadDir loads all the Terraform configuration files in a single
// directory and appends them together.
//
// Special files known as "override files" can also be present, which
// are merged into the loaded configuration. That is, the non-override
// files are loaded first to create the configuration. Then, the overrides
// are merged into the configuration to create the final configuration.
//
// Files are loaded in lexical order.
func LoadDir(root string) (*Config, error) {
        files, overrides, err := dirFiles(root)
        if err != nil {
                return nil, err
        }
        if len(files) == 0 && len(overrides) == 0 {
                return nil, &ErrNoConfigsFound{Dir: root}
        }

        // Determine the absolute path to the directory.
        rootAbs, err := filepath.Abs(root)
        if err != nil {
                return nil, err
        }

        var result *Config

        // Sort the files and overrides so we have a deterministic order
        sort.Strings(files)
        sort.Strings(overrides)

        // Load all the regular files, append them to each other.
        for _, f := range files {
                c, err := LoadFile(f)
                if err != nil {
                        return nil, err
                }

                if result != nil {
                        result, err = Append(result, c)
                        if err != nil {
                                return nil, err
                        }
                } else {
                        result = c
                }
        }
        if len(files) == 0 {
                result = &Config{}
        }

        // Load all the overrides, and merge them into the config
        for _, f := range overrides {
                c, err := LoadFile(f)
                if err != nil {
                        return nil, err
                }

                result, err = Merge(result, c)
                if err != nil {
                        return nil, err
                }
        }

        // Mark the directory
        result.Dir = rootAbs

        return result, nil
}

// Ext returns the Terraform configuration extension of the given
// path, or a blank string if it is an invalid function.
func ext(path string) string {
        if strings.HasSuffix(path, ".tf") {
                return ".tf"
        } else if strings.HasSuffix(path, ".tf.json") {
                return ".tf.json"
        } else {
                return ""
        }
}

func dirFiles(dir string) ([]string, []string, error) {
        f, err := os.Open(dir)
        if err != nil {
                return nil, nil, err
        }
        defer f.Close()

        fi, err := f.Stat()
        if err != nil {
                return nil, nil, err
        }
        if !fi.IsDir() {
                return nil, nil, fmt.Errorf(
                        "configuration path must be a directory: %s",
                        dir)
        }

        var files, overrides []string
        err = nil
        for err != io.EOF {
                var fis []os.FileInfo
                fis, err = f.Readdir(128)
                if err != nil && err != io.EOF {
                        return nil, nil, err
                }

                for _, fi := range fis {
                        // Ignore directories
                        if fi.IsDir() {
                                continue
                        }

                        // Only care about files that are valid to load
                        name := fi.Name()
                        extValue := ext(name)
                        if extValue == "" || IsIgnoredFile(name) {
                                continue
                        }

                        // Determine if we're dealing with an override
                        nameNoExt := name[:len(name)-len(extValue)]
                        override := nameNoExt == "override" ||
                                strings.HasSuffix(nameNoExt, "_override")

                        path := filepath.Join(dir, name)
                        if override {
                                overrides = append(overrides, path)
                        } else {
                                files = append(files, path)
                        }
                }
        }

        return files, overrides, nil
}

// IsIgnoredFile returns true or false depending on whether the
// provided file name is a file that should be ignored.
func IsIgnoredFile(name string) bool {
        return strings.HasPrefix(name, ".") || // Unix-like hidden files
                strings.HasSuffix(name, "~") || // vim
                strings.HasPrefix(name, "#") && strings.HasSuffix(name, "#") // emacs
}