terrafying 1.7.4 → 1.7.9

data/lib/terrafying/cli.rb

@@ -1,70 +1,72 @@
+# frozen_string_literal: true
+
 require 'thor'
 
 module Terrafying
   class Cli < Thor
-    class_option :lock_timeout, :type => :string, :default => nil
-    class_option :no_lock, :type => :boolean, :default => false
-    class_option :keep, :type => :boolean, :default => false
-    class_option :target, :type => :string, :default => nil
-    class_option :scope, :type => :string, :default => nil
-    class_option :dynamodb, :type => :boolean, :default => true
+    class_option :lock_timeout, type: :string, default: nil
+    class_option :no_lock, type: :boolean, default: false
+    class_option :keep, type: :boolean, default: false
+    class_option :target, type: :string, default: nil
+    class_option :scope, type: :string, default: nil
+    class_option :dynamodb, type: :boolean, default: true
 
-    desc "list PATH", "List resources defined"
+    desc 'list PATH', 'List resources defined'
     def list(path)
       puts "Defined resources:\n\n"
       Config.new(path, options).list.each do |name|
-        puts "#{name}"
+        puts name.to_s
       end
     end
 
-    desc "plan PATH", "Show execution plan"
+    desc 'plan PATH', 'Show execution plan'
     def plan(path)
       exit Config.new(path, options).plan
     end
 
-    desc "graph PATH", "Show execution graph"
+    desc 'graph PATH', 'Show execution graph'
     def graph(path)
       exit Config.new(path, options).graph
     end
 
-    desc "validate PATH", "Validate the generated Terraform"
+    desc 'validate PATH', 'Validate the generated Terraform'
     def validate(path)
       exit Config.new(path, options).validate
     end
 
-    desc "apply PATH", "Apply changes to resources"
-    option :force, :aliases => ['f'], :type => :boolean, :desc => "Forcefully remove any pending locks"
+    desc 'apply PATH', 'Apply changes to resources'
+    option :force, aliases: ['f'], type: :boolean, desc: 'Forcefully remove any pending locks'
     def apply(path)
       exit Config.new(path, options).apply
     end
 
-    desc "destroy PATH", "Destroy resources"
-    option :force, :aliases => ['f'], :type => :boolean, :desc => "Forcefully remove any pending locks"
+    desc 'destroy PATH', 'Destroy resources'
+    option :force, aliases: ['f'], type: :boolean, desc: 'Forcefully remove any pending locks'
     def destroy(path)
       exit Config.new(path, options).destroy
     end
 
-    desc "json PATH", "Show terraform JSON"
+    desc 'json PATH', 'Show terraform JSON'
     def json(path)
       puts(Config.new(path, options).json)
     end
 
-    desc "show-state PATH", "Show state"
+    desc 'show-state PATH', 'Show state'
     def show_state(path)
       puts(Config.new(path, options).show_state)
     end
 
-    desc "use-remote-state PATH", "Migrate to using remote state storage"
+    desc 'use-remote-state PATH', 'Migrate to using remote state storage'
     def use_remote_state(path)
       puts(Config.new(path, options).use_remote_state)
     end
 
-    desc "use-local-state PATH", "Migrate to using local state storage"
+    desc 'use-local-state PATH', 'Migrate to using local state storage'
     def use_local_state(path)
       puts(Config.new(path, options).use_local_state)
     end
 
-    desc "import PATH ADDR ID", "Import existing infrastructure into your Terraform state"
+    desc 'import PATH ADDR ID', 'Import existing infrastructure into your Terraform state'
     def import(path, addr, id)
       exit Config.new(path, options).import(addr, id)
     end

data/lib/terrafying/dynamodb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aws-sdk-dynamodb'
 require 'json'
 require 'securerandom'
@@ -9,7 +11,7 @@ class ::Aws::DynamoDB::Client
     begin
       yield block
     rescue ::Aws::DynamoDB::Errors::ResourceNotFoundException => e
-      if not retried
+      if !retried
         create_table(table_spec)
         retry
       else
@@ -22,10 +24,10 @@ end
 module Terrafying
   module DynamoDb
     def self.client
-      @@client ||= ::Aws::DynamoDB::Client.new({
-        region: Terrafying::Context::REGION,
-        #endpoint: 'http://localhost:8000',
-      })
+      @@client ||= ::Aws::DynamoDB::Client.new(
+        region: Terrafying::Context::REGION
+        # endpoint: 'http://localhost:8000',
+      )
     end
   end
 end

data/lib/terrafying/dynamodb/config.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 module Terrafying
   module DynamoDb
     class Config
       attr_accessor :state_table, :lock_table
