cfndsl 0.4.4 → 0.5.0.pre

data/lib/cfndsl/{Outputs.rb → outputs.rb}

@@ -1,12 +1,11 @@
-require 'cfndsl/JSONable'
+require 'cfndsl/jsonable'
 
 module CfnDsl
+  # Handles Output objects
   class OutputDefinition < JSONable
-    ##
-    # Handles Output objects
     dsl_attr_setter :Value, :Description, :Condition
 
-    def initialize( value=nil)
+    def initialize(value = nil)
       @Value = value if value
     end
   end

data/lib/cfndsl/{Parameters.rb → parameters.rb}

@@ -1,32 +1,31 @@
-require 'cfndsl/JSONable'
+require 'cfndsl/jsonable'
 
-module CfnDsl  
-  
+module CfnDsl
+  # Handles input parameter objects
   class ParameterDefinition < JSONable
-    ##
-    # Handles input parameter objects
-    dsl_attr_setter :Type, :Default, :NoEcho, :AllowedValues, :AllowedPattern, :MaxLength, :MinLength, :MaxValue, :MinValue, :Description, :ConstraintDescription
+    dsl_attr_setter :Type, :Default, :NoEcho, :AllowedValues, :AllowedPattern, :MaxLength,
+                    :MinLength, :MaxValue, :MinValue, :Description, :ConstraintDescription
+
     def initialize
       @Type = :String
     end
-    
+
     def String
       @Type = :String
     end
-    
+
     def Number
       @Type = :Number
     end
-    
+
     def CommaDelimitedList
       @Type = :CommaDelimitedList
     end
-   
-    def to_hash()
+
+    def to_hash
       h = {}
-      h[:Type] = @Type;
+      h[:Type] = @Type
       h[:Default] = @Default if @Default
     end
   end
-  
 end

data/lib/cfndsl/plurals.rb

@@ -0,0 +1,34 @@
+module CfnDsl
+  # Plural names for lists of content objects
+  module Plurals
+    @plurals = {
+      'Metadata' => 'Metadata',
+      'Property' => 'Properties',
+      'Policy' => 'Policies',
+      'PolicyDocument' => 'PolicyDocument',
+      'AssumeRolePolicyDocument' => 'AssumeRolePolicyDocument',
+      'SecurityGroupIngress' => 'SecurityGroupIngress',
+      'SecurityGroupEgress' => 'SecurityGroupEgress',
+      'DBSecurityGroupIngress' => 'DBSecurityGroupIngress',
+      'UpdatePolicy' => 'UpdatePolicy',
+      'CreationPolicy' => 'CreationPolicy'
+    }
+
+    @singles = {}
+    @plurals.each_pair { |key, val| @singles[val] = key }
+
+    def self.pluralize(name)
+      name = name.to_s
+      return @plurals[name] if @plurals.key?(name)
+
+      "#{name}s"
+    end
+
+    def self.singularize(name)
+      name = name.to_s
+      return @singles[name] if @singles.key?(name)
+
+      name[0..-2]
+    end
+  end
+end

data/lib/cfndsl/properties.rb

@@ -0,0 +1,21 @@
+require 'cfndsl/jsonable'
+
+module CfnDsl
+  # Handles property objects for Resources
+  #
+  # Usage
+  #   Resource("aaa") {
+  #     Property("propName", "propValue" )
+  #   }
+  #
+  class PropertyDefinition < JSONable
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+
+    def to_json(*a)
+      @value.to_json(*a)
+    end
+  end
+end

data/lib/cfndsl/rake_task.rb

@@ -1,15 +1,17 @@
-require "rake"
-require "rake/tasklib"
-require "cfndsl"
+require 'rake'
+require 'rake/tasklib'
+
+require 'cfndsl'
 
 module CfnDsl
+  # Rake Task
   class RakeTask < Rake::TaskLib
     attr_accessor :cfndsl_opts
 
     def initialize(name = nil)
       yield self if block_given?
 
-      desc "Generate Cloudformation" unless ::Rake.application.last_comment
+      desc 'Generate Cloudformation' unless ::Rake.application.last_comment
       task(name || :generate) do |_t, _args|
         cfndsl_opts[:files].each do |opts|
           generate(opts)
@@ -27,7 +29,7 @@ module CfnDsl
     end
 
     def log(opts)
-      type = opts[:output].nil? ? "STDOUT" : opts[:output]
+      type = opts[:output].nil? ? 'STDOUT' : opts[:output]
       verbose.puts("Writing to #{type}") if verbose
     end
 
@@ -36,7 +38,7 @@ module CfnDsl
     end
 
     def model(filename)
-      fail "#{filename} doesn't exist" unless File.exist? filename
+      raise "#{filename} doesn't exist" unless File.exist?(filename)
       verbose.puts("using extras #{extra}") if verbose
       CfnDsl.eval_file_with_extras(filename, extra, verbose).to_json
     end
@@ -50,7 +52,7 @@ module CfnDsl
     end
 
     def file_output(path)
-      File.open(File.expand_path(path), "w") { |f| yield f }
+      File.open(File.expand_path(path), 'w') { |f| yield f }
     end
   end
 end

data/lib/cfndsl/ref_check.rb

