sparkle_formation 3.0.30 → 3.0.32

data/lib/sparkle_formation/sparkle_collection.rb

@@ -1,11 +1,11 @@
-require 'sparkle_formation'
+require "sparkle_formation"
 
 class SparkleFormation
   # Provides a collection of sparkles
   # @todo add unmemoize behavior on collection modification to prevent
   # leak on long running processes with long lasting collections
   class SparkleCollection < Sparkle
-    autoload :Rainbow, 'sparkle_formation/sparkle_collection/rainbow'
+    autoload :Rainbow, "sparkle_formation/sparkle_collection/rainbow"
 
     # @return [Symbol] provider
     attr_accessor :provider
@@ -16,7 +16,7 @@ class SparkleFormation
     # @option args [Symbol, String] :provider name of default provider
     # @return [self]
     def initialize(args = {})
-      @provider = Bogo::Utility.snake(args.to_smash.fetch(:provider, 'aws')).to_sym
+      @provider = Bogo::Utility.snake(args.to_smash.fetch(:provider, "aws")).to_sym
       @root = nil
       @sparkles = []
     end
@@ -164,7 +164,7 @@ class SparkleFormation
         target_provider = provider
       end
       result = send(type_name).get(target_provider, name)
-      if result.nil? && type_name == 'templates'
+      if result.nil? && type_name == "templates"
         t_direct = sparkles.map do |pack|
           begin
             pack.get(:template, name, target_provider)

data/lib/sparkle_formation/sparkle_collection/rainbow.rb

@@ -1,5 +1,5 @@
-require 'sparkle_formation'
-require 'forwardable'
+require "sparkle_formation"
+require "forwardable"
 
 class SparkleFormation
   class SparkleCollection
@@ -73,7 +73,7 @@ class SparkleFormation
       def monochrome
         Array.new.tap do |result|
           spectrum.each do |item|
-            unless item.get(:args, :layering).to_s == 'merge'
+            unless item.get(:args, :layering).to_s == "merge"
               result.clear
             end
             result << item

data/lib/sparkle_formation/sparkle_formation.rb

@@ -1,4 +1,4 @@
-require 'sparkle_formation'
+require "sparkle_formation"
 
 # Formation container
 class SparkleFormation
@@ -9,13 +9,13 @@ class SparkleFormation
 
   # @return [Array<String>] directory names to ignore
   IGNORE_DIRECTORIES = [
-    'components',
-    'dynamics',
-    'registry',
+    "components",
+    "dynamics",
+    "registry",
   ]
 
   # @return [String] default stack resource name
-  DEFAULT_STACK_RESOURCE = 'AWS::CloudFormation::Stack'
+  DEFAULT_STACK_RESOURCE = "AWS::CloudFormation::Stack"
   # @return [Array<String>] collection of valid stack resource types
   VALID_STACK_RESOURCES = [DEFAULT_STACK_RESOURCE]
 
@@ -40,9 +40,9 @@ class SparkleFormation
     def sparkle_path=(path = nil)
       if path
         custom_paths[:sparkle_path] = path
-        custom_paths[:components_directory] = File.join(path, 'components')
-        custom_paths[:dynamics_directory] = File.join(path, 'dynamics')
-        custom_paths[:registry_directory] = File.join(path, 'registry')
+        custom_paths[:components_directory] = File.join(path, "components")
+        custom_paths[:dynamics_directory] = File.join(path, "dynamics")
+        custom_paths[:registry_directory] = File.join(path, "registry")
       end
       custom_paths[:sparkle_path]
     end
@@ -141,7 +141,7 @@ class SparkleFormation
     # @return [TrueClass]
     def load_dynamics!(directory)
       @loaded_dynamics ||= []
-      Dir.glob(File.join(directory, '*.rb')).each do |dyn|
+      Dir.glob(File.join(directory, "*.rb")).each do |dyn|
         dyn = File.expand_path(dyn)
         next if @loaded_dynamics.include?(dyn)
         instance_eval(IO.read(dyn), dyn, 1)
@@ -156,7 +156,7 @@ class SparkleFormation
     # @param directory [String]
     # @return [TrueClass]
     def load_registry!(directory)
-      Dir.glob(File.join(directory, '*.rb')).each do |reg|
+      Dir.glob(File.join(directory, "*.rb")).each do |reg|
         reg = File.expand_path(reg)
         require reg
       end
@@ -240,13 +240,13 @@ class SparkleFormation
         result = builtin_insert(dynamic_name, struct, *args, &block)
         unless result
           message = "Failed to locate requested dynamic block for insertion: #{dynamic_name} " \
