puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

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

@@ -0,0 +1,237 @@
+# Evaluate the dispatches defined as {Puppet::Pops::Functions::Dispatch}
+# instances to call the appropriate method on the
+# {Puppet::Pops::Functions::Function} instance.
+#
+# @api private
+class Puppet::Pops::Functions::Dispatcher
+  attr_reader :dispatchers
+
+# @api private
+  def initialize()
+    @dispatchers = [ ]
+  end
+
+  # Answers if dispatching has been defined
+  # @return [Boolean] true if dispatching has been defined
+  #
+  # @api private
+  def empty?
+    @dispatchers.empty?
+  end
+
+  # Dispatches the call to the first found signature (entry with matching type).
+  #
+  # @param instance [Puppet::Functions::Function] - the function to call
+  # @param calling_scope [T.B.D::Scope] - the scope of the caller
+  # @param args [Array<Object>] - the given arguments in the form of an Array
+  # @return [Object] - what the called function produced
+  #
+  # @api private
+  def dispatch(instance, calling_scope, args)
+    tc = Puppet::Pops::Types::TypeCalculator
+    actual = tc.infer_set(args)
+    found = @dispatchers.find { |d| tc.callable?(d.type, actual) }
+    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)}"
+    end
+  end
+
+  # Adds a regular dispatch for one method name
+  #
+  # @param type [Puppet::Pops::Types::PArrayType, Puppet::Pops::Types::PTupleType] - type describing signature
+  # @param method_name [String] - the name of the method that will be called when type matches given arguments
+  # @param names [Array<String>] - array with names matching the number of parameters specified by type (or empty array)
+  #
+  # @api private
+  def add_dispatch(type, method_name, param_names, block_name, injections, weaving, last_captures)
+    @dispatchers << Puppet::Pops::Functions::Dispatch.new(type, method_name, param_names, block_name, injections, weaving, last_captures)
+  end
+
+  # Produces a CallableType for a single signature, and a Variant[<callables>] otherwise
+  #
+  # @api private
+  def to_type()
+    # make a copy to make sure it can be contained by someone else (even if it is not contained here, it
+    # should be treated as immutable).
+    #
+    callables = dispatchers.map { | dispatch | dispatch.type.copy }
+
+    # multiple signatures, produce a Variant type of Callable1-n (must copy them)
+    # single signature, produce single Callable
+    callables.size > 1 ?  Puppet::Pops::Types::TypeFactory.variant(*callables) : callables.pop
+  end
+
+  # @api private
+  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

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

@@ -0,0 +1,77 @@
+# @note WARNING: This new function API is still under development and may change at
+#   any time
+#
+# A function in the puppet evaluator.
+#
+# Functions are normally defined by another system, which produces subclasses
+# of this class as well as constructing delegations to call the appropriate methods.
+#
+# This class should rarely be used directly. Instead functions should be
+# constructed using {Puppet::Functions.create_function}.
+#
+# @api public
+class Puppet::Pops::Functions::Function
+  # The scope where the function was defined
+  attr_reader :closure_scope
+
+  # The loader that loaded this function.
+  # Should be used if function wants to load other things.
+  #
+  attr_reader :loader
+
+  def initialize(closure_scope, loader)
+    @closure_scope = closure_scope
+    @loader = loader
+  end
+
+  # Invokes the function via the dispatching logic that performs type check and weaving.
+  # A specialized function may override this method to do its own dispatching and checking of
+  # the raw arguments. A specialized implementation can rearrange arguments, add or remove
+  # arguments and then delegate to the dispatching logic by calling:
+  #
+  # @example Delegating to the dispatcher
+  #     def call(scope, *args)
+  #       manipulated_args = args + ['easter_egg']
+  #       self.class.dispatcher.dispatch(self, scope, manipulated_args)
+  #     end
+  #
+  # System functions that must have access to the calling scope can use this technique. Functions
+  # in general should not need the calling scope. (The closure scope; what is visible where the function
+  # is defined) is available via the method `closure_scope`).
+  #
+  # @api public
+  def call(scope, *args)
+    self.class.dispatcher.dispatch(self, scope, args)
+  end
+
+  # Allows the implementation of a function to call other functions by name. The callable functions
+  # are those visible to the same loader that loaded this function (the calling function).
+  #
+  # @api public
+  def call_function(function_name, *args)
+    if the_loader = loader
+      func = the_loader.load(:function, function_name)
+      if func
+        return func.call(closure_scope, *args)
+      end
+    end
+    # Raise a generic error to allow upper layers to fill in the details about where in a puppet manifest this
+    # error originates. (Such information is not available here).
+    #
+    raise ArgumentError, "Function #{self.class.name}(): cannot call function '#{function_name}' - not found"
+  end
+
+  # The dispatcher for the function
+  #
+  # @api private
+  def self.dispatcher
+    @dispatcher ||= Puppet::Pops::Functions::Dispatcher.new
+  end
+
+  # Produces information about parameters in a way that is compatible with Closure
+  #
+  # @api private
+  def self.signatures
+    @dispatcher.signatures
+  end
+end