@@ -0,0 +1,44 @@
+# This module defines some methods for walking the reference tree
+# of various objects.
+module RefCheck
+  # Build up a set of references.
+  def build_references(refs)
+    raise 'Circular reference' if @_visited
+
+    @_visited = true
+
+    if respond_to?(:all_refs)
+      all_refs.each do |ref|
+        refs[ref.to_s] = 1
+      end
+    end
+
+    ref_children.each do |elem|
+      elem.build_references(refs) if elem.respond_to?(:build_references)
+    end
+
+    @_visited = nil
+
+    refs
+  end
+
+  def ref_children
+    []
+  end
+end
+
+# Mixin to Array
+class Array
+  include RefCheck
+  def ref_children
+    self
+  end
+end
+
+# Mixin to Array
+class Hash
+  include RefCheck
+  def ref_children
+    values
+  end
+end

data/lib/cfndsl/{Resources.rb → resources.rb}

@@ -1,36 +1,34 @@
-require 'cfndsl/JSONable'
-require 'cfndsl/Metadata'
-require 'cfndsl/Properties'
-require 'cfndsl/UpdatePolicy'
+require 'cfndsl/jsonable'
+require 'cfndsl/metadata'
+require 'cfndsl/properties'
+require 'cfndsl/update_policy'
 
 module CfnDsl
+  # Handles Resource objects
   class ResourceDefinition < JSONable
-    ##
-    # Handles Resource objects
     dsl_attr_setter :Type, :DependsOn, :DeletionPolicy, :Condition
     dsl_content_object :Property, :Metadata, :UpdatePolicy, :CreationPolicy
 
-    def addTag(name, value, propagate=nil)
-      self.send(:Tag) {
+    def add_tag(name, value, propagate = nil)
+      send(:Tag) do
         Key name
         Value value
         PropagateAtLaunch propagate unless propagate.nil?
-      }
+      end
     end
 
-    def get_references()
+    def all_refs
       refs = []
-      if @DependsOn then
-        if( @DependsOn.respond_to?(:each) ) then
+      if @DependsOn
+        if @DependsOn.respond_to?(:each)
           @DependsOn.each do |dep|
             refs.push dep
           end
         end
 
-        if( @DependsOn.instance_of?(String) ) then
-          refs.push @DependsOn
-        end
+        refs.push @DependsOn if @DependsOn.instance_of?(String)
       end
+
       refs
     end
   end

data/lib/cfndsl/types.rb

@@ -0,0 +1,151 @@
+require 'yaml'
+require 'cfndsl/jsonable'
+require 'cfndsl/plurals'
+require 'cfndsl/names'
+require 'cfndsl/types'
+
+module CfnDsl
+  # rubocop:disable Metrics/ModuleLength
+  module Types
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    def self.included(type_def)
+      types_list = YAML.load(File.open("#{File.dirname(__FILE__)}/#{type_def::TYPE_PREFIX}/types.yaml"))
+      type_def.const_set('Types_Internal', types_list)
+
+      # Do a little sanity checking - all of the types referenced in Resources
+      # should be represented in Types
+      types_list['Resources'].keys.each do |resource_name|
+        resource = types_list['Resources'][resource_name]
+        resource.values.each do |thing|
+          thing.values.each do |type|
+            if type.is_a?(Array)
+              type.each do |inner_type|
+                puts "unknown type #{inner_type}" unless types_list['Types'].key?(inner_type)
+              end
+            else
+              puts "unknown type #{type}" unless types_list['Types'].key?(type)
+            end
+          end
+        end
+      end
+
+      # All of the type values should also be references
+      types_list['Types'].values do |type|
+        if type.respond_to?(:values)
+          type.values.each do |tv|
+            puts "unknown type #{tv}" unless types_list['Types'].key?(tv)
+          end
+        end
+      end
+
+      classes = {}
+
+      # Go through and declare all of the types first
+      types_list['Types'].each_key do |typename|
+        if !type_def.const_defined?(typename)
+          klass = type_def.const_set(typename, Class.new(type_def::Type))
+          classes[typename] = klass
+        else
+          classes[typename] = type_def.const_get(typename)
+        end
+      end
+
+      # Now go through them again and define attribute setter methods
+      classes.each_pair do |typename, type|
+        typeval = types_list['Types'][typename]
+        next unless typeval.respond_to?(:each_pair)
+        typeval.each_pair do |attr_name, attr_type|
+          if attr_type.is_a?(Array)
+            klass = type_def.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
+                    array_params.each do |array_params_value|
+                      value = klass.new
+                      existing.push value
+                      value.instance_eval(&block(array_params_value)) 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
+                    array_params.each do |_|
+                      existing.push value
+                    end
+                  end
+                  return existing
+                end
+              end
+            end
+          else
+            klass = type_def.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
+  end
+  # rubocop:enable Metrics/ModuleLength
+end

data/lib/cfndsl/update_policy.rb

@@ -0,0 +1,25 @@
+require 'cfndsl/jsonable'
+
+module CfnDsl
+  # Handles autoscaling group update policy objects for Resources
+  #
+  # Usage
+  #   Resource("aaa") {
+  #     UpdatePolicy("AutoScalingRollingUpdate", {
+  #       "MinInstancesInService" => "1",
+  #       "MaxBatchSize" => "1",
+  #       "PauseTime" => "PT12M5S"
+  #     })
+  #   }
+  #
+  class UpdatePolicyDefinition < JSONable
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+
+    def to_json(*a)
+      @value.to_json(*a)
+    end
+  end
+end

data/lib/cfndsl/version.rb

@@ -1,3 +1,3 @@
 module CfnDsl
-  VERSION = "0.4.4"
+  VERSION = '0.5.0.pre'.freeze
 end