humidifier 4.1.1 → 4.2.0

data/lib/humidifier/loader.rb

@@ -4,39 +4,58 @@ module Humidifier
   # Reads the specs/CloudFormationResourceSpecification.json file and load each
   # resource as a class
   module Loader
-    # Handles searching the PropertyTypes specifications for a specific
-    # resource type
-    class PropertyTypes
-      attr_reader :structs
+    class Compiler
+      attr_reader :specification, :property_types
 
-      def initialize(structs)
-        @structs = structs
-      end
+      def initialize(specification)
+        @specification = specification
 
-      # find the substructures necessary for the given resource key
-      def search(key)
-        results = structs.keys.grep(/#{key}/)
-        shortened_names = results.map { |result| result.gsub("#{key}.", '') }
-        shortened_names.zip(structs.values_at(*results)).to_h.merge(global)
+        # Set an initial value for each property types so that we can handle
+        # cycles in the specification
+        @property_types = specification["PropertyTypes"].to_h do |name, _|
+          [name, {}]
+        end
       end
 
-      private
+      def compile
+        # Loop through every property type that's already defined and build up
+        # each of the properties into the list
+        property_types.each do |property_type_name, property_type|
+          prefix = property_type_name.split(".", 2).first
 
-      def global
-        @global ||= structs.reject { |key, _| key.match(/AWS/) }
-      end
-    end
+          subspec = specification["PropertyTypes"].fetch(property_type_name)
+          subspec.fetch("Properties") { {} }.each do |property_name, property|
+            property = build_property(prefix, property_name, property)
+            property_type[property.name] = property if property
+          end
+        end
+
+        # Loop through every resource type in the specification and define a
+        # class for each one dynamically.
+        specification["ResourceTypes"].each do |aws_name, resource_type|
+          _top, group, resource = aws_name.split("::")
+
+          properties = {}
+          resource_type["Properties"].each do |property_name, property|
+            property = build_property(aws_name, property_name, property)
+            properties[property.name] = property if property
+          end
 
-    class << self
-      # loop through the specs and register each class
-      def load
-        parsed = parse_spec
-        return unless parsed
+          resource_class =
+            Class.new(Resource) do
+              self.aws_name = aws_name
+              self.props = properties
+            end
 
-        types = PropertyTypes.new(parsed['PropertyTypes'])
-        parsed['ResourceTypes'].each do |key, spec|
-          match = key.match(/\A(\w+)::(\w+)::(\w+)\z/)
-          register(match[1], match[2], match[3], spec, types.search(key))
+          group_module =
+            if Humidifier.const_defined?(group)
+              Humidifier.const_get(group)
+            else
+              Humidifier.const_set(group, Module.new)
+            end
+
+          Humidifier.registry[aws_name] =
+            group_module.const_set(resource, resource_class)
         end
 
         Humidifier.registry.freeze
@@ -44,35 +63,72 @@ module Humidifier
 
       private
 
-      def build_class(aws_name, spec, substructs)
-        Class.new(Resource) do
-          self.aws_name = aws_name
-          self.props =
-            spec['Properties'].map do |(key, config)|
-              prop = Props.from(key, config, substructs)
-              [prop.name, prop]
-            end.to_h
+      def build_primitive(type, name, spec)
+        case type
+        in "Boolean"
+          Props::BooleanProp.new(name, spec)
+        in "Double"
+          Props::DoubleProp.new(name, spec)
+        in "Integer" | "Long"
+          Props::IntegerProp.new(name, spec)
+        in "Json"
+          Props::JsonProp.new(name, spec)
+        in "String"
+          Props::StringProp.new(name, spec)
+        in "Timestamp"
+          Props::TimestampProp.new(name, spec)
         end
       end
 
-      def parse_spec
-        path = File.expand_path(File.join('..', '..', SPECIFICATION), __dir__)
-        return unless File.file?(path)
-
-        JSON.parse(File.read(path))
+      def build_property(prefix, name, spec)
+        case spec.transform_keys(&:to_sym)
+        in { PrimitiveType: type }
+          build_primitive(type, name, spec)
+        in { Type: "List", PrimitiveItemType: type }
+          Props::ListProp.new(name, spec, build_primitive(type, name, spec))
+        in { Type: "Map", PrimitiveItemType: type }
+          Props::MapProp.new(name, spec, build_primitive(type, name, spec))
+        in { Type: "List", ItemType: "List" }
+          # specifically calling this out since
+          # AWS::Rekognition::StreamProcessor.PolygonRegionsOfInterest has a
+          # nested list structure that otherwise breaks the compiler
+          Props::ListProp.new(name, spec, Props::ListProp.new(name, spec))
+        in { Type: "List", ItemType: item_type }
+          Props::ListProp.new(
+            name,
+            spec,
+            Props::StructureProp.new(name, spec,
+                                     property_type(prefix, item_type))
+          )
+        in { Type: "Map", ItemType: item_type }
+          Props::MapProp.new(
+            name,
+            spec,
+            Props::StructureProp.new(name, spec,
+                                     property_type(prefix, item_type))
+          )
+        in { Type: type }
+          Props::StructureProp.new(name, spec, property_type(prefix, type))
+        else # rubocop:disable Layout/IndentationWidth
+          # It's possible to hit this clause if the specification has a property
+          # that is not currently supported by CloudFormation. In this case,
+          # we're not going to create a property at all for it.
+        end
       end
 
-      def register(top, group, resource, spec, substructs)
-        aws_name = "#{top}::#{group}::#{resource}"
-        resource_class = build_class(aws_name, spec, substructs)
-
-        unless Humidifier.const_defined?(group)
-          Humidifier.const_set(group, Module.new)
+      def property_type(prefix, type)
+        property_types.fetch("#{prefix}.#{type}") do
+          property_types.fetch(type)
         end
-
-        Humidifier.const_get(group).const_set(resource, resource_class)
-        Humidifier.registry[aws_name] = resource_class
       end
     end
+
+    # loop through the specs and register each class
+    def self.load
+      filepath = File.expand_path("../../#{SPECIFICATION}", __dir__)
+      return unless File.file?(filepath)
+
+      Compiler.new(JSON.parse(File.read(filepath))).compile
+    end
   end
 end

data/lib/humidifier/output.rb

@@ -11,9 +11,9 @@ module Humidifier
     end
 
     def to_cf
-      { 'Value' => Serializer.dump(value) }.tap do |cf|
-        cf['Description'] = description if description
-        cf['Export'] = { 'Name' => export_name } if export_name
+      { "Value" => Serializer.dump(value) }.tap do |cf|
+        cf["Description"] = description if description
+        cf["Export"] = { "Name" => export_name } if export_name
       end
     end
   end

data/lib/humidifier/parameter.rb

@@ -15,12 +15,12 @@ module Humidifier
         instance_variable_set(:"@#{property}", opts[property])
       end
 
-      @type = opts.fetch(:type, 'String')
+      @type = opts.fetch(:type, "String")
     end
 
     # CFN stack syntax
     def to_cf
-      { 'Type' => type }.tap do |cf|
+      { "Type" => type }.tap do |cf|
         PROPERTIES.each do |name, prop|
           value = public_send(prop)
           cf[name] = Serializer.dump(value) if value

data/lib/humidifier/props.rb

@@ -18,12 +18,12 @@ module Humidifier
 
       # the link to the AWS docs
       def documentation
-        spec['Documentation']
+        spec["Documentation"]
       end
 
       # true if this property is required by the resource
       def required?
-        spec['Required']
+        spec["Required"]
       end
 
       # CFN stack syntax
@@ -34,7 +34,7 @@ module Humidifier
       # the type of update that occurs when this property is updated on its
       # associated resource
       def update_type
-        spec['UpdateType']
+        spec["UpdateType"]
       end
 
       def valid?(value)
@@ -55,34 +55,70 @@ module Humidifier
 
     class BooleanProp < Prop
       allow_type TrueClass, FalseClass
+
+      def pretty_print(q)
+        q.text("(#{name}=boolean)")
+      end
     end
 
     class DoubleProp < Prop
       allow_type Integer, Float
+
+      def pretty_print(q)
+        q.text("(#{name}=double)")
+      end
     end
 
     class IntegerProp < Prop
       allow_type Integer
+
+      def pretty_print(q)
+        q.text("(#{name}=integer)")
+      end
     end
 
     class JsonProp < Prop
       allow_type Hash
+
+      def pretty_print(q)
+        q.text("(#{name}=json)")
+      end
     end
 
     class StringProp < Prop
       allow_type String
+
+      def pretty_print(q)
+        q.text("(#{name}=string)")
+      end
     end
 
     class TimestampProp < Prop
       allow_type Time, Date
+
+      def pretty_print(q)
+        q.text("(#{name}=timestamp)")
+      end
     end
 
     class ListProp < Prop
       attr_reader :subprop
 
-      def initialize(key, spec = {}, substructs = {})
+      def initialize(key, spec = {}, subprop = nil)
         super(key, spec)
-        @subprop = Props.singular_from(key, spec, substructs)
+        @subprop = subprop
+      end
+
+      def pretty_print(q)
+        q.group do
+          q.text("(#{name}=list")
+          q.nest(2) do
+            q.breakable
+            q.pp(subprop)
+          end
+          q.breakable("")
+          q.text(")")
+        end
       end
 
       def to_cf(list)
@@ -106,9 +142,21 @@ module Humidifier
     class MapProp < Prop
       attr_reader :subprop
 
-      def initialize(key, spec = {}, substructs = {})
+      def initialize(key, spec = {}, subprop = nil)
         super(key, spec)
-        @subprop = Props.singular_from(key, spec, substructs)
+        @subprop = subprop
+      end
+
+      def pretty_print(q)
+        q.group do
+          q.text("(#{name}=map")
+          q.nest(2) do
+            q.breakable
+            q.pp(subprop)
+          end
+          q.breakable("")
+          q.text(")")
+        end
       end
 
       def to_cf(map)
@@ -116,9 +164,9 @@ module Humidifier
           if map.respond_to?(:to_cf)
             map.to_cf
           else
-            map.map do |subkey, subvalue|
+            map.to_h do |subkey, subvalue|
               [subkey, subprop.to_cf(subvalue).last]
-            end.to_h
+            end
           end
 
         [key, cf_value]
@@ -134,9 +182,21 @@ module Humidifier
     class StructureProp < Prop
       attr_reader :subprops
 
-      def initialize(key, spec = {}, substructs = {})
+      def initialize(key, spec = {}, subprops = {})
         super(key, spec)
-        @subprops = subprops_from(substructs, spec['ItemType'] || spec['Type'])
+        @subprops = subprops
+      end
+
+      def pretty_print(q)
+        q.group do
+          q.text("(#{name}=structure")
+          q.nest(2) do
+            q.breakable
+            q.seplist(subprops.values) { |subprop| q.pp(subprop) }
+          end
+          q.breakable("")
+          q.text(")")
+        end
       end
 
       def to_cf(struct)
@@ -144,9 +204,9 @@ module Humidifier
           if struct.respond_to?(:to_cf)
             struct.to_cf
           else
-            struct.map do |subkey, subvalue|
+            struct.to_h do |subkey, subvalue|
               subprops[subkey.to_s].to_cf(subvalue)
-            end.to_h
+            end
           end
 
         [key, cf_value]
@@ -158,49 +218,11 @@ module Humidifier
 
       private
 
-      def subprops_from(substructs, type)
-        subprop_names = substructs.fetch(type, {}).fetch('Properties', {})
-
-        subprop_names.each_with_object({}) do |(key, config), subprops|
-          subprops[key.underscore] =
-            if config['ItemType'] == type
-              self
-            else
-              Props.from(key, config, substructs)
-            end
-        end
-      end
-
       def valid_struct?(struct)
         struct.all? do |key, value|
           subprops.key?(key.to_s) && subprops[key.to_s].valid?(value)
         end
       end
     end
-
-    class << self
-      # builds the appropriate prop object from the given spec line
-      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
-
-      # 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 primitive && !%w[List Map].include?(primitive)
-          primitive = 'Integer' if primitive == 'Long'
-          const_get(:"#{primitive}Prop").new(key, spec)
-        else
-          StructureProp.new(key, spec, substructs)
-        end
-      end
-    end
   end
 end

data/lib/humidifier/ref.rb

@@ -11,7 +11,7 @@ module Humidifier
 
     # Builds CFN syntax
     def to_cf
-      { 'Ref' => Serializer.dump(reference) }
+      { "Ref" => Serializer.dump(reference) }
     end
   end
 end

data/lib/humidifier/resource.rb

@@ -45,8 +45,8 @@ module Humidifier
         end
 
       common_attributes.merge!(
-        'Type' => self.class.aws_name,
-        'Properties' => props_cf.to_h
+        "Type" => self.class.aws_name,
+        "Properties" => props_cf.to_h
       )
     end
 
@@ -114,7 +114,7 @@ module Humidifier
 
     def validate_property(property)
       unless self.class.prop?(property)
-        raise ArgumentError, 'Attempting to set invalid property for ' \
+        raise ArgumentError, "Attempting to set invalid property for " \
                              "#{self.class.name}: #{property}"
       end
 

data/lib/humidifier/serializer.rb

@@ -5,9 +5,9 @@ module Humidifier
   class Serializer
     class << self
       # dumps the given object out to CFN syntax recursively
-      def dump(node) # rubocop:disable Metrics/CyclomaticComplexity
+      def dump(node)
         case node
-        when Hash    then node.map { |key, value| [key, dump(value)] }.to_h
+        when Hash    then node.to_h { |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

data/lib/humidifier/stack.rb

@@ -14,8 +14,8 @@ module Humidifier
         super(
           "Cannot use a template > #{MAX_TEMPLATE_URL_SIZE} bytes " \
           "(currently #{bytesize} bytes), consider using nested stacks " \
-          '(http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide' \
-          '/aws-properties-stack.html)'
+          "(http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide" \
+          "/aws-properties-stack.html)"
         )
       end
     end
@@ -37,7 +37,7 @@ module Humidifier
     end
 
     # The AWS region, can be set through the environment, defaults to us-east-1
-    AWS_REGION = ENV['AWS_REGION'] || 'us-east-1'
+    AWS_REGION = ENV.fetch("AWS_REGION", "us-east-1")
 
     # Lists of objects linked to the stack
     ENUMERABLE_RESOURCES =
@@ -184,7 +184,7 @@ module Humidifier
       perform_and_wait(:update, opts)
     end
 
-    def upload # rubocop:disable Metrics/AbcSize
+    def upload
       raise NoResourcesError.new(self, :upload) unless resources.any?
 
       bucket = Humidifier.config.s3_bucket
@@ -231,9 +231,9 @@ module Humidifier
         next if resources.empty?
 
         list[name] =
-          resources.map do |resource_name, resource|
+          resources.to_h do |resource_name, resource|
             [resource_name, resource.to_cf]
-          end.to_h
+          end
       end
     end
 

data/lib/humidifier/upgrade.rb

@@ -2,19 +2,19 @@
 
 module Humidifier
   class Upgrade
-    PATH = -File.expand_path(File.join('..', '..', SPECIFICATION), __dir__)
-    URL = 'https://docs.aws.amazon.com/AWSCloudFormation/latest' \
-          '/UserGuide/cfn-resource-specification.html'
+    PATH = -File.expand_path(File.join("..", "..", SPECIFICATION), __dir__)
+    URL = "https://docs.aws.amazon.com/AWSCloudFormation/latest" \
+          "/UserGuide/cfn-resource-specification.html"
 
     def perform
-      require 'net/http'
-      require 'nokogiri'
+      require "net/http"
+      require "nokogiri"
 
       response = Net::HTTP.get_response(uri).body
       parsed = JSON.parse(response)
 
       File.write(PATH, JSON.pretty_generate(parsed))
-      parsed['ResourceSpecificationVersion']
+      parsed["ResourceSpecificationVersion"]
     end
 
     def self.perform
@@ -28,11 +28,11 @@ module Humidifier
     end
 
     def uri
-      Nokogiri::HTML(page).css('table tr').detect do |tr|
-        name = tr.at_css('td:first-child p')
-        next if !name || name.text.strip != 'US East (N. Virginia)'
+      Nokogiri::HTML(page).css("table tr").detect do |tr|
+        name = tr.at_css("td:first-child p")
+        next if !name || name.text.strip != "US East (N. Virginia)"
 
-        break URI.parse(tr.at_css('td:nth-child(3) p a').attr('href'))
+        break URI.parse(tr.at_css("td:nth-child(3) p a").attr("href"))
       end
     end
   end

data/lib/humidifier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Humidifier
-  VERSION = '4.1.1'
+  VERSION = "4.2.0"
 end

data/lib/humidifier.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'json'
-require 'pathname'
-require 'yaml'
+require "date"
+require "json"
+require "pathname"
+require "yaml"
 
-require 'aws-sdk-cloudformation'
-require 'aws-sdk-s3'
-require 'fast_underscore'
-require 'thor'
-require 'thor/hollaback'
+require "aws-sdk-cloudformation"
+require "aws-sdk-s3"
+require "fast_underscore"
+require "thor"
+require "thor/hollaback"
 
 # Hook into the string extension and ensure it works for certain AWS acronyms
 String.prepend(
@@ -23,7 +23,7 @@ String.prepend(
 # container module for all gem classes
 module Humidifier
   # The file name of the specification for consistency.
-  SPECIFICATION = 'CloudFormationResourceSpecification.json'
+  SPECIFICATION = "CloudFormationResourceSpecification.json"
 
   # A parent class for all Humidifier errors for easier rescuing.
   class Error < StandardError; end
@@ -61,30 +61,30 @@ module Humidifier
 
     # a frozen hash of the given names mapped to their underscored version
     def underscore(names)
-      names.map { |name| [name, name.underscore.to_sym] }.to_h.freeze
+      names.to_h { |name| [name, name.underscore.to_sym] }.freeze
     end
   end
 end
 
-require 'humidifier/fn'
-require 'humidifier/ref'
-require 'humidifier/props'
-
-require 'humidifier/cli'
-require 'humidifier/condition'
-require 'humidifier/directory'
-require 'humidifier/loader'
-require 'humidifier/mapping'
-require 'humidifier/output'
-require 'humidifier/parameter'
-require 'humidifier/resource'
-require 'humidifier/serializer'
-require 'humidifier/stack'
-require 'humidifier/upgrade'
-require 'humidifier/version'
-
-require 'humidifier/config'
-require 'humidifier/config/mapper'
-require 'humidifier/config/mapping'
+require "humidifier/fn"
+require "humidifier/ref"
+require "humidifier/props"
+
+require "humidifier/cli"
+require "humidifier/condition"
+require "humidifier/directory"
+require "humidifier/loader"
+require "humidifier/mapping"
+require "humidifier/output"
+require "humidifier/parameter"
+require "humidifier/resource"
+require "humidifier/serializer"
+require "humidifier/stack"
+require "humidifier/upgrade"
+require "humidifier/version"
+
+require "humidifier/config"
+require "humidifier/config/mapper"
+require "humidifier/config/mapping"
 
 Humidifier::Loader.load