X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=vendor%2Fgithub.com%2Fhashicorp%2Fterraform%2Fterraform%2Ftransform_reference.go;h=be8c7f96c394e43468f84e9e6822871ed930c365;hb=15c0b25d011f37e7c20aeca9eaf461f78285b8d9;hp=c5452354d4b65917eef363aea0f67971b4d03b0e;hpb=07971ca38143c5faf951d152fba370ddcbe26ad5;p=github%2Ffretlink%2Fterraform-provider-statuscake.git

diff --git a/vendor/github.com/hashicorp/terraform/terraform/transform_reference.go b/vendor/github.com/hashicorp/terraform/terraform/transform_reference.go
index c545235..be8c7f9 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/transform_reference.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/transform_reference.go
@@ -76,6 +76,85 @@ func (t *ReferenceTransformer) Transform(g *Graph) error {
 	return nil
 }
 
+// DestroyReferenceTransformer is a GraphTransformer that reverses the edges
+// for locals and outputs that depend on other nodes which will be
+// removed during destroy. If a destroy node is evaluated before the local or
+// output value, it will be removed from the state, and the later interpolation
+// will fail.
+type DestroyValueReferenceTransformer struct{}
+
+func (t *DestroyValueReferenceTransformer) Transform(g *Graph) error {
+	vs := g.Vertices()
+	for _, v := range vs {
+		switch v.(type) {
+		case *NodeApplyableOutput, *NodeLocal:
+			// OK
+		default:
+			continue
+		}
+
+		// reverse any outgoing edges so that the value is evaluated first.
+		for _, e := range g.EdgesFrom(v) {
+			target := e.Target()
+
+			// only destroy nodes will be evaluated in reverse
+			if _, ok := target.(GraphNodeDestroyer); !ok {
+				continue
+			}
+
+			log.Printf("[TRACE] output dep: %s", dag.VertexName(target))
+
+			g.RemoveEdge(e)
+			g.Connect(&DestroyEdge{S: target, T: v})
+		}
+	}
+
+	return nil
+}
+
+// PruneUnusedValuesTransformer is s GraphTransformer that removes local and
+// output values which are not referenced in the graph. Since outputs and
+// locals always need to be evaluated, if they reference a resource that is not
+// available in the state the interpolation could fail.
+type PruneUnusedValuesTransformer struct{}
+
+func (t *PruneUnusedValuesTransformer) Transform(g *Graph) error {
+	// this might need multiple runs in order to ensure that pruning a value
+	// doesn't effect a previously checked value.
+	for removed := 0; ; removed = 0 {
+		for _, v := range g.Vertices() {
+			switch v.(type) {
+			case *NodeApplyableOutput, *NodeLocal:
+				// OK
+			default:
+				continue
+			}
+
+			dependants := g.UpEdges(v)
+
+			switch dependants.Len() {
+			case 0:
+				// nothing at all depends on this
+				g.Remove(v)
+				removed++
+			case 1:
+				// because an output's destroy node always depends on the output,
+				// we need to check for the case of a single destroy node.
+				d := dependants.List()[0]
+				if _, ok := d.(*NodeDestroyableOutput); ok {
+					g.Remove(v)
+					removed++
+				}
+			}
+		}
+		if removed == 0 {
+			break
+		}
+	}
+
+	return nil
+}
+
 // ReferenceMap is a structure that can be used to efficiently check
 // for references on a graph.
 type ReferenceMap struct {
@@ -96,6 +175,7 @@ func (m *ReferenceMap) References(v dag.Vertex) ([]dag.Vertex, []string) {
 	var matches []dag.Vertex
 	var missing []string
 	prefix := m.prefix(v)
+
 	for _, ns := range rn.References() {
 		found := false
 		for _, n := range strings.Split(ns, "/") {
@@ -108,19 +188,14 @@ func (m *ReferenceMap) References(v dag.Vertex) ([]dag.Vertex, []string) {
 			// Mark that we found a match
 			found = true
 
-			// Make sure this isn't a self reference, which isn't included
-			selfRef := false
 			for _, p := range parents {
+				// don't include self-references
 				if p == v {
-					selfRef = true
-					break
+					continue
 				}
-			}
-			if selfRef {
-				continue
+				matches = append(matches, p)
 			}
 
-			matches = append(matches, parents...)
 			break
 		}
 
@@ -296,14 +371,21 @@ func ReferenceFromInterpolatedVar(v config.InterpolatedVariable) []string {
 		return []string{fmt.Sprintf("%s.%d/%s.N", id, idx, id)}
 	case *config.UserVariable:
 		return []string{fmt.Sprintf("var.%s", v.Name)}
+	case *config.LocalVariable:
+		return []string{fmt.Sprintf("local.%s", v.Name)}
 	default:
 		return nil
 	}
 }
 
 func modulePrefixStr(p []string) string {
+	// strip "root"
+	if len(p) > 0 && p[0] == rootModulePath[0] {
+		p = p[1:]
+	}
+
 	parts := make([]string, 0, len(p)*2)
-	for _, p := range p[1:] {
+	for _, p := range p {
 		parts = append(parts, "module", p)
 	}