humidifier 0.7.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed17317e4e90ba482a45ad606fe918e99cd5361d
-  data.tar.gz: 3d7c79b5e6c4fd441480f8ce7b3f6a2a0d882875
+  metadata.gz: fe5b415f92136b9b0615485635bed3a6eaa1216c
+  data.tar.gz: 234763b8d4472cc9d50f3b63b222552e081bb522
 SHA512:
-  metadata.gz: b41b275e02e29db2c24fdf0962a156b4f4c4c0865591bb90331d44707f8c6fa4cc912e122560997e993e22d7afe1ecc948baf1b6da46b0a3d160177400f0ba92
-  data.tar.gz: ed3bdbeef33547d65878241963a6489830d7c8b1eb4abbc69a92ef687ef1e850183dd950f8b797bfc66004d976a82b3e91a2d9d18e3affb8011830ef798c8da2
+  metadata.gz: b8bffb418bb9316b042ed596a175a7a38f3b4e7cf494a5710a3509113f82b2cf0c02476be8a6673d6ddd301859b41c62201cdc4e021d66335384b8dde9ea02f5
+  data.tar.gz: fcf7020a824041b984bc221b279a806f7c67b93f7e73a14db570f8def9689b720c7ee0312ec8d3716f521c01f20ea04021abe1cc5f43711742829495b3503a44

data/README.md

@@ -20,7 +20,7 @@ Stacks are represented by the `Humidifier::Stack` class. You can set any of the
 stack = Humidifier::Stack.new(name: 'Example-Stack', aws_template_format_version: '2010-09-09')
 
 load_balancer = Humidifier::ElasticLoadBalancing::LoadBalancer.new(
-  listeners: [{ LoadBalancerPort: 80, Protocol: 'http', InstancePort: 80, InstanceProtocol: 'http' }]
+  listeners: [{ load_balancer_port: 80, protocol: 'http', instance_port: 80, instance_protocol: 'http' }]
 )
 load_balancer.scheme = 'internal'
 
@@ -92,7 +92,7 @@ The default rake task runs the tests. Coverage is reported on the command line,
 
 ### Specs
 
-The specs pulled from the CFN docs live under `/specs`. You can update them by running `bin/get-specs`. This script will scrape the docs by going to the [listings page](http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html), finding the list of CFN resources, and then downloading the spec for each resource by going to the individual page.
+The specs pulled from the CFN docs lives in `specs/CloudFormationResourceSpecification.json`. You can update it by running `bundle exec rake specs`. This script will pull down the latest [resource specification](http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-resource-specification.html) to be used with Humidifier.
 
 ### Extension
 

data/ext/humidifier/humidifier.c

@@ -1,20 +1,5 @@
 #include <humidifier.h>
 
