cfndsl 0.4.4 → 0.5.0.pre

data/lib/cfndsl/{Conditions.rb → conditions.rb}

@@ -1,13 +1,11 @@
-require 'cfndsl/JSONable'
+require 'cfndsl/jsonable'
 
 module CfnDsl
+  # Handles condition objects
+  #
+  # Usage:
+  #     Condition :ConditionName, FnEqual(Ref(:ParameterName), 'helloworld')
   class ConditionDefinition < JSONable
-    #
-    # Handles condition objects
-    #
-    # Usage:
-    #     Condition :ConditionName, FnEqual(Ref(:ParameterName), 'helloworld')
-
     def initialize(value)
       @value = value
     end

data/lib/cfndsl/creation_policy.rb

@@ -0,0 +1,21 @@
+require 'cfndsl/jsonable'
+
+module CfnDsl
+  # Handles creation policy objects for Resources
+  #
+  # Usage
+  #   Resource("aaa") {
+  #     CreationPolicy('ResourceSignal', { 'Count' => 1,  'Timeout' => 'PT10M' })
+  #   }
+  class CreationPolicyDefinition < JSONable
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def to_json(*a)
+      @value.to_json(*a)
+    end
+  end
+end

data/lib/cfndsl/errors.rb

@@ -0,0 +1,29 @@
+module CfnDsl
+  # Keeps track of errors
+  module Errors
+    @errors = []
+
+    def self.error(err, idx = nil)
+      if idx.nil?
+        @errors.push(err + "\n" + caller.join("\n") + "\n")
+      else
+        m = caller[idx].match(/^.*?:\d+:/)
+        err_loc = m ? m[0] : caller[idx]
+
+        @errors.push(err_loc + ' ' + err + "\n")
+      end
+    end
+
+    def self.clear
+      @errors = []
+    end
+
+    def self.errors
+      @errors
+    end
+
+    def self.errors?
+      !@errors.empty?
+    end
+  end
+end

data/lib/cfndsl/generate_types.rb

@@ -0,0 +1,154 @@
+require 'yaml'
+require 'cfndsl/jsonable'
+require 'cfndsl/plurals'
+require 'cfndsl/names'
+
+module CfnDsl
+  # Type generation helper
+  module GenerateTypes
+    # declare classes for all of the types with named methods for setting the values
+    class Type < JSONable
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    def generate_types(filename)
+      types = YAML.load(File.open(filename))
+      const_set('Types_Internal', types)
+
+      validate_types(types)
+
+      classes = {}
+
+      # Go through and declare all of the types first
+      types['Types'].each_key do |typename|
+        if !const_defined?(typename)
+          klass = const_set(typename, Class.new(self))
+          classes[typename] = klass
+        else
+          classes[typename] = const_get(typename)
+        end
+      end
+
+      # Now go through them again and define attribute setter methods
+      classes.each_pair do |typename, type|
+        typeval = types['Types'][typename]
+        next unless typeval.respond_to?(:each_pair)
+        typeval.each_pair do |attr_name, attr_type|
+          if attr_type.is_a?(Array)
+            klass = const_get(attr_type[0])
+            variable = "@#{attr_name}".to_sym
+
+            method = CfnDsl::Plurals.singularize(attr_name)
+            methods = attr_name
+            all_methods = CfnDsl.method_names(method) + CfnDsl.method_names(methods)
+            type.class_eval do
+              all_methods.each do |method_name|
+                define_method(method_name) do |value = nil, *rest, &block|
+                  existing = instance_variable_get(variable)
+                  # For no-op invocations, get out now
+                  return existing if value.nil? && rest.empty? && !block
+
+                  # We are going to modify the value in some
+                  # way, make sure that we have an array to mess
+                  # with if we start with nothing
+                  existing = instance_variable_set(variable, []) unless existing
+
+                  # special case for just a block, no args
+                  if value.nil? && rest.empty? && block
+                    val = klass.new
+                    existing.push val
+                    value.instance_eval(&block(val))
+                    return existing
+                  end
+
+                  # Glue all of our parameters together into
+                  # a giant array - flattening one level deep, if needed
+                  array_params = []
+                  if value.is_a?(Array)
+                    value.each { |x| array_params.push x }
+                  else
+                    array_params.push value
+                  end
+                  unless rest.empty?
+                    rest.each do |v|
+                      if v.is_a?(Array)
+                        array_params += rest
+                      else
+                        array_params.push v
+                      end
+                    end
+                  end
+
+                  # Here, if we were given multiple arguments either
+                  # as method [a,b,c], method(a,b,c), or even
+                  # method( a, [b], c) we end up with
+                  # array_params = [a,b,c]
+                  #
+                  # array_params will have at least one item
+                  # unless the user did something like pass in
+                  # a bunch of empty arrays.
+                  if block
+                    # TODO: Is this a bug? We don't do anything with the array conetns
+                    array_params.each do |_array_params_value|
+                      value = klass.new
+                      existing.push value
+                      value.instance_eval(&block(val)) if block
+                    end
+                  else
+                    # List of parameters with no block -
+                    # hope that the user knows what he is
+                    # doing and stuff them into our existing
+                    # array
+                    # TODO: Is this a bug? We don't do anything with the array conetns
+                    array_params.each do |_array_params_value|
+                      existing.push value
+                    end
+                  end
+                  return existing
+                end
+              end
+            end
+          else
+            klass = const_get(attr_type)
+            variable = "@#{attr_name}".to_sym
+
+            type.class_eval do
+              CfnDsl.method_names(attr_name) do |inner_method|
+                define_method(inner_method) do |value = nil, *_rest, &block|
+                  value ||= klass.new
+                  instance_variable_set(variable, value)
+                  value.instance_eval(&block) if block
+                  value
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+    private
+
+    # Do a little sanity checking - all of the types referenced in Resources
+    # should be represented in Types
+    def validate_types(types)
+      types['Resources'].values.each do |resource|
+        resource.values.each do |thing|
+          thing.values.flatten.each do |type|
+            puts "unknown type #{type}" unless types['Types'].key?(type)
+          end
+        end
+      end
+
+      # All of the type values should also be references
+      types['Types'].values do |type|
+        next unless type.respond_to?(:values)
+
+        type.values.each do |tv|
+          puts "unknown type #{tv}" unless types['Types'].key?(tv)
+        end
+      end
+    end
+  end
+end

