cfndsl 0.4.4 → 0.5.0.pre

data/lib/cfndsl/JSONable.rb

@@ -1,235 +0,0 @@
-require 'cfndsl/Errors'
-require 'cfndsl/RefCheck'
-
-module CfnDsl
-  module Functions
-    ##
-    # These functions are available anywhere inside
-    # a block for a JSONable object.
-    def Ref(value)
-      ##
-      # Equivalent to the CloudFormation template built in function Ref
-      RefDefinition.new(value)
-    end
-
-    def FnBase64( value )
-      ##
-      # Equivalent to the CloudFormation template built in function Fn::Base64
-      Fn.new("Base64", value);
-    end
-
-    def FnFindInMap( map, key, value)
-      ##
-      # Equivalent to the CloudFormation template built in function Fn::FindInMap
-      Fn.new("FindInMap", [map,key,value] )
-    end
-
-    def FnGetAtt(logicalResource, attribute)
-      ##
-      # Equivalent to the CloudFormation template built in function Fn::GetAtt
-      Fn.new( "GetAtt", [logicalResource, attribute] )
-    end
-
-    def FnGetAZs(region)
-      ##
-      # Equivalent to the CloudFormation template built in function Fn::GetAZs
-      Fn.new("GetAZs", region)
-    end
-
-    def FnJoin(string, array)
-      ##
-      # Equivalent to the CloudFormation template built in function Fn::Join
-      Fn.new("Join", [ string, array] )
-    end
-
-    def FnAnd(array)
-      ##
-      # Equivalent to the CloudFormation template built in function Fn::And
-      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
-
-    def FnEquals(value1, value2)
-      ##
-      # Equivalent to the Cloudformation template built in function Fn::Equals
-      Fn.new("Equals", [value1, value2])
-    end
-
-    def FnIf(conditionName, trueValue, falseValue)
-      ##
-      # Equivalent to the Cloudformation template built in function Fn::If
-      Fn.new("If", [conditionName, trueValue, falseValue])
-    end
-
-    def FnNot(value)
-      ##
-      # Equivalent to the Cloudformation template built in function Fn::Not
-      Fn.new("Not", value)
-    end
-
-    def FnOr(array)
-      ##
-      # Equivalent to the CloudFormation template built in function Fn::Or
-      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
-
-    def FnSelect(index, array)
-      ##
-      # Equivalent to the CloudFormation template built in function Fn::Select
-      Fn.new("Select", [ index, array] )
-    end
-
-    def FnFormat(string, *arguments)
-      ##
-      # 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.
-      #
-      array = [];
-      if(arguments.length == 0 ||
-         (arguments.length == 1 && arguments[0].instance_of?(Hash)) ) then
-        hash = arguments[0] || {}
-        string.scan( /(.*?)(%(%|\{([\w:]+)\})|\z)/m ) do |x,y|
-          array.push $1 if $1 && $1 != ""
-          if( $3 == '%' ) then
-            array.push '%'
-          elsif( $3 ) then
-            array.push hash[ $4 ] || hash[ $4.to_sym ] || Ref( $4 )
-          end
-        end
-      else
-        string.scan( /(.*?)(%(%|\d+)|\z)/m ) do |x,y|
-          array.push $1 if $1 && $1 != ""
-          if( $3 == '%' ) then
-            array.push '%'
-          elsif( $3 ) then
-            array.push arguments[ $3.to_i ]
-          end
-        end
-      end
-      Fn.new("Join", ["", array])
-    end
-  end
-
-  class JSONable
-    ##
-    # 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.
-
-    include Functions
-    extend Functions
-    include RefCheck
-
-    def to_json(*a)
-      ##
-      # 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.
-      hash = {}
-      self.instance_variables.each do |var|
-        name = var[1..-1]
-
-        if( name =~ /^__/ ) then
-          # if a variable starts with double underscore, strip one off
-          name = name[1..-1]
-        elsif( name =~ /^_/ ) then
-          # Hide variables that start with single underscore
-          name = nil
-        end
-
-        hash[name] = self.instance_variable_get var if name
-      end
-      hash.to_json(*a)
-    end
-
-    def ref_children
-      return self.instance_variables.map { |var| self.instance_variable_get var }
-    end
-
-    def declare(&block)
-      self.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
-
-
-  class Fn < JSONable
-    ##
-    # Handles all of the Fn:: objects
-    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 get_references()
-      return @_refs
-    end
-
-    def ref_children
-      return [@argument]
-    end
-  end
-
-  class RefDefinition < JSONable
-    ##
-    # Handles the Ref objects
-    def initialize( value )
-      @Ref = value
-    end
-
-    def get_references()
-      [@Ref]
-    end
-  end
-
-end

