puppet 4.7.1 → 4.8.0

data/lib/puppet/pops/label_provider.rb

@@ -40,8 +40,6 @@ module Puppet::Pops::LabelProvider
     count == 1 ? text : "#{text}s"
   end
 
-  private
-
   # Produces an *indefinite article* (a/an) for the given text ('a' if
   # it starts with a vowel) This is obviously flawed in the general
   # sense as may labels have punctuation at the start and this method
@@ -52,6 +50,8 @@ module Puppet::Pops::LabelProvider
     article_for_letter(first_letter_of(s))
   end
 
+  private
+
   def first_letter_of(string)
     char = string[0,1]
     if SKIPPED_CHARACTERS.include? char

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

@@ -150,6 +150,23 @@ class Loader
     LOADABLE_KINDS
   end
 
+  # A loader may want to implement its own version with more detailed information.
+  def to_s
+    loader_name
+  end
+
+  # Loaders may contain references to the environment they load items within.
+  # Consequently, calling Kernel#inspect may return strings that are large
+  # enough to cause OutOfMemoryErrors on some platforms.
+  #
+  # We do not call alias_method here as that would copy the content of to_s
+  # at this point to inspect (ie children would print out `loader_name`
+  # rather than their version of to_s if they chose to implement it).
+  def inspect
+    self.to_s
+  end
+
+
   # An entry for one entity loaded by the loader.
   #
   class NamedEntry

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

@@ -63,7 +63,6 @@ class StaticLoader < Loader
   attr_reader :loaded
   def initialize
     @loaded = {}
-    create_logging_functions()
     create_built_in_types()
     create_resource_type_references()
   end
@@ -99,46 +98,6 @@ class StaticLoader < Loader
     @loaded[typed_name]
   end
 
-  # Creates a function for each of the specified log levels
-  #
-  def create_logging_functions()
-    Puppet::Util::Log.levels.each do |level|
-
-      fc = Puppet::Functions.create_function(level) do
-        # create empty dispatcher to stop it from complaining about missing method since
-        # an override of :call is made instead of using dispatch.
-        dispatch(:log) { }
-
-        # Logs per the specified level, outputs formatted information for arrays, hashes etc.
-        # Overrides the implementation in Function that uses dispatching. This is not needed here
-        # since it accepts 0-n Object.
-        #
-        define_method(:call) do |scope, *vals|
-          # NOTE: 3x, does this: vals.join(" ")
-          # New implementation uses the evaluator to get proper formatting per type
-          # TODO: uses a fake scope (nil) - fix when :scopes are available via settings
-          mapped = vals.map {|v| Puppet::Pops::Evaluator::EvaluatorImpl.new.string(v, nil) }
-
-          # Bypass Puppet.<level> call since it picks up source from "self" which is not applicable in the 4x
-          # Function API.
-          # TODO: When a function can obtain the file, line, pos of the call merge those in (3x supports
-          #       options :file, :line. (These were never output when calling the 3x logging functions since
-          #       3x scope does not know about the calling location at that detailed level, nor do they
-          #       appear in a report to stdout/error when included). Now, the output simply uses scope (like 3x)
-          #       as this is good enough, but does not reflect the true call-stack, but is a rough estimate
-          #       of where the logging call originates from).
-          #
-          Puppet::Util::Log.create({:level => level, :source => scope, :message => mapped.join(" ")})
-        end
-      end
-
-      typed_name = TypedName.new(:function, level)
-      # TODO:closure scope is fake (an empty hash) - waiting for new global scope to be available via lookup of :scopes
-      func = fc.new({},self)
-      @loaded[ typed_name ] = NamedEntry.new(typed_name, func, __FILE__)
-    end
-  end
-
   def create_built_in_types
     origin_uri = URI("puppet:Puppet-Type-System/Static-Loader")
     type_map = Puppet::Pops::Types::TypeParser.type_map

data/lib/puppet/pops/lookup.rb

@@ -54,12 +54,24 @@ module Lookup
       elsif has_default
         answer = assert_type('Default value', value_type, default_value)
       else
+        lookup_invocation.emit_debug_info(debug_preamble(names)) if Puppet[:debug]
         fail_lookup(names)
       end
     end