-      
+
       def initialize
-        @state_table = "terrafying-state"
-        @lock_table = "terrafying-state-lock"
+        @state_table = 'terrafying-state'
+        @lock_table = 'terrafying-state-lock'
       end
     end
-    
+
     def config
       @config ||= Config.new
     end
     module_function :config
   end
-end
+end

data/lib/terrafying/dynamodb/named_lock.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'terrafying/dynamodb'
 require 'terrafying/dynamodb/config'
 
@@ -12,18 +14,18 @@ module Terrafying
 
       def status
         @client.ensure_table(table) do
-          resp = @client.get_item({
+          resp = @client.get_item(
             table_name: @table_name,
             key: {
-              "name" => @name,
+              'name' => @name
             },
-            consistent_read: true,
-          })
+            consistent_read: true
+          )
           if resp.item
             return {
               status: :locked,
-              locked_at: resp.item["locked_at"],
-              metadata: resp.item["metadata"]
+              locked_at: resp.item['locked_at'],
+              metadata: resp.item['metadata']
             }
           else
             return {
@@ -32,92 +34,87 @@ module Terrafying
           end
         end
       end
-      
+
       def acquire
         @client.ensure_table(table) do
-          begin
-            lock_id = SecureRandom.uuid
-            @client.update_item(acquire_request(lock_id))
-            return lock_id
-          rescue ::Aws::DynamoDB::Errors::ConditionalCheckFailedException
-            raise "Unable to acquire lock: #{status.inspect}" # TODO
-          end
+          lock_id = SecureRandom.uuid
+          @client.update_item(acquire_request(lock_id))
+          return lock_id
+        rescue ::Aws::DynamoDB::Errors::ConditionalCheckFailedException
+          raise "Unable to acquire lock: #{status.inspect}" # TODO
         end
       end
 
       def steal
         @client.ensure_table(table) do
-          begin
-            lock_id = SecureRandom.uuid
-            req = acquire_request(lock_id)
-            req.delete(:condition_expression)
-            @client.update_item(req)
-            return lock_id
-          rescue ::Aws::DynamoDB::Errors::ConditionalCheckFailedException
-            raise "Unable to steal lock: #{status.inspect}" # TODO
-          end
+          lock_id = SecureRandom.uuid
+          req = acquire_request(lock_id)
+          req.delete(:condition_expression)
+          @client.update_item(req)
+          return lock_id
+        rescue ::Aws::DynamoDB::Errors::ConditionalCheckFailedException
+          raise "Unable to steal lock: #{status.inspect}" # TODO
         end
       end
-      
+
       def release(lock_id)
         @client.ensure_table(table) do
-          begin
-            @client.delete_item({
-              table_name: @table_name,
-              key: {
-                "name" => @name,
-              },
-              return_values: "NONE",
-              condition_expression: "lock_id = :lock_id",
-              expression_attribute_values: {
-                ":lock_id" => lock_id,
-              },
-            })
-            nil
-          rescue ::Aws::DynamoDB::Errors::ConditionalCheckFailedException
-            raise "Unable to release lock: #{status.inspect}" # TODO
-          end
+          @client.delete_item(
+            table_name: @table_name,
+            key: {
+              'name' => @name
+            },
+            return_values: 'NONE',
+            condition_expression: 'lock_id = :lock_id',
+            expression_attribute_values: {
+              ':lock_id' => lock_id
+            }
+          )
+          nil
+        rescue ::Aws::DynamoDB::Errors::ConditionalCheckFailedException
+          raise "Unable to release lock: #{status.inspect}" # TODO
         end
       end
 
       private
+
       def acquire_request(lock_id)
         {
           table_name: @table_name,
           key: {
-            "name" => @name,
+            'name' => @name
           },
-          return_values: "NONE",
-          update_expression: "SET lock_id = :lock_id, locked_at = :locked_at, metadata = :metadata",
-          condition_expression: "attribute_not_exists(lock_id)",
+          return_values: 'NONE',
+          update_expression: 'SET lock_id = :lock_id, locked_at = :locked_at, metadata = :metadata',
+          condition_expression: 'attribute_not_exists(lock_id)',
           expression_attribute_values: {
-            ":lock_id" => lock_id,
-            ":locked_at" => Time.now.to_s,
-            ":metadata" => {
-              "owner" => "#{`git config user.name`.chomp} (#{`git config user.email`.chomp})",
-            },
-          },
+            ':lock_id' => lock_id,
+            ':locked_at' => Time.now.to_s,
+            ':metadata' => {
+              'owner' => "#{`git config user.name`.chomp} (#{`git config user.email`.chomp})"
+            }
+          }
         }
       end
