yutani 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bed76670778f66c3a40d8d86e5de3cef50b718cb
+  data.tar.gz: 9f061e4858b478a843e4a0d786f050c1b8436e15
+SHA512:
+  metadata.gz: d5209d59b656258ce292a7f0217996f807fc1fae43aab035bda4c56d4a556038a7603aced3f44c3e6ab9336f6d4f814f2fbaeb60b89c07cdb77c5fc923edb76a
+  data.tar.gz: 7cb439bef4a54df1e25239a075ffb694743286925ede586d1049deaf888eef8f2e16c1c744a5d6326e9c79a828b76759da342a05e92f0ca2ed417ad445742463

data/bin/install-terraform.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+https://releases.hashicorp.com/terraform/0.7.13/terraform_0.7.13_linux_amd64.zip

data/bin/yutani

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'yutani'
+
+Yutani::Cli::main(ARGV)

data/lib/yutani/cli.rb

@@ -0,0 +1,77 @@
+require 'thor'
+require 'yaml'
+require 'guard'
+require 'guard/commander'
+
+module Yutani
+  class Cli < Thor
+    map '-v' => :version, '--version' => :version
+    map '--hiera-config-file' => :hiera_config_file
+
+    def self.main(args)
+      begin
+        Cli.start(args)
+      rescue StandardError => e
+        Yutani.logger.fatal "#{e.class.name} #{e.message}"
+        Yutani.logger.fatal Yutani::Cli.format_backtrace(e.backtrace) unless e.backtrace.empty?
+
+        exit 1
+      end
+    end
+
+    desc 'build', 'Evaluates the given script and creates terraform files'
+    def build(script)
+      Yutani.build_from_file(script)
+    end
+
+    # we need to know these things:
+    # * the directory to restrict to watching for changes
+    # * 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
+
+guard :yield, { :run_on_modifications => run_build } do
+  watch(%r|^.*\.rb$|)
+end
+EOF
+      Guard.start(guardfile_contents: guardfile, watchdir: script_dir, debug: true)
+    end
+
+    desc 'version', 'Prints the current version of Yutani'
+    def version
+      puts Yutani::VERSION
+    end
+
+    desc 'init', 'Initialize with a basic setup'
+    def init
+      if File.exists? '.yutani.yml'
+        puts ".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
+
+        hiera_dir = Yutani::Config::DEFAULTS['hiera_config'][:yaml][:datadir]
+        FileUtils.mkdir hiera_dir unless Dir.exists? hiera_dir
+
+        common_yml = File.join(hiera_dir, 'common.yaml')
+        unless File.exists? common_yml
+          File.new(common_yml, 'w+')
+          puts "#{common_yml} created"
+        end
+      end
+    end
+
+    private
+
+    def self.format_backtrace(bt)
+      "Backtrace: #{bt.join("\n   from ")}"
+    end
+  end
+end

data/lib/yutani/config.rb

@@ -0,0 +1,34 @@
+module Yutani
+  class Config < Hash
+    CONFIG_FILE = '.yutani.yml'
+
+    # Strings rather than symbols are used for compatibility with YAML.
+    DEFAULTS = Config[{
+      "terraform_dir" => "terraform",
+      "hiera_config"  => {
+        :backends  => ["yaml"],
+        :hierarchy => ["common"],
+        :yaml      => {
+          :datadir=>"hiera"
+        },
+        :logger    => "noop"
+      }
+    }]
+
+    class << self
+      # Returns a Configuration filled with defaults and fixed for common
+      # problems and backwards-compatibility.
+      def from(user_config)
+        DEFAULTS.merge Config[user_config]
+      end
+    end
+
+    def read_config_file
+      if File.exists? CONFIG_FILE
+        YAML.load_file(CONFIG_FILE)
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/yutani/directory_tree.rb

@@ -0,0 +1,43 @@
+require 'rubygems/package'
+require 'fileutils'
+
+module Yutani
+  # An abstraction of a real directory tree on disk
+  # Permits us to decide later whether this will be written to disk
+  # or embedded in a tarball, or sent over scp, etc.
+  class DirectoryTree
+    File = Struct.new(:path, :permissions, :content)
+
+    attr_reader :files, :prefix
+
+    def initialize(prefix = './')
+      @prefix = prefix
+      @files = []
+    end
+
+    def add_file(path, permissions, content)
+      @files << File.new(::File.join(@prefix, path), permissions.to_i, content)
+    end
+
+    def to_fs
+      @files.each do |f|
+        FileUtils.mkdir_p(::File.dirname(f.path))
+        ::File.open(f.path, 'w+', f.permissions) do |new_f|
+          new_f.write f.content
+        end
+      end
+    end
+
+    def to_tar(io = STDOUT)
+      Gem::Package::TarWriter.new(io) do |tar|
+        @files.each do |f|
+          tar.mkdir(::File.dirname(f.path), '0755')
+
+          tar.add_file_simple(f.path, f.permissions, f.content.bytes.size) do |tar_file|
+            tar_file.write f.content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yutani/dsl_entity.rb

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