-// copies from the source string to the destination string after passing through a character whitelist filter
-// note that this is exclusively built for AWS::CloudFormation::Interface, so if AWS ever fixes their docs this can
-// be replaced by strcpy
-static void filter(char* dest, const char* source)
-{
-  int source_idx, dest_idx;
-
-  for (source_idx = 0, dest_idx = 0; source[source_idx] != '\0'; source_idx++) {
-    if (source[source_idx] != ':') {
-      dest[dest_idx++] = source[source_idx];
-    }
-  }
-  dest[dest_idx] = '\0';
-}
-
 // takes a substring from underscore_preprocess like EC2T or AWST and converts it to Ec2T or AwsT
 static void format_substring(char* substr, const int substr_idx, const int capitalize)
 {
@@ -64,7 +49,7 @@ static VALUE underscore(VALUE self, VALUE str)
   char *str_value = rb_string_value_cstr(&str);
   char orig_str[strlen(str_value) + 1];
 
-  filter(orig_str, str_value);
+  strcpy(orig_str, str_value);
   preprocess(orig_str);
 
   // manually null-terminating the string because on Fedora for strings of length 16 this breaks otherwise

data/ext/humidifier/humidifier.h

@@ -4,7 +4,6 @@
 #include <ctype.h>
 #include <ruby.h>
 
-static void filter(char* dest, const char* source);
 static void format_substring(char* substr, const int substr_idx, const int capitalize);
 static void preprocess(char* str);
 static VALUE underscore(VALUE self, VALUE str);

data/lib/humidifier/configuration.rb

@@ -3,6 +3,8 @@ module Humidifier
   # a container for user params
   class Configuration
 
+    # The message that gets displayed when the stack body is too large to use
+    # the template_body option
     UPLOAD_MESSAGE = <<-MSG.freeze
 The %{identifier} stack's body is too large to be use the template_body option, and therefore must use the
 template_url option instead. You can configure Humidifier to do this automatically by setting up the s3 config

data/lib/humidifier/fn.rb

@@ -5,7 +5,8 @@ module Humidifier
 
     # The list of all internal functions provided by AWS from
     # http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html
-    FUNCTIONS = Utils.underscored(%w[And Base64 Equals FindInMap GetAtt GetAZs If Join Not Or Select])
+    FUNCTIONS = Utils.underscored(%w[And Base64 Equals FindInMap GetAtt GetAZs
+                                     If ImportValue Join Not Or Select Sub])
 
     attr_accessor :name, :value
 

data/lib/humidifier/loader.rb

@@ -6,13 +6,44 @@ module Humidifier
   module Config
   end
 
-  # Reads each of the files under /specs/ and loads them each as a class
+  # Reads the specs/CloudFormationResourceSpecification.json file and load each resource as a class
   class Loader
+    # The path to the specification file
+    SPECPATH = File.expand_path(
+      File.join('..', '..', '..', 'specs', 'CloudFormationResourceSpecification.json'),
+      __FILE__
+    )
+
+    # Handles searching the PropertyTypes specifications for a specific resource type
+    class StructureContainer
+      attr_reader :structs
+
+      def initialize(structs)
+        @structs = structs
+      end
+
+      # find the substructures necessary for the given resource key
+      def search(key)
+        results = structs.keys.grep(/#{key}/)
+        Hash[results.map { |result| result.gsub("#{key}.", '') }.zip(structs.values_at(*results))].merge(global)
+      end
+
+      private
+
+      def global
+        @global ||= structs.select { |key, _| !key.match(/AWS/) }
+      end
+    end
 
     # loop through the specs and register each class
     def load
-      spec_directory = File.expand_path(File.join('..', '..', '..', 'specs', '*'), __FILE__)
-      Dir[spec_directory].each { |filepath| load_from(filepath) }
+      parsed   = JSON.parse(File.read(SPECPATH))
+      structs  = StructureContainer.new(parsed['PropertyTypes'])
+
+      parsed['ResourceTypes'].each do |key, spec|
+        match = key.match(/\AAWS::(\w+)::(\w+)\z/)
+        register(match[1], match[2], spec, structs.search(key))
+      end
     end
 
     # convenience class method to build a new loader and call load
@@ -22,28 +53,20 @@ module Humidifier
 
     private
 
-    def build_class(aws_name, spec)
+    def build_class(aws_name, spec, substructs)
       Class.new(Resource) do
         self.aws_name = aws_name
-        self.props = spec.each_with_object({}) do |spec_line, props|
-          prop = Props.from(spec_line)
-          props[prop.name] = prop unless prop.name.nil?
-        end
-      end
-    end
-
-    def load_from(filepath)
-      group, resource = Pathname.new(filepath).basename('.cf').to_s.split('-')
-      spec = File.readlines(filepath).select do |line|
-        # flipflop operator (http://stackoverflow.com/questions/14456634)
-        true if line.include?('Properties')...(line.strip == '}')
+        self.props =
+          Utils.enumerable_to_h(spec['Properties']) do |(key, config)|
+            prop = Props.from(key, config, substructs)
+            [prop.name, prop]
+          end
       end
-      register(group, resource, spec[1..-2])
     end
 
-    def register(group, resource, spec)
+    def register(group, resource, spec, substructs)
       aws_name = "AWS::#{group}::#{resource}"
-      resource_class = build_class(aws_name, spec)
+      resource_class = build_class(aws_name, spec, substructs)
 
       Humidifier.const_set(group, Module.new) unless Humidifier.const_defined?(group)
       Humidifier.const_get(group).const_set(resource, resource_class)

data/lib/humidifier/props/base.rb

@@ -0,0 +1,49 @@
+module Humidifier
+  module Props
+    # Superclass for all CFN properties
+    class Base
+
+      # The list of classes that are valid beyond the normal values for each prop
+      WHITELIST = [Fn, Ref].freeze
+
+      attr_reader :key, :name, :spec, :substructs
+
+      def initialize(key, spec = {}, substructs = {})
+        @key  = key
+        @name = Utils.underscore(key)
+        @spec = spec
+        after_initialize(substructs) if respond_to?(:after_initialize, true)
+      end
+
+      # true if the property type knows how to convert its values
+      def convertable?
+        respond_to?(:convert)
+      end
+
+      # the link to the AWS docs
+      def documentation
+        spec['Documentation']
+      end
+
+      # true if this property is required by the resource
+      def required?
+        spec['Required']
+      end
+
+      # CFN stack syntax
+      def to_cf(value)
+        [key, Serializer.dump(value)]
+      end
+
+      # the type of update that occurs when this property is updated on its associated resource
+      def update_type
+        spec['UpdateType']
+      end
+
+      # true if the given value is of a type contained in the whitelist
+      def whitelisted_value?(value)
+        WHITELIST.any? { |clazz| value.is_a?(clazz) }
+      end
+    end
+  end
+end

data/lib/humidifier/props/boolean_prop.rb

@@ -0,0 +1,21 @@
+module Humidifier
+  module Props
+    # A boolean property
+    class BooleanProp < Base
+      # converts through value == 'true'
+      def convert(value)
+        if %w[true false].include?(value)
+          puts "WARNING: Property #{name} should be a boolean, not a string"
+          value == 'true'
+        else
+          value
+        end
+      end
+
+      # true if it is a boolean
+      def valid?(value)
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      end
+    end
+  end
+end

data/lib/humidifier/props/double_prop.rb

@@ -0,0 +1,17 @@
+module Humidifier
+  module Props
+    # A double property
+    class DoubleProp < Base
+      # converts the value through #to_f unless it is whitelisted
+      def convert(value)
+        puts "WARNING: Property #{name} should be a double" unless valid?(value)
+        value.to_f
+      end
+
+      # true if it is whitelisted, an Integer, or a Float
+      def valid?(value)
+        whitelisted_value?(value) || value.is_a?(Integer) || value.is_a?(Float)
+      end
+    end
+  end
+end

data/lib/humidifier/props/integer_prop.rb

@@ -0,0 +1,17 @@
+module Humidifier
+  module Props
+    # An integer property
+    class IntegerProp < Base
+      # converts the value through #to_i unless it is whitelisted
+      def convert(value)
+        puts "WARNING: Property #{name} should be an integer" unless valid?(value)
+        value.to_i
+      end
+
+      # true if it is whitelisted or a Integer
+      def valid?(value)
+        whitelisted_value?(value) || value.is_a?(Integer)
+      end
+    end
+  end
+end

data/lib/humidifier/props/json_prop.rb

@@ -0,0 +1,11 @@
+module Humidifier
+  module Props
+    # A Json property
+    class JsonProp < Base
+      # true if the value is whitelisted, a Hash, or an Array
+      def valid?(value)
+        whitelisted_value?(value) || value.is_a?(Hash) || value.is_a?(Array)
+      end
+    end
+  end
+end

data/lib/humidifier/props/list_prop.rb

@@ -0,0 +1,20 @@
+module Humidifier
+  module Props
+    # A property that is contained in a list
+    class ListProp < Base
+      attr_reader :subprop
+
+      # Valid if the value is whitelisted or every value in the list is valid on the subprop
+      def valid?(list)
+        whitelisted_value?(list) || (list.is_a?(Enumerable) && list.all? { |value| subprop.valid?(value) })
+      end
+
+      private
+
+      # Finds the subprop that's specified in the spec
+      def after_initialize(substructs)
+        @subprop = Props.singular_from(key, spec, substructs)
+      end
+    end
+  end
+end

data/lib/humidifier/props/map_prop.rb

@@ -0,0 +1,20 @@
+module Humidifier
+  module Props
+    # A property that is contained in a Map
+    class MapProp < Base
+      attr_reader :subprop
+
+      # Valid if the value is whitelisted or every value in the map is valid on the subprop
+      def valid?(map)
+        whitelisted_value?(map) || (map.is_a?(Hash) && map.values.all? { |value| subprop.valid?(value) })
+      end
+
+      private
+
+      # Finds the subprop that's specified in the spec
+      def after_initialize(substructs)
+        @subprop = Props.singular_from(key, spec, substructs)
+      end
+    end
+  end
+end

data/lib/humidifier/props/string_prop.rb

@@ -0,0 +1,17 @@
+module Humidifier
+  module Props
+    # A string property
+    class StringProp < Base
+      # converts the value through #to_s unless it is whitelisted
+      def convert(value)
+        puts "WARNING: Property #{name} should be a string" unless valid?(value)
+        whitelisted_value?(value) ? value : value.to_s
+      end
+
+      # true if it is whitelisted or a String
+      def valid?(value)
+        whitelisted_value?(value) || value.is_a?(String)
+      end
+    end
+  end
+end

data/lib/humidifier/props/structure_prop.rb

@@ -0,0 +1,26 @@
+module Humidifier
+  module Props
+    # A structure property that references a structure from the specification
+    class StructureProp < Base
+      attr_reader :subprops
+
+      # true if the value is whitelisted or Hash and all keys are valid for their corresponding props
+      def valid?(struct)
+        whitelisted_value?(struct) ||
+          (struct.is_a?(Hash) &&
+          struct.all? { |key, value| subprops.key?(key.to_s) && subprops[key.to_s].valid?(value) })
+      end
+
+      private
+
+      def after_initialize(substructs)
+        type = spec['ItemType'] || spec['Type']
+        @subprops =
+          Utils.enumerable_to_h(substructs[type]['Properties']) do |(key, config)|
+            subprop = config['ItemType'] == type ? self : Props.from(nil, config, substructs)
+            [Utils.underscore(key), subprop]
+          end
+      end
+    end
+  end
+end

data/lib/humidifier/props/timestamp_prop.rb

@@ -0,0 +1,17 @@
+module Humidifier
+  module Props
+    # A timestamp (ISO 8601) property
+    class TimestampProp < Base
+      # converts the value through #to_s unless it is whitelisted
+      def convert(value)
+        puts "WARNING: Property #{name} should be a Date or Time" unless valid?(value)
+        valid?(value) ? value : DateTime.parse(value)
+      end
+
+      # true if it is whitelisted, a Time, or a Date
+      def valid?(value)
+        whitelisted_value?(value) || value.is_a?(Time) || value.is_a?(Date)
+      end
+    end
+  end
+end

data/lib/humidifier/props.rb

@@ -2,139 +2,26 @@ module Humidifier
 
   # Container for property of CFN resources
   module Props
-
-    # Superclass for all CFN properties
-    class Base
-
-      # The list of classes that are valid beyond the normal values for each prop
-      WHITELIST = [Fn, Ref].freeze
-
-      attr_accessor :key
-      attr_reader :value
-
-      def initialize(key = nil)
-        self.key = key
-      end
-
-      # true if the property type knows how to convert its values
-      def convertable?
-        respond_to?(:convert)
-      end
-
-      # the name of the property
-      def name
-        @name ||= Utils.underscore(key)
-      end
-
-      # CFN stack syntax
-      def to_cf(value)
-        [key, Serializer.dump(value)]
-      end
-
-      # true if the given value is of a type contained in the whitelist
-      def whitelisted_value?(value)
-        WHITELIST.any? { |clazz| value.is_a?(clazz) }
-      end
-    end
-
-    # An array property
-    class ArrayProp < Base
-      def valid?(value)
-        value.is_a?(Array)
-      end
-    end
-
-    # A boolean property
-    class BooleanProp < Base
-      # converts through value == 'true'
-      def convert(value)
-        if %w[true false].include?(value)
-          puts "WARNING: Property #{name} should be a boolean, not a string"
-          value == 'true'
-        else
-          value
-        end
-      end
-
-      # true if it is a boolean
-      def valid?(value)
-        value.is_a?(TrueClass) || value.is_a?(FalseClass)
-      end
-    end
-
-    # A JSON property (and the default)
-    class JSONProp < Base
-      def valid?(value)
-        whitelisted_value?(value) || value.is_a?(Hash) || value.is_a?(Array)
-      end
-    end
-
-    # An integer property
-    class IntegerProp < Base
-      # converts the value through #to_i unless it is whitelisted
-      def convert(value)
-        puts "WARNING: Property #{name} should be an integer" unless valid?(value)
-        value.to_i
-      end
-
-      # true if it is whitelisted or a Integer
-      def valid?(value)
-        whitelisted_value?(value) || value.is_a?(Integer)
-      end
-    end
-
-    # A string property
-    class StringProp < Base
-      # converts the value through #to_s unless it is whitelisted
-      def convert(value)
-        puts "WARNING: Property #{name} should be a string" unless valid?(value)
-        whitelisted_value?(value) ? value : value.to_s
-      end
-
-      # true if it is whitelisted or a String
-      def valid?(value)
-        whitelisted_value?(value) || value.is_a?(String)
-      end
-    end
-
-    # An number property
-    class NumberProp < Base
-      # converts the value through #to_i unless it is whitelisted
-      def convert(value)
-        puts "WARNING: Property #{name} should be a number" unless valid?(value)
-        value.to_i
-      end
-
-      # true if it is whitelisted or a Integer
-      def valid?(value)
-        whitelisted_value?(value) || value.is_a?(Integer)
-      end
-    end
-
     class << self
       # builds the appropriate prop object from the given spec line
-      def from(spec_line)
-        key, type = parse(spec_line)
-
-        case type
-        when 'Boolean' then BooleanProp.new(key)
-        when 'Integer' then IntegerProp.new(key)
-        when 'String' then StringProp.new(key)
-        when 'Number' then NumberProp.new(key)
-        when /\[.*?\]/ then ArrayProp.new(key)
-        else JSONProp.new(key)
+      def from(key, spec, substructs = {})
+        case spec['Type']
+        when 'List' then ListProp.new(key, spec, substructs)
+        when 'Map'  then MapProp.new(key, spec, substructs)
+        else             singular_from(key, spec, substructs)
         end
       end
 
-      # parses a spec line to return a key and type
-      def parse(spec_line)
-        spec_line.strip!
+      # builds a prop that is not a List or Map type
+      # PrimitiveType is one of Boolean, Double, Integer, Json, String, or Timestamp
+      def singular_from(key, spec, substructs)
+        primitive = spec['PrimitiveItemType'] || spec['PrimitiveType']
 
-        if spec_line.include?(':')
-          key, type = spec_line.gsub(/,\z/, '').split(': ').map(&:strip)
-          [key[1..-2], type]
+        if primitive
+          primitive = 'Integer' if primitive == 'Long'
+          const_get(:"#{primitive}Prop").new(key, spec)
         else
-          [nil, spec_line]
+          StructureProp.new(key, spec, substructs)
         end
       end
     end

data/lib/humidifier/sdk_payload.rb

@@ -82,9 +82,10 @@ MSG
 
     def template_param
       @template_param ||= begin
-        raise TemplateTooLargeError, template_body.bytesize if template_body.bytesize > MAX_TEMPLATE_URL_SIZE
+        bytesize = template_body.bytesize
+        raise TemplateTooLargeError, bytesize if bytesize > MAX_TEMPLATE_URL_SIZE
 
-        if template_body.bytesize > MAX_TEMPLATE_BODY_SIZE
+        if bytesize > MAX_TEMPLATE_BODY_SIZE
           { template_url: AwsShim.upload(self) }
         else
           { template_body: template_body }

data/lib/humidifier/serializer.rb

@@ -7,9 +7,11 @@ module Humidifier
       # dumps the given object out to CFN syntax recursively
       def dump(node)
         case node
-        when Hash then Utils.enumerable_to_h(node) { |(key, value)| [key, dump(value)] }
-        when Array then node.map { |value| dump(value) }
+        when Hash    then Utils.enumerable_to_h(node) { |(key, value)| [key, dump(value)] }
+        when Array   then node.map { |value| dump(value) }
         when Ref, Fn then dump(node.to_cf)
+        when Date    then node.iso8601
+        when Time    then node.to_datetime.iso8601
         else node
         end
       end

data/lib/humidifier/version.rb

@@ -1,4 +1,4 @@
 module Humidifier
   # Gem version
-  VERSION = '0.7.0'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/lib/humidifier.rb

@@ -10,6 +10,11 @@ require 'humidifier/fn'
 require 'humidifier/ref'
 require 'humidifier/props'
 
+require 'humidifier/props/base'
+%w[boolean double integer json list map string structure timestamp].each do |type|
+  require "humidifier/props/#{type}_prop"
+end
+
 require 'humidifier/aws_shim'
 require 'humidifier/condition'
 require 'humidifier/configuration'