data/lib/cfndsl/jsonable.rb

@@ -0,0 +1,214 @@
+require 'cfndsl/errors'
+require 'cfndsl/ref_check'
+
+module CfnDsl
+  # These functions are available anywhere inside
+  # a block for a JSONable object.
+  module Functions
+    # Equivalent to the CloudFormation template built in function Ref
+    def Ref(value)
+      RefDefinition.new(value)
+    end
+
+    # Equivalent to the CloudFormation template built in function Fn::Base64
+    def FnBase64(value)
+      Fn.new('Base64', value)
+    end
+
+    # Equivalent to the CloudFormation template built in function Fn::FindInMap
+    def FnFindInMap(map, key, value)
+      Fn.new('FindInMap', [map, key, value])
+    end
+
+    # Equivalent to the CloudFormation template built in function Fn::GetAtt
+    def FnGetAtt(logical_resource, attribute)
+      Fn.new('GetAtt', [logical_resource, attribute])
+    end
+
+    # Equivalent to the CloudFormation template built in function Fn::GetAZs
+    def FnGetAZs(region)
+      Fn.new('GetAZs', region)
+    end
+
+    # Equivalent to the CloudFormation template built in function Fn::Join
+    def FnJoin(string, array)
+      Fn.new('Join', [string, array])
+    end
+
+    # Equivalent to the CloudFormation template built in function Fn::And
+    def FnAnd(array)
+      if !array || array.count < 2 || array.count > 10
+        raise 'The array passed to Fn::And must have at least 2 elements and no more than 10'
+      end
+      Fn.new('And', array)
+    end
+
+    # Equivalent to the Cloudformation template built in function Fn::Equals
+    def FnEquals(value1, value2)
+      Fn.new('Equals', [value1, value2])
+    end
+
+    # Equivalent to the Cloudformation template built in function Fn::If
+    def FnIf(condition_name, true_value, false_value)
+      Fn.new('If', [condition_name, true_value, false_value])
+    end
+
+    # Equivalent to the Cloudformation template built in function Fn::Not
+    def FnNot(value)
+      Fn.new('Not', value)
+    end
+
+    # Equivalent to the CloudFormation template built in function Fn::Or
+    def FnOr(array)
+      if !array || array.count < 2 || array.count > 10
+        raise 'The array passed to Fn::Or must have at least 2 elements and no more than 10'
+      end
+      Fn.new('Or', array)
+    end
+
+    # Equivalent to the CloudFormation template built in function Fn::Select
+    def FnSelect(index, array)
+      Fn.new('Select', [index, array])
+    end
+
+    # Usage
+    #  FnFormat('This is a %0. It is 100%% %1', 'test', 'effective')
+    # or
+    #  FnFormat('This is a %{test}. It is 100%% %{effective}',
+    #            :test => 'test",
+    #            :effective => 'effective')
+    #
+    # These will each generate a call to Fn::Join that when
+    # evaluated will produce the string "This is a test. It is 100%
+    # effective."
+    #
+    # Think of this as %0, %1, etc in the format string being replaced by the
+    # corresponding arguments given after the format string. '%%' is replaced
+    # by the '%' character.
+    #
+    # The actual Fn::Join call corresponding to the above FnFormat call would be
+    # {"Fn::Join": ["",["This is a ","test",". It is 100","%"," ","effective"]]}
+    #
+    # If no arguments are given, or if a hash is given and the format
+    # variable name does not exist in the hash, it is used as a Ref
+    # to an existing resource or parameter.
+    #
+    # TODO Can we simplyfy this somehow?
+    # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    def FnFormat(string, *arguments)
+      array = []
+
+      if arguments.empty? || (arguments.length == 1 && arguments[0].instance_of?(Hash))
+        hash = arguments[0] || {}
+        string.scan(/(.*?)(?:%(%|\{([\w:]+)\})|\z)/m) do |x, y, z|
+          array.push x if x && !x.empty?
+
+          next unless y
+
+          array.push(y == '%' ? '%' : (hash[z] || hash[z.to_sym] || Ref(z)))
+        end
+      else
+        string.scan(/(.*?)(?:%(%|\d+)|\z)/m) do |x, y|
+          array.push x if x && !x.empty?
+
+          next unless y
+
+          array.push(y == '%' ? '%' : arguments[y.to_i])
+        end
+      end
+      Fn.new('Join', ['', array])
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+  end
+
+  # This is the base class for just about everything useful in the
+  # DSL. It knows how to turn DSL Objects into the corresponding
+  # json, and it lets you create new built in function objects
+  # from inside the context of a dsl object.
+  class JSONable
+    include Functions
+    extend Functions
+    include RefCheck
+
+    # Use instance variables to build a json object. Instance
+    # variables that begin with a single underscore are elided.
+    # Instance variables that begin with two underscores have one of
+    # them removed.
+    def to_json(*a)
+      hash = {}
+      instance_variables.each do |var|
+        name = var[1..-1]
+
+        if name =~ /^__/
+          # if a variable starts with double underscore, strip one off
+          name = name[1..-1]
+        elsif name =~ /^_/
+          # Hide variables that start with single underscore
+          name = nil
+        end
+
+        hash[name] = instance_variable_get(var) if name
+      end
+      hash.to_json(*a)
+    end
+
+    def ref_children
+      instance_variables.map { |var| instance_variable_get(var) }
+    end
+
+    def declare(&block)
+      instance_eval(&block) if block_given?
+    end
+
+    def method_missing(meth, *args, &_block)
+      error = "Undefined symbol: #{meth}"
+      error = "#{error}(" + args.inspect[1..-2] + ')' unless args.empty?
+      error = "#{error}\n\nTry '#{titleize(meth)}' instead" if incorrect_capitalization?(meth)
+      CfnDsl::Errors.error(error, 1)
+    end
+
+    def incorrect_capitalization?(method)
+      method != titleize(method) && respond_to?(titleize(method))
+    end
+
+    def titleize(method)
+      method.to_s.clone.tap do |m|
+        m[0] = m[0, 1].upcase
+      end.to_sym
+    end
+  end
+
+  # Handles all of the Fn:: objects
+  class Fn < JSONable
+    def initialize(function, argument, refs = [])
+      @function = function
+      @argument = argument
+      @_refs = refs
+    end
+
+    def to_json(*a)
+      hash = {}
+      hash["Fn::#{@function}"] = @argument
+      hash.to_json(*a)
+    end
+
+    def references
+      @_refs
+    end
+
+    def ref_children
+      [@argument]
+    end
+  end
+
+  # Handles the Ref objects
+  class RefDefinition < JSONable
+    def initialize(value)
+      @Ref = value
+    end
+
+    def all_refs
+      [@Ref]
+    end
+  end
+end

data/lib/cfndsl/mappings.rb

@@ -0,0 +1,23 @@
+require 'cfndsl/jsonable'
+
+module CfnDsl
+  # Handles mapping objects
+  #
+  # Usage:
+  #     Mapping("AWSRegionArch2AMI", {
+  #               "us-east-1" => { "32" => "ami-6411e20d", "64" => "ami-7a11e213" },
+  #               "us-west-1" => { "32" => "ami-c9c7978c", "64" => "ami-cfc7978a" },
+  #               "eu-west-1" => { "32" => "ami-37c2f643", "64" => "ami-31c2f645" },
+  #               "ap-southeast-1" => { "32" => "ami-66f28c34", "64" => "ami-60f28c32" },
+  #               "ap-northeast-1" => { "32" => "ami-9c03a89d", "64" => "ami-a003a8a1" }
+  #    })
+  class MappingDefinition < JSONable
+    def initialize(value)
+      @value = value
+    end
+
+    def to_json(*a)
+      @value.to_json(*a)
+    end
+  end
+end