data/lib/puppet/pops/issues.rb

@@ -403,6 +403,10 @@ module Puppet::Pops::Issues
     "First argument to Resource[] must be a resource type or a String. Got #{actual}."
   end
 
+  EMPTY_RESOURCE_SPECIALIZATION = issue :EMPTY_RESOURCE_SPECIALIZATION do
+    "Arguments to Resource[] are all empty/undefined"
+  end
+
   ILLEGAL_HOSTCLASS_NAME = hard_issue :ILLEGAL_HOSTCLASS_NAME, :name do
     "Illegal Class name in class reference. #{label.a_an_uc(name)} cannot be used where a String is expected"
   end
@@ -414,6 +418,10 @@ module Puppet::Pops::Issues
     "Unacceptable name. The name '#{name}' is unacceptable as the name of #{label.a_an(semantic)}"
   end
 
+  NON_NAMESPACED_FUNCTION = hard_issue :NON_NAMESPACED_FUNCTION, :name do
+    "A Puppet Function must be defined within a module name-space. The name '#{name}' is unacceptable."
+  end
+
   NOT_NUMERIC = issue :NOT_NUMERIC, :value do
     "The value '#{value}' cannot be converted to Numeric."
   end
@@ -458,4 +466,8 @@ module Puppet::Pops::Issues
   ILLEGAL_EPP_PARAMETERS = issue :ILLEGAL_EPP_PARAMETERS do
     "Ambiguous EPP parameter expression. Probably missing '<%-' before parameters to remove leading whitespace"
   end
+
+  DISCONTINUED_IMPORT = hard_issue :DISCONTINUED_IMPORT do
+    "Use of 'import' has been discontinued in favor of a manifest directory. See http://links.puppetlabs.com/puppet-import-deprecation"
+  end
 end

data/lib/puppet/pops/loader/base_loader.rb

