puppet 4.0.0 → 4.1.0

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

@@ -60,6 +60,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
     if scope.bound?(name)
       if Puppet::Parser::Scope::RESERVED_VARIABLE_NAMES.include?(name)
         fail(Puppet::Pops::Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
+      elsif name == "server_facts" && Puppet[:trusted_server_facts]
+        fail(Puppet::Pops::Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
       else
         fail(Puppet::Pops::Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
       end
@@ -316,7 +318,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # for the type of the name.
     # Note, locations are available per parameter.
     #
-    scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters)
+    scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters.flatten)
   end
 
   # Capitalizes each segment of a qualified name
@@ -335,7 +337,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
-
+    # A *=> results in an array of arrays
+    evaluated_parameters = evaluated_parameters.flatten
     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} )
@@ -409,15 +412,17 @@ module Puppet::Pops::Evaluator::Runtime3Support
 
   # This is the same type of "truth" as used in the current Puppet DSL.
   #
-  def is_true? o
+  def is_true?(value, o)
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
-    case o
+    case value
     # Support :undef since it may come from a 3x structure
     when :undef
       false
+    when String
+      true
     else
-      !!o
+      !!value
     end
   end
 

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

@@ -71,7 +71,12 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
         else
           # Careful so no new nil arguments are added since they would override default
           # parameter values in the received
-          new_args << args[knit] if knit < args.size
+          if knit < 0
+            idx = -knit - 1
+            new_args += args[idx..-1] if idx < args.size
+          else
+            new_args << args[knit] if knit < args.size
+          end
         end
       end
       new_args

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

@@ -46,7 +46,13 @@ class Puppet::Pops::Functions::Dispatcher
   #
   # @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)
+    add(Puppet::Pops::Functions::Dispatch.new(type, method_name, param_names, block_name, injections, weaving, last_captures))
+  end
+
+  # Adds a dispatch directly to the set of dispathers.
+  # @api private
+  def add(a_dispatch)
+    @dispatchers << a_dispatch
   end
 
   # Produces a CallableType for a single signature, and a Variant[<callables>] otherwise

data/lib/puppet/pops/issue_reporter.rb

@@ -11,19 +11,14 @@ class Puppet::Pops::IssueReporter
   def self.assert_and_report(acceptor, options)
     return unless acceptor
 
-    max_errors = Puppet[:max_errors]
-    max_warnings = Puppet[:max_warnings]
-    max_deprecations =
-    if Puppet[:disable_warnings].include?('deprecations')
-      0
-    else
-      Puppet[:max_deprecations]
-    end
+    max_errors       = options[:max_errors]   || Puppet[:max_errors]
+    max_warnings     = options[:max_warnings] || Puppet[:max_warnings]
+    max_deprecations = options[:max_deprecations] || (Puppet[:disable_warnings].include?('deprecations') ? 0 : Puppet[:max_deprecations])
 
-    emit_warnings = options[:emit_warnings] || false
-    emit_errors = options[:emit_errors].nil? ? true : !!options[:emit_errors]
-    emit_message = options[:message]
-    emit_exception = options[:exception_class] || Puppet::ParseError
+    emit_warnings    = options[:emit_warnings] || false
+    emit_errors      = options[:emit_errors].nil? ? true : !!options[:emit_errors]
+    emit_message     = options[:message]
+    emit_exception   = options[:exception_class] || Puppet::ParseErrorWithIssue
 
     # If there are warnings output them
     warnings = acceptor.warnings
@@ -37,10 +32,10 @@ class Puppet::Pops::IssueReporter
           # deprecation of constructs in manifests! (It is not designed for that purpose even if
           # used throughout the code base).
           #
-          Puppet.warning(formatter.format(w)) if emitted_dw < max_deprecations
+          log_message(:warning, formatter, w) if emitted_dw < max_deprecations
           emitted_dw += 1
         else