data/lib/cfndsl/Mappings.rb

@@ -1,25 +0,0 @@
-require 'cfndsl/JSONable'
-
-module CfnDsl    
-  class MappingDefinition < JSONable
-    ##
-    # 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" }
-    #    })
-    
-    def initialize(value)
-      @value = value
-    end
-    
-    def to_json(*a)
-      @value.to_json(*a)
-    end
-  end
-end

data/lib/cfndsl/Metadata.rb

@@ -1,22 +0,0 @@
-require 'cfndsl/JSONable'
-
-module CfnDsl  
-  
-  class MetadataDefinition < JSONable
-    ## 
-    # Handles Metadata objects
-    def initialize(value) 
-      @value = value;
-    end
-
-    def value
-      return @value
-    end
-    
-    def to_json(*a) 
-      @value.to_json(*a)
-    end
-
-  end
-
-end

data/lib/cfndsl/Plurals.rb

@@ -1,35 +0,0 @@
-module CfnDsl
-  module Plurals
-    ##
-    # Plural names for lists of content objects
-    #
-    
-    @@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.has_key? name )
-      return "#{name}s"
-    end
-
-    def self.singularize(name)
-      name = name.to_s
-      return @@singles[name] if( @@singles.has_key? name )
-      return name[0..-2]
-    end
-  end
-end

data/lib/cfndsl/Properties.rb

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

data/lib/cfndsl/RefCheck.rb

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

data/lib/cfndsl/Types.rb

