puppet 3.8.7 → 4.0.0.rc1

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

@@ -1,12 +1,15 @@
 # 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.
 #
+require 'puppet/plugins/syntax_checkers'
 module Puppet::Pops::Evaluator::ExternalSyntaxSupport
-  # TODO: This can be simplified if the Factory directly supporteded hash_of/type_of
+  # TODO: This can be simplified if the Factory directly supported hash_of/type_of
   TYPES = Puppet::Pops::Types::TypeFactory
+  SERVICE_TYPE = Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_TYPE
+  SERVICE_NAME = Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_KEY
 
   def assert_external_syntax(scope, result, syntax, reference_expr)
-    @@HASH_OF_SYNTAX_CHECKERS ||= TYPES.hash_of(TYPES.type_of(::Puppetx::SYNTAX_CHECKERS_TYPE))
+    @@HASH_OF_SYNTAX_CHECKERS ||= TYPES.hash_of(TYPES.type_of(SERVICE_TYPE))
     # ignore 'unspecified syntax'
     return if syntax.nil? || syntax == ''
 
@@ -31,7 +34,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
   # Returns nil if there is no registered checker.
   #
   def checker_for_syntax(scope, syntax)
-    checkers_hash = scope.compiler.injector.lookup(scope, @@HASH_OF_SYNTAX_CHECKERS, ::Puppetx::SYNTAX_CHECKERS) || {}
+    checkers_hash = scope.compiler.injector.lookup(scope, @@HASH_OF_SYNTAX_CHECKERS, SERVICE_NAME) || {}
     checkers_hash[lookup_keys_for_syntax(syntax).find {|x| checkers_hash[x] }]
   end
 

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

@@ -134,7 +134,7 @@ class Puppet::Pops::Evaluator::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 {|x| transform(x, scope) }}
+      real = left_right_evaluated.collect {|x| [x].flatten.collect {|y| transform(y, scope) }}
       real[0].flatten!
       real[1].flatten!
       real[0].uniq!

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

@@ -140,7 +140,7 @@ class Runtime3Converter
       when Puppet::Pops::Types::PResourceType
         type_name = split_type.type_name
         title = split_type.title
-        if type_name =~ /^(::)?[Cc]lass$/
+        if type_name =~ /^(::)?[Cc]lass/
           ['class', title.nil? ? nil : title.sub(/^::/, '')]
         else
           # Ensure that title is '' if nil

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

@@ -194,7 +194,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # 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).
     #
-    if source.is_a?(Puppet::Parser::Collector) || source.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+    if source.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       source_resource = source
     else
@@ -202,7 +202,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
       type, title = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(source)
       source_resource = Puppet::Resource.new(type, title)
     end
-    if target.is_a?(Puppet::Parser::Collector) || target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+    if target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       target_resource = target
     else
@@ -229,37 +229,6 @@ module Puppet::Pops::Evaluator::Runtime3Support
     n
   end
 
-  # Provides the ability to call a 3.x or 4.x function from the perspective of a 3.x function or ERB template.
-  # The arguments to the function must be an Array containing values compliant with the 4.x calling convention.
-  # If the targeted function is a 3.x function, the values will be transformed.
-  # @param name [String] the name of the function (without the 'function_' prefix used by scope)
-  # @param args [Array] arguments, may be empty
-  # @param scope [Object] the (runtime specific) scope where evaluation takes place
-  # @raise ArgumentError 'unknown function' if the function does not exist
-  #
-  def external_call_function(name, args, scope, &block)
-    # Call via 4x API if the function exists there
-    loaders = scope.compiler.loaders
-    # Since this is a call from non puppet code, it is not possible to relate it to a module loader
-    # It is known where the call originates by using the scope associated module - but this is the calling scope
-    # and it does not defined the visibility of functions from a ruby function's perspective. Instead,
-    # this is done from the perspective of the environment.
-    loader = loaders.private_environment_loader
-    if loader && func = loader.load(:function, name)
-      return func.call(scope, *args, &block)
-    end
-
-    # Call via 3x API if function exists there
-    raise ArgumentError, "Unknown function '#{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
-    mapped_args = Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, scope, '')
-    result = scope.send("function_#{name}", mapped_args, &block)
-    # Prevent non r-value functions from leaking their result (they are not written to care about this)
-    Puppet::Parser::Functions.rvalue?(name) ? result : nil
-  end
-
   def call_function(name, args, o, scope, &block)
     # Call via 4x API if the function exists there
     loaders = scope.compiler.loaders
@@ -304,15 +273,6 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
     # from the raised exception. (It may be good enough).
 
