yutani 0.0.5 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba4fbd47b60fbd3cfa4fcb75a7b98f5717fee099
-  data.tar.gz: 18e4a37db64e9e6233758fdf251c36787492af7e
+  metadata.gz: 3a8429b5ebef83eb6a439a01fb542973221d0386
+  data.tar.gz: 49d5ea9b1161aacc544489bca25d8e6b07c93c60
 SHA512:
-  metadata.gz: 21cda1d6990d8c7f62a435b3565c1f7551cad94d94419254b80c959803174bd51beba0e31559c2b5c53ead34613ba84117c09003696dcacd4e2b789e3835d3d0
-  data.tar.gz: f8def293272b24075575ba67c51bb6c5c69734a9b9e74cf0c5186800d36b4976c99960f638fbe3d599c94c515d087e3b24898dfd5d1cd49c800012c332a2d8bc
+  metadata.gz: 4a3c7679596ea8d4602586701ac439e84c4cbf0bb92dc475fbc6817bf194c70ef1b632705e6153c434dd53810bc813c88fbd1b5a1c71aa272f74c98a9d7c7cd9
+  data.tar.gz: 305d1813cc2929ecda7dcd3ddb71dbff4433337dddd9ac36241cf41cecd37b7994efe9eb689462723f66993f4995be2ad9ab3f8b47cc6d2711ac85897853bc99

data/lib/yutani/cli.rb

@@ -1,7 +1,8 @@
 require 'thor'
+require 'json'
+require 'pp'
 require 'yaml'
-require 'guard'
-require 'guard/commander'
+require 'listen'
 
 module Yutani
   class Cli < Thor
@@ -19,27 +20,48 @@ module Yutani
       end
     end
 
-    desc 'build', 'Evaluates the given script and creates terraform files'
-    def build(script)
-      Yutani.build_from_file(script)
+    desc 'build', 'Evaluates DSL scripts and creates terraform files'
+    def build
+      scripts_dir = Yutani::Config::DEFAULTS['scripts_dir']
+
+      files = Dir.glob(File.join(scripts_dir, '*.rb'))
+      if files.empty?
+        raise "Could not find any scripts in '#{scripts_dir}'"
+      end
+
+      files.each do |script|
+        Yutani.eval_file(script)
+      end
+
+      unless Yutani.stacks.empty?
+        Yutani.stacks.each {|s| s.to_fs}
+      end
     end
 
     # we need to know these things:
     # * the directory to restrict to watching for changes
-    # * the script that build should evaluate 
+    # * the script that build should evaluate
     # * the glob  - this is hardcoded to *.rb
-    desc 'watch', 'Run build upon changes to files/directories'
-    def watch(script, script_dir)
-			guardfile = <<-EOF
-run_build = proc do
-  system("yutani build #{script}")
-end
+    desc 'watch', 'Run build upon changes to scripts'
+    def watch
+      Listen.to(Yutani::Config::DEFAULTS['scripts_dir']) do |m, a, d|
+        Yutani.logger.info "Re-build triggered: #{m} modified" unless m.empty?
+        Yutani.logger.info "Re-build triggered: #{a} added" unless a.empty?
+        Yutani.logger.info "Re-build triggered: #{d} deleted" unless d.empty?
 
-guard :yield, { :run_on_modifications => run_build } do
-  watch(%r|^.*\.rb$|)
-end
-EOF
-      Guard.start(guardfile_contents: guardfile, watchdir: script_dir, debug: true)
+        build
+
+        Yutani.logger.info "Re-build finished"
+      end.start
+
+      # exit cleanly upon Ctrl-C
+      %w[INT TERM USR1].each do |sig|
+        Signal.trap(sig) do
+          exit
+        end
+      end
+
+      sleep
     end
 
     desc 'version', 'Prints the current version of Yutani'
@@ -47,16 +69,66 @@ EOF
       puts Yutani::VERSION
     end
 
