cfndsl 0.17.5 → 1.0.0.pre.1

data/lib/cfndsl/mappings.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'cfndsl/jsonable'
+require_relative 'jsonable'
 
 module CfnDsl
   # Handles mapping objects

data/lib/cfndsl/module.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'cfndsl/plurals'
-require 'cfndsl/names'
+require_relative 'plurals'
+require_relative 'names'
 
 # Adds some dsl module helpers
 class Module
@@ -53,6 +53,7 @@ class Module
   # on the main object, and the block is then evaluated in the context
   # of the new object.
   #
+  # rubocop:disable Metrics/MethodLength
   def dsl_content_object(*symbols)
     symbols.each do |symbol|
       plural = CfnDsl::Plurals.pluralize(symbol) # @@plurals[symbol] || "#{symbol}s"
@@ -67,12 +68,22 @@ class Module
               hash = {}
               instance_variable_set(pluralvar, hash)
             end
-            hash[name] ||= definition_class.new(*values)
-            hash[name].instance_eval(&block) if block
-            return hash[name]
+            instance = hash[name]
+
+            if !instance
+              instance = definition_class.new(*values)
+              hash[name] = instance
+            elsif !instance.is_a?(definition_class)
+              raise ArgumentError, "#{method}(#{name}) already exists and is not a #{definition_class}"
+            elsif !values.empty?
+              raise ArgumentError, "wrong number of arguments (given #{values.size + 1}, expected 1) as #{method}(#{name}) already exists"
+            end
+            instance.instance_eval(&block) if block
+            return instance
           end
         end
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/cfndsl/orchestration_template.rb

@@ -1,10 +1,22 @@
 # frozen_string_literal: true
 
-require 'cfndsl/jsonable'
-require 'cfndsl/names'
-require 'cfndsl/aws/types'
-require 'cfndsl/os/types'
-require 'cfndsl/globals'
+require_relative 'globals'
+require_relative 'module'
+require_relative 'jsonable'
+require_relative 'names'
+require_relative 'plurals'
+require_relative 'ref_check'
+require_relative 'properties'
+require_relative 'update_policy'
+require_relative 'creation_policy'
+require_relative 'conditions'
+require_relative 'mappings'
+require_relative 'resources'
+require_relative 'rules'
+require_relative 'parameters'
+require_relative 'outputs'
+
+require 'tsort'
 
 module CfnDsl
   # Handles the overall template object
@@ -34,7 +46,7 @@ module CfnDsl
 
             abreve_name = parts.join('_')
             if accessors.key? abreve_name
-              accessors.delete abreve_name # Delete potentially ambiguous names
+              accessors[abreve_name] = :duplicate # Delete potentially ambiguous names
             else
               accessors[abreve_name] = type_module.const_get resource_name
               types_mapping[abreve_name] = resource
@@ -42,17 +54,25 @@ module CfnDsl
             parts.shift
           end
         end
-        accessors.each_pair { |acc, res| create_resource_accessor(acc, res, types_mapping[acc]) }
+        accessors.each_pair { |acc, res| create_resource_accessor(acc, res, types_mapping[acc]) unless res == :duplicate }
       end
 
       def create_resource_def(name, info)
-        resource = Class.new ResourceDefinition
+        resource = Class.new ResourceDefinition do
+          # do not allow Type to be respecified
+          def Type(type = nil)
+            return @Type unless type
+            raise CfnDsl::Error, "Cannot override previously defined Type #{@Type} with #{type}" unless type == @Type
+
+            super
+          end
+        end
         resource_name = name.gsub(/::/, '_')
         type_module.const_set(resource_name, resource)
         info['Properties'].each_pair do |pname, ptype|
           if ptype.is_a? Array
             pclass = type_module.const_get ptype.first
-            create_array_property_def(resource, pname, pclass)
+            create_array_property_def(resource, pname, pclass, info)
           else
             pclass = type_module.const_get ptype
             create_property_def(resource, pname, pclass)
