terraform_dsl 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5ba050edd5f77df1afad2a171fe81b140f1ad09
+  data.tar.gz: eb7d97ed6e27a68abac7a3c63607f67c6c12da0f
+SHA512:
+  metadata.gz: 2b9e2eda30ddc8943012088c07bb53718daba7ac23a3aaebe3233c528ee39e732dc0fa8ca681d5b3386209a3d3c53e70605cad60eb53c267963dfe688274830f
+  data.tar.gz: 8b1eda39d07c1921b212ea16e197d42ef2c8d9e87451b0ebb4f1ada4dc38c252d936862769ce3f18f2603c6c52e7b79b193440caaf8b05cb037b10f4d46aa110

data/lib/tasks/tasks.rb

@@ -0,0 +1,12 @@
+require 'rake'
+
+module Terraform
+  # Loads all rake tasks when terraform_dsl is included by a rake script
+  class Tasks
+    def self.loadall
+      Dir.glob("#{File.join(File.dirname(__dir__), 'tasks')}/*.rake").each { |r| load r }
+      template_path = ENV['TERRAFORM_TEMPLATE_PATH'] || 'templates'
+      Dir.glob("#{File.join(Dir.pwd,template_path)}/*.rb").each { |t| require_relative t }
+    end
+  end
+end

data/lib/tasks/terraform.rake

@@ -0,0 +1,126 @@
+require_relative '../terraform_dsl.rb'
+namespace 'terraform' do
+  desc 'Loads available stack modules'
+  task :load do
+    Terraform::Stacks.load
+  end
+
+  desc 'Initialize stacks.yml if it does not exist'
+  task :init do
+    Terraform::Stacks.init
+  end
+
+  desc 'Fetch modules for a stack'
+  task :get, [:name] => :load do |_t, args|
+    stack = Terraform::Stacks.stacks[args[:name]]
+    stack.get
+  end
+
+  desc 'Fetch modules for all stacks'
+  task get_all: :load do
+    Terraform::Stacks.stacks.each do |_name, stack|
+      stack.get
+    end
+  end
+
+  desc 'List all available stacks'
+  task list: :load do
+    Terraform::Stacks.stacks.each do |name, _stack|
+      puts name
+    end
+  end
+
+  desc 'Show details about a stack by name'
+  task :show, [:name] => :load do |_t, args|
+    fail 'Specify a name' unless args[:name]
+    stack = Terraform::Stacks.stacks[args[:name]]
+    puts stack
+    stack.plan
+  end
+
+  desc 'Show all pending stack changes'
+  task show_all: [:load, :get_all] do
+    Terraform::Stacks.stacks.each do |_name, stack|
+      puts stack
+      stack.plan
+    end
+  end
+
+  desc 'Show pending changes for a stack'
+  task :plan, [:name] => :load do |_t, args|
+    fail 'Specify a name' unless args[:name]
+    stack = Terraform::Stacks.stacks[args[:name]]
+    stack.plan
+  end
+
+  desc 'Apply pending changes for a stack'
+  task :apply, [:name] => :load do |_t, args|
+    fail 'Specify a name' unless args[:name]
+    stack = Terraform::Stacks.stacks[args[:name]]
+    stack.apply
+  end
+
+  desc 'Apply all pending stack changes'
+  task apply_all: :load do
+    Terraform::Stacks.stacks.each do |_name, stack|
+      puts stack
+      stack.apply
+    end
+  end
+
+  desc 'Destroy a stack'
+  task :destroy, [:name] => :load do |_t, args|
+    fail 'Specify a name' unless args[:name]
+    stack = Terraform::Stacks.stacks[args[:name]]
+    stack.destroy
+  end
+
+  desc 'Push stack state to remote location'
+  task :push, [:name] => [:load, :remote_config] do |_t, args|
+    stack = Terraform::Stacks.stacks[args[:name]]
+    stack.push
+  end
+
+  desc 'Push stack states to remote location'
+  task push_all: [:load, :remote_config_all] do
+    Terraform::Stacks.stacks.each do |_name, stack|
+      puts stack
+      stack.push
+    end
+  end
+
+  desc 'Pulls stack state from remote location'
+  task :pull, [:name] => [:load, :remote_config] do |_t, args|
+    stack = Terraform::Stacks.stacks[args[:name]]
+    stack.pull
+  end
+
+  desc 'Pulls stack states from remote location'
+  task pull_all: [:load, :remote_config_all] do
+    Terraform::Stacks.stacks.each do |_name, stack|
+      puts stack
+      stack.pull
+    end
+  end
+
+  desc 'Sets up remote config for a stack'
+  task :remote_config, [:name] => [:load] do |_t, args|
+    stack = Terraform::Stacks.stacks[args[:name]]
+    stack.remote_config
+  end
+
+  desc 'Sets up remote config for all stacks that support it'
+  task remote_config_all: :load do
+    Terraform::Stacks.stacks.each do |_name, stack|
+      puts stack
+      stack.remote_config
+    end
+  end
+
+  desc 'Generate a UUID for a stack, so stacks do not clobber each other'
+  task :uuid do
+    uuid = Terraform::Stacks.uuid
+    puts "uuid: #{uuid}"
+    puts 'Add this as a field to a new stack to prevent clobbering stacks with the same name'
+  end
+end