+    desc 'target', 'Generate list of Terraform targets'
+    def target(stack_dir, *args)
+      files = Dir.glob(File.join(stack_dir, '*.tf.json'))
+      if files.empty?
+        raise "Could not find *.tf.json files in #{stack_dir}"
+      end
+
+      if args.empty?
+        raise "No targets specified"
+      end
+
+      contents = files.inject({}) do |h, f|
+        h.merge!(JSON.parse(File.read(f)))
+        h
+      end
+
+      targets = contents['resource'].inject({}) do |h,(k,v)|
+        h[k] = v.select do |k,v|
+          (args - k.split('_')).empty?
+        end
+        h
+      end.reject{|k,v| v.empty? }
+
+      target_flags = targets.inject([]) do |flags, (k,v)|
+        flags << v.keys.map do |resource_name|
+          "-target " + ["resource", k, resource_name].join('.')
+        end
+        flags
+      end.flatten
+
+      puts target_flags.join(" ")
+    end
+
+    # Invoke Terraform CLI command
+    def method_missing(name, *args, &block)
+      %x/terraform #{name} #{args}/
+    end
+
     desc 'init', 'Initialize with a basic setup'
     def init
       if File.exists? '.yutani.yml'
-        puts ".yutani.yml already exists, skipping initialization"
+        Yutani.logger.warn ".yutani.yml already exists, skipping initialization"
       else
         File.open('.yutani.yml', 'w+') do |f|
           f.write Yutani::Config::DEFAULTS.to_yaml(indent: 2)
           puts ".yutani.yml created"
         end
 
+        unless Dir.exists? Yutani::Config::DEFAULTS['terraform_dir']
+          FileUtils.mkdir Yutani::Config::DEFAULTS['terraform_dir']
+        end
+
+        unless Dir.exists? Yutani::Config::DEFAULTS['scripts_dir']
+          FileUtils.mkdir Yutani::Config::DEFAULTS['scripts_dir']
+        end
+
+        unless Dir.exists? Yutani::Config::DEFAULTS['includes_dir']
+          FileUtils.mkdir Yutani::Config::DEFAULTS['includes_dir']
+        end
+
         hiera_dir = Yutani::Config::DEFAULTS['hiera_config'][:yaml][:datadir]
         FileUtils.mkdir hiera_dir unless Dir.exists? hiera_dir
 

data/lib/yutani/config.rb