@@ -61,9 +81,66 @@ module CfnDsl
         resource_name
       end
 
-      def create_property_def(resource, pname, pclass)
+      # rubocop:disable Metrics/PerceivedComplexity
+      def create_array_property_def(resource, pname, pclass, info)
+        singular_name = CfnDsl::Plurals.singularize pname
+        plural_name = singular_name == pname ? CfnDsl::Plurals.pluralize(pname) : pname
+
+        if singular_name == plural_name
+          # Generate the extended list concat method
+          plural_name = nil
+        elsif pname == plural_name && info['Properties'].include?(singular_name)
+          # The singlular name is a different property, do not redefine it here but rather use the extended form
+          #  with the plural name. This allows construction of deep types, but no mechanism to overwrite a previous value
+          # (eg CodePipeline::Pipeline ArtifactStores vs ArtifactStore)
+          # Note is is also possible (but unlikely) for the spec to change in a way that triggers this condition where it did not
+          # before which will result in breaking behaviour for existing apps.
+          singular_name = plural_name
+          plural_name = nil
+        elsif pname == singular_name && info['Properties'].include?(plural_name)
+          # The plural name is a different property, do not redefine it here
+          # Note it is unlikely that a singular form is going to be a List property if the plural form also exists.
+          plural_name = singular_name
+        end
+
+        # Plural form just a normal property definition expecting an Array type
+        create_property_def(resource, pname, Array, plural_name) if plural_name
+
+        # Singular form understands concatenation and Fn::If property
+        create_singular_property_def(resource, pname, pclass, singular_name) if singular_name
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def create_resource_accessor(accessor, resource, type)
+        class_eval do
+          CfnDsl.method_names(accessor) do |method|
+            define_method(method) do |name, *values, &block|
+              name = name.to_s
+              @Resources ||= {}
+              instance = @Resources[name]
+              if !instance
+                instance = resource.new(*values)
+                # Previously the type was set after the block was evaled
+                # But now trying to reset Type on a specific subtype will raise exception
+                instance.instance_variable_set('@Type', type)
+                @Resources[name] = instance
+              elsif type != (other_type = instance.instance_variable_get('@Type'))
+                raise ArgumentError, "Resource #{name}<#{other_type}> exists, and is not a <#{type}>"
+              elsif !values.empty?
+                raise ArgumentError, "wrong number of arguments (given #{values.size + 1}, expected 1) as Resource #{name} already exists"
+              end
+              @Resources[name].instance_eval(&block) if block
+              instance
+            end
+          end
+        end
+      end
+
+      private
+
+      def create_property_def(resource, pname, pclass, method_name = pname)
         resource.class_eval do
-          CfnDsl.method_names(pname) do |method|
+          CfnDsl.method_names(method_name) do |method|
             define_method(method) do |*values, &block|
               values.push pclass.new if values.empty?
               @Properties ||= {}
@@ -75,114 +152,139 @@ module CfnDsl
         end
       end
 
-      def create_array_property_def(resource, pname, pclass)
-        create_property_def(resource, pname, Array)
-
-        sname = CfnDsl::Plurals.singularize pname
-
-        return if sname == pname
-
+      def create_singular_property_def(resource, pname, pclass, singular_name)
         resource.class_eval do
-          CfnDsl.method_names(sname) do |method|
-            define_method(method) do |value = nil, &block|
+          CfnDsl.method_names(singular_name) do |method|
+            define_method(method) do |value = nil, fn_if: nil, **hash_value, &block|
+              value = hash_value unless value || hash_value.empty?
               @Properties ||= {}
               @Properties[pname] ||= PropertyDefinition.new([])
-              value ||= pclass.new
-              @Properties[pname].value.push value
-              value.instance_eval(&block) if block
+              if value.is_a?(Array)
+                @Properties[pname].value.concat(value)
+              else
+                value ||= pclass.new
+                @Properties[pname].value.push fn_if ? FnIf(fn_if, value, Ref('AWS::NoValue')) : value
+                value.instance_eval(&block) if block
+              end
               value
             end
           end
         end
       end