data/lib/terraform_dsl.rb

@@ -0,0 +1,4 @@
+require_relative 'terraform_dsl/stack.rb'
+require_relative 'terraform_dsl/stacks.rb'
+require_relative 'terraform_dsl/stack_module.rb'
+require_relative 'tasks/tasks.rb' if defined? Rake

data/lib/terraform_dsl/aws/remote_s3.rb

@@ -0,0 +1,20 @@
+module Terraform
+  module Aws
+    # Support AWS S3 remote state backend
+    module Remote_S3
+      private
+
+      def options_for_s3(command)
+        options = ''
+        options = "-backend=s3 #{config_opts_s3}" if command == :config
+        "terraform remote #{command} #{options}"
+      end
+
+      def config_opts_s3
+        config = "-backend-config='key=#{@stack.stack_id}' "
+        config += @stack.remote['s3'].map { |k, v| "-backend-config='#{k}=#{v}'" }.join(' ')
+        config
+      end
+    end
+  end
+end

data/lib/terraform_dsl/aws/tagging.rb

@@ -0,0 +1,23 @@
+module Terraform
+  # Aws provider-specific functionality, to be mixed in to stack elements
+  module Aws
+    def self.taggable?(resource_type)
+      supports_tagging = [:aws_autoscaling_group, :aws_customer_gateway,
+                          :aws_db_instance, :aws_elasticache_cluster,
+                          :aws_elb, :aws_instance, :aws_internet_gateway,
+                          :aws_network_acl, :aws_network_interface, :aws_route53_zone,
+                          :aws_route_table, :aws_s3_bucket, :aws_security_group,
+                          :aws_subnet, :aws_vpc, :aws_vpc_dhcp_options,
+                          :aws_vpc_peering_connection, :aws_vpn_connection,
+                          :aws_vpn_gateway]
+      supports_tagging.include?(resource_type.to_sym)
+    end
+
+    # Tag all resources (that support tagging) that we created with this stack id
+    def post_processing_aws
+      return unless Aws.taggable?(@resource_type)
+      @fields[:tags] ||= {}
+      @fields[:tags][:terraform_stack_id] = var(:terraform_stack_id)
+    end
+  end
+end

data/lib/terraform_dsl/command.rb

@@ -0,0 +1,58 @@
+module Terraform
+  # Wraps terraform command execution
+  class Command
+    attr_accessor :command
+
+    def initialize(stack, command)
+      @stack = stack
+      @command = options_for(command)
+      prepare
+    end
+
+    def env
+      vars = {}
+      @stack.variables.each { |k, v| vars["TF_VAR_#{k}"] = v[:default] }
+      @stack.module.secrets.each do |_provider, secrets|
+        secrets.each do |k, v|
+          vars[k.to_s] = v
+        end
+      end
+      vars
+    end
+
+    def execute
+      Process.waitpid(spawn(env, @command, chdir: @stack.stack_dir))
+      fail 'Command failed' unless $CHILD_STATUS.to_i == 0
+    end
+
+    protected
+
+    def prepare
+      FileUtils.mkdir_p(@stack.stack_dir)
+      File.open(File.join(@stack.stack_dir, 'terraform.tf.json'), 'w') { |f| f.write(generate) }
+    end
+
+    def options_for(cmd)
+      options = begin
+        case cmd
+        when :apply
+          '-input=false'
+        when :destroy
+          '-input=false -force'
+        when :plan
+          '-input=false -module-depth=-1'
+        when :graph
+          '-draw-cycles'
+        else
+          ''
+        end
+      end
+
+      "terraform #{cmd} #{options}"
+    end
+
+    def generate
+      @stack.module.generate
+    end
+  end
+end