+    lookup_invocation.emit_debug_info(debug_preamble(names)) if Puppet[:debug]
     answer
   end
 
+  # @api private
+  def self.debug_preamble(names)
+    if names.size == 1
+      names = "'#{names[0]}'"
+    else
+      names = names.map { |n| "'#{n}'" }.join(', ')
+    end
+    "Lookup of #{names}"
+  end
+
   # @api private
   def self.search_and_merge(name, lookup_invocation, merge)
     return Puppet::DataProviders.lookup_adapter(lookup_invocation).lookup(name, lookup_invocation, merge)

data/lib/puppet/pops/lookup/context.rb

@@ -0,0 +1,86 @@
+module Puppet::Pops
+  module Lookup
+    class Context
+      include Types::PuppetObject
+
+      def self._ptype
+        @type
+      end
+
+      def self.register_ptype(loader, ir)
+        tf = Types::TypeFactory
+        @type = Pcore::create_object_type(loader, ir, self, 'Puppet::LookupContext', 'Any',
+          {
+            'environment_name' => Types::PStringType::NON_EMPTY,
+            'module_name' => {
+              Types::KEY_TYPE => tf.optional(Types::PStringType::NON_EMPTY),
+              Types::KEY_VALUE => nil
+            }
+          },
+          {
+            'not_found' => tf.callable([0, 0], tf.undef),
+            'explain' => tf.callable([0, 0, tf.callable(0,0)], tf.undef),
+            'cache' => tf.callable([tf.scalar, tf.any], tf.undef),
+            'cache_all' => tf.callable([tf.hash_kv(tf.scalar, tf.any)], tf.undef),
+            'cached_value' => tf.callable([tf.scalar], tf.any),
+            'cached_entries' => tf.variant(
+              tf.callable([0, 0, tf.callable(1,1)], tf.undef),
+              tf.callable([0, 0, tf.callable(2,2)], tf.undef),
+              tf.callable([0, 0], tf.iterable(tf.tuple([tf.scalar, tf.any])))
+            )
+          }
+        ).resolve(Types::TypeParser.singleton, loader)
+      end
+
+      attr_reader :environment_name
+      attr_reader :module_name
+
+      def initialize(environment_name, module_name, lookup_invocation = Invocation.current)
+        @lookup_invocation = lookup_invocation
+        @environment_name = environment_name
+        @module_name = module_name
+        @cache = {}
+      end
+
+      def cache(key, value)
+        @cache[key] = value
+        nil
+      end
+
+      def cache_all(hash)
+        @cache.merge!(hash)
+        nil
+      end
+
+      def cached_value(key)
+        @cache[key]
+      end
+
+      def cached_entries(&block)
+        @cache
+        if block_given?
+          enumerator = @cache.each_pair
+          @cache.size.times do
+            if block.arity == 2
+              yield(*enumerator.next)
+            else
+              yield(enumerator.next)
+            end
+          end
+          nil
+        else
+          Types::Iterable.on(@cache)
+        end
+      end
+
+      def explain(&block)
+        @lookup_invocation.report_text(&block) unless @lookup_invocation.nil?
+        nil
+      end
+
+      def not_found
+        throw :no_such_key
+      end
+    end
+  end
+end

data/lib/puppet/pops/lookup/explainer.rb

@@ -18,9 +18,9 @@ module Puppet::Pops::Lookup
     end
 
     def to_s
-      io = StringIO.new
+      io = ''
       dump_on(io, '', '')
-      io.string
+      io
     end
 
     def dump_on(io, indent, first_indent)
@@ -34,6 +34,7 @@ module Puppet::Pops::Lookup
     def initialize(parent)
       @parent = parent
       @event = nil
+      @texts = nil
     end
 
     def found_in_overrides(key, value)
@@ -59,6 +60,11 @@ module Puppet::Pops::Lookup
       @event = :result
     end
 
+    def text(text)
+      @texts ||= []
+      @texts << text
+    end
+
     def not_found(key)
       @key = key
       @event = :not_found
@@ -81,6 +87,7 @@ module Puppet::Pops::Lookup
       hash[:key] = @key unless @key.nil?
       hash[:value] = @value if [:found, :found_in_defaults, :found_in_overrides, :result].include?(@event)
       hash[:event] = @event unless @event.nil?