+    end
 
-      def create_resource_accessor(accessor, resource, type)
-        class_eval do
-          CfnDsl.method_names(accessor) do |method|
-            define_method(method) do |name, *values, &block|
-              name = name.to_s
-              @Resources ||= {}
-              @Resources[name] ||= resource.new(*values)
-              @Resources[name].instance_eval(&block) if block
-              @Resources[name].instance_variable_set('@Type', type)
-              @Resources[name]
-            end
-          end
-        end
+    def initialize(description = nil, &block)
+      @AWSTemplateFormatVersion = '2010-09-09'
+      @Description = description if description
+      declare(&block) if block_given?
+    end
+
+    alias _Condition Condition
+
+    # Condition has two usages at this level
+    # @overload Condition(name,expression)
+    # @overload Condition(name) - referencing a condition in a condition expression
+    def Condition(name, expression = nil)
+      if expression
+        _Condition(name, expression)
+      else
+        { Condition: ConditionDefinition.new(name) }
       end
     end
 
-    def initialize
-      @AWSTemplateFormatVersion = '2010-09-09'
+    def check_refs
+      invalids = check_condition_refs + check_resource_refs + check_output_refs + check_rule_refs
+      invalids unless invalids.empty?
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity
-    def valid_ref?(ref, origin = nil)
+    def valid_ref?(ref, ref_containers = [GLOBAL_REFS, @Resources, @Parameters])
       ref = ref.to_s
-      origin = origin.to_s if origin
+      ref_containers.any? { |c| c && c.key?(ref) }
+    end
 
-      return true if GLOBAL_REFS.key?(ref)
+    def check_condition_refs
+      invalids = []
 
-      return true if @Parameters&.key?(ref)
+      # Conditions can refer to other conditions in Fn::And, Fn::Or and Fn::Not
+      invalids.concat(_check_refs(:Condition, :condition_refs, [@Conditions]))
 
-      return !origin || !@_resource_refs || !@_resource_refs[ref] || !@_resource_refs[ref].key?(origin) if @Resources.key?(ref)
+      # They can also Ref Globals and Parameters (but not Resources))
+      invalids.concat(_check_refs(:Condition, :all_refs, [GLOBAL_REFS, @Parameters]))
+    end
 
-      false
+    def check_resource_refs
+      invalids = []
+      invalids.concat(_check_refs(:Resource, :all_refs, [@Resources, GLOBAL_REFS, @Parameters]))
+
+      # DependsOn and conditions in Fn::If expressions
+      invalids.concat(_check_refs(:Resource, :condition_refs, [@Conditions]))
     end
-    # rubocop:enable Metrics/PerceivedComplexity
 
-    def check_refs
-      invalids = check_resource_refs + check_output_refs + check_rule_refs
-      invalids unless invalids.empty?
+    def check_output_refs
+      invalids = []
+      invalids.concat(_check_refs(:Output, :all_refs, [@Resources, GLOBAL_REFS, @Parameters]))
+      invalids.concat(_check_refs(:Output, :condition_refs, [@Conditions]))
     end
 
-    def check_resource_refs
+    def check_rule_refs
       invalids = []
-      @_resource_refs = {}
-      if @Resources
-        @Resources.each_key do |resource|
-          @_resource_refs[resource.to_s] = @Resources[resource].build_references({})
-        end
-        @_resource_refs.each_key do |origin|
-          @_resource_refs[origin].each_key do |ref|
-            invalids.push "Invalid Reference: Resource #{origin} refers to #{ref}" unless valid_ref?(ref, origin)
-          end
-        end
-      end
+      invalids.concat(_check_refs(:Rule, :all_refs, [@Resources, GLOBAL_REFS, @Parameters]))
+      invalids.concat(_check_refs(:Rule, :condition_refs, [@Conditions]))
       invalids
     end
 