data/lib/terraform_dsl/module.rb

@@ -0,0 +1,36 @@
+require_relative 'stack_element'
+require_relative 'stack_modules'
+require_relative 'stack_module'
+require_relative 'stacks'
+
+module Terraform
+  class Module < StackElement
+    def initialize(parent_module, module_name, &block)
+      super(parent_module, &block)
+
+      if @fields[:source].match(/^module_/)
+        build_submodule(parent_module, module_name)
+      end
+    end
+
+  private
+
+    def build_submodule(parent_module, module_name)
+      generated = generate_child_module(parent_module)
+      module_path = File.join(Stacks.dir, parent_module.id, module_name.to_s)
+      FileUtils.mkdir_p(module_path)
+      File.open(File.join(module_path, 'stack_module.tf.json'),'w') { |f| f.write(generated) }
+      @fields[:source] = File.expand_path(module_path)
+    end
+
+    def generate_child_module(parent_module)
+      variables = @fields.clone
+      variables.delete(:source)
+      variables[:terraform_stack_id] = parent_module.id
+      child_name = @fields[:source].gsub(/^module_/,'')
+      child_module = StackModules.get(child_name)
+      child_module.build(variables)
+      child_module.generate
+    end
+  end
+end

data/lib/terraform_dsl/output.rb

@@ -0,0 +1,6 @@
+require_relative 'stack_element.rb'
+
+module Terraform
+  class Output < StackElement
+  end
+end

data/lib/terraform_dsl/provider.rb

@@ -0,0 +1,13 @@
+require_relative 'secrets.rb'
+require_relative 'stack_element.rb'
+
+module Terraform
+  # Implements DSL for a terraform provider, and a means of loading secrets.
+  class Provider < StackElement
+    def load_secrets(name)
+      @secrets ||= {}
+      @secrets[name.to_sym] = SECRETS[name.to_sym]
+      @secrets
+    end
+  end
+end

data/lib/terraform_dsl/remote.rb

@@ -0,0 +1,29 @@
+require_relative 'aws/remote_s3.rb'
+
+module Terraform
+  class Remote < Command
+    class RemoteNotSupported < Exception; end
+    include Aws::Remote_S3
+    def initialize(stack, command)
+      super
+      unless @stack.remote.first
+        puts "\tWARNING: #{@stack.name} is not configured with a remote backend"
+        return
+      end
+
+      backend = @stack.remote.keys.first
+      sym = "options_for_#{backend}"
+
+      if self.respond_to?(sym, include_private: true)
+        @command = send(sym, command)
+      else
+        fail RemoteNotSupported, "Remote backend #{backend} is not supported yet"
+      end
+    end
+
+    def execute
+      return unless @stack.remote.first
+      super
+    end
+  end
+end

data/lib/terraform_dsl/resource.rb

@@ -0,0 +1,44 @@
+require_relative 'stack_element.rb'
+
+module Terraform
+  # Defines a terraform resource
+  class Resource < StackElement
+    attr_reader :resource_name
+
+    def initialize(parent_module, resource_name, resource_type, &block)
+      @resource_name = resource_name
+      @resource_type = resource_type
+      super(parent_module, &block)
+
+      # Allow provider specific post processing
+      sym = "post_processing_#{resource_type.split('_').first}"
+      send(sym) if self.respond_to?(sym, include_private: true)
+    end
+
+    # Allow provisioner blocks to be nested within resources
+    def provisioner(provisioner_type, &block)
+      provisioner_type = provisioner_type.to_sym
+
+      @fields[:provisioner] = @fields[:provisioner] || []
+
+      provisioner_set = Provisioner.new(@module, &block)
+      @fields[:provisioner] << { cleanup_provisioner_type(provisioner_type) => provisioner_set.fields }
+    end
+
+    private
+
+    def cleanup_provisioner_type(provisioner_type)
+      case provisioner_type.to_sym
+      when :remote_exec
+        'remote-exec'
+      when :local_exec
+        'local-exec'
+      else
+        provisioner_type
+      end
+    end
+  end
+  # Defines a terraform resource provisioner
+  class Provisioner < StackElement
+  end
+end