-      
+
       def table
         {
           table_name: @table_name,
           attribute_definitions: [
             {
-              attribute_name: "name",
-              attribute_type: "S",
-            },
+              attribute_name: 'name',
+              attribute_type: 'S'
+            }
           ],
           key_schema: [
             {
-              attribute_name: "name",
-              key_type: "HASH",
-            },
+              attribute_name: 'name',
+              key_type: 'HASH'
+            }
           ],
           provisioned_throughput: {
             read_capacity_units: 1,
-            write_capacity_units: 1,
+            write_capacity_units: 1
           }
         }
       end

data/lib/terrafying/dynamodb/state.rb

@@ -1,31 +1,33 @@
+# frozen_string_literal: true
+
 require 'digest'
 require 'terrafying/dynamodb/config'
 
 module Terrafying
   module DynamoDb
     class StateStore
-      def initialize(scope, opts = {})
+      def initialize(scope, _opts = {})
         @scope = scope
         @client = Terrafying::DynamoDb.client
         @table_name = Terrafying::DynamoDb.config.state_table
       end
-      
+
       def get
         @client.ensure_table(table) do
-          resp = @client.query({
+          resp = @client.query(
             table_name: @table_name,
             limit: 1,
             key_conditions: {
-              "scope" => {
+              'scope' => {
                 attribute_value_list: [@scope],
-                comparison_operator: "EQ",
+                comparison_operator: 'EQ'
               }
             },
-            scan_index_forward: false,
-          })
+            scan_index_forward: false
+          )
           case resp.items.count
           when 0 then return nil
-          when 1 then return resp.items.first["state"]
+          when 1 then return resp.items.first['state']
           else raise 'More than one item found when retrieving state. This is a bug and should never happen.' if resp.items.count != 1
           end
         end
@@ -35,58 +37,56 @@ module Terrafying
         @client.ensure_table(table) do
           sha256 = Digest::SHA256.hexdigest(state)
           json = JSON.parse(state)
-          @client.update_item({
+          @client.update_item(
             table_name: @table_name,
             key: {
-              "scope" => @scope,
-              "serial" => json["serial"].to_i,
+              'scope' => @scope,
+              'serial' => json['serial'].to_i
             },
-            return_values: "NONE",
-            update_expression: "SET sha256 = :sha256, #state = :state",
-            condition_expression: "attribute_not_exists(serial) OR sha256 = :sha256",
+            return_values: 'NONE',
+            update_expression: 'SET sha256 = :sha256, #state = :state',
+            condition_expression: 'attribute_not_exists(serial) OR sha256 = :sha256',
             expression_attribute_names: {
-              "#state" => "state",
+              '#state' => 'state'
             },
             expression_attribute_values: {
-              ":sha256" => sha256,
-              ":state" => state,
+              ':sha256' => sha256,
+              ':state' => state
             }
-          })
+          )
         end
       end
-      
+
       def table
         {
           table_name: @table_name,
           attribute_definitions: [
             {
-              attribute_name: "scope",
-              attribute_type: "S",
+              attribute_name: 'scope',
+              attribute_type: 'S'
             },
             {
-              attribute_name: "serial",
-              attribute_type: "N",
+              attribute_name: 'serial',
+              attribute_type: 'N'
             }
           ],
           key_schema: [
             {
-              attribute_name: "scope",
-              key_type: "HASH",
+              attribute_name: 'scope',
+              key_type: 'HASH'
             },
             {
-              attribute_name: "serial",
-              key_type: "RANGE",
-            },
-            
+              attribute_name: 'serial',
+              key_type: 'RANGE'
+            }
+
           ],
           provisioned_throughput: {
             read_capacity_units: 1,
-            write_capacity_units: 1,
+            write_capacity_units: 1
           }
         }
       end
     end
   end
 end
-
-

data/lib/terrafying/generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'base64'
 require 'erb'
@@ -6,40 +8,36 @@ require 'deep_merge'
 require 'terrafying/aws'
 
 module Terrafying
-
-  ARG_PLACEHOLDER = "ARG_PLACEHOLDER123"
+  ARG_PLACEHOLDER = 'ARG_PLACEHOLDER123'
 
   class Ref
-
     def fn_call(fn, *args)
-      if args.length == 0
-        args = [ARG_PLACEHOLDER]
-      end
+      args = [ARG_PLACEHOLDER] if args.empty?
       FnRef.new(fn: fn, args: args, ref: self)
     end
 
     def downcase
-      fn_call("lower")
+      fn_call('lower')
     end
 
     def strip