-    def check_output_refs
-      invalids = []
-      output_refs = {}
-      if @Outputs
-        @Outputs.each_key do |resource|
-          output_refs[resource.to_s] = @Outputs[resource].build_references({})
-        end
-        output_refs.each_key do |origin|
-          output_refs[origin].each_key do |ref|
-            invalids.push "Invalid Reference: Output #{origin} refers to #{ref}" unless valid_ref?(ref)
-          end
-        end
+    # For testing for cycles
+    class RefHash < Hash
+      include TSort
+
+      alias tsort_each_node each_key
+      def tsort_each_child(node, &block)
+        fetch(node, []).each(&block)
       end
-      invalids
     end
 
-    def check_rule_refs
+    # rubocop:disable Metrics/PerceivedComplexity
+    def _check_refs(container_name, method, source_containers)
+      container = instance_variable_get("@#{container_name}s")
+      return [] unless container
+
       invalids = []
-      @_rule_refs = {}
-      if @Rules
-        @Rules.each_key do |rule|
-          @_rule_refs[resource.to_s] = @Rules[rule].build_references({})
+      referred_by = RefHash.new { |h, k| h[k] = [] }
+      self_check = source_containers.first.eql?(container)
+
+      container.each_pair do |name, entry|
+        name = name.to_s
+        begin
+          refs = entry.build_references([], self_check && name, method)
+          refs.each { |r| referred_by[r.to_s] << name }
+        rescue RefCheck::SelfReference, RefCheck::NullReference => e
+          # Topological sort will not detect self or null references
+          invalids.push("#{container_name} #{e.message}")
         end
-        @_rule_refs.each_key do |origin|
-          @_rule_refs[origin].each_key do |ref|
-            invalids.push "Invalid Reference: Rule #{origin} refers to #{ref}" unless valid_ref?(ref, origin)
-          end
+      end
+
+      referred_by.each_pair do |ref, names|
+        unless valid_ref?(ref, source_containers)
+          invalids.push "Invalid Reference: #{container_name}s #{names} refer to unknown #{method == :condition_refs ? 'Condition' : 'Reference'} #{ref}"
         end
       end
+
+      begin
+        referred_by.tsort if self_check && invalids.empty? # Check for cycles
+      rescue TSort::Cyclic => e
+        invalids.push "Cyclic references found in #{container_name}s #{referred_by} - #{e.message}"
+      end
+
       invalids
     end
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def validate
+      errors = check_refs || []
+      raise CfnDsl::Error, "#{errors.size} errors in template\n#{errors.join("\n")}" unless errors.empty?
+
+      self
+    end
   end
   # rubocop:enable Metrics/ClassLength
 end

data/lib/cfndsl/outputs.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'cfndsl/jsonable'
+require_relative 'jsonable'
 
 module CfnDsl
   # Handles Output objects
@@ -14,5 +14,9 @@ module CfnDsl
     def initialize(value = nil)
       @Value = value if value
     end
+
+    def condition_refs
+      [@Condition].flatten.compact.map(&:to_s)
+    end
   end
 end

data/lib/cfndsl/parameters.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'cfndsl/jsonable'
+require_relative 'jsonable'
 
 module CfnDsl
   # Handles input parameter objects

data/lib/cfndsl/plurals.rb

@@ -24,7 +24,18 @@ module CfnDsl
     end
 
     def singularize(name)
-      @singles.fetch(name.to_s) { |key| key[0..-2] }
+      @singles.fetch(name.to_s) do |key|
+        case key
+        when /List$/
+          key[0..-5]
+        when /ies$/
+          key[0..-4] + 'y'
+        when /s$/
+          key[0..-2]
+        else
+          key
+        end
+      end
     end
   end
 end

data/lib/cfndsl/properties.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'cfndsl/jsonable'
+require_relative 'jsonable'
 
 module CfnDsl
   # Handles property objects for Resources