-
-    # In 3.x scope does not resolve classes as absolute names.
-    # In 4.x it does. This comment, and the conditional logic in the if below
-    # should be removed when merged to 4.x
-    #
-    if type_name == CLASS_STRING
-      resource_titles = resource_titles.map {|s| s.index('::') != 0 ? "::#{s}" : s }
-    end
-
     # resolve in scope.
     fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type_name, resource_titles)
 
@@ -341,7 +301,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_STRING
+        scope.compiler.evaluate_classes([resource_title], scope, false) 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)
@@ -356,7 +316,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.flatten)
+    scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters)
   end
 
   # Capitalizes each segment of a qualified name
@@ -375,8 +335,7 @@ 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} )
@@ -450,18 +409,15 @@ module Puppet::Pops::Evaluator::Runtime3Support
 
   # This is the same type of "truth" as used in the current Puppet DSL.
   #
-  def is_true?(value, o)
+  def is_true? o
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
-    case value
+    case o
     # Support :undef since it may come from a 3x structure
     when :undef
       false
-    when String
-      @migration_checker.report_empty_string_true(value, o)
-      true
     else
-      !!value
+      !!o
     end
   end
 
@@ -514,11 +470,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
   class ExceptionRaisingAcceptor < Puppet::Pops::Validation::Acceptor
     def accept(diagnostic)
       super
-      Puppet::Pops::IssueReporter.assert_and_report(self, {
-        :message => "Evaluation Error:", 
-        :emit_warnings => true,  # log warnings
-        :exception_class => Puppet::PreformattedError
-      })
+      Puppet::Pops::IssueReporter.assert_and_report(self, {:message => "Evaluation Error:", :emit_warnings => true })
       if errors?
         raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
       end

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

@@ -71,12 +71,7 @@ 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
-          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
+          new_args << args[knit] if knit < args.size
         end
       end
       new_args

data/lib/puppet/pops/issue_reporter.rb

@@ -11,14 +11,19 @@ class Puppet::Pops::IssueReporter
   def self.assert_and_report(acceptor, options)
     return unless acceptor
 
-    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])
+    max_errors = Puppet[:max_errors]
+    max_warnings = Puppet[:max_warnings]
+    max_deprecations =
+    if Puppet[:disable_warnings].include?('deprecations')
+      0
+    else
+      Puppet[:max_deprecations]
+    end
 
-    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
+    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
 
     # If there are warnings output them
     warnings = acceptor.warnings
@@ -32,10 +37,10 @@ class Puppet::Pops::IssueReporter
           # deprecation of constructs in manifests! (It is not designed for that purpose even if
           # used throughout the code base).
           #
-          log_message(:warning, formatter, w) if emitted_dw < max_deprecations
+          Puppet.warning(formatter.format(w)) if emitted_dw < max_deprecations
           emitted_dw += 1
         else
-          log_message(:warning, formatter, w) if emitted_w < max_warnings
+          Puppet.warning(formatter.format(w)) if emitted_w < max_warnings
           emitted_w += 1
         end
         break if emitted_w >= max_warnings && emitted_dw >= max_deprecations # but only then
@@ -51,7 +56,7 @@ class Puppet::Pops::IssueReporter
       formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
       if errors.size == 1 || max_errors <= 1
         # raise immediately