-          Puppet.warning(formatter.format(w)) if emitted_w < max_warnings
+          log_message(:warning, formatter, w) if emitted_w < max_warnings
           emitted_w += 1
         end
         break if emitted_w >= max_warnings && emitted_dw >= max_deprecations # but only then
@@ -56,7 +51,7 @@ class Puppet::Pops::IssueReporter
       formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
       if errors.size == 1 || max_errors <= 1
         # raise immediately
-        exception = emit_exception.new(format_with_prefix(emit_message, formatter.format(errors[0])))
+        exception = create_exception(emit_exception, emit_message, formatter, errors[0])
         # if an exception was given as cause, use it's backtrace instead of the one indicating "here"
         if errors[0].exception
           exception.set_backtrace(errors[0].exception.backtrace)
@@ -68,7 +63,7 @@ class Puppet::Pops::IssueReporter
         Puppet.err(emit_message)
       end
       errors.each do |e|
-        Puppet.err(formatter.format(e))
+        log_message(:err, formatter, e)
         emitted += 1
         break if emitted >= max_errors
       end
@@ -84,4 +79,35 @@ class Puppet::Pops::IssueReporter
     return message unless prefix
     [prefix, message].join(' ')
   end
+
+  def self.create_exception(exception_class, emit_message, formatter, diagnostic)
+    file = diagnostic.file
+    file = (file.is_a?(String) && file.empty?) ? nil : file
+    line = pos = nil
+    if diagnostic.source_pos
+      line = diagnostic.source_pos.line
+      pos = diagnostic.source_pos.pos
+    end
+    exception_class.new(format_with_prefix(emit_message, formatter.format_message(diagnostic)), file, line, pos, nil, diagnostic.issue.issue_code)
+  end
+  private_class_method :create_exception
+
+  def self.log_message(severity, formatter, diagnostic)
+    file = diagnostic.file
+    file = (file.is_a?(String) && file.empty?) ? nil : file
+    line = pos = nil
+    if diagnostic.source_pos
+      line = diagnostic.source_pos.line
+      pos = diagnostic.source_pos.pos
+    end
+    Puppet::Util::Log.create({
+        :level => severity,
+        :message => formatter.format_message(diagnostic),
+        :issue_code => diagnostic.issue.issue_code,
+        :file => file,
+        :line => line,
+        :pos => pos,
+      })
+  end
+  private_class_method :log_message
 end

data/lib/puppet/pops/issues.rb

@@ -162,11 +162,16 @@ module Puppet::Pops::Issues
 
   # Variables are immutable, cannot reassign in the same assignment scope
   ILLEGAL_REASSIGNMENT = hard_issue :ILLEGAL_REASSIGNMENT, :name do
-    "Cannot reassign variable #{name}"
+    if Puppet::Pops::Validation::Checker4_0::RESERVED_PARAMETERS[name]
+      "Cannot reassign built in (or already assigned) variable '$#{name}'"
+    else
+      "Cannot reassign variable '$#{name}'"
+    end
   end
 
+  # Variables facts and trusted
   ILLEGAL_RESERVED_ASSIGNMENT = hard_issue :ILLEGAL_RESERVED_ASSIGNMENT, :name do
-    "Attempt to assign to a reserved variable name: '#{name}'"
+    "Attempt to assign to a reserved variable name: '$#{name}'"
   end
 
   # Assignment cannot be made to numeric match result variables
@@ -174,6 +179,11 @@ module Puppet::Pops::Issues
     "Illegal attempt to assign to the numeric match result variable '$#{varname}'. Numeric variables are not assignable"
   end
 
+  # Assignment can only be made to certain types of left hand expressions such as variables.
+  ILLEGAL_ASSIGNMENT_CONTEXT = hard_issue :ILLEGAL_ASSIGNMENT_CONTEXT do
+    "Assignment not allowed here"
+  end
+
   # parameters cannot have numeric names, clashes with match result variables
   ILLEGAL_NUMERIC_PARAMETER = issue :ILLEGAL_NUMERIC_PARAMETER, :name do
     "The numeric parameter name '$#{name}' cannot be used (clashes with numeric match result variables)"
