openvox 7.37.1 → 8.19.0

data/lib/puppet/pops/evaluator/external_syntax_support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This module is an integral part of the evaluator. It deals with the concern of validating
 # external syntax in text produced by heredoc and templates.
 #
@@ -28,7 +30,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
   #
   def checker_for_syntax(_, syntax)
     checkers_hash = Puppet.lookup(:plugins)[Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_KEY]
-    checkers_hash[lookup_keys_for_syntax(syntax).find {|x| checkers_hash[x] }]
+    checkers_hash[lookup_keys_for_syntax(syntax).find { |x| checkers_hash[x] }]
   end
 
   # Returns an array of possible syntax names
@@ -42,5 +44,4 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
     end
     result
   end
-
 end

data/lib/puppet/pops/evaluator/json_strict_literal_evaluator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Literal values for
 #
 #   * String
@@ -17,9 +19,9 @@
 #   * String with interpolation
 #
 class Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator
-  #include Puppet::Pops::Utils
+  # include Puppet::Pops::Utils
 
-  COMMA_SEPARATOR = ', '.freeze
+  COMMA_SEPARATOR = ', '
 
   def initialize
     @@literal_visitor ||= Puppet::Pops::Visitor.new(self, "literal", 0, 0)
@@ -68,15 +70,14 @@ class Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator
   end
 
   def literal_LiteralList(o)
-    o.values.map {|v| literal(v) }
+    o.values.map { |v| literal(v) }
   end
 
   def literal_LiteralHash(o)
-    o.entries.reduce({}) do |result, entry|
+    o.entries.each_with_object({}) do |entry, result|
       key = literal(entry.key)
       throw :not_literal unless key.is_a?(String)
       result[key] = literal(entry.value)
-      result
     end
   end
 end

data/lib/puppet/pops/evaluator/literal_evaluator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Evaluator
 # Literal values for
@@ -14,8 +16,7 @@ module Evaluator
 # AccessExpresion
 #
 class LiteralEvaluator
-
-  COMMA_SEPARATOR = ', '.freeze
+  COMMA_SEPARATOR = ', '
 
   def initialize
     @@literal_visitor ||= Visitor.new(self, "literal", 0, 0)
@@ -86,13 +87,12 @@ class LiteralEvaluator
   end
 
   def literal_LiteralList(o)
-    o.values.map {|v| literal(v) }
+    o.values.map { |v| literal(v) }
   end
 
   def literal_LiteralHash(o)
-    o.entries.reduce({}) do |result, entry|
+    o.entries.each_with_object({}) do |entry, result|
       result[literal(entry.key)] = literal(entry.value)
-      result
     end
   end
 end

data/lib/puppet/pops/evaluator/puppet_proc.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Complies with Proc API by mapping a Puppet::Pops::Evaluator::Closure to a ruby Proc.
 # Creating and passing an instance of this class instead of just a plain block makes
 # it possible to inherit the parameter info and arity from the closure. Advanced users
@@ -47,11 +49,11 @@ class Puppet::Pops::Evaluator::PuppetProc < Proc
     @closure.parameters.map do |param|
       sym = param.name.to_sym
       if param.captures_rest
-        [ :rest, sym ]
+        [:rest, sym]
       elsif param.value
-        [ :opt, sym ]
+        [:opt, sym]
       else
-        [ :req, sym ]
+        [:req, sym]
       end
     end
   end
@@ -63,6 +65,7 @@ class Puppet::Pops::Evaluator::PuppetProc < Proc
     parameters.reduce(0) do |memo, param|
       count = memo + 1
       break -count unless param[0] == :req
+
       count
     end
   end

data/lib/puppet/pops/evaluator/relationship_operator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Evaluator
 # The RelationshipOperator implements the semantics of the -> <- ~> <~ operators creating relationships or notification
@@ -9,7 +11,6 @@ module Evaluator
 # module. Later when more is cleaned up this can be simplified further.
 #
 class RelationshipOperator
-
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
@@ -17,6 +18,7 @@ class RelationshipOperator
 
   class IllegalRelationshipOperandError < RuntimeError
     attr_reader :operand
+
     def initialize operand
       @operand = operand
     end
@@ -24,6 +26,7 @@ class RelationshipOperator
 
   class NotCatalogTypeError < RuntimeError
     attr_reader :type
+
     def initialize type
       @type = type
     end
@@ -44,7 +47,7 @@ class RelationshipOperator
   # Catch all non transformable objects
   # @api private
   def transform_Object(o, scope)
-    raise IllegalRelationshipOperandError.new(o)
+    raise IllegalRelationshipOperandError, o
   end
 
   # A Resource is by definition a Catalog type, but of 3.x type
@@ -87,7 +90,7 @@ class RelationshipOperator
 
   # Array content needs to be transformed
   def transform_Array(o, scope)
-    o.map{|x| transform(x, scope) }
+    o.map { |x| transform(x, scope) }
   end
 
   # Asserts (and returns) the type if it is a PCatalogEntryType
@@ -95,8 +98,9 @@ class RelationshipOperator
   #
   def assert_catalog_type(o, scope)
     unless @type_calculator.assignable?(@catalog_type, o)
-      raise NotCatalogTypeError.new(o)
+      raise NotCatalogTypeError, o
     end
+
     # TODO must check if this is an abstract PResourceType (i.e. without a type_name) - which should fail ?
     # e.g. File -> File (and other similar constructs) - maybe the catalog protects against this since references
     # may be to future objects...
@@ -123,7 +127,7 @@ class RelationshipOperator
     # assert operator (should have been validated, but this logic makes assumptions which would
     # screw things up royally). Better safe than sorry.
     unless RELATIONSHIP_OPERATORS.include?(relationship_expression.operator)
-      fail(Issues::UNSUPPORTED_OPERATOR, relationship_expression, {:operator => relationship_expression.operator})
+      fail(Issues::UNSUPPORTED_OPERATOR, relationship_expression, { :operator => relationship_expression.operator })
     end
 
     begin
@@ -139,7 +143,7 @@ class RelationshipOperator
       # into an array, and thus the resulting left and right must be flattened individually
       # Once flattened, the operands should be sets (to remove duplicate entries)
       #
-      real = left_right_evaluated.collect {|x| [x].flatten.collect {|y| transform(y, scope) }}
+      real = left_right_evaluated.collect { |x| [x].flatten.collect { |y| transform(y, scope) } }
       real[0].flatten!
       real[1].flatten!
       real[0].uniq!
@@ -149,12 +153,12 @@ class RelationshipOperator
       source, target = reverse_operator?(relationship_expression) ? real.reverse : real
 
       # Add the relationships to the catalog
-      source.each {|s| target.each {|t| add_relationship(s, t, RELATION_TYPE[relationship_expression.operator], scope) }}
+      source.each { |s| target.each { |t| add_relationship(s, t, RELATION_TYPE[relationship_expression.operator], scope) } }
 
       # The result is the transformed source RHS unless it is empty, in which case the transformed LHS is returned.
       # This closes the gap created by an empty set of references in a chain of relationship
       # such that X -> [ ] -> Y results in  X -> Y.
-      #result = real[1].empty? ? real[0] : real[1]
+      # result = real[1].empty? ? real[0] : real[1]
       if real[1].empty?
         # right side empty, simply use the left (whatever it may be)
         result = real[0]
@@ -169,11 +173,10 @@ class RelationshipOperator
         result = right
       end
       result
-
     rescue NotCatalogTypeError => e
-      fail(Issues::NOT_CATALOG_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
+      fail(Issues::NOT_CATALOG_TYPE, relationship_expression, { :type => @type_calculator.string(e.type) })
     rescue IllegalRelationshipOperandError => e
-      fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, {:operand => e.operand})
+      fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, { :operand => e.operand })
     end
   end
 

data/lib/puppet/pops/evaluator/runtime3_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops::Evaluator
 # Converts nested 4x supported values to 3x values. This is required because
 # resources and other objects do not know about the new type system, and does not support
@@ -7,7 +9,7 @@ module Puppet::Pops::Evaluator
 # Users should not create instances of this class. Instead the class methods {Runtime3Converter.convert},
 # {Runtime3Converter.map_args}, or {Runtime3Converter.instance} should be used
 class Runtime3Converter
-  MAX_INTEGER =  Puppet::Pops::MAX_INTEGER
+  MAX_INTEGER = Puppet::Pops::MAX_INTEGER
   MIN_INTEGER = Puppet::Pops::MIN_INTEGER
 
   # Converts 4x supported values to a 3x values. Same as calling Runtime3Converter.instance.map_args(...)
@@ -46,7 +48,7 @@ class Runtime3Converter
   # @return [Array] The converted values
   #
   def map_args(args, scope, undef_value)
-    args.map {|a| convert(a, scope, undef_value) }
+    args.map { |a| convert(a, scope, undef_value) }
   end
 
   # Converts a 4x supported value to a 3x value.
@@ -66,14 +68,16 @@ class Runtime3Converter
 
   def convert_Integer(o, scope, undef_value)
     return o unless o < MIN_INTEGER || o > MAX_INTEGER
+
     range_end = o > MAX_INTEGER ? 'max' : 'min'
-    raise Puppet::Error, "Use of a Ruby Integer outside of Puppet Integer #{range_end} range, got '#{"0x%x" % o}'"
+    raise Puppet::Error, "Use of a Ruby Integer outside of Puppet Integer #{range_end} range, got '#{'0x%x' % o}'"
   end
 
   def convert_BigDecimal(o, scope, undef_value)
     # transform to same value float value if possible without any rounding error
     f = o.to_f
     return f unless f != o
+
     raise Puppet::Error, "Use of a Ruby BigDecimal value outside Puppet Float range, got '#{o}'"
   end
 
@@ -90,13 +94,13 @@ class Runtime3Converter
 
   def convert_Array(o, scope, undef_value)
     ic = @inner_converter
-    o.map {|x| ic.convert(x, scope, undef_value) }
+    o.map { |x| ic.convert(x, scope, undef_value) }
   end
 
   def convert_Hash(o, scope, undef_value)
     result = {}
     ic = @inner_converter
-    o.each {|k,v| result[ic.convert(k, scope, undef_value)] = ic.convert(v, scope, undef_value) }
+    o.each { |k, v| result[ic.convert(k, scope, undef_value)] = ic.convert(v, scope, undef_value) }
     result
   end
 
@@ -106,6 +110,7 @@ class Runtime3Converter
 
   def convert_Symbol(o, scope, undef_value)
     return o unless o == :undef
+
     !@inner ? undef_value : nil
   end
 
@@ -132,23 +137,23 @@ class Runtime3Converter
   def catalog_type_to_split_type_title(catalog_type)
     split_type = catalog_type.is_a?(Puppet::Pops::Types::PTypeType) ? catalog_type.type : catalog_type
     case split_type
-      when Puppet::Pops::Types::PClassType
-        class_name = split_type.class_name
-        ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
-      when Puppet::Pops::Types::PResourceType
-        type_name = split_type.type_name
-        title = split_type.title
-        if type_name =~ /^(::)?[Cc]lass$/
-          ['class', title.nil? ? nil : title.sub(/^::/, '')]
-        else
-          # Ensure that title is '' if nil
-          # Resources with absolute name always results in error because tagging does not support leading ::
-          [type_name.nil? ? nil : type_name.sub(/^::/, '').downcase, title.nil? ? '' : title]
-        end
+    when Puppet::Pops::Types::PClassType
+      class_name = split_type.class_name
+      ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
+    when Puppet::Pops::Types::PResourceType
+      type_name = split_type.type_name
+      title = split_type.title
+      if type_name =~ /^(::)?[Cc]lass$/
+        ['class', title.nil? ? nil : title.sub(/^::/, '')]
       else
-        #TRANSLATORS 'PClassType' and 'PResourceType' are Puppet types and should not be translated
-        raise ArgumentError, _("Cannot split the type %{class_name}, it represents neither a PClassType, nor a PResourceType.") %
-            { class_name: catalog_type.class }
+        # Ensure that title is '' if nil
+        # Resources with absolute name always results in error because tagging does not support leading ::
+        [type_name.nil? ? nil : type_name.sub(/^::/, '').downcase, title.nil? ? '' : title]
+      end
+    else
+      # TRANSLATORS 'PClassType' and 'PResourceType' are Puppet types and should not be translated
+      raise ArgumentError, _("Cannot split the type %{class_name}, it represents neither a PClassType, nor a PResourceType.") %
+                           { class_name: catalog_type.class }
     end
   end
 
@@ -160,14 +165,13 @@ class Runtime3Converter
     @convert_visitor = Puppet::Pops::Visitor.new(self, 'convert', 2, 2)
   end
 
-  @instance = self.new
+  @instance = new
 end
 
 # A Ruby function written for the 3.x API cannot be expected to handle extended data types. This
 # converter ensures that they are converted to String format
 # @api private
 class Runtime3FunctionArgumentConverter < Runtime3Converter
-
   def convert_Regexp(o, scope, undef_value)
     # Puppet 3x cannot handle parameter values that are regular expressions. Turn into regexp string in
     # source form
@@ -202,20 +206,20 @@ class Runtime3FunctionArgumentConverter < Runtime3Converter
   # Converts result back to 4.x by replacing :undef with nil in Array and Hash objects
   #
   def self.convert_return(val3x)
-    if val3x == :undef
+    case val3x
+    when :undef
       nil
-    elsif val3x.is_a?(Array)
-      val3x.map {|v| convert_return(v) }
-    elsif val3x.is_a?(Hash)
+    when Array
+      val3x.map { |v| convert_return(v) }
+    when Hash
       hsh = {}
-      val3x.each_pair {|k,v| hsh[convert_return(k)] = convert_return(v)}
+      val3x.each_pair { |k, v| hsh[convert_return(k)] = convert_return(v) }
       hsh
     else
       val3x
     end
   end
 
-  @instance = self.new
+  @instance = new
 end
-
 end

data/lib/puppet/pops/evaluator/runtime3_resource_support.rb

@@ -1,12 +1,12 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Evaluator
-
 # @api private
 module Runtime3ResourceSupport
-  CLASS_STRING = 'class'.freeze
+  CLASS_STRING = 'class'
 
   def self.create_resources(file, line, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
-
     env = scope.environment
     #    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope)
 
@@ -14,7 +14,7 @@ module Runtime3ResourceSupport
       # Resolve a 'class' and its titles
       resource_titles = resource_titles.collect do |a_title|
         hostclass = env.known_resource_types.find_hostclass(a_title)
-        hostclass ?  hostclass.name : a_title
+        hostclass ? hostclass.name : a_title
       end
       # resolved type is just the string CLASS
       resolved_type = CLASS_STRING
@@ -35,35 +35,35 @@ module Runtime3ResourceSupport
     # as this makes the created resource retain the type instance.
     #
     resource_titles.map do |resource_title|
-        resource = Puppet::Parser::Resource.new(
-          resolved_type, resource_title,
-          :parameters => evaluated_parameters,
-          :file => file,
-          :line => line,
-          :kind => Puppet::Resource.to_kind(resolved_type),
-          :exported => exported,
-          :virtual => virtual,
-          # WTF is this? Which source is this? The file? The name of the context ?
-          :source => scope.source,
-          :scope => scope,
-          :strict => true
-        )
-
-        # If this resource type supports inheritance (e.g. 'class') the parent chain must be walked
-        # This impl delegates to the resource type to figure out what is needed.
-        #
-        if resource.resource_type.is_a? Puppet::Resource::Type
-          resource.resource_type.instantiate_resource(scope, resource)
-        end
-
-        scope.compiler.add_resource(scope, resource)
-
-        # Classes are evaluated immediately
-        scope.compiler.evaluate_classes([resource_title], scope, false) if resolved_type == CLASS_STRING
-
-        # Turn the resource into a PTypeType (a reference to a resource type)
-        # weed out nil's
-        resource_to_ptype(resource)
+      resource = Puppet::Parser::Resource.new(
+        resolved_type, resource_title,
+        :parameters => evaluated_parameters,
+        :file => file,
+        :line => line,
+        :kind => Puppet::Resource.to_kind(resolved_type),
+        :exported => exported,
+        :virtual => virtual,
+        # WTF is this? Which source is this? The file? The name of the context ?
+        :source => scope.source,
+        :scope => scope,
+        :strict => true
+      )
+
+      # If this resource type supports inheritance (e.g. 'class') the parent chain must be walked
+      # This impl delegates to the resource type to figure out what is needed.
+      #
+      if resource.resource_type.is_a? Puppet::Resource::Type
+        resource.resource_type.instantiate_resource(scope, resource)
+      end
+
+      scope.compiler.add_resource(scope, resource)
+
+      # Classes are evaluated immediately
+      scope.compiler.evaluate_classes([resource_title], scope, false) if resolved_type == CLASS_STRING
+
+      # Turn the resource into a PTypeType (a reference to a resource type)
+      # weed out nil's
+      resource_to_ptype(resource)
     end
   end
 
@@ -76,7 +76,8 @@ module Runtime3ResourceSupport
   end
 
   def self.resource_to_ptype(resource)
-    nil if resource.nil?
+    return nil if resource.nil?
+
     # inference returns the meta type since the 3x Resource is an alternate way to describe a type
     Puppet::Pops::Types::TypeCalculator.singleton().infer(resource).type
   end
@@ -113,7 +114,6 @@ module Runtime3ResourceSupport
     krt.find_definition(type_name)
   end
   private_class_method :find_defined_resource_type
-
 end
 end
 end

data/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Evaluator
 # A module with bindings between the new evaluator and the 3x runtime.
@@ -6,8 +8,7 @@ module Evaluator
 #
 # @api private
 module Runtime3Support
-
-  NAME_SPACE_SEPARATOR = '::'.freeze
+  NAME_SPACE_SEPARATOR = '::'
 
   # Fails the evaluation of _semantic_ with a given issue.
   #
@@ -17,7 +18,7 @@ module Runtime3Support
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
-  def fail(issue, semantic, options={}, except=nil)
+  def fail(issue, semantic, options = {}, except = nil)
     optionally_fail(issue, semantic, options, except)
     # an error should have been raised since fail always fails
     raise ArgumentError, _("Internal Error: Configuration of runtime error handling wrong: should have raised exception")
@@ -32,11 +33,11 @@ module Runtime3Support
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
-  def optionally_fail(issue, semantic, options={}, except=nil)
+  def optionally_fail(issue, semantic, options = {}, except = nil)
     if except.nil? && diagnostic_producer.severity_producer[issue] == :error
       # Want a stacktrace, and it must be passed as an exception
       begin
-       raise EvaluationError.new()
+        raise EvaluationError
       rescue EvaluationError => e
         except = e
       end
@@ -53,13 +54,13 @@ module Runtime3Support
   # @return [!] this method may not return, nil if it does
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments
   #
-  def runtime_issue(issue, options={})
+  def runtime_issue(issue, options = {})
     # Get position from puppet runtime stack
     file, line = Puppet::Pops::PuppetStack.top_of_stack
 
     # Use a SemanticError as the sourcepos
-    semantic = Puppet::Pops::SemanticError.new(issue, nil, options.merge({:file => file, :line => line}))
-    optionally_fail(issue,  semantic)
+    semantic = Puppet::Pops::SemanticError.new(issue, nil, options.merge({ :file => file, :line => line }))
+    optionally_fail(issue, semantic)
     nil
   end
 
@@ -79,14 +80,14 @@ module Runtime3Support
     # TODO: Improve the messy implementation in Scope.
     #
     if name == "server_facts"
-      fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
+      fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, { :name => name })
     end
 
     if scope.bound?(name)
       if Puppet::Parser::Scope::RESERVED_VARIABLE_NAMES.include?(name)
-        fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
+        fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, { :name => name })
       else
-        fail(Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
+        fail(Issues::ILLEGAL_REASSIGNMENT, o, { :name => name })
       end
     end
     scope.setvar(name, value)
@@ -109,7 +110,7 @@ module Runtime3Support
     # if not set by a match expression.
     #
     unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
-      optionally_fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
+      optionally_fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, { :name => name })
     end
     nil # in case unknown variable is configured as a warning or ignore
   end
@@ -146,6 +147,7 @@ module Runtime3Support
     # is in the source.
     #
     raise ArgumentError, _("Internal error - attempt to create a local scope without a hash") unless hash.is_a?(Hash)
+
     scope.ephemeral_from(hash)
   end
 
@@ -252,12 +254,14 @@ module Runtime3Support
     if v.is_a?(Numeric)
       return v
     end
+
     n = Utils.to_n(v)
     unless n
-      fail(Issues::NOT_NUMERIC, o, {:value => v})
+      fail(Issues::NOT_NUMERIC, o, { :value => v })
     end
+
     # this point is reached if there was a conversion
-    optionally_fail(Issues::NUMERIC_COERCION, o, {:before => v, :after => n})
+    optionally_fail(Issues::NUMERIC_COERCION, o, { :before => v, :after => n })
     n
   end
 
@@ -306,7 +310,7 @@ module Runtime3Support
       end
     end
     # Call via 3x API if function exists there without having been autoloaded
-    fail(Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
+    fail(Issues::UNKNOWN_FUNCTION, o, { :name => name }) unless Puppet::Parser::Functions.function(name)
 
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
@@ -319,10 +323,10 @@ module Runtime3Support
   def create_resource_parameter(o, scope, name, value, operator)
     file, line = extract_file_line(o)
     Puppet::Parser::Resource::Param.new(
-      :name   => name,
-      :value  => convert(value, scope, nil), # converted to 3x since 4x supports additional objects / types
+      :name => name,
+      :value => convert(value, scope, nil), # converted to 3x since 4x supports additional objects / types
       :source => scope.source, :line => line, :file => file,
-      :add    => operator == '+>'
+      :add => operator == '+>'
     )
   end
 
@@ -371,8 +375,9 @@ module Runtime3Support
     evaluated_parameters = evaluated_parameters.flatten
     evaluated_resources.each do |r|
       unless r.is_a?(Types::PResourceType) && r.type_name != 'class'
-        fail(Issues::ILLEGAL_OVERRIDDEN_TYPE, o, {:actual => r} )
+        fail(Issues::ILLEGAL_OVERRIDDEN_TYPE, o, { :actual => r })
       end
+
       t = Runtime3ResourceSupport.find_resource_type(scope, r.type_name)
       resource = Puppet::Parser::Resource.new(
         t, r.title, {
@@ -434,13 +439,8 @@ module Runtime3Support
   #
   def is_parameter_of_resource?(scope, resource, name)
     return false unless name.is_a?(String)
-    resource.valid_parameter?(name)
-  end
 
-  def resource_to_ptype(resource)
-    nil if resource.nil?
-    # inference returns the meta type since the 3x Resource is an alternate way to describe a type
-    type_calculator.infer(resource).type
+    resource.valid_parameter?(name)
   end
 
   # This is the same type of "truth" as used in the current Puppet DSL.
@@ -459,12 +459,6 @@ module Runtime3Support
     end
   end
 
-  # Utility method for TrueClass || FalseClass
-  # @param x [Object] the object to test if it is instance of TrueClass or FalseClass
-  def is_boolean? x
-    x.is_a?(TrueClass) || x.is_a?(FalseClass)
-  end
-
   def extract_file_line(o)
     o.is_a?(Model::Positioned) ? [o.file, o.line] : [nil, -1]
   end
@@ -472,15 +466,14 @@ module Runtime3Support
   # Creates a diagnostic producer
   def diagnostic_producer
     Validation::DiagnosticProducer.new(
-      ExceptionRaisingAcceptor.new(),                   # Raises exception on all issues
+      ExceptionRaisingAcceptor.new(), # Raises exception on all issues
       SeverityProducer.new(), # All issues are errors
-      Model::ModelLabelProvider.new())
+      Model::ModelLabelProvider.new()
+    )
   end
 
   # Configure the severity of failures
   class SeverityProducer < Validation::SeverityProducer
-    Issues = Issues
-
     def initialize
       super
       p = self
@@ -518,10 +511,10 @@ module Runtime3Support
     def accept(diagnostic)
       super
       IssueReporter.assert_and_report(self, {
-        :message => "Evaluation Error:",
-        :emit_warnings => true,  # log warnings
-        :exception_class => Puppet::PreformattedError
-      })
+                                        :message => "Evaluation Error:",
+                                        :emit_warnings => true, # log warnings
+                                        :exception_class => Puppet::PreformattedError
+                                      })
       if errors?
         raise ArgumentError, _("Internal Error: Configuration of runtime error handling wrong: should have raised exception")
       end