+      hash[:texts] = @texts unless @texts.nil?
       hash[:type] = type
       hash
     end
@@ -98,6 +105,11 @@ module Puppet::Pops::Lookup
         io << ' in defaults' if @event == :found_in_defaults
         io << "\n"
       end
+      dump_texts(io, indent, @texts)
+    end
+
+    def dump_texts(io, indent, texts)
+      texts.each { |text| io << indent << text << "\n" } unless texts.nil?
     end
 
     def dump_value(io, indent, value)
@@ -218,7 +230,7 @@ module Puppet::Pops::Lookup
       # It's pointless to report a merge where there's only one branch
       return branches[0].dump_on(io, indent, first_indent) if branches.size == 1
 
-      io << first_indent << 'Merge strategy ' << @merge.class.key << "\n"
+      io << first_indent << 'Merge strategy ' << @merge.class.key.to_s << "\n"
       indent = increase_indent(indent)
       options = options_wo_strategy
       unless options.nil?
@@ -297,7 +309,7 @@ module Puppet::Pops::Lookup
     end
 
     def dump_on(io, indent, first_indent)
-      io << first_indent << 'Data Binding "' << @binding_terminus << "\"\n"
+      io << first_indent << 'Data Binding "' << @binding_terminus.to_s << "\"\n"
       indent = increase_indent(indent)
       branches.each {|b| b.dump_on(io, indent, indent)}
       dump_outcome(io, indent)
@@ -323,7 +335,7 @@ module Puppet::Pops::Lookup
     def dump_on(io, indent, first_indent)
       io << first_indent << 'Data Provider "' << @provider.name << "\"\n"
       indent = increase_indent(indent)
-      io << indent << 'ConfigurationPath "' << @provider.config_path << "\"\n" if @provider.respond_to?(:config_path)
+      io << indent << 'ConfigurationPath "' << @provider.config_path.to_s << "\"\n" if @provider.respond_to?(:config_path)
       branches.each {|b| b.dump_on(io, indent, indent)}
       dump_outcome(io, indent)
     end
@@ -347,7 +359,7 @@ module Puppet::Pops::Lookup
     end
 
     def dump_on(io, indent, first_indent)
-      io << indent << 'Path "' << @path.path << "\"\n"
+      io << indent << 'Path "' << @path.path.to_s << "\"\n"
       indent = increase_indent(indent)
       io << indent << 'Original path: "' << @path.original_path << "\"\n"
       branches.each {|b| b.dump_on(io, indent, indent)}
@@ -498,6 +510,10 @@ module Puppet::Pops::Lookup
       @current.result(result)
     end
 
+    def accept_text(text)
+      @current.text(text)
+    end
+
     def dump_on(io, indent, first_indent)
       branches.each { |b| b.dump_on(io, indent, first_indent) }
     end
@@ -506,4 +522,28 @@ module Puppet::Pops::Lookup
       branches.size == 1 ? branches[0].to_hash : super
     end
   end
+
+  class DebugExplainer < Explainer
+    attr_reader :wrapped_explainer
+
+    def initialize(wrapped_explainer)
+      @wrapped_explainer = wrapped_explainer
+      if wrapped_explainer.nil?
+        @current = self
+        @explain_options = false
+        @only_explain_options = false
+      else
+        @current = wrapped_explainer
+        @explain_options = wrapped_explainer.explain_options?
+        @only_explain_options = wrapped_explainer.only_explain_options?
+      end
+    end
+
+    def emit_debug_info(preamble)
+      io = ''
+      io << preamble << "\n"
+      @current.dump_on(io, '  ', '  ')
+      Puppet.debug(io.chomp!)
+    end
+  end
 end

data/lib/puppet/pops/lookup/invocation.rb

@@ -3,6 +3,10 @@ module Puppet::Pops::Lookup
     attr_reader :scope, :override_values, :default_values, :explainer
     attr_accessor :module_name, :top_key
 
+    def self.current
+        nil # TODO, determine how to obtain the current lookup invocation.
+    end
+
     # Creates a context object for a lookup invocation. The object contains the current scope, overrides, and default
     # values and may optionally contain an {ExplanationAcceptor} instance that will receive book-keeping information
     # about the progress of the lookup.