data/lib/terraform_dsl/secrets.rb

@@ -0,0 +1,29 @@
+require 'json'
+require 'open3'
+
+# Load and provide access to secrets required by terraform providers
+class SecretHash < Hash
+  class SecretNotFound < Exception; end
+
+  def initialize
+    super { |_secrets, key| fail SecretNotFound, "Secret `#{key}` not found" }
+  end
+end
+
+if ENV['TERRAFORM_ENV'] == 'test'
+  SECRETS ||= {
+    aws: {
+      access_key_id: 'foo',
+      secret_access_key: 'bar'
+    }
+  }
+else
+  SECRETS ||= begin
+    secrets_file = File.expand_path(ENV['CONFIG_PATH'] || 'config/secrets.json')
+    if File.exist?(secrets_file)
+      JSON.parse(File.read(secrets_file), symbolize_names: true, object_class: SecretHash)
+    else
+      {}
+    end
+  end
+end

data/lib/terraform_dsl/stack.rb

@@ -0,0 +1,79 @@
+require_relative 'stacks'
+require_relative 'stack_modules'
+require_relative 'command'
+require_relative 'remote'
+
+module Terraform
+  # Wrapper to instantiate a stack from a yaml definition
+  class Stack
+    class MalformedConfig < Exception; end
+    class << self
+      def load(config)
+        fail MalformedConfig, "Configuration malformed at #{config}" unless config.is_a?(Hash)
+        fail MalformedConfig, "A name must be specified for the stack #{config}" unless config.key?('name')
+        fail MalformedConfig, 'You must specify a uuid. Get one from rake uuid and add it to the config' unless config.key?('uuid')
+        new(config)
+      end
+    end
+
+    attr_reader :name, :description, :module,
+                :stack_dir, :stack_id, :remote
+
+    def initialize(config)
+      @name = config['name']
+      @uuid = config['uuid']
+      @description = config['description'] || ''
+      @variables = config['variables'] || {}
+      @remote = config['remote'] || {}
+      @stack_id = "terraform_#{@name}_#{@uuid}"
+      @module = StackModules.get(config['root'])
+      @variables['terraform_stack_id'] = @stack_id
+      @stack_dir = File.join(Stacks.dir, @stack_id)
+      @module.build(@variables.map { |k, v| [k.to_sym, v] }.to_h)
+    end
+
+    def apply
+      Command.new(self, :apply).execute
+    end
+
+    def destroy
+      Command.new(self, :destroy).execute
+    end
+
+    def plan
+      Command.new(self, :plan).execute
+    end
+
+    def get
+      Command.new(self, :get).execute
+    end
+
+    def show
+      Command.new(self, :show).execute
+    end
+
+    def pull
+      Remote.new(self, :pull).execute
+    end
+
+    def push
+      Remote.new(self, :pull).execute
+    end
+
+    def remote_config
+      Remote.new(self, :config).execute
+    end
+
+    def variables
+      @module.variables
+    end
+
+    def to_s
+      <<-eos
+Name: #{@name}
+Description: #{@description}
+Stack Directory: #{@stack_dir}
+      eos
+    end
+  end
+end

data/lib/terraform_dsl/stack_element.rb

@@ -0,0 +1,62 @@
+require_relative 'aws/tagging.rb'
+
+module Terraform
+  # Defines a single terraform stack element, subclass for any element defined in terraform DSL
+  class StackElement
+    include Aws
+    attr_reader :fields
+
+    def initialize(stack_module, &block)
+      @module = stack_module
+      @fields = {}
+      instance_eval(&block)
+    end
+
+    private
+
+    # Allows resource attributes to be specified with a nice syntax
+    # If the method is implemented, it will be treated as a nested resource
+    def method_missing(method_name, *args, &block)
+      symbol = method_name.to_sym
+      if args.length == 1
+        if args[0].nil?
+          fail "Passed nil to '#{method_name}'. Generally disallowed, subclass StackElement if you need this."
+        end
+        add_field(symbol, args[0])
+      else
+        add_field(symbol, Terraform::StackElement.new(@module, &block).fields)
+      end
+    end
+
+    # Get the runtime value of a variable
+    def get(variable_name)
+      @module.get(variable_name)
+    end
+
+    # Reference a variable
+    def var(variable_name)
+      "${var.#{variable_name}}"
+    end
+
+    # Syntax to handle interpolation of resource variables
+    def value_of(resource_type, resource_name, value_type)
+      "${#{resource_type}.#{resource_name}.#{value_type}}"
+    end
+
+    # Shorthand to interpolate the ID of another resource
+    def id_of(resource_type, resource_name)
+      value_of(resource_type, resource_name, :id)
+    end
+
+    def add_field(symbol, value)
+      existing = @fields[symbol]
+      if existing
+        # If it's already an array, just push to it
+        @fields[symbol] = [existing] unless existing.is_a?(Array)
+        @fields[symbol] << value
+      else
+        @fields[symbol] = value
+      end
+    end
+  end
+end