@@ -4,6 +4,8 @@ module Yutani
 
     # Strings rather than symbols are used for compatibility with YAML.
     DEFAULTS = Config[{
+      "scripts_dir" => "scripts",
+      "includes_dir" => "includes",
       "terraform_dir" => "terraform",
       "hiera_config"  => {
         :backends  => ["yaml"],

data/lib/yutani/dsl_entity.rb

@@ -1,9 +1,7 @@
 module Yutani
   class DSLEntity
-    attr_accessor :scope
-
     def hiera(k)
-      Yutani::Hiera.lookup(k, @scope)
+      Yutani::Hiera.lookup(k)
     end
   end
 end

data/lib/yutani/hiera.rb

@@ -1,6 +1,32 @@
+require 'hiera'
+
+# say something about the purpose of this wrapper, for instance
+# the way in which yutani maintains a stack of hiera scopes and
+# then merges them when a lookup occurs
 module Yutani
   module Hiera
+    class NonExistentKeyException < StandardError; end
+
+    @scopes = []
+
     class << self
+      attr_accessor :hiera, :scopes
+
+      def scope
+        @scopes.inject({}){|h,scope| h.merge(scope) }
+      end
+
+      def push(kv)
+        # hiera doesn't accept symbols for scope keys or values
+        @scopes.push Yutani::Utils.convert_symbols_to_strings_in_flat_hash(kv)
+
+        Yutani.logger.debug "hiera scope: %s" % scope
+      end
+
+      def pop
+        @scopes.pop
+      end
+
       def hiera(config_override={})
         @hiera ||= init_hiera(config_override)
       end
@@ -14,15 +40,14 @@ module Yutani
         )
       end
 
-      def lookup(k, scope)
-        # hiera expects strings, not symbols
-        hiera_scope = scope.inject({}){|h,(k,v)| h[k.to_s] = v.to_s; h}
-        Yutani.logger.debug "hiera scope: %s" % hiera_scope
+      def lookup(k)
+
+        # hiera expects key to be a string
+        v = hiera.lookup(k.to_s, nil, scope)
 
-        v = Yutani::Hiera.hiera.lookup(k.to_s, nil, hiera_scope)
-        Yutani.logger.warn "hiera couldn't find value for key #{k}" if v.nil?
+        raise NonExistentKeyException.new(v) if v.nil?
 
-        # let us use symbols for hash keys
+        # if nested hash, let user lookup nested keys with strings or symbols
         Yutani::Utils.convert_nested_hash_to_indifferent_access(v)
       end
     end

data/lib/yutani/provider.rb

@@ -1,15 +1,13 @@
-require 'active_support/hash_with_indifferent_access'
-
 module Yutani
   class Provider < DSLEntity
     attr_accessor :provider_name, :fields
 
     def initialize(provider_name, **scope, &block)
       @provider_name      = provider_name
-      @scope              = HashWithIndifferentAccess.new(scope)
+      @scope              = scope
       @fields             = {}
 
-      instance_eval &block if block_given?
+      Docile.dsl_eval(self, &block) if block_given?
     end
 
     def []=(k,v)
@@ -22,6 +20,10 @@ module Yutani
       }
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      true
+    end
+
     def method_missing(name, *args, &block)
       if block_given?
         raise StandardError, 

data/lib/yutani/resource.rb

@@ -1,73 +1,53 @@
-require 'active_support/hash_with_indifferent_access'
-
 module Yutani
   class Resource < DSLEntity
-    attr_accessor :resource_type, :resources, :fields, :mods, :resource_name
+    attr_accessor :resource_type, :namespace, :fields
 
-    def initialize(resource_type, resource_name, **scope, &block)
+    def initialize(resource_type, *namespace, &block)
       @resource_type      = resource_type
-      @resource_name      = resource_name
-      @scope              = HashWithIndifferentAccess.new(scope)
+      @namespace          = namespace
       @fields             = {}
 
-      instance_eval &block if block_given?
+      Docile.dsl_eval(self, &block) if block_given?
     end
 
-    def []=(k,v)
-      @fields[k] = v
+    def resource_name
+      @namespace.join('_')
     end
 
     def to_h
       {
         @resource_type => {
-          @resource_name => @fields
+          resource_name => @fields
         }
       }
     end
 
-    def ref(m='.', t, n, a)
-      Reference.new(m, t, n, a)
+    def ref(resource_type, *namespace, attr)
+      "${%s}" % [resource_type, namespace.join('_'), attr].join('.')
     end
 
-    def resolve_references!(&block)
-      @fields.each do |k,v|
-        case v
-        when Reference
-          @fields[k] = yield v
-        when SubResource
-          v.fields.each do |k,v|
-            if v.is_a? Reference
-              v.fields[k] = yield v
-            end
-          end
-        else
-          next
-        end
-      end
+    def respond_to_missing?(method_name, include_private = false)
+      true
     end
 
     def method_missing(name, *args, &block)
-      if block_given?
-        sub = SubResource.new(scope)
+      if name =~ /ref_(.*)/
+        # redirect ref_id, ref_name, etc, to ref()
+        ref(*args, $1)
+      elsif block_given?
+        # handle sub resources, like tags, listener, etc
+        sub = SubResource.new
         sub.instance_exec(&block)
         @fields[name] = sub.fields
       else
-        # remove leading '_' if present.
-        # DSL users have to do prefix with underscore when they want to use
-        # a resource property that has same name as an existing ruby method
-        # i.e. 'timeout'
-        sans_underscore = name.to_s.sub(/^_/, '').to_sym
-        @fields[sans_underscore] = args.first
+        @fields[name] = args.first
       end
     end
   end
 
   class SubResource < Resource 
-    def initialize(scope)
-      @scope  = scope
+    def initialize
       @fields = {}
     end
   end
-
-  ResourceAttribute = Struct.new(:type, :name, :attr)
 end

data/lib/yutani/stack.rb

@@ -1,22 +1,105 @@
+require 'json'
+
 module Yutani
-  # a stack is a terraform module with
-  # additional properties:
-  # * module name is hardcoded to 'root'
-  # * can only be found at top-level (it's an error if found within another stack/module)
-  # * because it's the top-level module, it's immediately evaluated
-  # * ability to configure remote state
-  class Stack < Mod
+  class Stack < DSLEntity
+    attr_accessor :resources, :providers, :outputs, :variables
+
+    def initialize(*namespace, &block)
+      @resources   = []
+      @providers   = []
+      @outputs     = {}
+      @variables   = {}
+      @namespace   = namespace
+
+      Docile.dsl_eval(self, &block) if block_given?
+    end
+
+    def name
+      @namespace.join('_')
+    end
+
+    def resource(resource_type, *namespace, &block)
+      @resources <<
+        Resource.new(resource_type, *namespace, &block)
+    end
+
+    def provider(name, &block)
+      @providers <<
+        Provider.new(name, &block)
+    end
+
+    # troposphere-like methods
+    def add_resource(resource)
+      @resources << resource
+    end
+
+    def add_provider(provider)
+      @providers << provider
+    end
 
-    def initialize(name, **scope, &block)
-      super(name, nil, scope, {stack_name: name}, &block)
+    def inc(&block)
+      includes_dir = Yutani::Config::DEFAULTS['includes_dir']
+      path = File.join(includes_dir, yield)
+
+      eval File.read(path), block.binding, path
+    end
+
+    # this generates the contents of *.tf.main
+    def to_h
+      h = { 
+        resource: @resources.inject(DeepMergeHash.new){|resources,r|
+          resources.deep_merge!(r.to_h)
+        },
+        provider: @providers.inject(DeepMergeHash.new){|providers,r|
+          providers.deep_merge(r.to_h)
+        },
+        output: @outputs.inject({}){|outputs,(k,v)|
+          outputs[k] = { value: v }
+          outputs
+        },
+        variable: @variables.inject({}){|variables,(k,v)|
+          variables[k] = {}
+          variables
+        }
+      }
+
+      # terraform doesn't like empty output and variable collections
+      h.delete_if {|_,v| v.empty? }
+    end
+
+    def pretty_json
+      JSON.pretty_generate(to_h)
+    end
+
+    def dir_path
+      name
+    end
+
+    def tar(filename)
+      File.open(filename, 'w+') do |tarball|
+        create_dir_tree('./').to_tar(tarball)
+      end
     end
 
-    def path
-      "/root"
+    def to_fs(prefix='./terraform')
+      create_dir_tree(prefix).to_fs
     end
 
-    def [](name)
-      descendents.find{|d| d.name == name}
+    def create_dir_tree(prefix)
+      dir_tree(DirectoryTree.new(prefix), '')
+    end
+
+    def dir_tree(dt, prefix)
+      full_dir_path = File.join(prefix, self.dir_path)
+      main_tf_path = File.join(full_dir_path, 'main.tf.json')
+
+      dt.add_file(
+        main_tf_path,
+        0644,
+        self.pretty_json
+      )
+
+      dt
     end
   end
 end

data/lib/yutani/utils.rb

@@ -1,14 +1,32 @@
-require 'active_support/hash_with_indifferent_access'
+require 'hashie'
 
 module Yutani
+	class IndifferentHash < Hash
+    include Hashie::Extensions::MergeInitializer
+		include Hashie::Extensions::IndifferentAccess
+	end
+
+	class DeepMergeHash < Hash
+		include Hashie::Extensions::DeepMerge
+	end
+
   module Utils
     class << self
+      def convert_symbols_to_strings_in_flat_hash(h)
+        h.inject({}) do |h, (k,v)|
+          k = k.is_a?(Symbol) ? k.to_s : k
+          v = v.is_a?(Symbol) ? v.to_s : v
+          h[k] = v
+          h
+        end
+      end
+
       def convert_nested_hash_to_indifferent_access(v)
         case v
         when Array
           v.map{|i| convert_nested_hash_to_indifferent_access(i) }
         when Hash
-          HashWithIndifferentAccess.new(v)
+          IndifferentHash.new(v)
         else
           v
         end

data/lib/yutani/version.rb

@@ -1,3 +1,3 @@
 module Yutani
-  VERSION = '0.0.5'
+  VERSION = '0.1.12'
 end

data/lib/yutani.rb

@@ -1,38 +1,37 @@
-require 'hiera'
-require 'hashie'
+begin; require 'pry'; rescue LoadError; end
+
 require 'logger'
+require 'docile'
+
 require 'yutani/version'
 require 'yutani/config'
 require 'yutani/hiera'
 require 'yutani/cli'
 require 'yutani/dsl_entity'
-require 'yutani/reference'
 require 'yutani/directory_tree'
-require 'yutani/mod'
 require 'yutani/stack'
 require 'yutani/resource'
 require 'yutani/provider'
 require 'yutani/utils'
 
 module Yutani
-
   @stacks = []
 
   class << self
-    attr_accessor :hiera, :stacks, :logger, :entry_path
-  end
+    # do we need :logger?
+    attr_accessor :hiera, :stacks, :logger
 
-  class << self
     def logger
       @logger ||= (
-        logger = Logger.new(STDOUT)
+        logger = Logger.new(STDERR)
         logger.level = Logger.const_get(ENV.fetch('LOG_LEVEL', 'INFO'))
         logger
       )
     end
 
-    def stack(name, **scope, &block)
-      s = Stack.new(name, **scope, &block)
+    # DSL statement
+    def stack(*namespace, &block)
+      s = Stack.new(*namespace, &block)
       @stacks << s
       s
     end
@@ -47,14 +46,27 @@ module Yutani
       Config.from(config.merge(override))
     end
 
-    def build_from_file(file)
-      Yutani.entry_path = file
+    def scope(**kv, &block)
+      Hiera.push kv
 
-      instance_eval(File.read(file), file)
+      # let user use symbols or strings for keys
+      yield Yutani::IndifferentHash.new(Hiera.scope)
 
-      unless stacks.empty?
-        stacks.each {|s| s.to_fs}
+      Hiera.pop
+    end
+
+    def dsl_eval(str, *args, &block)
+      Docile.dsl_eval(self, *args, &block)
+    end
+
+    def eval_string(*args, str, file)
+      dsl_eval(str, *args, file) do
+        instance_eval(str, file)
       end
     end
+
+    def eval_file(*args, file)
+      eval_string(File.read(file), file)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yutani
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.12
 platform: ruby
 authors:
 - Louis Garman
@@ -79,33 +79,45 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.19.1
 - !ruby/object:Gem::Dependency
-  name: guard
+  name: docile
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.0
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.0
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.5
 - !ruby/object:Gem::Dependency
-  name: guard-yield
+  name: listen
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.1.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.1.5
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -134,6 +146,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.14.2
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.0
 description: Generates JSON for Terraform
 email: louisgarman+yutani@gmail.com
 executables:
@@ -149,10 +175,7 @@ files:
 - lib/yutani/directory_tree.rb
 - lib/yutani/dsl_entity.rb
 - lib/yutani/hiera.rb
-- lib/yutani/mod.rb
 - lib/yutani/provider.rb
-- lib/yutani/reference.rb
-- lib/yutani/reference_path.rb
 - lib/yutani/resource.rb
 - lib/yutani/stack.rb
 - lib/yutani/utils.rb

data/lib/yutani/mod.rb

@@ -1,321 +0,0 @@
-require 'json'
-require 'hashie'
-require 'pp'
-
-module Yutani
-  # Maps to a terraform module. Named 'mod' to avoid confusion with 
-  # ruby 'module'.
-  # It can contain :
-  # * other modules
-  # * resources
-  # * other resources (provider, data, etc)
-  # * variables
-  # * outputs
-  # Its block is evaluated depending upon whether it is enclosed within 
-  # another module
-  # It has the following properties
-  # * mandatory name of type symbol
-  # * optional scope of type hash
-  # * ability to output a tar of its contents
-  class Mod < DSLEntity
-    attr_accessor :name, :resources, :providers, :block, :mods, :params, :outputs, :variables
-
-    def initialize(name, parent, local_scope, parent_scope, &block)
-      @name                = name.to_sym
-
-      @scope               = parent_scope.merge(local_scope)
-      @scope[:module_name] = name
-      @local_scope         = local_scope
-      @parent              = parent
-
-      @mods                = []
-      @resources           = []
-      @providers           = []
-      @outputs             = {}
-      @params              = {}
-      @variables           = {}
-
-      instance_eval        &block
-    end
-
-    def mod(name, **scope, &block)
-
-      @mods << Mod.new(name, self, scope, @scope, &block)
-    end
-
-    def source(path)
-      absolute_path = File.expand_path(path, File.dirname(Yutani.entry_path))
-      contents = File.read absolute_path
-
-      instance_eval contents, path
-    end
-
-    def resources_hash
-      @resources.inject({}) do |r_hash, r|
-        r_hash[r.resource_type] ||= {}
-        r_hash[r.resource_type][r.resource_name] = r 
-        r_hash
-      end
-    end
-
-    def debug
-      resolve_references!(self)
-      #pp @mods.unshift(self).map{|m| m.to_h }
-    end
-
-    class MyHash < Hash
-      include Hashie::Extensions::DeepMerge
-    end
-
-    # this generates the contents of *.tf.main
-    def to_h
-      h = { 
-        module: @mods.inject({}) {|modules,m|
-          modules[m.tf_name] = {}
-          modules[m.tf_name][:source] = m.dir_path
-          modules[m.tf_name].merge! m.params
-          modules
-        },
-        resource: @resources.inject(MyHash.new){|resources,r|
-          resources.deep_merge(r.to_h)
-        },
-        provider: @providers.inject(MyHash.new){|providers,r|
-          providers.deep_merge(r.to_h)
-        },
-        output: @outputs.inject({}){|outputs,(k,v)|
-          outputs[k] = { value: v }
-          outputs
-        },
-        variable: @variables.inject({}){|variables,(k,v)|
-          variables[k] = {}
-          variables
-        }
-      }
-
-      # terraform doesn't like empty output and variable collections
-      h.delete_if {|_,v| v.empty? }
-    end
-
-    def tf_name
-      dirs = @local_scope.values.map{|v| v.to_s.gsub('-', '_') }
-      dirs.unshift(name)
-      dirs.join('_')
-    end
-
-    def dir_path
-      tf_name
-    end
-
-    def resource(resource_type, identifiers, **scope, &block)
-      merged_scope = @scope.merge(scope)
-      @resources <<
-        Resource.new(resource_type, identifiers, merged_scope, &block)
-    end
-
-    def provider(provider_name, **scope, &block)
-      merged_scope = @scope.merge(scope)
-      @providers <<
-        Provider.new(provider_name, merged_scope, &block)
-    end
-
-    def pretty_json
-      JSON.pretty_generate(to_h)
-    end
-
-    def children
-      @mods
-    end
-
-    def descendents
-      children + children.map{|c| c.descendents}.flatten
-    end
-
-    def parent?(mod)
-      @parent.name == mod.name
-    end
-
-    # given name of mod, return bool
-    def child?(mod)
-      children.map{|m| m.name }.include? mod.name
-    end
-
-    def child_by_name(name)
-      children.find{|child| child.name == name.to_sym}
-    end
-
-    def path
-      File.join(@parent.path, name.to_s)
-    end
-
-    class InvalidReferencePathException < StandardError; end
-
-    # rel_path: relative path to a target mod
-    # ret an array of mods tracing that path 
-    # sorted from target -> source
-    # mods: array of module objects, which after being built is returned
-    # path: array of path strings: i.e. [.. .. .. a b c]
-
-    def generate_pathway(mods, path)
-      curr = path.shift
-
-      case curr
-      when /[a-z]+/
-        child = child_by_name(curr)
-        if child.nil?
-          raise InvalidReferencePathException, "no such module #{curr}" 
-        else
-          child.generate_pathway(mods.unshift(self), path)
-        end
-      when '..'
-        if @parent.nil?
-          raise InvalidReferencePathException, "no such module #{curr}" 
-        else
-          @parent.generate_pathway(mods.unshift(self), path)
-        end
-      when nil
-        return mods.unshift(self)
-      else
-        raise InvalidReferencePathException, "invalid path component: #{curr}" 
-      end
-    end
-
-    # recursive linked-list function, propagating a variable
-    # from a target module to a source module
-    # seed var with array of [type,name,attr]
-    def propagate(prev, nxt, var)
-      if prev.empty?
-        # we are the source module
-        if nxt.empty?
-          # src and target in same mod
-          "${%s}" % var.join('.')
-        else
-          if self.child? nxt.first
-            # there is no 'composition' mod,
-            new_var = [self.name, var].flatten
-            nxt.first.params[new_var.join('_')] = "${%s}" % new_var.join('.')
-            nxt.first.variables[new_var] = ''
-
-            nxt.shift.propagate(prev.push(self), nxt, var)
-          elsif self.parent?(nxt.first)
-            # we are propagating upward the variable
-            self.outputs[var.join('_')] = "${%s}" % var.join('.')
-            nxt.shift.propagate(prev.push(self), nxt, var.join('_'))
-          else
-            raise "Propagation error!"
-          end
-        end
-      else
-        if nxt.empty?
-          # we're the source module
-          if self.child? prev.last
-            # it's been propagated 'up' to us
-            "${module.%s.%s}" % [prev.last.name, var]
-          elsif self.parent? prev.last
-            # it's been propagated 'down' to us
-            "${var.%s}" % var
-          else
-            raise "Propagation error!"
-          end
-        else
-          if self.child? prev.last and self.child? nxt.first
-            # we're a 'composition' module; the common ancestor
-            # to source and target modules
-            new_var = [prev.last.name, var]
-            nxt.first.params[new_var.join('_')] = "${module.%s.%s}" % new_var
-            nxt.first.variables[new_var.join('_')] = ""
-
-            nxt.shift.propagate(prev.push(self), nxt, new_var.join('_'))
-          elsif self.child? prev.last and self.parent? nxt.first
-            # we're propagating 'upward' the variable
-            # towards the common ancestor
-            
-            new_var = [prev.last.name, var]
-            self.outputs[new_var.join('_')] = "${module.%s.%s}" % new_var
-
-            nxt.shift.propagate(prev.push(self), nxt, new_var.join('_'))
-          elsif self.parent? prev.last and self.parent? nxt.first
-            # we cannot be a child to two parents in a tree!
-            raise "Progation error!"
-          elsif self.parent? prev.last and self.child? nxt.first
-            nxt.first.params[var] = "${var.%s}" % var
-            nxt.first.variables[var] = ""
-
-            nxt.shift.propagate(prev.push(self), nxt, var)
-          else
-            raise "Propagation error!"
-          end
-        end
-      end
-    end
-
-    def resolve_references!
-      @resources.each do |r|
-        r.resolve_references! do |ref|
-
-          matching_resources = []
-
-          path_components = ref.relative_path(self).split('/')
-          mod_path = generate_pathway([], path_components)
-          target_mod = mod_path.shift
- 
-          # lookup matching resources in mod_path.first
-          matches = ref.find_matching_resources_in_module!(target_mod)
-
-          if matches.empty?
-            raise ReferenceException, 
-              "no matching resources found in mod #{target_mod.name}"
-          end
-
-          interpolation_strings = matches.map do |res|
-            ra = ResourceAttribute.new(res.resource_type, res.resource_name, ref.attr)
-            # clone mod_path, because propagate() will alter it
-            target_mod.propagate([], mod_path.clone, [ra.type, ra.name, ra.attr])
-          end
-          interpolation_strings.length == 1 ? interpolation_strings[0] : 
-            interpolation_strings
-        end
-      end
-
-      children.each do |m|
-        m.resolve_references!
-      end
-    end
-
-    def tar(filename)
-      # ideally, this needs to be done automatically as part of to_h
-      resolve_references!
-
-      File.open(filename, 'w+') do |tarball|
-        create_dir_tree('./').to_tar(tarball)
-      end
-    end
-
-    def to_fs(prefix='./terraform')
-      # ideally, this needs to be done automatically as part of to_h
-      resolve_references!
-
-      create_dir_tree(prefix).to_fs
-    end
-
-    def create_dir_tree(prefix)
-      dir_tree(DirectoryTree.new(prefix), '')
-    end
-
-    def dir_tree(dt, prefix)
-      full_dir_path = File.join(prefix, self.dir_path)
-      main_tf_path = File.join(full_dir_path, 'main.tf.json')
-
-      dt.add_file(
-        main_tf_path,
-        0644,
-        self.pretty_json
-      )
-
-      mods.each do |m|
-        m.dir_tree(dt, full_dir_path)
-      end
-
-      dt
-    end
-  end
-end

data/lib/yutani/reference.rb

@@ -1,57 +0,0 @@
-require 'pathname'
-
-module Yutani
-  class Reference
-
-    attr_reader :path
-
-    def initialize(path='.', t, n, a)
-      @path       = path
-      @t          = t
-      @n          = n
-      @a          = a
-    end
-
-    def relative_path(source_mod)
-      source_path = Pathname.new(source_mod.path)
-      target_path = Pathname.new(@path)
-      target_path.relative_path_from(source_path).to_s
-    end
-
-    def resource_type
-      @t
-    end
-
-    def resource_name
-      @n
-    end
-
-    def attr
-      @a
-    end
-
-    def find_matching_resources_in_module!(mod)
-      resolutions = []
-      # we currently support strings for t n and a, and regex
-      # for n only
-      mod.resources.each do |resource|
-        if resource.resource_type == self.resource_type.to_sym
-          case self.resource_name
-          when Regexp
-            if resource.resource_name =~ self.resource_name
-              resolutions.push(resource)
-            end
-          when Symbol
-            if resource.resource_name == self.resource_name.to_sym
-              resolutions.push(resource)
-            end
-          else
-            raise "unsupported class #{self.resource_name.class}"
-          end
-        end
-      end
-
-      resolutions
-    end
-  end
-end

data/lib/yutani/reference_path.rb

@@ -1,28 +0,0 @@
-module Yutani
-  class ReferencePath
-    def initialize(mods, resource_type, resource_name, attr)
-      @mods          = mods
-      @resource_type = resource_type
-      @resource_name = resource_name
-      @attr          = attr
-    end
-
-    def interpolation_string(prefix=nil, mods=[])
-      resource_params = [@resource_type, @resource_name, @attr]
-      if prefix.nil?
-        # we're referencing a resource in the local module
-        resource_params.join('.')
-      else
-        resource_params.join('_')
-      end
-    end
-
-    def shift(prev, curr, nxt)
-      traverse(prev.push(curr), nxt.shift, nxt)
-    end
-
-    def traverse(prev,
-      shift(prev, curr, nxt)
-    end
-  end
-end