-          "(valid: #{struct._self.sparkle.dynamics.fetch(struct._self.sparkle.provider, {}).keys.sort.join(', ')})"
+          "(valid: #{struct._self.sparkle.dynamics.fetch(struct._self.sparkle.provider, {}).keys.sort.join(", ")})"
           if struct._self.provider_resources && struct._self.provider_resources.registry.keys.size > 1
             t_name = struct._self.provider_resources.registry.keys.first
             valid_t_name = Bogo::Utility.snake(
               t_name.split(
                 struct._self.provider_resources.resource_type_splitter
-              ).join('_')
+              ).join("_")
             )
             message << "\nBuiltin dynamics pattern `#{t_name}` -> `:#{Bogo::Utility.snake(valid_t_name)}`"
           end
@@ -275,12 +275,12 @@ class SparkleFormation
         __t_stringish(item)
       end
       to_nest = struct._self.sparkle.get(:template, template, options[:provider])
-      resource_name = template.to_s.gsub('__', '_')
+      resource_name = template.to_s.gsub("__", "_")
       unless args.empty?
         resource_name = [
           options.delete(:overwrite_name) ? nil : resource_name,
-          args.map { |a| Bogo::Utility.snake(a) }.join('_'),
-        ].flatten.compact.join('_').to_sym
+          args.map { |a| Bogo::Utility.snake(a) }.join("_"),
+        ].flatten.compact.join("_").to_sym
       end
       resource_name = struct._process_key(resource_name.to_sym)
       nested_template = compile(to_nest[:path], :sparkle)
@@ -318,7 +318,7 @@ class SparkleFormation
           resource_name = [
             _name,
             _config.fetch(:resource_name_suffix, dynamic_name),
-          ].compact.join('_').to_sym
+          ].compact.join("_").to_sym
         else
           resource_name = _name._root
         end
@@ -326,9 +326,9 @@ class SparkleFormation
         new_resource = struct.resources.set!(resource_name)
         new_resource.type lookup_key
         properties = new_resource.properties
-        config_keys = _config.keys.zip(_config.keys.map { |k| snake(k).to_s.tr('_', '') })
+        config_keys = _config.keys.zip(_config.keys.map { |k| snake(k).to_s.tr("_", "") })
         struct._self.provider_resources.resource(dynamic_name, :properties).each do |prop_name|
-          key = (config_keys.detect { |k| k.last == snake(prop_name).to_s.tr('_', '') } || []).first
+          key = (config_keys.detect { |k| k.last == snake(prop_name).to_s.tr("_", "") } || []).first
           value = _config[key] if key
           if value
             if value.is_a?(Proc)
@@ -432,7 +432,7 @@ class SparkleFormation
     end
     self.provider = options.fetch(:provider, @parent ? @parent.provider : :aws)
     if provider == :aws || !options[:disable_aws_builtins]