data/lib/terraform_dsl/stack_module.rb

@@ -0,0 +1,123 @@
+require 'json'
+require 'fileutils'
+
+require_relative 'stack_modules.rb'
+require_relative 'resource.rb'
+require_relative 'provider.rb'
+require_relative 'variable.rb'
+require_relative 'module.rb'
+require_relative 'output.rb'
+
+module Terraform
+
+  class StackModule
+
+    class << self
+      def define(name, &block)
+        template = self.new(name, &block)
+        StackModules.register(name, template)
+      end
+
+      def flatten_variable_arrays(variables)
+        variables.map do |k,v|
+          if v.is_a?(Hash) && v.key?(:default) && v[:default].is_a?(Array)
+            v[:default] = v[:default].join(',')
+          elsif v.is_a?(Array)
+            v = v.join(',')
+          end
+          [k, v]
+        end.to_h
+      end
+
+    end
+
+    attr_accessor :secrets
+
+    def initialize(name, &block)
+      @stack_elements = { resource: {}, provider: {}, variable: {}, output: {}, module: {} }
+      @secrets = {}
+      @block = block
+      variable(:terraform_stack_id) {}
+    end
+
+    def clone
+      b = @block
+      StackModule.new(@name, &b)
+    end
+
+    def build(**kwargs)
+      vars = kwargs.map{ |k, v| [k, {default: v}] }.to_h
+      @stack_elements[:variable].merge!(vars)
+      b = @block
+      instance_eval(&b)
+    end
+
+    def generate
+      JSON.pretty_generate(elements)
+    end
+
+    def variables
+      elements[:variable]
+    end
+
+    def outputs
+      @stack_elements[:output]
+    end
+
+    def get(variable)
+      @stack_elements[:variable].fetch(variable)[:default]
+    end
+
+    def elements
+      elements = @stack_elements.clone
+      variables = StackModule.flatten_variable_arrays(@stack_elements[:variable])
+      @stack_elements[:module].each do |mod, data|
+        elements[:module][mod] = StackModule.flatten_variable_arrays(data)
+      end
+      elements[:variable] = variables
+      elements
+    end
+
+    def id
+      get(:terraform_stack_id)
+    end
+
+  private
+
+    def register_resource(resource_type, name, &block)
+      @stack_elements[:resource] ||= {}
+      @stack_elements[:resource][resource_type.to_sym] ||= {}
+      @stack_elements[:resource][resource_type.to_sym][name.to_sym] = Terraform::Resource.new(self, name, resource_type, &block).fields
+    end
+
+    def register_variable(name, &block)
+      new_variable = Terraform::Variable.new(self, &block).fields
+      unless @stack_elements[:variable].key?(name.to_sym)
+        @stack_elements[:variable][name.to_sym] = { default: new_variable[:default] || '' }
+      end
+    end
+
+    def register_output(name, &block)
+      new_output = Terraform::Output.new(self, &block).fields
+      @stack_elements[:output][name.to_sym] = new_output
+    end
+
+    def register_module(name, &block)
+      new_module = Terraform::Module.new(self, name, &block).fields
+      @stack_elements[:module][name.to_sym] = new_module
+    end
+
+    def register_provider(name, &block)
+      provider = Terraform::Provider.new(self, &block)
+      @secrets.merge!(provider.load_secrets(name))
+      @stack_elements[:provider][name.to_sym] = provider.fields
+    end
+
+    alias_method :resource, :register_resource
+    alias_method :variable, :register_variable
+    alias_method :provider, :register_provider
+    alias_method :output,   :register_output
+    alias_method :submodule,    :register_module
+
+  end
+end

