sfn 3.0.26 → 3.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1000514f95a36a106dc13fd6eaf7a38a9e716776
-  data.tar.gz: fc0d733bafcd09198a2a56252c574956ded1ae22
+  metadata.gz: 403602f06deb39fe3f2751236c97dd6f06443431
+  data.tar.gz: 69f16806fb62a281b40d8f6588b4d5bf5772419d
 SHA512:
-  metadata.gz: 7ef25e6f6722a338b428d5707dde1912d0c94a8c3adab30a297fe9ad830f0cbc415eff1130e3f824bcc0d46bd2f6e423259595f6093486dd3efe51d50e8d801c
-  data.tar.gz: a179f76dd94173102a5e6d07fb20e91a4f689b21a02a6d79024d09bc10c373dee37403f8e15e7152692642de738c457039d76523c9a5c693408e195df8e2b4dc
+  metadata.gz: b36166fbdb2424563aec23d2c068616264582b25192ab4e377ae7312aa210d1565d721270af1885bc14196e4f56a05afa47afa1b926a815de278aa8c90591415
+  data.tar.gz: 710cf024266fbe9725150f0930756e28d5a284b85db61ad033b048e106fd90bc3cd94c3c8e4b316f474b65e2148acc3e02afa9b06c2b3f676f557cb48a09c07d

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v3.0.28
+* [fix] Fix stack save policy callback (#264)
+* [fix] Prevent processing unset event arrays
+* [enhancement] Support graphing terraform provider templates
+
 # v3.0.26
 * [fix] Properly support compile time parameter setting with/without stack name (#261)
 * [fix] Default stack name when storing policy internally if no name provided

data/lib/sfn/api_provider/terraform.rb

@@ -66,6 +66,5 @@ module Sfn
       end
 
     end
-
   end
 end

data/lib/sfn/callback/stack_policy.rb

@@ -80,8 +80,8 @@ module Sfn
           @policies[p_stack.name]
         ).to_smash
         if(stack_policy)
-          stack_policy[:statement].delete_if do |policy_item|
-            policy_match = policy_item[:resource].to_s.match(
+          stack_policy[:Statement].delete_if do |policy_item|
+            policy_match = policy_item[:Resource].to_s.match(
               %r{LogicalResourceId/(?<logical_id>.+)$}
             )
             if(policy_match)

data/lib/sfn/command.rb

@@ -65,13 +65,13 @@ module Sfn
     # @return [TrueClass, FalseClass]
     def load_api_provider_extensions!
       if(config.get(:credentials, :provider))
-        base_ext = Bogo::Utility.camel(config.get(:credentials, :provider))
+        base_ext = Bogo::Utility.camel(config.get(:credentials, :provider)).to_sym
         targ_ext = self.class.name.split('::').last
-        if(ApiProvider.const_defined?(base_ext))
+        if(ApiProvider.constants.include?(base_ext))
           base_module = ApiProvider.const_get(base_ext)
           ui.debug "Loading core provider extensions via `#{base_module}`"
           extend base_module
-          if(base_module.const_defined?(targ_ext))
+          if(base_module.constants.include?(targ_ext))
             targ_module = base_module.const_get(targ_ext)
             ui.debug "Loading targeted provider extensions via `#{targ_module}`"
             extend targ_module

data/lib/sfn/command/events.rb

@@ -63,6 +63,7 @@ module Sfn
       # @return [Array<Hash>]
       def get_events(*args)
         stack_events = discover_stacks(stack).map do |i_stack|
+          i_events = []
           begin
             if(@initial_complete && i_stack.in_progress?)
               i_events = i_stack.events.update!
@@ -73,12 +74,17 @@ module Sfn
             if(e.class.to_s.start_with?('Errno'))
               ui.warn "Connection error encountered: #{e.message} (retrying)"
               ui.debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
-              sleep(5)
-              retry
+            else
+              ui.error "Unexpected error received fetching events: #{e.message}"
+              ui.debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
             end
+            sleep(5)
+            retry
           end
-          i_events.map do |e|
-            e.attributes.merge(:stack_name => i_stack.name).to_smash
+          if(i_events)
+            i_events.map do |e|
+              e.attributes.merge(:stack_name => i_stack.name).to_smash
+            end
           end
         end.flatten.compact.find_all{|e| e[:time] }.reverse
         stack_events.delete_if{|evt| @seen_events.include?(evt)}

data/lib/sfn/command/graph.rb

@@ -6,6 +6,8 @@ module Sfn
     # Graph command
     class Graph < Command
 
+      autoload :Provider, 'sfn/command/graph/provider'
+
       include Sfn::CommandModule::Base
       include Sfn::CommandModule::Template
       include Sfn::CommandModule::Stack
@@ -21,13 +23,17 @@ module Sfn
         config[:print_only] = true
         validate_graph_style!
         file = load_template_file
-        if(file.provider == :aws)
+        provider = Bogo::Utility.camel(file.provider).to_sym
+        if(Provider.constants.include?(provider))
+          graph_const = Provider.const_get(provider)
+          ui.debug "Loading provider graph implementation - #{graph_const}"
+          extend graph_const
           @outputs = Smash.new
           ui.info "Template resource graph generation - Style: #{ui.color(config[:graph_style], :bold)}"
           if(config[:file])
             ui.puts "  -> path: #{config[:file]}"
           end
-          template_dump = file.compile.dump!.to_smash
+          template_dump = file.compile.sparkle_dump!.to_smash
           run_action 'Pre-processing template for graphing' do
             output_discovery(template_dump, @outputs, nil, nil)
             ui.debug 'Output remapping results from pre-processing:'
@@ -53,8 +59,11 @@ module Sfn
             nil
           end
         else
+          valid_providers = Provider.constants.sort.map{ |provider|
+            Bogo::Utility.snake(provider)
+          }.join('`, `')
           ui.error "Graphing for provider `#{file.provider}` not currently supported."
-          ui.error "Currently supported providers: `aws`."
+          ui.error "Currently supported providers: `#{valid_providers}`."
         end
       end
 
@@ -77,137 +86,6 @@ module Sfn
         graph
       end
 
-      def output_discovery(template, outputs, resource_name, parent_template, name='')
-        if(template['Resources'])
-          template['Resources'].keys.each do |r_name|
-            r_info = template['Resources'][r_name]
-            if(r_info['Type'] == 'AWS::CloudFormation::Stack')
-              output_discovery(r_info['Properties']['Stack'], outputs, r_name, template, r_name)
-            end
-          end
-        end
-        if(parent_template)
-          ui.debug "Pre-processing stack resource `#{resource_name}`"
-          substack_parameters = Smash[
-            parent_template.fetch('Resources', resource_name, 'Properties', 'Parameters', {}).map do |key, value|
-              result = [key, value]
-              if(value.is_a?(Hash))
-                v_key = value.keys.first
-                v_value = value.values.first
-                if(v_key == 'Fn::GetAtt' && parent_template.fetch('Resources', {}).keys.include?(v_value.first) && v_value.last.start_with?('Outputs.'))
-                  output_key = v_value.first + '__' + v_value.last.split('.', 2).last
-                  ui.debug "Output key for check: #{output_key}"
-                  if(outputs.key?(output_key))
-                    new_value = outputs[output_key]
-                    result = [key, new_value]
-                    ui.debug "Parameter for output swap `#{key}`: #{value} -> #{new_value}"
-                  end
-                end
-              end
-              result
-            end
-          ]
-
-          ui.debug "Generated internal parameters for `#{resource_name}`: #{substack_parameters}"
-
-          processor = GraphProcessor.new({},
-            :parameters => substack_parameters
-          )
-          template['Resources'] = processor.dereference_processor(
-            template['Resources'], ['Ref']
-          )
-          template['Outputs'] = processor.dereference_processor(
-            template['Outputs'], ['Ref']
-          )
-          rename_processor = GraphProcessor.new({},
-            :parameters => Smash[
-              template.fetch('Resources', {}).keys.map do |r_key|
-                [r_key, {'Ref' => [name, r_key].join}]
-              end
-            ]
-          )
-          derefed_outs = rename_processor.dereference_processor(
-            template.fetch('Outputs', {})
-          ) || {}
-
-          derefed_outs.each do |o_name, o_data|
-            o_key = [name, o_name].join('__')
-            outputs[o_key] = o_data['Value']
-          end
-        end
-        outputs.dup.each do |key, value|
-          if(value.is_a?(Hash))
-            v_key = value.keys.first
-            v_value = value.values.first
-            if(v_key == 'Fn::GetAtt' && v_value.last.start_with?('Outputs.'))
-              output_key = v_value.first << '__' << v_value.last.split('.', 2).last
-              if(outputs.key?(output_key))
-                outputs[key] = outputs[output_key]
-              end
-            end
-          end
-        end
-      end
-
-      def edge_detection(template, graph, name = '', resource_names = [])
-        resources = template.fetch('Resources', {})
-        node_prefix = name
-        resources.each do |resource_name, resource_data|
-          node_name = [node_prefix, resource_name].join
-          if(resource_data['Type'] == 'AWS::CloudFormation::Stack')
-            graph.subgraph << generate_graph(
-              resource_data['Properties'].delete('Stack'),
-              :name => resource_name,
-              :type => resource_data['Type'],
-              :resource_names => resource_names
-            )
-            next
-          else
-            graph.node(node_name).attributes << graph.fillcolor(colorize(node_prefix.empty? ? config[:file] : node_prefix).inspect)
-            graph.box3d << graph.node(node_name)
-          end
-          graph.filled << graph.node(node_name)
-          graph.node(node_name).label "#{resource_name}\n<#{resource_data['Type']}>\n#{name}"
-          resource_dependencies(resource_data, resource_names + resources.keys).each do |dep_name|
-            if(resources.keys.include?(dep_name))
-              dep_name = [node_prefix, dep_name].join
-            end
-            if(config[:graph_style] == 'creation')
-              @root_graph.edge(dep_name, node_name)
-            else
-              @root_graph.edge(node_name, dep_name)
-            end
-          end
-        end
-        resource_names.concat resources.keys.map{|r_name| [node_prefix, r_name].join}
-      end
-
-      def resource_dependencies(data, names)
-        case data
-        when Hash
-          data.map do |key, value|
-            if(key == 'Ref' && names.include?(value))
-              value
-            elsif(key == 'DependsOn')
-              [value].flatten.compact.find_all do |dependson_name|
-                names.include?(dependson_name)
-              end
-            elsif(key == 'Fn::GetAtt' && names.include?(res = [value].flatten.compact.first))
-              res
-            else
-              resource_dependencies(key, names) +
-                resource_dependencies(value, names)
-            end
-          end.flatten.compact.uniq
-        when Array
-          data.map do |item|
-            resource_dependencies(item, names)
-          end.flatten.compact.uniq
-        else
-          []
-        end
-      end
-
       def colorize(string)
         hash = string.chars.inject(0) do |memo, chr|
           if(memo + chr.ord > 127)
@@ -240,38 +118,6 @@ module Sfn
         end
       end
 
-      class GraphProcessor < SparkleFormation::Translation
-        MAP = {}
-        REF_MAPPING = {}
-        FN_MAPPING = {}
-
-        attr_accessor :name
-
-        def initialize(template, args={})
-          super
-          @name = args[:name]
-        end
-
-        def apply_function(hash, funcs=[])
-          k, v = hash.first
-          if(hash.size == 1)
-            case k
-            when 'Ref'
-              parameters.key?(v) ? parameters[v] : hash
-            when 'Fn::Join'
-              v.last
-            when 'Fn::Select'
-              v.last[v.first.to_i]
-            else
-              hash
-            end
-          else
-            hash
-          end
-        end
-
-      end
-
     end
   end
 end

data/lib/sfn/command/graph/aws.rb

@@ -0,0 +1,174 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # Graph command
+    class Graph < Command
+      module Provider
+        module Aws
+          class AwsGraphProcessor < SparkleFormation::Translation
+            MAP = {}
+            REF_MAPPING = {}
+            FN_MAPPING = {}
+
+            attr_accessor :name
+
+            def initialize(template, args={})
+              super
+              @name = args[:name]
+            end
+
+            def apply_function(hash, funcs=[])
+              k, v = hash.first
+              if(hash.size == 1)
+                case k
+                when 'Ref'
+                  parameters.key?(v) ? parameters[v] : hash
+                when 'Fn::Join'
+                  v.last
+                when 'Fn::Select'
+                  v.last[v.first.to_i]
+                else
+                  hash
+                end
+              else
+                hash
+              end
+            end
+          end
+
+          def output_discovery(template, outputs, resource_name, parent_template, name='')
+            if(template['Resources'])
+              template['Resources'].keys.each do |r_name|
+                r_info = template['Resources'][r_name]
+                if(r_info['Type'] == 'AWS::CloudFormation::Stack')
+                  output_discovery(r_info['Properties']['Stack'], outputs, r_name, template, r_name)
+                end
+              end
+            end
+            if(parent_template)
+              ui.debug "Pre-processing stack resource `#{resource_name}`"
+              substack_parameters = Smash[
+                parent_template.fetch('Resources', resource_name, 'Properties', 'Parameters', {}).map do |key, value|
+                  result = [key, value]
+                  if(value.is_a?(Hash))
+                    v_key = value.keys.first
+                    v_value = value.values.first
+                    if(v_key == 'Fn::GetAtt' && parent_template.fetch('Resources', {}).keys.include?(v_value.first) && v_value.last.start_with?('Outputs.'))
+                      output_key = v_value.first + '__' + v_value.last.split('.', 2).last
+                      ui.debug "Output key for check: #{output_key}"
+                      if(outputs.key?(output_key))
+                        new_value = outputs[output_key]
+                        result = [key, new_value]
+                        ui.debug "Parameter for output swap `#{key}`: #{value} -> #{new_value}"
+                      end
+                    end
+                  end
+                  result
+                end
+              ]
+
+              ui.debug "Generated internal parameters for `#{resource_name}`: #{substack_parameters}"
+
+              processor = AwsGraphProcessor.new({},
+                :parameters => substack_parameters
+              )
+              template['Resources'] = processor.dereference_processor(
+                template['Resources'], ['Ref']
+              )
+              template['Outputs'] = processor.dereference_processor(
+                template['Outputs'], ['Ref']
+              )
+              rename_processor = AwsGraphProcessor.new({},
+                :parameters => Smash[
+                  template.fetch('Resources', {}).keys.map do |r_key|
+                    [r_key, {'Ref' => [name, r_key].join}]
+                  end
+                ]
+              )
+              derefed_outs = rename_processor.dereference_processor(
+                template.fetch('Outputs', {})
+              ) || {}
+
+              derefed_outs.each do |o_name, o_data|
+                o_key = [name, o_name].join('__')
+                outputs[o_key] = o_data['Value']
+              end
+            end
+            outputs.dup.each do |key, value|
+              if(value.is_a?(Hash))
+                v_key = value.keys.first
+                v_value = value.values.first
+                if(v_key == 'Fn::GetAtt' && v_value.last.start_with?('Outputs.'))
+                  output_key = v_value.first << '__' << v_value.last.split('.', 2).last
+                  if(outputs.key?(output_key))
+                    outputs[key] = outputs[output_key]
+                  end
+                end
+              end
+            end
+          end
+
+          def edge_detection(template, graph, name = '', resource_names = [])
+            resources = template.fetch('Resources', {})
+            node_prefix = name
+            resources.each do |resource_name, resource_data|
+              node_name = [node_prefix, resource_name].join
+              if(resource_data['Type'] == 'AWS::CloudFormation::Stack')
+                graph.subgraph << generate_graph(
+                  resource_data['Properties'].delete('Stack'),
+                  :name => resource_name,
+                  :type => resource_data['Type'],
+                  :resource_names => resource_names
+                )
+                next
+              else
+                graph.node(node_name).attributes << graph.fillcolor(colorize(node_prefix.empty? ? config[:file] : node_prefix).inspect)
+                graph.box3d << graph.node(node_name)
+              end
+              graph.filled << graph.node(node_name)
+              graph.node(node_name).label "#{resource_name}\n<#{resource_data['Type']}>\n#{name}"
+              resource_dependencies(resource_data, resource_names + resources.keys).each do |dep_name|
+                if(resources.keys.include?(dep_name))
+                  dep_name = [node_prefix, dep_name].join
+                end
+                if(config[:graph_style] == 'creation')
+                  @root_graph.edge(dep_name, node_name)
+                else
+                  @root_graph.edge(node_name, dep_name)
+                end
+              end
+            end
+            resource_names.concat resources.keys.map{|r_name| [node_prefix, r_name].join}
+          end
+
+          def resource_dependencies(data, names)
+            case data
+            when Hash
+              data.map do |key, value|
+                if(key == 'Ref' && names.include?(value))
+                  value
+                elsif(key == 'DependsOn')
+                  [value].flatten.compact.find_all do |dependson_name|
+                    names.include?(dependson_name)
+                  end
+                elsif(key == 'Fn::GetAtt' && names.include?(res = [value].flatten.compact.first))
+                  res
+                else
+                  resource_dependencies(key, names) +
+                    resource_dependencies(value, names)
+                end
+              end.flatten.compact.uniq
+            when Array
+              data.map do |item|
+                resource_dependencies(item, names)
+              end.flatten.compact.uniq
+            else
+              []
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sfn/command/graph/provider.rb

@@ -0,0 +1,13 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # Graph command
+    class Graph < Command
+      module Provider
+        autoload :Aws, "sfn/command/graph/aws"
+        autoload :Terraform, "sfn/command/graph/terraform"
+      end
+    end
+  end
+end

data/lib/sfn/command/graph/terraform.rb

@@ -0,0 +1,193 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # Graph command
+    class Graph < Command
+      module Provider
+        module Terraform
+          class TerraformGraphProcessor < SparkleFormation::Translation
+            MAP = {}
+            REF_MAPPING = {}
+            FN_MAPPING = {}
+
+            attr_accessor :name
+
+            def initialize(template, args={})
+              super
+              @name = args[:name]
+            end
+
+            def dereference_processor(obj, funcs=[])
+              case obj
+              when Array
+                obj = obj.map{|v| dereference_processor(v, funcs)}
+              when Hash
+                new_hash = {}
+                obj.each do |k, v|
+                  new_hash[k] = dereference_processor(v, funcs)
+                end
+                obj = new_hash
+              when String
+                obj = apply_function(obj, funcs)
+              end
+              obj
+            end
+
+            def parameters
+              Hash[
+                @original.fetch('parameters', {}).map do |k, v|
+                  [k, v.fetch('default', '')]
+                end
+              ].merge(@parameters)
+            end
+
+            def resources
+              @original.fetch('resources', {})
+            end
+
+            def outputs
+              @original.fetch('outputs', {})
+            end
+
+            def apply_function(string, funcs=[])
+              # first check for vars and replace with params
+              string.scan(/(\$\{var\.(.+?)\})/).each do |match|
+                if(parameters[match.last])
+                  string.sub!(match.first, parameters[match.last])
+                end
+              end
+              string
+            end
+          end
+
+          def output_discovery(template, outputs, resource_name, parent_template, name='')
+            if(template['resources'])
+              template['resources'].keys.each do |r_name|
+                r_info = template['resources'][r_name]
+                if(r_info['type'] == 'module')
+                  output_discovery(r_info['properties']['stack'], outputs, r_name, template, r_name)
+                end
+              end
+            end
+            if(parent_template)
+              ui.debug "Pre-processing stack resource `#{resource_name}`"
+              substack_parameters = Smash[
+                parent_template.fetch('resources', resource_name, 'properties', 'parameters', {}).map do |key, value|
+                  result = [key, value]
+                  if(value.to_s.start_with?('${module.'))
+                    output_key = value.sub('${module.', '').sub('}', '').sub('.', '__')
+                    ui.debug "Output key for check: #{output_key}"
+                    if(outputs.key?(output_key))
+                      new_value = outputs[output_key]
+                      result = [key, new_value]
+                      ui.debug "Parameter for output swap `#{key}`: #{value} -> #{new_value}"
+                    end
+                  end
+                  result
+                end
+              ]
+
+              ui.debug "Generated internal parameters for `#{resource_name}`: #{substack_parameters}"
+
+              processor = TerraformGraphProcessor.new({},
+                :parameters => substack_parameters
+              )
+              template['resources'] = processor.dereference_processor(
+                template['resources'], []
+              )
+              template['outputs'] = processor.dereference_processor(
+                template['outputs'], []
+              )
+              derefed_outs = template['outputs'] || {}
+              derefed_outs.each do |o_name, o_data|
+                o_key = [name, o_name].join('__')
+                val = o_data['value']
+                if(val.start_with?('${') && val.scan('.').count == 2)
+                  val = val.split('.')
+                  val[1] = "#{name}__#{val[1]}"
+                  val = val.join('.')
+                end
+                outputs[o_key] = val
+              end
+            end
+            outputs.dup.each do |key, value|
+              if(value.to_s.start_with?('${module.'))
+                output_key = value.to_s.sub('${module.', '').sub('}', '').sub('.', '__')
+                if(outputs.key?(output_key))
+                  outputs[key] = outputs[output_key]
+                end
+              end
+            end
+          end
+
+          def edge_detection(template, graph, name = '', resource_names = [])
+            resources = (template.fetch('resources', {}) || {})
+            node_prefix = name
+            resources.each do |resource_name, resource_data|
+              node_name = [node_prefix, resource_name].join('__')
+              if(resource_data['type'] == 'module')
+                graph.subgraph << generate_graph(
+                  resource_data['properties'].delete('stack'),
+                  :name => resource_name,
+                  :type => resource_data['type'],
+                  :resource_names => resource_names
+                )
+                next
+              else
+                graph.node(node_name).attributes << graph.fillcolor(colorize(node_prefix.empty? ? config[:file] : node_prefix).inspect)
+                graph.box3d << graph.node(node_name)
+              end
+              graph.filled << graph.node(node_name)
+              graph.node(node_name).label "#{resource_name}\n<#{resource_data['type']}>\n#{name}"
+              resource_dependencies(resource_data, resource_names + resources.keys).each do |dep_name|
+                if(resources.keys.include?(dep_name))
+                  dep_name = [node_prefix, dep_name].join('__')
+                end
+                if(config[:graph_style] == 'creation')
+                  @root_graph.edge(dep_name, node_name)
+                else
+                  @root_graph.edge(node_name, dep_name)
+                end
+              end
+            end
+            resource_names.concat resources.keys.map{|r_name| [node_prefix, r_name].join('__')}
+          end
+
+          def resource_dependencies(data, names)
+            case data
+            when String
+              result = []
+              if(data.start_with?('${') && data.scan('.').count >= 1)
+                data = data.tr('${}', '')
+                check_name = data.split('.')[1]
+                if names.include?(check_name)
+                  result.push(check_name)
+                end
+              end
+              result
+            when Hash
+              data.map do |key, value|
+                if(key == 'depends_on')
+                  [value].flatten.compact.map do |dependson_name|
+                    dep_name = dependson_name.split('.').last
+                    dep_name if names.include?(dep_name)
+                  end
+                else
+                  resource_dependencies(key, names) +
+                  resource_dependencies(value, names)
+                end
+              end.flatten.compact.uniq
+            when Array
+              data.map do |item|
+                resource_dependencies(item, names)
+              end.flatten.compact.uniq
+            else
+              []
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sfn/version.rb

@@ -1,4 +1,4 @@
 module Sfn
   # Current library version
-  VERSION = Gem::Version.new('3.0.26')
+  VERSION = Gem::Version.new('3.0.28')
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sfn
 version: !ruby/object:Gem::Version
-  version: 3.0.26
+  version: 3.0.28
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-25 00:00:00.000000000 Z
+date: 2017-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bogo-cli
@@ -409,6 +409,9 @@ files:
 - lib/sfn/command/events.rb
 - lib/sfn/command/export.rb
 - lib/sfn/command/graph.rb
+- lib/sfn/command/graph/aws.rb
+- lib/sfn/command/graph/provider.rb
+- lib/sfn/command/graph/terraform.rb
 - lib/sfn/command/import.rb
 - lib/sfn/command/init.rb
 - lib/sfn/command/inspect.rb
@@ -484,7 +487,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: SparkleFormation CLI