-      require 'sparkle_formation/aws'
+      require "sparkle_formation/aws"
     end
     @parameters = set_generation_parameters!(
       options.fetch(:compile_time_parameters,
@@ -463,12 +463,12 @@ class SparkleFormation
   def seed_self
     memoize(:seed) do
       options = @seed
-      if options[:inherit] && options[:layering].to_s == 'merge'
-        raise ArgumentError.new 'Cannot merge and inherit!'
+      if options[:inherit] && options[:layering].to_s == "merge"
+        raise ArgumentError.new "Cannot merge and inherit!"
       end
       if options[:inherit]
         inherit_from(options[:inherit])
-      elsif options[:layering].to_s == 'merge'
+      elsif options[:layering].to_s == "merge"
         merge_previous!
       end
       true
@@ -521,7 +521,7 @@ class SparkleFormation
                                       :components => template.composition.composite,
                                       :overrides => composition.overrides)
     composition.components.each do |item|
-      if item.respond_to?(:key) && item.key == '__base__'
+      if item.respond_to?(:key) && item.key == "__base__"
         item.key = Smash.new(
           :template => name,
           :component => :__base__,
@@ -592,12 +592,12 @@ class SparkleFormation
 
   # Attributes allowed for generation parameter definitions
   ALLOWED_GENERATION_PARAMETERS = [
-    'type', 'default', 'description', 'multiple', 'prompt_when_nested',
-    'allowed_values', 'allowed_pattern', 'max_length', 'min_length',
-    'max_value', 'min_value',
+    "type", "default", "description", "multiple", "prompt_when_nested",
+    "allowed_values", "allowed_pattern", "max_length", "min_length",
+    "max_value", "min_value",
   ]
   # Allowed data types for parameters
-  VALID_GENERATION_PARAMETER_TYPES = ['String', 'Number', 'Complex']
+  VALID_GENERATION_PARAMETER_TYPES = ["String", "Number", "Complex"]
 
   # Get or set the compile time parameter setting block. If a get
   # request the ancestor path will be searched to root
@@ -663,7 +663,7 @@ class SparkleFormation
       if thing.is_a?(String)
         # NOTE: This needs to be deprecated and removed
         # TODO: deprecate
-        key = File.basename(thing.to_s).sub('.rb', '')
+        key = File.basename(thing.to_s).sub(".rb", "")
         composition.new_component(key, &self.class.load_component(thing))
       else
         composition.new_component(thing)
@@ -701,7 +701,7 @@ class SparkleFormation
       set_compile_time_parameters!
       if provider && SparkleStruct.const_defined?(camel(provider))
         struct_class = SparkleStruct.const_get(camel(provider))
-        struct_name = [SparkleStruct.name, camel(provider)].join('::')
+        struct_name = [SparkleStruct.name, camel(provider)].join("::")
         struct_class.define_singleton_method(:name) { struct_name }
         struct_class.define_singleton_method(:to_s) { struct_name }
       else
@@ -755,7 +755,7 @@ class SparkleFormation
   def set_compiled_state(compiled)
     storage_compile_state = Smash.new
     parameters.each do |param_key, param_config|
-      if param_config.fetch(:type, 'string').to_s.downcase.to_sym != :complex
+      if param_config.fetch(:type, "string").to_s.downcase.to_sym != :complex
         storage_compile_state[param_key] = compile_state[param_key]
       end
     end
@@ -873,7 +873,7 @@ class SparkleFormation
   # @note will auto downcase name prior to comparison
   def output_matched?(p_name, output_names)
     output_names.detect do |o_name|
-      Bogo::Utility.snake(o_name).tr('_', '') == Bogo::Utility.snake(p_name).tr('_', '')
+      Bogo::Utility.snake(o_name).tr("_", "") == Bogo::Utility.snake(p_name).tr("_", "")
     end
   end
 

data/lib/sparkle_formation/sparkle_struct.rb

@@ -1,5 +1,5 @@
-require 'sparkle_formation'
-require 'attribute_struct/monkey_camels'
+require "sparkle_formation"
+require "attribute_struct/monkey_camels"
 
 class SparkleFormation
 
@@ -74,7 +74,7 @@ class SparkleFormation
     def _self(*_)
       unless @self
         if _parent.nil?
-          ::Kernel.raise ::ArgumentError.new 'Creator did not provide return reference!'
+          ::Kernel.raise ::ArgumentError.new "Creator did not provide return reference!"
         else
           _parent._self
         end
@@ -114,13 +114,13 @@ class SparkleFormation
     # FunctionStruct
     def method_missing(sym, *args, &block)
       if sym.is_a?(::String) || sym.is_a?(::Symbol)
-        if sym.to_s.start_with?('_') || sym.to_s.end_with?('!')
+        if sym.to_s.start_with?("_") || sym.to_s.end_with?("!")
           ::Kernel.raise ::NoMethodError.new "Undefined method `#{sym}` for #{_klass.name}"
         end
       end
       super(*[sym, *args], &block)
       if sym.is_a?(::String) || sym.is_a?(::Symbol)
-        if (s = sym.to_s).end_with?('=')
+        if (s = sym.to_s).end_with?("=")
           s.slice!(-1, s.length)
           sym = s
         end

data/lib/sparkle_formation/translation.rb

@@ -1,12 +1,12 @@
-require 'sparkle_formation'
-require 'multi_json'
-require 'logger'
+require "sparkle_formation"
+require "multi_json"
+require "logger"
 
 class SparkleFormation
   # Translator
   class Translation
-    autoload :Heat, 'sparkle_formation/translation/heat'
-    autoload :Rackspace, 'sparkle_formation/translation/rackspace'
+    autoload :Heat, "sparkle_formation/translation/heat"
+    autoload :Rackspace, "sparkle_formation/translation/rackspace"
 
     include SparkleFormation::Utils::AnimalStrings
     include SparkleFormation::SparkleAttribute
@@ -41,25 +41,25 @@ class SparkleFormation
     # @return [Hash] parameters for template
     def parameters
       Hash[
-        @original.fetch('Parameters', {}).map do |k, v|
-          [k, v.fetch('Default', '')]
+        @original.fetch("Parameters", {}).map do |k, v|
+          [k, v.fetch("Default", "")]
         end
       ].merge(@parameters)
     end
 
     # @return [Hash] mappings for template
     def mappings
-      @original.fetch('Mappings', {})
+      @original.fetch("Mappings", {})
     end
 
     # @return [Hash] resources for template
     def resources
-      @original.fetch('Resources', {})
+      @original.fetch("Resources", {})
     end
 
     # @return [Hash] outputs for template
     def outputs
-      @original.fetch('Outputs', {})
+      @original.fetch("Outputs", {})
     end
 
     # @return [Hash] resource mapping
@@ -96,18 +96,18 @@ class SparkleFormation
     # @return [Hash, NilClass] new resource Hash or nil
     def resource_translation(resource_name, resource_args)
       new_resource = {}
-      lookup = map[:resources][resource_args['Type']]
+      lookup = map[:resources][resource_args["Type"]]
       if lookup.nil?
-        logger.warn "Failed to locate resource type: #{resource_args['Type']}"
+        logger.warn "Failed to locate resource type: #{resource_args["Type"]}"
         nil
       elsif lookup == :delete
         logger.warn "Deleting resource #{resource_name} due to configuration"
         nil
       else
-        new_resource['Type'] = lookup[:name]
-        if resource_args['Properties']
-          new_resource['Properties'] = format_properties(
-            :original_properties => resource_args['Properties'],
+        new_resource["Type"] = lookup[:name]
+        if resource_args["Properties"]
+          new_resource["Properties"] = format_properties(
+            :original_properties => resource_args["Properties"],
             :property_map => lookup[:properties],
             :new_resource => new_resource,
             :original_resource => resource_args,
@@ -130,7 +130,7 @@ class SparkleFormation
     # @option args [Hash] :original_resource
     # @return [Hash]
     def format_properties(args)
-      args[:new_resource]['Properties'] = {}.tap do |new_properties|
+      args[:new_resource]["Properties"] = {}.tap do |new_properties|
         args[:original_properties].each do |property_name, property_value|
           new_key = args[:property_map][property_name]
           if new_key
@@ -147,7 +147,7 @@ class SparkleFormation
             end
           else
             logger.warn "Failed to locate property conversion for `#{property_name}` on " \
-                        "resource type `#{args[:new_resource]['Type']}`. Passing directly."
+                        "resource type `#{args[:new_resource]["Type"]}`. Passing directly."
             new_properties[default_key_format(property_name)] = property_value
           end
         end
@@ -159,8 +159,8 @@ class SparkleFormation
     # @param value [Hash] resources hash
     # @return [Hash]
     def translate_resources(value)
-      translated['Resources'] = {}
-      translated['Resources'].tap do |modified_resources|
+      translated["Resources"] = {}
+      translated["Resources"].tap do |modified_resources|
         value.each do |resource_name, resource_args|
           new_resource = resource_translation(resource_name, resource_args)
           if new_resource
@@ -185,7 +185,7 @@ class SparkleFormation
     def dereference(obj)
       result = obj
       if obj.is_a?(Hash)
-        name = obj['Ref'] || obj['get_param']
+        name = obj["Ref"] || obj["get_param"]
         if name
           p_val = parameters[name.to_s]
           if p_val
@@ -203,7 +203,7 @@ class SparkleFormation
     def resource_name(obj)
       case obj
       when Hash
-        obj['Ref'] || obj['get_resource']
+        obj["Ref"] || obj["get_resource"]
       else
         obj.to_s
       end
@@ -258,13 +258,13 @@ class SparkleFormation
     def apply_rename(hash, names = [])
       k, v = hash.first
       if hash.size == 1
-        if k.start_with?('Fn::')
+        if k.start_with?("Fn::")
           {self.class.const_get(:FN_MAPPING).fetch(k, k) => attr_mapping(*v)}
-        elsif k == 'Ref'
+        elsif k == "Ref"
           if resources.key?(v)
-            {'get_resource' => v}
+            {"get_resource" => v}
           else
-            {'get_param' => self.class.const_get(:REF_MAPPING).fetch(v, v)}
+            {"get_param" => self.class.const_get(:REF_MAPPING).fetch(v, v)}
           end
         else
           hash
@@ -283,7 +283,7 @@ class SparkleFormation
       result = [resource_name, value]
       if r = resources[resource_name]
         attr_map = self.class.const_get(:FN_ATT_MAPPING)
-        if attr_map[r['Type']] && replacement = attr_map[r['Type']][value]
+        if attr_map[r["Type"]] && replacement = attr_map[r["Type"]][value]
           result = [resource_name, *[replacement].flatten.compact]
         end
       end
@@ -299,11 +299,11 @@ class SparkleFormation
     #   replacements using the REF_MAPPING constant
     def apply_function(hash, funcs = [])
       k, v = hash.first
-      if hash.size == 1 && (k.start_with?('Fn') || k == 'Ref') && (funcs.empty? || funcs.include?(k))
+      if hash.size == 1 && (k.start_with?("Fn") || k == "Ref") && (funcs.empty? || funcs.include?(k))
         case k
-        when 'Fn::Join'
+        when "Fn::Join"
           v.last.join(v.first)
-        when 'Fn::FindInMap'
+        when "Fn::FindInMap"
           map_holder = mappings[v[0]]
           if map_holder
             map_item = map_holder[dereference(v[1])]
@@ -315,8 +315,8 @@ class SparkleFormation
           else
             raise "Failed to find mapping! (#{v[0]})"
           end
-        when 'Ref'
-          {'Ref' => self.class.const_get(:REF_MAPPING).fetch(v, v)}
+        when "Ref"
+          {"Ref" => self.class.const_get(:REF_MAPPING).fetch(v, v)}
         else
           hash
         end

data/lib/sparkle_formation/translation/heat.rb

@@ -17,14 +17,14 @@ class SparkleFormation
           translated[snake(k).to_s] = v
         end
         # params
-        cache.fetch('Parameters', {}).each do |k, v|
-          translated['parameters'][k] = Hash[
+        cache.fetch("Parameters", {}).each do |k, v|
+          translated["parameters"][k] = Hash[
             v.map do |key, value|
-              if key == 'Type'
+              if key == "Type"
                 [snake(key).to_s, value.downcase]
-              elsif key == 'AllowedValues'
+              elsif key == "AllowedValues"
                 # @todo fix this up to properly build constraints
-                ['constraints', [{'allowed_values' => value}]]
+                ["constraints", [{"allowed_values" => value}]]
               else
                 [snake(key).to_s, value]
               end
@@ -32,34 +32,34 @@ class SparkleFormation
           ]
         end
         # resources
-        cache.fetch('Resources', {}).each do |r_name, r_value|
-          translated['resources'][r_name] = Hash[
+        cache.fetch("Resources", {}).each do |r_name, r_value|
+          translated["resources"][r_name] = Hash[
             r_value.map do |k, v|
               [snake(k).to_s, v]
             end
           ]
         end
         # outputs
-        cache.fetch('Outputs', {}).each do |o_name, o_value|
-          translated['outputs'][o_name] = Hash[
+        cache.fetch("Outputs", {}).each do |o_name, o_value|
+          translated["outputs"][o_name] = Hash[
             o_value.map do |k, v|
               [snake(k).to_s, v]
             end
           ]
         end
-        translated.delete('awstemplate_format_version')
-        translated['heat_template_version'] = '2013-05-23'
+        translated.delete("awstemplate_format_version")
+        translated["heat_template_version"] = "2013-05-23"
         # no HOT support for mappings, so remove and clean pseudo
         # params in refs
-        if translated['resources']
-          translated['resources'] = dereference_processor(translated['resources'], ['Fn::FindInMap', 'Ref'])
-          translated['resources'] = rename_processor(translated['resources'])
+        if translated["resources"]
+          translated["resources"] = dereference_processor(translated["resources"], ["Fn::FindInMap", "Ref"])
+          translated["resources"] = rename_processor(translated["resources"])
         end
-        if translated['outputs']
-          translated['outputs'] = dereference_processor(translated['outputs'], ['Fn::FindInMap', 'Ref'])
-          translated['outputs'] = rename_processor(translated['outputs'])
+        if translated["outputs"]
+          translated["outputs"] = dereference_processor(translated["outputs"], ["Fn::FindInMap", "Ref"])
+          translated["outputs"] = rename_processor(translated["outputs"])
         end
-        translated.delete('mappings')
+        translated.delete("mappings")
         complete_launch_config_lb_setups
         true
       end
@@ -76,9 +76,9 @@ class SparkleFormation
       # @return [Object]
       # rubocop:disable Metrics/MethodLength
       def neutron_loadbalancer_finalizer(resource_name, new_resource, old_resource)
-        listeners = new_resource['Properties'].delete('listeners') || []
-        healthcheck = new_resource['Properties'].delete('health_check')
-        subnet = (new_resource['Properties'].delete('subnets') || []).first
+        listeners = new_resource["Properties"].delete("listeners") || []
+        healthcheck = new_resource["Properties"].delete("health_check")
+        subnet = (new_resource["Properties"].delete("subnets") || []).first
 
         # if health check is provided, create resource and apply to
         # all pools generated
@@ -86,83 +86,83 @@ class SparkleFormation
           healthcheck_name = "#{resource_name}HealthCheck"
           check = {
             healthcheck_name => {
-              'Type' => 'OS::Neutron::HealthMonitor',
-              'Properties' => {}.tap { |properties|
-                {'Timeout' => 'timeout', 'Interval' => 'delay', 'HealthyThreshold' => 'max_retries'}.each do |aws, hot|
+              "Type" => "OS::Neutron::HealthMonitor",
+              "Properties" => {}.tap { |properties|
+                {"Timeout" => "timeout", "Interval" => "delay", "HealthyThreshold" => "max_retries"}.each do |aws, hot|
                   if healthcheck[aws]
                     properties[hot] = healthcheck[aws]
                   end
                 end
-                type, port, path = healthcheck['Target'].split(%r{(:|/.*)}).find_all { |x| x != ':' }
-                properties['type'] = type
+                type, port, path = healthcheck["Target"].split(%r{(:|/.*)}).find_all { |x| x != ":" }
+                properties["type"] = type
                 if path
-                  properties['url_path'] = path
+                  properties["url_path"] = path
                 end
               },
             },
           }
-          translated['Resources'].merge!(check)
+          translated["Resources"].merge!(check)
         end
 
         base_listener = listeners.shift
         base_pool_name = "#{resource_name}Pool"
         base_pool = {
           base_pool_name => {
-            'Type' => 'OS::Neutron::Pool',
-            'Properties' => {
-              'lb_method' => 'ROUND_ROBIN',
-              'monitors' => [
-                {'get_resource' => healthcheck_name},
+            "Type" => "OS::Neutron::Pool",
+            "Properties" => {
+              "lb_method" => "ROUND_ROBIN",
+              "monitors" => [
+                {"get_resource" => healthcheck_name},
               ],
-              'protocol' => base_listener['Protocol'],
-              'vip' => {
-                'protocol_port' => base_listener['LoadBalancerPort'],
+              "protocol" => base_listener["Protocol"],
+              "vip" => {
+                "protocol_port" => base_listener["LoadBalancerPort"],
               },
-              'subnet' => subnet,
+              "subnet" => subnet,
             },
           },
         }
         if healthcheck
-          base_pool[base_pool_name]['Properties'].merge(
-            'monitors' => [
-              {'get_resource' => healthcheck_name},
+          base_pool[base_pool_name]["Properties"].merge(
+            "monitors" => [
+              {"get_resource" => healthcheck_name},
             ],
           )
         end
 
-        translated['Resources'].merge!(base_pool)
-        new_resource['Properties']['pool_id'] = {'get_resource' => base_pool_name}
-        new_resource['Properties']['protocol_port'] = base_listener['InstancePort']
+        translated["Resources"].merge!(base_pool)
+        new_resource["Properties"]["pool_id"] = {"get_resource" => base_pool_name}
+        new_resource["Properties"]["protocol_port"] = base_listener["InstancePort"]
 
         listeners.each_with_index do |listener, count|
           pool_name = "#{resource_name}PoolVip#{count}"
           pool = {
             pool_name => {
-              'Type' => 'OS::Neutron::Pool',
-              'Properties' => {
-                'lb_method' => 'ROUND_ROBIN',
-                'protocol' => listener['Protocol'],
-                'subnet' => subnet,
-                'vip' => {
-                  'protocol_port' => listener['LoadBalancerPort'],
+              "Type" => "OS::Neutron::Pool",
+              "Properties" => {
+                "lb_method" => "ROUND_ROBIN",
+                "protocol" => listener["Protocol"],
+                "subnet" => subnet,
+                "vip" => {
+                  "protocol_port" => listener["LoadBalancerPort"],
                 },
               },
             },
           }
           if healthcheck
-            pool[pool_name]['Properties'].merge(
-              'monitors' => [
-                {'get_resource' => healthcheck_name},
+            pool[pool_name]["Properties"].merge(
+              "monitors" => [
+                {"get_resource" => healthcheck_name},
               ],
             )
           end
 
           lb_name = "#{resource_name}Vip#{count}"
           lb = {lb_name => MultiJson.load(MultiJson.dump(new_resource))}
-          lb[lb_name]['Properties']['pool_id'] = {'get_resource' => pool_name}
-          lb[lb_name]['Properties']['protocol_port'] = listener['InstancePort']
-          translated['Resources'].merge!(pool)
-          translated['Resources'].merge!(lb)
+          lb[lb_name]["Properties"]["pool_id"] = {"get_resource" => pool_name}
+          lb[lb_name]["Properties"]["protocol_port"] = listener["InstancePort"]
+          translated["Resources"].merge!(pool)
+          translated["Resources"].merge!(lb)
         end
       end
 
@@ -171,18 +171,18 @@ class SparkleFormation
       # multiple listeners (ports) have been defined resulting in
       # multiple isolated LB resources
       def complete_launch_config_lb_setups
-        translated['resources'].find_all do |resource_name, resource|
-          resource['type'] == 'OS::Heat::AutoScalingGroup'
+        translated["resources"].find_all do |resource_name, resource|
+          resource["type"] == "OS::Heat::AutoScalingGroup"
         end.each do |name, value|
-          if lbs = value['properties'].delete('load_balancers')
+          if lbs = value["properties"].delete("load_balancers")
             lbs.each do |lb_ref|
               lb_name = resource_name(lb_ref)
-              lb_resource = translated['resources'][lb_name]
-              vip_resources = translated['resources'].find_all do |k, v|
-                k.match(/#{lb_name}Vip\d+/) && v['type'] == 'OS::Neutron::LoadBalancer'
+              lb_resource = translated["resources"][lb_name]
+              vip_resources = translated["resources"].find_all do |k, v|
+                k.match(/#{lb_name}Vip\d+/) && v["type"] == "OS::Neutron::LoadBalancer"
               end
-              value['properties']['load_balancers'] = vip_resources.map do |vip_name|
-                {'get_resource' => vip_name}
+              value["properties"]["load_balancers"] = vip_resources.map do |vip_name|
+                {"get_resource" => vip_name}
               end
             end
           end
@@ -200,7 +200,7 @@ class SparkleFormation
       # @return [Array<String, Object>] name and new value
       # @todo implement
       def nova_server_block_device_mapping(value, args = {})
-        ['block_device_mapping', value]
+        ["block_device_mapping", value]
       end
 
       # Custom mapping for server user data
@@ -212,8 +212,8 @@ class SparkleFormation
       # @option args [Hash] :original_resource
       # @return [Array<String, Object>] name and new value
       def nova_server_user_data(value, args = {})
-        args[:new_properties][:user_data_format] = 'RAW'
-        args[:new_properties][:config_drive] = 'true'
+        args[:new_properties][:user_data_format] = "RAW"
+        args[:new_properties][:config_drive] = "true"
         [:user_data, Hash[value.values.first]]
       end
 
@@ -225,25 +225,25 @@ class SparkleFormation
       # @param old_resource [Hash]
       # @return [Object]
       def nova_server_finalizer(resource_name, new_resource, old_resource)
-        if old_resource['Metadata']
-          new_resource['Metadata'] = old_resource['Metadata']
-          proceed = new_resource['Metadata'] &&
-                    new_resource['Metadata']['AWS::CloudFormation::Init'] &&
-                    config = new_resource['Metadata']['AWS::CloudFormation::Init']['config']
+        if old_resource["Metadata"]
+          new_resource["Metadata"] = old_resource["Metadata"]
+          proceed = new_resource["Metadata"] &&
+                    new_resource["Metadata"]["AWS::CloudFormation::Init"] &&
+                    config = new_resource["Metadata"]["AWS::CloudFormation::Init"]["config"]
           if proceed
             # NOTE: This is a stupid hack since HOT gives the URL to
             # wget directly and if special characters exist, it fails
-            if files = config['files']
+            if files = config["files"]
               files.each do |key, args|
-                if args['source']
-                  if args['source'].is_a?(String)
-                    args['source'].replace("\"#{args['source']}\"")
+                if args["source"]
+                  if args["source"].is_a?(String)
+                    args["source"].replace("\"#{args["source"]}\"")
                   else
-                    args['source'] = {
-                      'Fn::Join' => [
-                        '', [
+                    args["source"] = {
+                      "Fn::Join" => [
+                        "", [
                           "\"",
-                          args['source'],
+                          args["source"],
                           "\"",
                         ],
                       ],
@@ -265,13 +265,13 @@ class SparkleFormation
       # @param old_resource [Hash]
       # @return [TrueClass]
       def neutron_subnet_finalizer(resource_name, new_resource, old_resource)
-        azs = new_resource['Properties'].delete('availability_zone')
+        azs = new_resource["Properties"].delete("availability_zone")
         if azs
           network_name = "NetworkFor#{resource_name}"
-          translated['Resources'][network_name] = {
-            'type' => 'OS::Neutron::Network',
+          translated["Resources"][network_name] = {
+            "type" => "OS::Neutron::Network",
           }
-          new_resource['Properties']['network'] = {'get_resource' => network_name}
+          new_resource["Properties"]["network"] = {"get_resource" => network_name}
         end
         true
       end
@@ -283,7 +283,7 @@ class SparkleFormation
       # @param old_resource [Hash]
       # @return [TrueClass]
       def neutron_net_finalizer(resource_name, new_resource, old_resource)
-        new_resource['Properties'].clear
+        new_resource["Properties"].clear
         true
       end
 
@@ -312,7 +312,7 @@ class SparkleFormation
       # @return [Array<String, Object>] name and new value
       # @todo implement
       def autoscaling_group_launchconfig(value, args = {})
-        ['resource', value]
+        ["resource", value]
       end
 
       # Default keys to snake cased format (underscore)
@@ -326,71 +326,71 @@ class SparkleFormation
       # Heat translation mapping
       MAP = {
         :resources => {
-          'AWS::EC2::Instance' => {
-            :name => 'OS::Nova::Server',
+          "AWS::EC2::Instance" => {
+            :name => "OS::Nova::Server",
             :finalizer => :nova_server_finalizer,
             :properties => {
-              'AvailabilityZone' => 'availability_zone',
-              'BlockDeviceMappings' => :nova_server_block_device_mapping,
-              'ImageId' => 'image',
-              'InstanceType' => 'flavor',
-              'KeyName' => 'key_name',
-              'NetworkInterfaces' => 'networks',
-              'SecurityGroups' => 'security_groups',
-              'SecurityGroupIds' => 'security_groups',
-              'Tags' => 'metadata',
-              'UserData' => :nova_server_user_data,
+              "AvailabilityZone" => "availability_zone",
+              "BlockDeviceMappings" => :nova_server_block_device_mapping,
+              "ImageId" => "image",
+              "InstanceType" => "flavor",
+              "KeyName" => "key_name",
+              "NetworkInterfaces" => "networks",
+              "SecurityGroups" => "security_groups",
+              "SecurityGroupIds" => "security_groups",
+              "Tags" => "metadata",
+              "UserData" => :nova_server_user_data,
             },
           },
-          'AWS::AutoScaling::AutoScalingGroup' => {
-            :name => 'OS::Heat::AutoScalingGroup',
+          "AWS::AutoScaling::AutoScalingGroup" => {
+            :name => "OS::Heat::AutoScalingGroup",
             :properties => {
-              'Cooldown' => 'cooldown',
-              'DesiredCapacity' => 'desired_capacity',
-              'MaxSize' => 'max_size',
-              'MinSize' => 'min_size',
-              'LaunchConfigurationName' => :autoscaling_group_launchconfig,
+              "Cooldown" => "cooldown",
+              "DesiredCapacity" => "desired_capacity",
+              "MaxSize" => "max_size",
+              "MinSize" => "min_size",
+              "LaunchConfigurationName" => :autoscaling_group_launchconfig,
             },
           },
-          'AWS::AutoScaling::LaunchConfiguration' => :delete,
-          'AWS::ElasticLoadBalancing::LoadBalancer' => {
-            :name => 'OS::Neutron::LoadBalancer',
+          "AWS::AutoScaling::LaunchConfiguration" => :delete,
+          "AWS::ElasticLoadBalancing::LoadBalancer" => {
+            :name => "OS::Neutron::LoadBalancer",
             :finalizer => :neutron_loadbalancer_finalizer,
             :properties => {
-              'Instances' => 'members',
-              'Listeners' => 'listeners',
-              'HealthCheck' => 'health_check',
-              'Subnets' => 'subnets',
+              "Instances" => "members",
+              "Listeners" => "listeners",
+              "HealthCheck" => "health_check",
+              "Subnets" => "subnets",
             },
           },
-          'AWS::EC2::VPC' => {
-            :name => 'OS::Neutron::Net',
+          "AWS::EC2::VPC" => {
+            :name => "OS::Neutron::Net",
             :finalizer => :neutron_net_finalizer,
             :properties => {
-              'CidrBlock' => 'cidr',
+              "CidrBlock" => "cidr",
             },
           },
-          'AWS::EC2::Subnet' => {
-            :name => 'OS::Neutron::Subnet',
+          "AWS::EC2::Subnet" => {
+            :name => "OS::Neutron::Subnet",
             :finalizer => :neutron_subnet_finalizer,
             :properties => {
-              'CidrBlock' => 'cidr',
-              'VpcId' => 'network',
-              'AvailabilityZone' => 'availability_zone',
+              "CidrBlock" => "cidr",
+              "VpcId" => "network",
+              "AvailabilityZone" => "availability_zone",
             },
           },
         },
       }
 
       REF_MAPPING = {
-        'AWS::StackName' => 'OS::stack_name',
-        'AWS::StackId' => 'OS::stack_id',
-        'AWS::Region' => 'OS::stack_id', # @todo i see it set in source, but no function. wat
+        "AWS::StackName" => "OS::stack_name",
+        "AWS::StackId" => "OS::stack_id",
+        "AWS::Region" => "OS::stack_id", # @todo i see it set in source, but no function. wat
       }
 
       FN_MAPPING = {
-        'Fn::GetAtt' => 'get_attr',
-        'Fn::Join' => 'list_join',
+        "Fn::GetAtt" => "get_attr",
+        "Fn::Join" => "list_join",
       }
     end
   end