@@ -0,0 +1,102 @@
+# BaseLoader
+# ===
+# An abstract implementation of Puppet::Pops::Loader::Loader
+#
+# A derived class should implement `find(typed_name)` and set entries, and possible handle "miss caching".
+#
+# @api private
+#
+class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
+
+  # The parent loader
+  attr_reader :parent
+
+  # An internal name used for debugging and error message purposes
+  attr_reader :loader_name
+
+  def initialize(parent_loader, loader_name)
+    @parent = parent_loader # the higher priority loader to consult
+    @named_values = {}      # hash name => NamedEntry
+    @last_name = nil        # the last name asked for (optimization)
+    @last_result = nil      # the value of the last name (optimization)
+    @loader_name = loader_name # the name of the loader (not the name-space it is a loader for)
+  end
+
+  # @api public
+  #
+  def load_typed(typed_name)
+    # The check for "last queried name" is an optimization when a module searches. First it checks up its parent
+    # chain, then itself, and then delegates to modules it depends on.
+    # These modules are typically parented by the same
+    # loader as the one initiating the search. It is inefficient to again try to search the same loader for
+    # the same name.
+    if typed_name == @last_name
+      @last_result
+    else
+      @last_name = typed_name
+      @last_result = internal_load(typed_name)
+    end
+  end
+
+  # This method is final (subclasses should not override it)
+  #
+  # @api private
+  #
+  def get_entry(typed_name)
+    @named_values[typed_name]
+  end
+
+  # @api private
+  #
+  def set_entry(typed_name, value, origin = nil)
+    if entry = @named_values[typed_name] then fail_redefined(entry); end
+    @named_values[typed_name] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, value, origin)
+  end
+
+  # @api private
+  #
+  def add_entry(type, name, value, origin)
+    set_entry(Puppet::Pops::Loader::Loader::TypedName.new(type, name), value, origin)
+  end
+
+  # Promotes an already created entry (typically from another loader) to this loader
+  #
+  # @api private
+  #
+  def promote_entry(named_entry)
+    typed_name = named_entry.typed_name
+    if entry = @named_values[typed_name] then fail_redefined(entry); end
+    @named_values[typed_name] = named_entry
+  end
+
+  private
+
+  def fail_redefine(entry)
+    origin_info = entry.origin ? " Originally set at #{origin_label(entry.origin)}." : "unknown location"
+    raise ArgumentError, "Attempt to redefine entity '#{entry.typed_name}' originally set at #{origin_label(origin)}.#{origin_info}"
+  end
+
+  # TODO: Should not really be here?? - TODO: A Label provider ? semantics for the URI?
+  #
+  def origin_label(origin)
+    if origin && origin.is_a?(URI)
+      origin.to_s
+    elsif origin.respond_to?(:uri)
+      origin.uri.to_s
+    else
+      nil
+    end
+  end
+
+  # loads in priority order:
+  # 1. already loaded here
+  # 2. load from parent
+  # 3. find it here
+  # 4. give up
+  #
+  def internal_load(typed_name)
+    # avoid calling get_entry, by looking it up
+    @named_values[typed_name] || parent.load_typed(typed_name) || find(typed_name)
+  end
+
+end

data/lib/puppet/pops/loader/dependency_loader.rb

@@ -0,0 +1,60 @@
+# =DependencyLoader
+# This loader provides visibility into a set of other loaders. It is used as a child of a ModuleLoader (or other
+# loader) to make its direct dependencies visible for loading from contexts that have access to this dependency loader.
+# Access is typically given to logic that resides inside of the module, but not to those that just depend on the module.
+#
+# It is instantiated with a name, and with a set of dependency_loaders.
+#
+# @api private
+#
+class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
+
+  # An index of module_name to module loader used to speed up lookup of qualified names
+  attr_reader :index
+
+  # Creates a DependencyLoader for one parent loader
+  #
+  # @param parent_loader [Puppet::Pops::Loader] typically a module loader for the root
+  # @param name [String] the name of the dependency-loader (used for debugging and tracing only)
+  # @param dependency_loaders [Array<Puppet::Pops::Loader>] array of loaders for modules this module depends on
+  #
+  def initialize(parent_loader, name, dependency_loaders)
+    super parent_loader, name
+    @dependency_loaders = dependency_loaders
+  end
+
+  # Finds name in a loader this loader depends on / can see
+  #
+  def find(typed_name)
+    if typed_name.qualified
+      if loader = index()[typed_name.name_parts[0]]
+        loader.load_typed(typed_name)
+      else
+        # no module entered as dependency with name matching first segment of wanted name
+        nil
+      end
+    else
+      # a non name-spaced name, have to search since it can be anywhere.
+      # (Note: superclass caches the result in this loader as it would have to repeat this search for every
+      # lookup otherwise).
+      loaded = @dependency_loaders.reduce(nil) do |previous, loader|
+        break previous if !previous.nil?
+        loader.load_typed(typed_name)
+      end
+      if loaded
+        promote_entry(loaded)
+      end
+      loaded
+    end
+  end
+
+  def to_s()
+    "(DependencyLoader '#{@loader_name}' [" + @dependency_loaders.map {|loader| loader.to_s }.join(' ,') + "])"
+  end
+
+  private
+
+  def index()
+    @index ||= @dependency_loaders.reduce({}) { |index, loader| index[loader.module_name] = loader; index }
+  end
+end