data/lib/yutani/hiera.rb

@@ -0,0 +1,30 @@
+module Yutani
+  module Hiera
+    class << self
+      def hiera(config_override={})
+        @hiera ||= init_hiera(config_override)
+      end
+
+      def init_hiera(override={})
+        conf = Yutani.config(override)
+
+        # hiera_config_file trumps hiera_config
+        ::Hiera.new(config:
+          conf.fetch('hiera_config_file', conf['hiera_config'])
+        )
+      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
+
+        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?
+
+        # let us use symbols for hash keys
+        Yutani::Utils.convert_nested_hash_to_indifferent_access(v)
+      end
+    end
+  end
+end

data/lib/yutani/mod.rb

@@ -0,0 +1,321 @@
+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/provider.rb

@@ -0,0 +1,34 @@
+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)
+      @fields             = {}
+
+      instance_eval &block if block_given?
+    end
+
+    def []=(k,v)
+      @fields[k] = v
+    end
+
+    def to_h
+      {
+        @provider_name => @fields
+      }
+    end
+
+    def method_missing(name, *args, &block)
+      if block_given?
+        raise StandardError, 
+          "provider properties do not accept blocks as parameters"
+      else
+        @fields[name] = args.first
+      end
+    end
+  end
+end

data/lib/yutani/reference.rb

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,28 @@
+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

data/lib/yutani/resource.rb

@@ -0,0 +1,72 @@
+require 'active_support/hash_with_indifferent_access'
+
+module Yutani
+  class Resource < DSLEntity
+    attr_accessor :resource_type, :resources, :fields, :mods, :resource_name
+
+    def initialize(resource_type, resource_name, **scope, &block)
+      @resource_type      = resource_type
+      @resource_name      = resource_name
+      @scope              = HashWithIndifferentAccess.new(scope)
+      @fields             = {}
+
+      instance_eval &block if block_given?
+    end
+
+    def []=(k,v)
+      @fields[k] = v
+    end
+
+    def to_h
+      {
+        @resource_type => {
+          @resource_name => @fields
+        }
+      }
+    end
+
+    def ref(m='.', t, n, a)
+      Reference.new(m, t, n, a)
+    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
+    end
+
+    def method_missing(name, *args, &block)
+      if block_given?
+        sub = SubResource.new(scope)
+        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'
+        @fields[name] = args.first.to_s.sub(/^_/, '')
+      end
+    end
+  end
+
+  class SubResource < Resource 
+    def initialize(scope)
+      @scope  = scope
+      @fields = {}
+    end
+  end
+
+  ResourceAttribute = Struct.new(:type, :name, :attr)
+end

data/lib/yutani/stack.rb

@@ -0,0 +1,22 @@
+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
+
+    def initialize(name, **scope, &block)
+      super(name, nil, scope, {stack_name: name}, &block)
+    end
+
+    def path
+      "/root"
+    end
+
+    def [](name)
+      descendents.find{|d| d.name == name}
+    end
+  end
+end

data/lib/yutani/utils.rb

@@ -0,0 +1,18 @@
+require 'active_support/hash_with_indifferent_access'
+
+module Yutani
+  module Utils
+    class << self
+      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)
+        else
+          v
+        end
+      end
+    end 
+  end
+end

data/lib/yutani/version.rb

@@ -0,0 +1,3 @@
+module Yutani
+  VERSION = '0.0.2'
+end

data/lib/yutani.rb

@@ -0,0 +1,60 @@
+require 'hiera'
+require 'hashie'
+require 'logger'
+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
+
+  class << self
+    def logger
+      @logger ||= (
+        logger = Logger.new(STDOUT)
+        logger.level = Logger.const_get(ENV.fetch('LOG_LEVEL', 'INFO'))
+        logger
+      )
+    end
+
+    def stack(name, **scope, &block)
+      s = Stack.new(name, **scope, &block)
+      @stacks << s
+      s
+    end
+
+    def config(override = {})
+      config = Config.new
+      override = Config[override]
+
+      config = config.read_config_file
+
+      # Merge DEFAULTS < .yutani.yml < override
+      Config.from(config.merge(override))
+    end
+
+    def build_from_file(file)
+      Yutani.entry_path = file
+
+      instance_eval(File.read(file), file)
+
+      unless stacks.empty?
+        stacks.each {|s| s.to_fs}
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: yutani
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Louis Garman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.3
+- !ruby/object:Gem::Dependency
+  name: hiera
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.1
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+- !ruby/object:Gem::Dependency
+  name: guard-yield
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+description: Generates JSON for Terraform
+email: louisgarman+yutani@gmail.com
+executables:
+- yutani
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/install-terraform.sh
+- bin/yutani
+- lib/yutani.rb
+- lib/yutani/cli.rb
+- lib/yutani/config.rb
+- 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
+- lib/yutani/version.rb
+homepage: https://github.com/leg100/yutani
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.3'
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Terraform DSL
+test_files: []