-        exception = create_exception(emit_exception, emit_message, formatter, errors[0])
+        exception = emit_exception.new(format_with_prefix(emit_message, formatter.format(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)
@@ -63,7 +68,7 @@ class Puppet::Pops::IssueReporter
         Puppet.err(emit_message)
       end
       errors.each do |e|
-        log_message(:err, formatter, e)
+        Puppet.err(formatter.format(e))
         emitted += 1
         break if emitted >= max_errors
       end
@@ -79,35 +84,4 @@ 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

@@ -73,30 +73,19 @@ module Puppet::Pops::Issues
       instance_eval &block
     end
 
-    # Obtains the label provider given as a key `:label` in the hash passed to #format. The label provider is
-    # return if no arguments are given. If given an argument, returns the result of calling #label on the label
-    # provider.
+    # Returns the label provider given as a key in the hash passed to #format.
+    # If given an argument, calls #label on the label provider (caller would otherwise have to
+    # call label.label(it)
     #
-    # @param args [Object] one object to obtain a label for or zero arguments to obtain the label provider
-    # @return [Puppet::Pops::LabelProvider,String] the label provider or label depending on if an argument is given or not
-    # @raise [Puppet::Error] if no label provider is found
-    def label(*args)
-      args.empty? ? label_provider : label_provider.label(args[0])
-    end
-
-    # Returns the label provider given as key `:label` in the hash passed to #format.
-    # @return [Puppet::Pops::LabelProvider] the label provider
-    # @raise [Puppet::Error] if no label provider is found
-    def label_provider
-      label_provider = @data[:label]
-      raise Puppet::Error, 'Label provider key :label must be set to produce the text of the message!' unless label_provider
-      label_provider
+    def label(it = nil)
+      raise "Label provider key :label must be set to produce the text of the message!" unless @data[:label]
+      it.nil? ? @data[:label] : @data[:label].label(it)
     end
 
     # Returns the label provider given as a key in the hash passed to #format.
     #
     def semantic
-      raise Puppet::Error, 'Label provider key :semantic must be set to produce the text of the message!' unless @data[:semantic]
+      raise "Label provider key :semantic must be set to produce the text of the message!" unless @data[:semantic]
       @data[:semantic]
     end
   end
@@ -254,15 +243,11 @@ module Puppet::Pops::Issues
   end
 
   ILLEGAL_NAME = hard_issue :ILLEGAL_NAME, :name do
-    "Illegal name. The given name '#{name}' does not conform to the naming rule /^((::)?[a-z_]\w*)(::[a-z]\\w*)*$/"
-  end
-
-  ILLEGAL_PARAM_NAME = hard_issue :ILLEGAL_PARAM_NAME, :name do
-    "Illegal parameter name. The given name '#{name}' does not conform to the naming rule /^[a-z_]\\w*$/"
+    "Illegal name. The given name #{name} does not conform to the naming rule /^((::)?[a-z_]\w*)(::[a-z]\w*)*$/"
   end
 
   ILLEGAL_VAR_NAME = hard_issue :ILLEGAL_VAR_NAME, :name do
-    "Illegal variable name, The given name '#{name}' does not conform to the naming rule /^((::)?[a-z]\\w*)*((::)?[a-z_]\\w*)$/"
+    "Illegal variable name, The given name '#{name}' does not conform to the naming rule /^((::)?[a-z]\w*)*((::)?[a-z_]\w*)$/"
   end
 
   ILLEGAL_NUMERIC_VAR_NAME = hard_issue :ILLEGAL_NUMERIC_VAR_NAME, :name do
@@ -389,17 +374,13 @@ 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
 
   BAD_TYPE_SLICE_ARITY = issue :BAD_TYPE_SLICE_ARITY, :base_type, :min, :max, :actual do
     base_type_label = base_type.is_a?(String) ? base_type : label.a_an_uc(base_type)
-    if max == -1 || max == 1.0 / 0.0 # Infinity
+    if max == -1 || max == Float::INFINITY
       "#{base_type_label}[] accepts #{min} or more arguments. Got #{actual}"
     elsif max && max != min
       "#{base_type_label}[] accepts #{min} to #{max} arguments. Got #{actual}"
@@ -428,7 +409,7 @@ module Puppet::Pops::Issues
     "Illegal Class name in class reference. #{label.a_an_uc(name)} cannot be used where a String is expected"
   end
 
-  ILLEGAL_DEFINITION_NAME = hard_issue :ILLEGAL_DEFINTION_NAME, :name do
+  ILLEGAL_DEFINITION_NAME = hard_issue :ILLEGAL_DEFINITION_NAME, :name do
     "Unacceptable name. The name '#{name}' is unacceptable as the name of #{label.a_an(semantic)}"
   end
 
@@ -537,10 +518,6 @@ module Puppet::Pops::Issues
     "Use of reserved word: #{word}, must be quoted if intended to be a String value"
   end
 
-  FUTURE_RESERVED_WORD = issue :FUTURE_RESERVED_WORD, :word do
-    "Use of future reserved word: '#{word}'"
-  end
-
   RESERVED_TYPE_NAME = hard_issue :RESERVED_TYPE_NAME, :name do
     "The name: '#{name}' is already defined by Puppet and can not be used as the name of #{label.a_an(semantic)}."
   end
@@ -557,10 +534,6 @@ module Puppet::Pops::Issues
     "Resource Override can only operate on resources, got: #{label.label(actual)}"
   end
 
-  DUPLICATE_PARAMETER = hard_issue :DUPLICATE_PARAMETER, :param_name do
-    "The parameter '#{param_name}' is declared more than once in the parameter list"
-  end
-
   RESERVED_PARAMETER = hard_issue :RESERVED_PARAMETER, :container, :param_name do
     "The parameter $#{param_name} redefines a built in parameter in #{label.the(container)}"
   end
@@ -573,95 +546,7 @@ module Puppet::Pops::Issues
     "Unfolding of attributes from Hash can only be used once per resource body"
   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 do
-    'Illegal number'
-  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(', ')}'"
+  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
 end