data/lib/terraform_dsl/stack_modules.rb

@@ -0,0 +1,24 @@
+module Terraform
+  # Stack module factory, register a module and provide clones of it
+  class StackModules
+    class ModuleNotFound < StandardError; end
+    class ModuleAlreadyRegistered < StandardError; end
+
+    class << self
+      def register(name, stack_module)
+        fail ModuleAlreadyRegistered, "#{name} is already a registered stack_module" if @stack_modules.key?(name.downcase)
+        @stack_modules[name.downcase] = stack_module
+      end
+
+      def get(stack_module_name)
+        fail ModuleNotFound, "#{stack_module_name} module module not found" unless @stack_modules.key?(stack_module_name.downcase)
+        @stack_modules[stack_module_name.downcase].clone
+      end
+
+      def reset!
+        @stack_modules ||= {}
+      end
+    end
+    reset!
+  end
+end

data/lib/terraform_dsl/stacks.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+require 'securerandom'
+
+require_relative 'stack.rb'
+
+module Terraform
+  # Singleton to keep track of stack templates
+  class Stacks
+    class MalformedConfig < StandardError; end
+    class << self
+      attr_reader :stacks
+
+      def load
+        config = ENV['STACK_CONFIG'] || 'stacks.yml'
+        fail 'stacks.yml must exist in root directory, or specify STACK_CONFIG pointing to stacks.yml' unless File.exist?(config)
+        stack_specs = YAML.load(File.read(config))
+        fail MalformedConfig, 'Stacks must be an array' unless stack_specs.key?('stacks') && stack_specs['stacks'].is_a?(Array)
+        common = stack_specs['common'] || {}
+        stack_specs['stacks'].each do |stack_spec|
+          stack = Stack.load(stack_spec.merge(common))
+          @stacks[stack.name] = stack
+        end
+      end
+
+      def init
+        config = ENV['STACK_CONFIG'] || 'stacks.yml'
+        fail "stacks.yaml already exists at #{File.expand_path(config)}" if File.exist?(config)
+        File.open(config,'w') do |f|
+          f.write(YAML.dump(base_config))
+        end
+      end
+
+      def uuid
+        "#{Time.now.utc.to_i}_#{SecureRandom.urlsafe_base64(6)}"
+      end
+
+      def base_config
+        {
+          'common' => {},
+          'stacks' => [ base_stack_config ],
+        }
+      end
+
+      def base_stack_config
+        {
+          'name' => 'SET_NAME',
+          'uuid' => uuid,
+          'description' => 'SET_A_DESCRIPTION',
+          'root' => 'SET_A_TEMPLATE',
+          'variables' => {},
+        }
+      end
+
+      def reset!
+        @stacks ||= {}
+      end
+
+      def dir
+        File.expand_path(File.join(ENV['TERRAFORM_DATA_DIR'] || 'data', 'stacks'))
+      end
+    end
+    reset!
+  end
+end

data/lib/terraform_dsl/variable.rb

@@ -0,0 +1,6 @@
+require_relative 'stack_element.rb'
+
+module Terraform
+  class Variable < StackElement
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: terraform_dsl
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Dale Hamel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: Terraform DSL provides a syntax for managing terraform infrastructure
+  entirely in git
+email: dale.hamel@srvthe.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tasks/tasks.rb
+- lib/tasks/terraform.rake
+- lib/terraform_dsl.rb
+- lib/terraform_dsl/aws/remote_s3.rb
+- lib/terraform_dsl/aws/tagging.rb
+- lib/terraform_dsl/command.rb
+- lib/terraform_dsl/module.rb
+- lib/terraform_dsl/output.rb
+- lib/terraform_dsl/provider.rb
+- lib/terraform_dsl/remote.rb
+- lib/terraform_dsl/resource.rb
+- lib/terraform_dsl/secrets.rb
+- lib/terraform_dsl/stack.rb
+- lib/terraform_dsl/stack_element.rb
+- lib/terraform_dsl/stack_module.rb
+- lib/terraform_dsl/stack_modules.rb
+- lib/terraform_dsl/stacks.rb
+- lib/terraform_dsl/variable.rb
+homepage: https://rubygems.org/gems/terraform_dsl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Wrap hashicorps "terraform" in a ruby DSL for managing stack templates
+test_files: []
+has_rdoc: