puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

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

@@ -34,7 +34,8 @@ class Puppet::Pops::Evaluator::RelationshipOperator
     @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
     @type_parser = Puppet::Pops::Types::TypeParser.new()
 
-    @catalog_type = Puppet::Pops::Types::TypeFactory.catalog_entry()
+    tf = Puppet::Pops::Types::TypeFactory
+    @catalog_type = tf.variant(tf.catalog_entry, tf.type_type(tf.catalog_entry))
   end
 
   def transform(o, scope)
@@ -61,7 +62,7 @@ class Puppet::Pops::Evaluator::RelationshipOperator
 
   # Types are what they are, just check the type
   # @api private
-  def transform_PAbstractType(o, scope)
+  def transform_PAnyType(o, scope)
     assert_catalog_type(o, scope)
   end
 

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

@@ -5,6 +5,8 @@
 # @api private
 module Puppet::Pops::Evaluator::Runtime3Support
 
+  NAME_SPACE_SEPARATOR = '::'.freeze
+
   # Fails the evaluation of _semantic_ with a given issue.
   #
   # @param issue [Puppet::Pops::Issue] the issue to report
@@ -72,7 +74,11 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # Not ideal, scope should support numeric lookup directly instead.
     # TODO: consider fixing scope
     catch(:undefined_variable) {
-      return scope.lookupvar(name.to_s)
+      x = scope.lookupvar(name.to_s)
+      # Must convert :undef back to nil - this can happen when an undefined variable is used in a
+      # parameter's default value expression - there nil must be :undef to work with the rest of 3x.
+      # Now that the value comes back to 4x it is changed to nil.
+      return (x == :undef) ? nil : x
     }
     # It is always ok to reference numeric variables even if they are not assigned. They are always undef
     # if not set by a match expression.
@@ -95,7 +101,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
     scope.exist?(name.to_s)
   end
 
-  def set_match_data(match_data, o, scope)
+  def set_match_data(match_data, scope)
     # See set_variable for rationale for not passing file and line to ephemeral_from.
     # NOTE: The 3x scope adds one ephemeral(match) to its internal stack per match that succeeds ! It never
     # clears anything. Thus a context that performs many matches will get very deep (there simply is no way to
@@ -185,11 +191,6 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # and convoluted path of evaluation.
     # In order to do this in a way that is similar to 3.x two resources are created to be used as keys.
     #
-    #
-    # TODO: logic that creates a PCatalogEntryType should resolve it to ensure it is loaded (to the best of known_resource_types knowledge).
-    # If this is not done, the order in which things are done may be different? OTOH, it probably works anyway :-)
-    # TODO: Not sure if references needs to be resolved via the scope?
-    #
     # And if that is not enough, a source/target may be a Collector (a baked query that will be evaluated by the
     # compiler - it is simply passed through here for processing by the compiler at the right time).
     #
@@ -229,22 +230,20 @@ module Puppet::Pops::Evaluator::Runtime3Support
   end
 
   def call_function(name, args, o, scope)
-    # Call via 4x API if it is available, and the function exists
-    #
-    if loaders = Puppet.lookup(:loaders) {nil}
-      # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
-      adapter = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::LoaderAdapter)
-      loader = adapter.nil? ? loaders.private_environment_loader : adapter.loader
-      if loader && func = loader.load(:function, name)
-        return func.call(scope, *args)
-      end
+    # Call via 4x API if the function exists there
+    loaders = scope.compiler.loaders
+    # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
+    adapter = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::LoaderAdapter)
+    loader = adapter.nil? ? loaders.private_environment_loader : adapter.loader
+    if loader && func = loader.load(:function, name)
+      return func.call(scope, *args)
     end
 
+    # Call via 3x API if function exists there
     fail(Puppet::Pops::Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
 
-    # TODO: if Puppet[:biff] == true, then 3x functions should be called via loaders above
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
-    # NOTE: Passing an empty string last converts :undef to empty string
+    # NOTE: Passing an empty string last converts nil/:undef to empty string
     mapped_args = args.map {|a| convert(a, scope, '') }
     result = scope.send("function_#{name}", mapped_args)
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
@@ -256,12 +255,15 @@ module Puppet::Pops::Evaluator::Runtime3Support
     file, line = extract_file_line(o)
     Puppet::Parser::Resource::Param.new(
       :name   => name,
+      # Here we must convert nil values to :undef for the 3x logic to work
       :value  => convert(value, scope, :undef), # converted to 3x since 4x supports additional objects / types
       :source => scope.source, :line => line, :file => file,
       :add    => operator == :'+>'
     )
   end
 
+  CLASS_STRING = 'class'.freeze
+
   def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
 
     # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
@@ -296,7 +298,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
           resource.resource_type.instantiate_resource(scope, resource)
         end
         scope.compiler.add_resource(scope, resource)
-        scope.compiler.evaluate_classes([resource_title], scope, false, true) if fully_qualified_type == 'class'
+        scope.compiler.evaluate_classes([resource_title], scope, false, true) if fully_qualified_type == CLASS_STRING
         # Turn the resource into a PType (a reference to a resource type)
         # weed out nil's
         resource_to_ptype(resource)
@@ -317,7 +319,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
   # Capitalizes each segment of a qualified name
   #
   def capitalize_qualified_name(name)
-    name.split(/::/).map(&:capitalize).join('::')
+    name.split(/::/).map(&:capitalize).join(NAME_SPACE_SEPARATOR)
   end
 
   # Creates resource overrides for all resource type objects in evaluated_resources. The same set of
@@ -332,6 +334,9 @@ module Puppet::Pops::Evaluator::Runtime3Support
     file, line = extract_file_line(o)
 
     evaluated_resources.each do |r|
+      unless r.is_a?(Puppet::Pops::Types::PResourceType) && r.type_name != 'class'
+        fail(Puppet::Pops::Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
+      end
       resource = Puppet::Parser::Resource.new(
       r.type_name, r.title,
         :parameters => evaluated_parameters,
@@ -360,15 +365,28 @@ module Puppet::Pops::Evaluator::Runtime3Support
   def get_resource_parameter_value(scope, resource, parameter_name)
     # This gets the parameter value, or nil (for both valid parameters and parameters that do not exist).
     val = resource[parameter_name]
-    if val.nil? && defaults = scope.lookupdefaults(resource.type)
-      # NOTE: 3x resource keeps defaults as hash using symbol for name as key to Parameter which (again) holds
-      # name and value.
-      # NOTE: meta parameters that are unset ends up here, and there are no defaults for those encoded
-      # in the defaults, they may receive hardcoded defaults later (e.g. 'tag').
-      param = defaults[parameter_name.to_sym]
-      # Some parameters (meta parameters like 'tag') does not return a param from which the value can be obtained
-      # at all times. Instead, they return a nil param until a value has been set.
-      val = param.nil? ? nil : param.value
+
+    # Sometimes the resource is a Puppet::Parser::Resource and sometimes it is
+    # a Puppet::Resource. The Puppet::Resource case occurs when puppet language
+    # is evaluated against an already completed catalog (where all instances of
+    # Puppet::Parser::Resource are converted to Puppet::Resource instances).
+    # Evaluating against an already completed catalog is really only found in
+    # the language specification tests, where the puppet language is used to
+    # test itself.
+    if resource.is_a?(Puppet::Parser::Resource)
+      # The defaults must be looked up in the scope where the resource was created (not in the given
+      # scope where the lookup takes place.
+      resource_scope = resource.scope
+      if val.nil? && resource_scope && defaults = resource_scope.lookupdefaults(resource.type)
+        # NOTE: 3x resource keeps defaults as hash using symbol for name as key to Parameter which (again) holds
+        # name and value.
+        # NOTE: meta parameters that are unset ends up here, and there are no defaults for those encoded
+        # in the defaults, they may receive hardcoded defaults later (e.g. 'tag').
+        param = defaults[parameter_name.to_sym]
+        # Some parameters (meta parameters like 'tag') does not return a param from which the value can be obtained
+        # at all times. Instead, they return a nil param until a value has been set.
+        val = param.nil? ? nil : param.value
+      end
     end
     val
   end
@@ -381,7 +399,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
 
   def resource_to_ptype(resource)
     nil if resource.nil?
-    type_calculator.infer(resource)
+    # inference returns the meta type since the 3x Resource is an alternate way to describe a type
+    type_calculator.infer(resource).type
   end
 
   # This is the same type of "truth" as used in the current Puppet DSL.
@@ -390,8 +409,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
     case o
-    when ''
-      false
+    # Support :undef since it may come from a 3x structure
     when :undef
       false
     else
@@ -423,6 +441,11 @@ module Puppet::Pops::Evaluator::Runtime3Support
     undef_value
   end
 
+  def convert_String(o, scope, undef_value)
+    # although wasteful, needed because user code may mutate these strings in Resources
+    o.frozen? ? o.dup : o
+  end
+
   def convert_Object(o, scope, undef_value)
     o
   end
@@ -445,46 +468,53 @@ module Puppet::Pops::Evaluator::Runtime3Support
 
   def convert_Symbol(o, scope, undef_value)
     case o
+    # Support :undef since it may come from a 3x structure
     when :undef
-      undef_value  # 3x wants :undef as empty string in function
+      undef_value  # 3x wants undef as either empty string or :undef
     else
       o   # :default, and all others are verbatim since they are new in future evaluator
     end
   end
 
-  def convert_PAbstractType(o, scope, undef_value)
+  def convert_PAnyType(o, scope, undef_value)
     o
   end
 
-  def convert_PResourceType(o,scope, undef_value)
-    # Needs conversion by calling scope to resolve the name and possibly return a different name
-    # Resolution can only be called with an array, and returns an array. Here there is only one name
-    type, titles = scope.resolve_type_and_titles(o.type_name, [o.title])
-    # Note: a title of nil makes Resource class throw error with information that is wrong
-    Puppet::Resource.new(type, titles[0].nil? ? '' : titles[0] )
-  end
+  def convert_PCatalogEntryType(o, scope, undef_value)
+    # Since 4x does not support dynamic scoping, all names are absolute and can be
+    # used as is (with some check/transformation/mangling between absolute/relative form
+    # due to Puppet::Resource's idiosyncratic behavior where some references must be
+    # absolute and others cannot be.
+    # Thus there is no need to call scope.resolve_type_and_titles to do dynamic lookup.
 
-  def convert_PHostClassType(o, scope, undef_value)
-    # Needs conversion by calling scope to resolve the name and possibly return a different name
-    # Resolution can only be called with an array, and returns an array. Here there is only one name
-    type, titles = scope.resolve_type_and_titles('class', [o.class_name])
-    # Note: a title of nil makes Resource class throw error with information that is wrong
-    Puppet::Resource.new(type, titles[0].nil? ? '' : titles[0] )
+    Puppet::Resource.new(*catalog_type_to_split_type_title(o))
   end
 
   private
 
   # Produces an array with [type, title] from a PCatalogEntryType
-  # Used to produce reference resource instances (used when 3x is operating on a resource).
+  # This method is used to produce the arguments for creation of reference resource instances
+  # (used when 3x is operating on a resource).
+  # Ensures that resources are *not* absolute.
   #
   def catalog_type_to_split_type_title(catalog_type)
-    case catalog_type
+    split_type = catalog_type.is_a?(Puppet::Pops::Types::PType) ? catalog_type.type : catalog_type
+    case split_type
     when Puppet::Pops::Types::PHostClassType
-      return ['Class', catalog_type.class_name]
+      class_name = split_type.class_name
+      ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
     when Puppet::Pops::Types::PResourceType
-      return [catalog_type.type_name, catalog_type.title]
+      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(/^::/, ''), title.nil? ? '' : title]
+      end
     else
-      raise ArgumentError, "Cannot split the type #{catalog_type.class}, it is neither a PHostClassType, nor a PResourceClass."
+      raise ArgumentError, "Cannot split the type #{catalog_type.class}, it represents neither a PHostClassType, nor a PResourceType."
     end
   end
 
@@ -504,7 +534,6 @@ module Puppet::Pops::Evaluator::Runtime3Support
     Puppet::Pops::Validation::DiagnosticProducer.new(
       ExceptionRaisingAcceptor.new(),                   # Raises exception on all issues
       SeverityProducer.new(), # All issues are errors
-#      Puppet::Pops::Validation::SeverityProducer.new(), # All issues are errors
       Puppet::Pops::Model::ModelLabelProvider.new())
   end
 
@@ -521,6 +550,10 @@ module Puppet::Pops::Evaluator::Runtime3Support
       else
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
       end
+
+      # Store config issues, ignore or warning
+      p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
+      p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
     end
   end
 

data/lib/puppet/pops/functions/dispatch.rb

@@ -51,18 +51,23 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
     if injections.empty?
       args
     else
-      injector = Puppet.lookup(:injector)
+      injector = nil # lazy lookup of injector Puppet.lookup(:injector)
       weaving.map do |knit|
         if knit.is_a?(Array)
           injection_data = @injections[knit[0]]
-          # inject
-          if injection_data[3] == :producer
+          case injection_data[3]
+          when :dispatcher_internal
+            # currently only supports :scope injection
+            scope
+          when :producer
+            injector ||= Puppet.lookup(:injector)
             injector.lookup_producer(scope, injection_data[0], injection_data[2])
           else
+            injector ||= Puppet.lookup(:injector)
             injector.lookup(scope, injection_data[0], injection_data[2])
           end
         else
-          # pick that argument
+          # pick that argument (injection of static value)
           args[knit]
         end
       end

data/lib/puppet/pops/functions/dispatcher.rb

@@ -6,7 +6,7 @@
 class Puppet::Pops::Functions::Dispatcher
   attr_reader :dispatchers
 
-# @api private
+  # @api private
   def initialize()
     @dispatchers = [ ]
   end
@@ -34,7 +34,7 @@ class Puppet::Pops::Functions::Dispatcher
     if found
       found.invoke(instance, calling_scope, args)
     else
-      raise ArgumentError, "function '#{instance.class.name}' called with mis-matched arguments\n#{diff_string(instance.class.name, actual)}"
+      raise ArgumentError, "function '#{instance.class.name}' called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string(instance.class.name, actual, @dispatchers)}"
     end
   end
 
@@ -67,171 +67,4 @@ class Puppet::Pops::Functions::Dispatcher
   def signatures
     @dispatchers
   end
-
-  private
-
-  # Produces a string with the difference between the given arguments and support signature(s).
-  #
-  # @api private
-  def diff_string(name, args_type)
-    result = [ ]
-    if @dispatchers.size < 2
-      dispatch = @dispatchers[ 0 ]
-      params_type  = dispatch.type.param_types
-      block_type   = dispatch.type.block_type
-      params_names = dispatch.param_names
-      result << "expected:\n  #{name}(#{signature_string(dispatch)}) - #{arg_count_string(dispatch.type)}"
-    else
-      result << "expected one of:\n"
-      result << (@dispatchers.map do |d|
-        params_type = d.type.param_types
-        "  #{name}(#{signature_string(d)}) - #{arg_count_string(d.type)}"
-      end.join("\n"))
-    end
-    result << "\nactual:\n  #{name}(#{arg_types_string(args_type)}) - #{arg_count_string(args_type)}"
-    result.join('')
-  end
-
-  # Produces a string for the signature(s)
-  #
-  # @api private
-  def signature_string(dispatch) # args_type, param_names
-    param_types  = dispatch.type.param_types
-    block_type   = dispatch.type.block_type
-    param_names = dispatch.param_names
-
-    from, to = param_types.size_range
-    if from == 0 && to == 0
-      # No parameters function
-      return ''
-    end
-
-    required_count = from
-    # there may be more names than there are types, and count needs to be subtracted from the count
-    # to make it correct for the last named element
-    adjust = max(0, param_names.size() -1)
-    last_range = [max(0, (from - adjust)), (to - adjust)]
-
-    types =
-    case param_types
-    when Puppet::Pops::Types::PTupleType
-      param_types.types
-    when Puppet::Pops::Types::PArrayType
-      [ param_types.element_type ]
-    end
-    tc = Puppet::Pops::Types::TypeCalculator
-
-    # join type with names (types are always present, names are optional)
-    # separate entries with comma
-    #
-    result =
-    if param_names.empty?
-      types.each_with_index.map {|t, index| tc.string(t) + opt_value_indicator(index, required_count, 0) }
-    else
-      limit = param_names.size
-      result = param_names.each_with_index.map do |name, index|
-        [tc.string(types[index] || types[-1]), name].join(' ') + opt_value_indicator(index, required_count, limit)
-      end
-    end.join(', ')
-
-    # Add {from, to} for the last type
-    # This works for both Array and Tuple since it describes the allowed count of the "last" type element
-    # for both. It does not show anything when the range is {1,1}.
-    #
-    result += range_string(last_range)
-
-    # If there is a block, include it with its own optional count {0,1}
-    case dispatch.type.block_type
-    when Puppet::Pops::Types::POptionalType
-      result << ', ' unless result == ''
-      result << "#{tc.string(dispatch.type.block_type.optional_type)} #{dispatch.block_name} {0,1}"
-    when Puppet::Pops::Types::PCallableType
-      result << ', ' unless result == ''
-      result << "#{tc.string(dispatch.type.block_type)} #{dispatch.block_name}"
-    when NilClass
-      # nothing
-    end
-    result
-  end
-
-  # Why oh why Ruby do you not have a standard Math.max ?
-  # @api private
-  def max(a, b)
-    a >= b ? a : b
-  end
-
-  # @api private
-  def opt_value_indicator(index, required_count, limit)
-    count = index + 1
-    (count > required_count && count < limit) ? '?' : ''
-  end
-
-  # @api private
-  def arg_count_string(args_type)
-    if args_type.is_a?(Puppet::Pops::Types::PCallableType)
-      size_range = args_type.param_types.size_range # regular parameters
-      adjust_range=
-      case args_type.block_type
-      when Puppet::Pops::Types::POptionalType
-        size_range[1] += 1
-      when Puppet::Pops::Types::PCallableType
-        size_range[0] += 1
-        size_range[1] += 1
-      when NilClass
-        # nothing
-      else
-        raise ArgumentError, "Internal Error, only nil, Callable, and Optional[Callable] supported by Callable block type"
-      end
-    else
-      size_range = args_type.size_range
-    end
-    "arg count #{range_string(size_range, false)}"
-  end
-
-  # @api private
-  def arg_types_string(args_type)
-    types =
-    case args_type
-    when Puppet::Pops::Types::PTupleType
-      last_range = args_type.repeat_last_range
-      args_type.types
-    when Puppet::Pops::Types::PArrayType
-      last_range = args_type.size_range
-      [ args_type.element_type ]
-    end
-    # stringify generalized versions or it will display Integer[10,10] for "10", String['the content'] etc.
-    # note that type must be copied since generalize is a mutating operation
-    tc = Puppet::Pops::Types::TypeCalculator
-    result = types.map { |t| tc.string(tc.generalize!(t.copy)) }.join(', ')
-
-    # Add {from, to} for the last type
-    # This works for both Array and Tuple since it describes the allowed count of the "last" type element
-    # for both. It does not show anything when the range is {1,1}.
-    #
-    result += range_string(last_range)
-    result
-  end
-
-  # Formats a range into a string of the form: `{from, to}`
-  #
-  # The following cases are optimized:
-  #
-  #   * from and to are equal => `{from}`
-  #   * from and to are both and 1 and squelch_one == true => `''`
-  #   * from is 0 and to is 1 => `'?'`
-  #   * to is INFINITY => `{from, }`
-  #
-  # @api private
-  def range_string(size_range, squelch_one = true)
-    from, to = size_range
-    if from == to
-      (squelch_one && from == 1) ? '' : "{#{from}}"
-    elsif to == Puppet::Pops::Types::INFINITY
-      "{#{from},}"
-    elsif from == 0 && to == 1
-      '?'
-    else
-      "{#{from},#{to}}"
-    end
-  end
 end