-      fn_call("trimspace")
+      fn_call('trimspace')
     end
 
     def split(separator)
-      fn_call("split", separator, ARG_PLACEHOLDER)
+      fn_call('split', separator, ARG_PLACEHOLDER)
     end
 
-    def slice(idx, length=0)
+    def slice(idx, length = 0)
       if length != 0
-        fn_call("slice", ARG_PLACEHOLDER, idx, idx+length)
+        fn_call('slice', ARG_PLACEHOLDER, idx, idx + length)
       else
-        fn_call("element", ARG_PLACEHOLDER, idx)
+        fn_call('element', ARG_PLACEHOLDER, idx)
       end
     end
 
     def realise
-      ""
+      ''
     end
 
     def to_s
@@ -47,15 +45,15 @@ module Terrafying
     end
 
     def to_str
-      self.to_s
+      to_s
     end
 
     def <=>(other)
-      self.to_s <=> other.to_s
+      to_s <=> other.to_s
     end
 
     def ==(other)
-      self.to_s == other.to_s
+      to_s == other.to_s
     end
 
     def [](key)
@@ -66,18 +64,17 @@ module Terrafying
       end
     end
 
-    def []=(k, v)
+    def []=(_k, _v)
       raise "You can't set a value this way"
     end
-
   end
 
   class RootRef < Ref
     def initialize(
-          kind: :resource,
-          type: "",
-          name:
-        )
+      kind: :resource,
+      type: '',
+      name:
+    )
       @kind = kind
       @type = type
       @name = name
@@ -85,16 +82,14 @@ module Terrafying
 
     def realise
       type = [@type]
-      if @kind != :resource
-        type = [@kind, @type]
-      end
+      type = [@kind, @type] if @kind != :resource
 
-      (type + [@name]).reject(&:empty?).join(".")
+      (type + [@name]).reject(&:empty?).join('.')
     end
 
     def fn_call(fn, *args)
       if @kind == :resource
-        self["id"].fn_call(fn, *args)
+        self['id'].fn_call(fn, *args)
       else
         super
       end
@@ -111,9 +106,9 @@ module Terrafying
 
   class AttributeRef < Ref
     def initialize(
-          ref:,
-          key:
-        )
+      ref:,
+      key:
+    )
       @ref = ref
       @key = key
     end
@@ -125,9 +120,9 @@ module Terrafying
 
   class IndexRef < Ref
     def initialize(
-          ref:,
-          idx:
-        )
+      ref:,
+      idx:
+    )
       @ref = ref
       @idx = idx
     end
@@ -139,10 +134,10 @@ module Terrafying
 
   class FnRef < Ref
     def initialize(
-          ref:,
-          fn:,
-          args: []
-        )
+      ref:,
+      fn:,
+      args: []
+    )
       @ref = ref
       @fn = fn
       @args = args
@@ -150,7 +145,7 @@ module Terrafying
 
     def realise
       ref = @ref.realise
-      args = @args.map { |arg|
+      args = @args.map do |arg|
         if arg == ARG_PLACEHOLDER
           ref
         elsif arg.is_a? String
@@ -158,19 +153,18 @@ module Terrafying
         else
           arg
         end
-      }.join(", ")
+      end.join(', ')
 
       "#{@fn}(#{args})"
     end
   end
 
   class Context
-
-    REGION = ENV.fetch("AWS_REGION", "eu-west-1")
+    REGION = ENV.fetch('AWS_REGION', 'eu-west-1')
 
     PROVIDER_DEFAULTS = {
       aws: { region: REGION }
-    }
+    }.freeze
 
     def self.bundle(&block)
       ctx = Context.new
@@ -182,7 +176,7 @@ module Terrafying
 
     def initialize
       @output = {
-        "resource" => {}
+        'resource' => {}
       }
       @children = []
     end
@@ -195,6 +189,7 @@ module Terrafying
       key = provider_key(name, spec)
       @providers ||= {}
       raise "Duplicate provider configuration detected for #{key}" if key_exists_spec_differs(key, name, spec)
+
       @providers[key] = { name.to_s => spec }
       @output['provider'] = @providers.values
       key
@@ -209,40 +204,52 @@ module Terrafying
     end
 
     def local(name, value)
-      @output["locals"] ||= {}
+      @output['locals'] ||= {}
 
-      raise "Local already exists #{name.to_s}" if @output["locals"].has_key? name.to_s
+      raise "Local already exists #{name}" if @output['locals'].key? name.to_s
 
-      @output["locals"][name.to_s] = value
+      @output['locals'][name.to_s] = value
       RootRef.new(kind: :local, name: name)
     end
 
     def var(name, spec)