@@ -1,309 +0,0 @@
-require 'yaml'
-require 'cfndsl/JSONable'
-require 'cfndsl/Plurals'
-require 'cfndsl/names'
-
-module CfnDsl
-  module AWSTypes
-    aws_types = YAML::load( File.open( "#{File.dirname(__FILE__)}/aws_types.yaml") );
-    AWSTypes.const_set( "AWS_Types", aws_types);
-   
-    # Do a little sanity checking - all of the types referenced in Resources
-    # should be represented in Types
-    aws_types["Resources"].keys.each do |resource_name|
-      #puts resource_name
-      
-      resource = aws_types["Resources"][resource_name]
-      resource.values.each do |thing|
-        thing.values.each do |type|
-          if( type.kind_of? Array ) then
-            type.each do | type |
-              puts "unknown type #{type}" unless aws_types["Types"].has_key? type 
-            end
-          else
-            puts "unknown type #{type}" unless aws_types["Types"].has_key? type 
-          end
-        end
-      end
-    end
-    
-    # All of the type values should also be references
-    
-    aws_types["Types"].values do |type|
-      if( type.respond_to? :values) then
-        type.values.each do |tv|
-          puts "unknown type #{tv}" unless aws_types["Types"].has_key? tv 
-        end
-      end
-    end
-      
-    # declare classes for all of the types with named methods for setting the values
-    class AWSType < JSONable
-    end
-  
-    classes = {}
-    
-    # Go through and declare all of the types first
-    aws_types["Types"].each_key do |typename|
-      if( ! AWSTypes.const_defined? typename ) then
-        klass = AWSTypes.const_set( typename, Class.new(AWSType ) )
-        classes[typename] = klass
-      else
-        classes[typename] = AWSTypes.const_get(typename)
-      end 
-    end
-    
-    # Now go through them again and define attribute setter methods
-    classes.each_pair do |typename,type|
-      #puts typename
-      typeval = aws_types["Types"][typename]
-      if( typeval.respond_to? :each_pair ) then
-        typeval.each_pair do |attr_name, attr_type|
-          if( attr_type.kind_of? Array ) then
-            klass = CfnDsl::AWSTypes.const_get( attr_type[0] )
-            variable = "@#{attr_name}".to_sym
-            
-            method = CfnDsl::Plurals::singularize(attr_name)
-            methods = attr_name
-            all_methods = CfnDsl::methodNames(method) +
-              CfnDsl::methodNames(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? and rest.length == 0 and ! 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
-                  if( !existing ) then
-                    existing = instance_variable_set( variable, [] )
-                  end
-
-                  # special case for just a block, no args
-                  if( value.nil? and rest.length == 0 and block ) then
-                    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.kind_of? Array) then 
-                    value.each {|x| array_params.push x}
-                  else
-                    array_params.push value
-                  end
-                  if( rest.length > 0) then
-                    rest.each do |v|
-                      if( v.kind_of? Array ) then
-                        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 then
-                    array_params.each do |val|
-                      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
-                    array_params.each do |val|
-                      existing.push value
-                    end
-                  end
-                  return existing
-                end
-              end
-            end
-          else
-            klass = CfnDsl::AWSTypes.const_get( attr_type );
-            variable = "@#{attr_name}".to_sym
-
-            type.class_eval do 
-              CfnDsl::methodNames(attr_name) do |method|
-                define_method(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
-  end
-
-  module OSTypes
-    os_types = YAML::load( File.open( "#{File.dirname(__FILE__)}/os_types.yaml") );
-    OSTypes.const_set( "OS_Types", os_types);
-   
-    # Do a little sanity checking - all of the types referenced in Resources
-    # should be represented in Types
-    os_types["Resources"].keys.each do |resource_name|
-      #puts resource_name
-      
-      resource = os_types["Resources"][resource_name]
-      resource.values.each do |thing|
-        thing.values.each do |type|
-          if( type.kind_of? Array ) then
-            type.each do | type |
-              puts "unknown type #{type}" unless os_types["Types"].has_key? type 
-            end
-          else
-            puts "unknown type #{type}" unless os_types["Types"].has_key? type 
-          end
-        end
-      end
-    end
-    
-    # All of the type values should also be references
-    
-    os_types["Types"].values do |type|
-      if( type.respond_to? :values) then
-        type.values.each do |tv|
-          puts "unknown type #{tv}" unless os_types["Types"].has_key? tv 
-        end
-      end
-    end
-      
-    # declare classes for all of the types with named methods for setting the values
-    class OSType < JSONable
-    end
-  
-    classes = {}
-    
-    # Go through and declare all of the types first
-    os_types["Types"].each_key do |typename|
-      if( ! OSTypes.const_defined? typename ) then
-        klass = OSTypes.const_set( typename, Class.new(OSType ) )
-        classes[typename] = klass
-      else
-        classes[typename] = OSTypes.const_get(typename)
-      end 
-    end
-    
-    # Now go through them again and define attribute setter methods
-    classes.each_pair do |typename,type|
-      #puts typename
-      typeval = os_types["Types"][typename]
-      if( typeval.respond_to? :each_pair ) then
-        typeval.each_pair do |attr_name, attr_type|
-          if( attr_type.kind_of? Array ) then
-            klass = CfnDsl::OSTypes.const_get( attr_type[0] )
-            variable = "@#{attr_name}".to_sym
-            
-            method = CfnDsl::Plurals::singularize(attr_name)
-            methods = attr_name
-            all_methods = CfnDsl::methodNames(method) +
-              CfnDsl::methodNames(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? and rest.length == 0 and ! 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
-                  if( !existing ) then
-                    existing = instance_variable_set( variable, [] )
-                  end
-
-                  # special case for just a block, no args
-                  if( value.nil? and rest.length == 0 and block ) then
-                    val = klass.new
-                    existing.push val
-                    value.instance_eval &block(val)
-                    return existin
-                  end
-                     
-                  # Glue all of our parameters together into
-                  # a giant array - flattening one level deep, if needed
-                  array_params = []
-                  if( value.kind_of? Array) then 
-                    value.each {|x| array_params.push x}
-                  else
-                    array_params.push value
-                  end
-                  if( rest.length > 0) then
-                    rest.each do |v|
-                      if( v.kind_of? Array ) then
-                        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 then
-                    array_params.each do |val|
-                      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
-                    array_params.each do |val|
-                      existing.push value
-                    end
-                  end
-                  return existing
-                end
-              end
-            end
-          else
-            klass = CfnDsl::OSTypes.const_get( attr_type );
-            variable = "@#{attr_name}".to_sym
-
-            type.class_eval do 
-              CfnDsl::methodNames(attr_name) do |method|
-                define_method(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
-  end  
-
-  
-end
-