@@ -194,6 +204,14 @@ module Puppet::Pops::Issues
     "Illegal attempt to assign to #{label.a_an(semantic)} via [index/key]. Not an assignable reference"
   end
 
+  ILLEGAL_MULTI_ASSIGNMENT_SIZE = hard_issue :ILLEGAL_MULTI_ASSIGNMENT_SIZE, :expected, :actual do
+    "Mismatched number of assignable entries and values, expected #{expected}, got #{actual}"
+  end
+
+  MISSING_MULTI_ASSIGNMENT_KEY = hard_issue :MISSING_MULTI_ASSIGNMENT_KEY, :key do
+    "No value for required key '#{key}' in assignment to variables from hash"
+  end
+
   APPENDS_DELETES_NO_LONGER_SUPPORTED = hard_issue :APPENDS_DELETES_NO_LONGER_SUPPORTED, :operator do
     "The operator '#{operator}' is no longer supported. See http://links.puppetlabs.com/remove-plus-equals"
   end
@@ -374,6 +392,10 @@ module Puppet::Pops::Issues
     "#{label.a_an_uc(left_value)}[] cannot use #{actual} where #{expected_text} expected"
   end
 
+  BAD_NOT_UNDEF_SLICE_TYPE = issue :BAD_NOT_UNDEF_SLICE_TYPE, :base_type, :actual do
+    "#{base_type}[] argument must be a Type or a String. Got #{actual}"
+  end
+
   BAD_TYPE_SLICE_TYPE = issue :BAD_TYPE_SLICE_TYPE, :base_type, :actual do
     "#{base_type}[] arguments must be types. Got #{actual}"
   end
@@ -549,4 +571,96 @@ module Puppet::Pops::Issues
   ILLEGAL_CATALOG_RELATED_EXPRESSION = hard_issue :ILLEGAL_CATALOG_RELATED_EXPRESSION do
     "This #{label.label(semantic)} appears in a context where catalog related expressions are not allowed"
   end
+
+  SYNTAX_ERROR = hard_issue :SYNTAX_ERROR, :where do
+    "Syntax error at #{where}"
+  end
+
+  ILLEGAL_CLASS_REFERENCE = hard_issue :ILLEGAL_CLASS_REFERENCE do
+    'Illegal class reference'
+  end
+
+  ILLEGAL_FULLY_QUALIFIED_CLASS_REFERENCE = hard_issue :ILLEGAL_FULLY_QUALIFIED_CLASS_REFERENCE do
+    'Illegal fully qualified class reference'
+  end
+
+  ILLEGAL_FULLY_QUALIFIED_NAME = hard_issue :ILLEGAL_FULLY_QUALIFIED_NAME do
+    'Illegal fully qualified name'
+  end
+
+  ILLEGAL_NAME_OR_BARE_WORD = hard_issue :ILLEGAL_NAME_OR_BARE_WORD do
+    'Illegal name or bare word'
+  end
+
+  ILLEGAL_NUMBER = hard_issue :ILLEGAL_NUMBER, :value do
+    "Illegal number '#{value}'"
+  end
+
+  ILLEGAL_UNICODE_ESCAPE = issue :ILLEGAL_UNICODE_ESCAPE do
+    "Unicode escape '\\u' was not followed by 4 hex digits or 1-6 hex digits in {} or was > 10ffff"
+  end
+
+  INVALID_HEX_NUMBER = hard_issue :INVALID_HEX_NUMBER, :value do
+    "Not a valid hex number #{value}"
+  end
+
+  INVALID_OCTAL_NUMBER = hard_issue :INVALID_OCTAL_NUMBER, :value do
+    "Not a valid octal number #{value}"
+  end
+
+  INVALID_DECIMAL_NUMBER = hard_issue :INVALID_DECIMAL_NUMBER, :value do
+    "Not a valid decimal number #{value}"
+  end
+
+  NO_INPUT_TO_LEXER = hard_issue :NO_INPUT_TO_LEXER do
+    "Internal Error: No string or file given to lexer to process."
+  end
+
+  UNRECOGNIZED_ESCAPE = issue :UNRECOGNIZED_ESCAPE, :ch do
+    "Unrecognized escape sequence '\\#{ch}'"
+  end
+
+  UNCLOSED_QUOTE = hard_issue :UNCLOSED_QUOTE, :after, :followed_by do
+    "Unclosed quote after #{after} followed by '#{followed_by}'"
+  end
+
+  EPP_INTERNAL_ERROR = hard_issue :EPP_INTERNAL_ERROR, :error do
+    "Internal error: #{error}"
+  end
+
+  EPP_UNBALANCED_TAG = hard_issue :EPP_UNBALANCED_TAG do
+    'Unbalanced epp tag, reached <eof> without closing tag.'
+  end
+
+  EPP_UNBALANCED_COMMENT = hard_issue :EPP_UNBALANCED_COMMENT do
+    'Reaching end after opening <%# without seeing %>'
+  end
+
+  EPP_UNBALANCED_EXPRESSION = hard_issue :EPP_UNBALANCED_EXPRESSION do
+    'Unbalanced embedded expression - opening <% and reaching end of input'
+  end
+
+  HEREDOC_UNCLOSED_PARENTHESIS = hard_issue :HEREDOC_UNCLOSED_PARENTHESIS, :followed_by do
+    "Unclosed parenthesis after '@(' followed by '#{followed_by}'"
+  end
+
+  HEREDOC_WITHOUT_END_TAGGED_LINE = hard_issue :HEREDOC_WITHOUT_END_TAGGED_LINE do
+    'Heredoc without end-tagged line'
+  end
+
+  HEREDOC_INVALID_ESCAPE = hard_issue :HEREDOC_INVALID_ESCAPE, :actual do
+    "Invalid heredoc escape char. Only t, r, n, s,  u, L, $ allowed. Got '#{actual}'"
+  end
+
+  HEREDOC_INVALID_SYNTAX = hard_issue :HEREDOC_INVALID_SYNTAX do
+    'Invalid syntax in heredoc expected @(endtag[:syntax][/escapes])'
+  end
+
+  HEREDOC_WITHOUT_TEXT = hard_issue :HEREDOC_WITHOUT_TEXT do
+    'Heredoc without any following lines of text'
+  end
+
+  HEREDOC_MULTIPLE_AT_ESCAPES = hard_issue :HEREDOC_MULTIPLE_AT_ESCAPES, :escapes do
+    "An escape char for @() may only appear once. Got '#{escapes.join(', ')}'"
+  end
 end

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

@@ -21,6 +21,9 @@
 #
 class Puppet::Pops::Loader::Loader
 
+  # Describes the kinds of things that loaders can load
+  LOADABLE_KINDS = [:func_4x, :func_4xpp].freeze
+
   # Produces the value associated with the given name if already loaded, or available for loading
   # by this loader, one of its parents, or other loaders visible to this loader.
   # This is the method an external party should use to "get" the named element.
@@ -119,6 +122,14 @@ class Puppet::Pops::Loader::Loader
     raise NotImplementedError.new
   end
 
+  # A loader is by default a loader for all kinds of loadables. An implementation may override
+  # if it cannot load all kinds.
+  #
+  # @api private
+  def loadables
+    LOADABLE_KINDS
+  end
+
   # An entry for one entity loaded by the loader.
   #
   class NamedEntry

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

@@ -4,7 +4,7 @@
 # The central loader knowledge about paths, what they represent and how to instantiate from them.
 # Contains helpers (*smart paths*) to deal with lazy resolution of paths.
 #
-# TODO: Currently only supports loading of functions (3 kinds)
+# TODO: Currently only supports loading of functions (2 kinds)
 #
 module Puppet::Pops::Loader::LoaderPaths
   # Returns an array of SmartPath, each instantiated with a reference to the given loader (for root path resolution
@@ -12,10 +12,17 @@ module Puppet::Pops::Loader::LoaderPaths
   # mutated.
   #
   def self.relative_paths_for_type(type, loader)
-    result =
+    result = []
     case type
     when :function
-        [FunctionPath4x.new(loader)]
+        # Only include support for the loadable items the loader states it can contain
+        if loader.loadables.include?(:func_4x)
+          result << FunctionPath4x.new(loader)
+        end
+        if loader.loadables.include?(:func_4xpp)
+          result << FunctionPathPP.new(loader)
+        end
+        # When wanted also add FunctionPath3x to load 3x functions
     else
       # unknown types, simply produce an empty result; no paths to check, nothing to find... move along...
       []
@@ -44,8 +51,12 @@ module Puppet::Pops::Loader::LoaderPaths
     def generic_path()
       return @generic_path unless @generic_path.nil?
 
-      root_path = @loader.path
-      @generic_path = (root_path.nil? ? relative_path : File.join(root_path, relative_path))
+      the_root_path = root_path() # @loader.path
+      @generic_path = (the_root_path.nil? ? relative_path : File.join(the_root_path, relative_path))
+    end
+
+    def root_path
+      @loader.path
     end
 
     # Effective path is the generic path + the name part(s) + extension.
@@ -64,8 +75,10 @@ module Puppet::Pops::Loader::LoaderPaths
   end
 
   class RubySmartPath < SmartPath
+    EXTENSION = '.rb'.freeze
+
     def extension
-      ".rb"
+      EXTENSION
     end
 
     # Duplication of extension information, but avoids one call
@@ -74,6 +87,29 @@ module Puppet::Pops::Loader::LoaderPaths
     end
   end
 
+  # A PuppetSmartPath is rooted at the loader's directory one level up from what the loader specifies as it
+  # path (which is a reference to its 'lib' directory.
+  #
+  class PuppetSmartPath < SmartPath
+    EXTENSION = '.pp'.freeze
+
+    def extension
+      EXTENSION
+    end
+
+    def root_path
+      # Drop the lib part (it may not exist and cannot be navigated to in a relative way)
+      Puppet::FileSystem.dir_string(@loader.path)
+    end
+
+    # Duplication of extension information, but avoids one call
+    def effective_path(typed_name, start_index_in_name)
+      # Puppet name to path always skips the name-space as that is part of the generic path
+      # i.e. <module>/mymodule/functions/foo.pp is the function mymodule::foo
+      "#{File.join(generic_path, typed_name.name_parts[ 1..-1 ])}.pp"
+    end
+  end
+
   class FunctionPath4x < RubySmartPath
     FUNCTION_PATH_4X = File.join('puppet', 'functions')
 
@@ -86,6 +122,31 @@ module Puppet::Pops::Loader::LoaderPaths
     end
   end
 
+  class FunctionPath3x < RubySmartPath
+    FUNCTION_PATH_3X = File.join('puppet', 'parser', 'functions')
+
+    def relative_path
+      FUNCTION_PATH_3X
+    end
+
+    def instantiator()
+      Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
+    end
+  end
+
+  class FunctionPathPP < PuppetSmartPath
+    # Navigate to directory where 'lib' is, then down again
+    FUNCTION_PATH_PP = File.join('functions')
+
+    def relative_path
+      FUNCTION_PATH_PP
+    end
+
+    def instantiator()
+      Puppet::Pops::Loader::PuppetFunctionInstantiator
+    end
+  end
+
   # SmartPaths
   # ===
   # Holds effective SmartPath instances per type