-      @output["variable"] ||= {}
+      @output['variable'] ||= {}
 
-      raise "Var already exists #{name.to_s}" if @output["variable"].has_key? name.to_s
+      raise "Var already exists #{name}" if @output['variable'].key? name.to_s
 
-      @output["variable"][name.to_s] = spec
+      @output['variable'][name.to_s] = spec
       RootRef.new(kind: :var, name: name)
     end
 
     def data(type, name, spec)
-      @output["data"] ||= {}
-      @output["data"][type.to_s] ||= {}
+      @output['data'] ||= {}
+      @output['data'][type.to_s] ||= {}
+
+      raise "Data already exists #{type}.#{name}" if @output['data'][type.to_s].key? name.to_s
 
-      raise "Data already exists #{type.to_s}.#{name.to_s}" if @output["data"][type.to_s].has_key? name.to_s
-      @output["data"][type.to_s][name.to_s] = spec
+      @output['data'][type.to_s][name.to_s] = spec
       RootRef.new(kind: :data, type: type, name: name)
     end
 
     def resource(type, name, attributes)
-      @output["resource"][type.to_s] ||= {}
+      @output['resource'][type.to_s] ||= {}
 
-      raise "Resource already exists #{type.to_s}.#{name.to_s}" if @output["resource"][type.to_s].has_key? name.to_s
-      @output["resource"][type.to_s][name.to_s] = attributes
+      raise "Resource already exists #{type}.#{name}" if @output['resource'][type.to_s].key? name.to_s
+
+      @output['resource'][type.to_s][name.to_s] = attributes
       RootRef.new(kind: :resource, type: type, name: name)
     end
 
+    def tf_module(name, spec)
+      @output['module'] ||= {}
+
+      raise "Module already exists #{name}" if @output['module'].key? name.to_s
+
+      @output['module'][name.to_s] = spec
+
+      RootRef.new(kind: :module, name: name)
+    end
+
     def template(relative_path, params = {})
       dir = caller_locations[0].path
       filename = File.join(File.dirname(dir), relative_path)
@@ -255,8 +262,8 @@ module Terrafying
       @children.inject(@output) { |out, c| out.deep_merge(c.output_with_children) }
     end
 
-    def id_of(type,name)
-      output_of(type, name, "id")
+    def id_of(type, name)
+      output_of(type, name, 'id')
     end
 
     def output_of(type, name, key)
@@ -270,8 +277,8 @@ module Terrafying
     def resource_names
       out = output_with_children
       ret = []
-      for type in out["resource"].keys
-        for id in out["resource"][type].keys
+      out['resource'].keys.each do |type|
+        out['resource'][type].keys.each do |id|
           ret << "#{type}.#{id}"
         end
       end
@@ -281,8 +288,8 @@ module Terrafying
     def resources
       out = output_with_children
       ret = []
-      for type in out["resource"].keys
-        for id in out["resource"][type].keys
+      out['resource'].keys.each do |type|
+        out['resource'][type].keys.each do |id|
           ret << "${#{type}.#{id}.id}"
         end
       end
@@ -295,23 +302,21 @@ module Terrafying
     end
 
     def tf_safe(str)
-      str.gsub(/[\.\s\/\?]/, "-")
+      str.gsub(%r{[\.\s/\?]}, '-').gsub(%r{\*}, "star")
     end
-
   end
 
   class RootContext < Context
-
     def initialize
       super
       @providers = {}
     end
 
     def backend(name, spec)
-      @output["terraform"] = {
+      @output['terraform'] = {
         backend: {
-          name => spec,
-        },
+          name => spec
+        }
       }
     end
 
@@ -324,22 +329,19 @@ module Terrafying
     end
 
     def output_with_children
-
-      PROVIDER_DEFAULTS.each { |name, spec|
-        if not key_exists_spec_differs(provider_key(name, spec), name, spec)
+      PROVIDER_DEFAULTS.each do |name, spec|
+        unless key_exists_spec_differs(provider_key(name, spec), name, spec)
           provider(name, spec)
         end
-      }
+      end
 
       super
     end
-
   end
 
   Generator = RootContext.new
 
   module DSL
-
     %w[
       add!
       aws
@@ -349,16 +351,15 @@ module Terrafying
       provider
       resource
       data
+      tf_module
       template
       tf_safe
       id_of
       output_of
-    ].each { |name|
-      define_method(name) { |*args|
+    ].each do |name|
+      define_method(name) do |*args|
         Generator.send(name, *args)
-      }
-    }
-
+      end
+    end
   end
-
 end