@@ -23,6 +27,7 @@ module Puppet::Pops::Lookup
       unless explainer.is_a?(Explainer)
         explainer = explainer == true ? Explainer.new : nil
       end
+      explainer = DebugExplainer.new(explainer) if Puppet[:debug] && !explainer.is_a?(DebugExplainer)
       @explainer = explainer
     end
 
@@ -44,6 +49,14 @@ module Puppet::Pops::Lookup
       end
     end
 
+    def emit_debug_info(preamble)
+      debug_explainer = @explainer
+      if debug_explainer.is_a?(DebugExplainer)
+        @explainer = debug_explainer.wrapped_explainer
+        debug_explainer.emit_debug_info(preamble)
+      end
+    end
+
     # The qualifier_type can be one of:
     # :global - qualifier is the data binding terminus name
     # :data_provider - qualifier a DataProvider instance
@@ -114,6 +127,12 @@ module Puppet::Pops::Lookup
     def report_module_not_found
       @explainer.accept_module_not_found unless @explainer.nil?
     end
+
+    def report_text(&block)
+      unless @explainer.nil?
+        @explainer.accept_text(block.call)
+      end
+    end
   end
 end
 

data/lib/puppet/pops/lookup/sub_lookup.rb

@@ -9,7 +9,7 @@ module SubLookup
   # parameter block. The block must return an exception instance.
   #
   # @param key [String] the string to split
-  # @return Array<String> the array of segments
+  # @return [Array<String>] the array of segments
   # @yieldparam problem [String] the problem, i.e. 'Syntax error'
   # @yieldreturn [Exception] the exception to raise
   #

data/lib/puppet/pops/model/factory.rb

@@ -228,10 +228,11 @@ class Factory
     end
   end
 
-  def build_LambdaExpression(o, parameters, body)
+  def build_LambdaExpression(o, parameters, body, return_type)
     o.parameters = parameters.map {|p| build(p) }
     b = f_build_body(body)
     o.body = to_ops(b) if b
+    o.return_type = to_ops(return_type) unless return_type.nil?
     o
   end
 
@@ -243,6 +244,15 @@ class Factory
     o
   end
 
+  def build_FunctionDefinition(o, name, parameters, body, return_type)
+    o.parameters = parameters.map {|p| build(p) }
+    b = f_build_body(body)
+    o.body = b.current if b
+    o.name = name
+    o.return_type = to_ops(return_type) unless return_type.nil?
+    o
+  end
+
   def build_CapabilityMapping(o, kind, component, capability, mappings)
     o.kind = kind
     component = component.current if component.instance_of?(Factory)
@@ -690,7 +700,7 @@ class Factory
       params = parameters
       parameters_specified = true
     end
-    LAMBDA(params, new(EppExpression, parameters_specified, body))
+    LAMBDA(params, new(EppExpression, parameters_specified, body), nil)
   end
 
   def self.RESERVED(name, future=false)
@@ -817,12 +827,12 @@ class Factory
     new(Application, name, parameters, body)
   end
 
-  def self.FUNCTION(name, parameters, body)
-    new(FunctionDefinition, name, parameters, body)
+  def self.FUNCTION(name, parameters, body, return_type)
+    new(FunctionDefinition, name, parameters, body, return_type)
   end
 
-  def self.LAMBDA(parameters, body)
-    new(LambdaExpression, parameters, body)
+  def self.LAMBDA(parameters, body, return_type)
+    new(LambdaExpression, parameters, body, return_type)
   end
 
   def self.TYPE_ASSIGNMENT(lhs, rhs)
@@ -855,7 +865,10 @@ class Factory
     'err'     => true,
 
     'fail'    => true,
-    'import'  => true  # discontinued, but transform it to make it call error reporting function
+    'import'  => true,  # discontinued, but transform it to make it call error reporting function
+    'break'   => true,
+    'next'    => true,
+    'return'  => true
   }
   # Returns true if the given name is a "statement keyword" (require, include, contain,
   # error, notice, info, debug
@@ -1136,4 +1149,3 @@ class Factory
 end
 end
 end
-