puppet 4.3.2 → 4.4.0

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

@@ -0,0 +1,85 @@
+require 'rgen/ecore/ecore'
+
+# Literal values for
+#
+#   * String
+#   * Numbers
+#   * Booleans
+#   * Undef (produces nil)
+#   * Array
+#   * Hash where keys must be Strings
+#   * QualifiedName
+#
+# Not considered literal:
+#
+#   * QualifiedReference  # i.e. File, FooBar
+#   * Default is not accepted as being literal
+#   * Regular Expression is not accepted as being literal
+#   * Hash with non String keys
+#   * String with interpolatin
+#
+class Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator
+  #include Puppet::Pops::Utils
+
+  EMPTY_STRING = ''.freeze
+  COMMA_SEPARATOR = ', '.freeze
+
+  def initialize
+    @@literal_visitor ||= Puppet::Pops::Visitor.new(self, "literal", 0, 0)
+  end
+
+  def literal(ast)
+    @@literal_visitor.visit_this_0(self, ast)
+  end
+
+  def literal_Object(o)
+    throw :not_literal
+  end
+
+  def literal_Factory(o)
+    literal(o.model)
+  end
+
+  def literal_Program(o)
+    literal(o.body)
+  end
+
+  def literal_LiteralString(o)
+    o.value
+  end
+
+  def literal_QualifiedName(o)
+    o.value
+  end
+
+  def literal_LiteralNumber(o)
+    o.value
+  end
+
+  def literal_LiteralBoolean(o)
+    o.value
+  end
+
+  def literal_LiteralUndef(o)
+    nil
+  end
+
+  def literal_ConcatenatedString(o)
+    # use double quoted string value if there is no interpolation
+    throw :not_literal unless o.segments.size == 1 && o.segments[0].is_a?(Puppet::Pops::Model::LiteralString)
+    o.segments[0].value
+  end
+
+  def literal_LiteralList(o)
+    o.values.map {|v| literal(v) }
+  end
+
+  def literal_LiteralHash(o)
+    o.entries.reduce({}) do |result, entry|
+      key = literal(entry.key)
+      throw :not_literal unless key.is_a?(String)
+      result[key] = literal(entry.value)
+      result
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+module Puppet::Pops
+module Evaluator
 # The RelationshipOperator implements the semantics of the -> <- ~> <~ operators creating relationships or notification
 # relationships between the left and right hand side's references to resources.
 #
@@ -6,14 +8,12 @@
 # This is done to separate the concerns of the new evaluator from the 3x runtime; messy logic goes into the runtime support
 # module. Later when more is cleaned up this can be simplified further.
 #
-class Puppet::Pops::Evaluator::RelationshipOperator
+class RelationshipOperator
 
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
-  include Puppet::Pops::Evaluator::Runtime3Support
-
-  Issues = Puppet::Pops::Issues
+  include Runtime3Support
 
   class IllegalRelationshipOperandError < RuntimeError
     attr_reader :operand
@@ -30,11 +30,11 @@ class Puppet::Pops::Evaluator::RelationshipOperator
   end
 
   def initialize
-    @type_transformer_visitor = Puppet::Pops::Visitor.new(self, "transform", 1, 1)
-    @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
-    @type_parser = Puppet::Pops::Types::TypeParser.new()
+    @type_transformer_visitor = Visitor.new(self, "transform", 1, 1)
+    @type_calculator = Types::TypeCalculator.new()
+    @type_parser = Types::TypeParser.new()
 
-    tf = Puppet::Pops::Types::TypeFactory
+    tf = Types::TypeFactory
     @catalog_type = tf.variant(tf.catalog_entry, tf.type_type(tf.catalog_entry))
   end
 
@@ -51,19 +51,19 @@ class Puppet::Pops::Evaluator::RelationshipOperator
   # A Resource is by definition a Catalog type, but of 3.x type
   # @api private
   def transform_Resource(o, scope)
-    Puppet::Pops::Types::TypeFactory.resource(o.type, o.title)
+    Types::TypeFactory.resource(o.type, o.title)
   end
 
   # A string must be a type reference in string format
   # @api private
   def transform_String(o, scope)
-    assert_catalog_type(@type_parser.parse(o), scope)
+    assert_catalog_type(@type_parser.parse(o, scope), scope)
   end
 
   # A qualified name is short hand for a class with this name
   # @api private
   def transform_QualifiedName(o, scope)
-    Puppet::Pops::Types::TypeFactory.host_class(o.value)
+    Types::TypeFactory.host_class(o.value)
   end
 
   # Types are what they are, just check the type
@@ -165,3 +165,5 @@ class Puppet::Pops::Evaluator::RelationshipOperator
     REVERSE_OPERATORS.include?(o.operator)
   end
 end
+end
+end

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

@@ -88,6 +88,11 @@ class Runtime3Converter
   end
   alias :convert2_Hash :convert_Hash
 
+  def convert_Iterator(o, scope, undef_value)
+    raise Puppet::Error, 'Use of an Iterator is not supported here'
+  end
+  alias :convert2_Iterator :convert_Iterator
+
   def convert_Regexp(o, scope, undef_value)
     # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
     # source form

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

@@ -1,16 +1,18 @@
+module Puppet::Pops
+module Evaluator
 # A module with bindings between the new evaluator and the 3x runtime.
 # The intention is to separate all calls into scope, compiler, resource, etc. in this module
 # to make it easier to later refactor the evaluator for better implementations of the 3x classes.
 #
 # @api private
-module Puppet::Pops::Evaluator::Runtime3Support
+module Runtime3Support
 
   NAME_SPACE_SEPARATOR = '::'.freeze
 
   # Fails the evaluation of _semantic_ with a given issue.
   #
-  # @param issue [Puppet::Pops::Issue] the issue to report
-  # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
+  # @param issue [Issue] the issue to report
+  # @param semantic [ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
   # @param options [Hash] hash of optional named data elements for the given issue
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
@@ -24,8 +26,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
   # Optionally (based on severity) Fails the evaluation of _semantic_ with a given issue
   # If the given issue is configured to be of severity < :error it is only reported, and the function returns.
   #
-  # @param issue [Puppet::Pops::Issue] the issue to report
-  # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
+  # @param issue [Issue] the issue to report
+  # @param semantic [ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
   # @param options [Hash] hash of optional named data elements for the given issue
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
@@ -59,11 +61,11 @@ 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} )
+        fail(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} )
+        fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
       else
-        fail(Puppet::Pops::Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
+        fail(Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
       end
     end
     scope.setvar(name, value)
@@ -86,8 +88,9 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # if not set by a match expression.
     #
     unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
-      fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
+      optionally_fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
     end
+    nil # in case unknown variable is configured as a warning
   end
 
   # Returns true if the variable of the given name is set in the given most nested scope. True is returned even if
@@ -136,10 +139,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
   end
 
   def set_scope_nesting_level(scope, level)
-    # Yup, 3x uses this method to reset the level, it also supports passing :all to destroy all 
-    # ephemeral/local scopes - which is a sure way to create havoc.
-    #
-    scope.unset_ephemeral_var(level)
+    # 3x uses this method to reset the level,
+    scope.pop_ephemerals(level)
   end
 
   # Adds a relationship between the given `source` and `target` of the given `relationship_type`
@@ -196,20 +197,20 @@ 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::Pops::Evaluator::Collectors::AbstractCollector)
+    if source.is_a?(Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       source_resource = source
     else
       # transform into the wonderful String representation in 3x
-      type, title = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(source)
+      type, title = Runtime3Converter.instance.catalog_type_to_split_type_title(source)
       source_resource = Puppet::Resource.new(type, title)
     end
-    if target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+    if target.is_a?(Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       target_resource = target
     else
       # transform into the wonderful String representation in 3x
-      type, title = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(target)
+      type, title = Runtime3Converter.instance.catalog_type_to_split_type_title(target)
       target_resource = Puppet::Resource.new(type, title)
     end
     # Add the relationship to the compiler for later evaluation.
@@ -225,8 +226,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
   # @return [Numeric] value `v` converted to Numeric.
   #
   def coerce_numeric(v, o, scope)
-    unless n = Puppet::Pops::Utils.to_n(v)
-      fail(Puppet::Pops::Issues::NOT_NUMERIC, o, {:value => v})
+    unless n = Utils.to_n(v)
+      fail(Issues::NOT_NUMERIC, o, {:value => v})
     end
     n
   end
@@ -258,35 +259,25 @@ module Puppet::Pops::Evaluator::Runtime3Support
 
     # 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, '')
+    mapped_args = 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
-    # 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)
-
-    # Use source location to determine calling module, or use the private_environment_loader (sees env + all modules)
-    # This is necessary since not all .pp files are loaded by a Puppet::Pops::Loader (see PUP-1833)
-    adapter ||= Puppet::Pops::Adapters::LoaderAdapter.adapt_by_source(scope, o)
-
-    loader = adapter.nil? ? loaders.private_environment_loader : adapter.loader
+    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope)
     if loader && func = loader.load(:function, name)
       Puppet::Util::Profiler.profile(name, [:functions, name]) do
         return func.call(scope, *args, &block)
       end
     end
-
     # Call via 3x API if function exists there
-    fail(Puppet::Pops::Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
+    fail(Issues::UNKNOWN_FUNCTION, o, {:name => 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, '')
+    mapped_args = 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
@@ -304,7 +295,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
   end
 
   def convert(value, scope, undef_value)
-    Puppet::Pops::Evaluator::Runtime3Converter.convert(value, scope, undef_value)
+    Runtime3Converter.convert(value, scope, undef_value)
   end
 
   CLASS_STRING = 'class'.freeze
@@ -315,6 +306,7 @@ 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).
 
+
     # resolve in scope.
     fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type_name, resource_titles)
 
@@ -380,8 +372,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # 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} )
+      unless r.is_a?(Types::PResourceType) && r.type_name != 'class'
+        fail(Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
       end
       resource = Puppet::Parser::Resource.new(
       r.type_name, r.title,
@@ -473,27 +465,27 @@ module Puppet::Pops::Evaluator::Runtime3Support
   end
 
   def extract_file_line(o)
-    source_pos = Puppet::Pops::Utils.find_closest_positioned(o)
+    source_pos = Utils.find_closest_positioned(o)
     return [nil, -1] unless source_pos
     [source_pos.locator.file, source_pos.line]
   end
 
   def find_closest_positioned(o)
-    return nil if o.nil? || o.is_a?(Puppet::Pops::Model::Program)
-    o.offset.nil? ? find_closest_positioned(o.eContainer) : Puppet::Pops::Adapters::SourcePosAdapter.adapt(o)
+    return nil if o.nil? || o.is_a?(Model::Program)
+    o.offset.nil? ? find_closest_positioned(o.eContainer) : Adapters::SourcePosAdapter.adapt(o)
   end
 
   # Creates a diagnostic producer
   def diagnostic_producer
-    Puppet::Pops::Validation::DiagnosticProducer.new(
+    Validation::DiagnosticProducer.new(
       ExceptionRaisingAcceptor.new(),                   # Raises exception on all issues
       SeverityProducer.new(), # All issues are errors
-      Puppet::Pops::Model::ModelLabelProvider.new())
+      Model::ModelLabelProvider.new())
   end
 
   # Configure the severity of failures
-  class SeverityProducer < Puppet::Pops::Validation::SeverityProducer
-    Issues = Puppet::Pops::Issues
+  class SeverityProducer < Validation::SeverityProducer
+    Issues = Issues
 
     def initialize
       super
@@ -505,6 +497,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
       end
 
+      p[Issues::UNKNOWN_VARIABLE]             = Puppet[:strict_variables] ? :error : :warning
+
       # 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
@@ -512,10 +506,10 @@ module Puppet::Pops::Evaluator::Runtime3Support
   end
 
   # An acceptor of diagnostics that immediately raises an exception.
-  class ExceptionRaisingAcceptor < Puppet::Pops::Validation::Acceptor
+  class ExceptionRaisingAcceptor < Validation::Acceptor
     def accept(diagnostic)
       super
-      Puppet::Pops::IssueReporter.assert_and_report(self, {
+      IssueReporter.assert_and_report(self, {
         :message => "Evaluation Error:", 
         :emit_warnings => true,  # log warnings
         :exception_class => Puppet::PreformattedError
@@ -529,3 +523,5 @@ module Puppet::Pops::Evaluator::Runtime3Support
   class EvaluationError < StandardError
   end
 end
+end
+end

data/lib/puppet/pops/issue_reporter.rb

@@ -1,6 +1,7 @@
-class Puppet::Pops::IssueReporter
+module Puppet::Pops
+class IssueReporter
 
-  # @param acceptor [Puppet::Pops::Validation::Acceptor] the acceptor containing reported issues
+  # @param acceptor [Validation::Acceptor] the acceptor containing reported issues
   # @option options [String] :message (nil) A message text to use as prefix in
   #   a single Error message
   # @option options [Boolean] :emit_warnings (false) whether warnings should be emitted
@@ -23,7 +24,7 @@ class Puppet::Pops::IssueReporter
     # If there are warnings output them
     warnings = acceptor.warnings
     if emit_warnings && warnings.size > 0
-      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
+      formatter = Validation::DiagnosticFormatterPuppetStyle.new
       emitted_w = 0
       emitted_dw = 0
       acceptor.warnings.each do |w|
@@ -48,7 +49,7 @@ class Puppet::Pops::IssueReporter
       unless emit_errors
         raise emit_exception.new(emit_message)
       end
-      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
+      formatter = Validation::DiagnosticFormatterPuppetStyle.new
       if errors.size == 1 || max_errors <= 1
         # raise immediately
         exception = create_exception(emit_exception, emit_message, formatter, errors[0])
@@ -111,3 +112,4 @@ class Puppet::Pops::IssueReporter
   end
   private_class_method :log_message
 end
+end

data/lib/puppet/pops/issues.rb

@@ -1,7 +1,8 @@
 # Defines classes to deal with issues, and message formatting and defines constants with Issues.
 # @api public
 #
-module Puppet::Pops::Issues
+module Puppet::Pops
+module Issues
   # Describes an issue, and can produce a message for an occurrence of the issue.
   #
   class Issue
@@ -48,7 +49,7 @@ module Puppet::Pops::Issues
         # Evaluate the message block in the msg data's binding
         msgdata.format(hash, &message_block)
       rescue StandardError => e
-        Puppet::Pops::Issues::MessageData
+        MessageData
         raise RuntimeError, "Error while reporting issue: #{issue_code}. #{e.message}", caller
       end
     end
@@ -73,19 +74,30 @@ module Puppet::Pops::Issues
       instance_eval &block
     end
 
-    # 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)
+    # 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.
     #
-    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)
+    # @param args [Object] one object to obtain a label for or zero arguments to obtain the label provider
+    # @return [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 [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
     end
 
     # Returns the label provider given as a key in the hash passed to #format.
     #
     def semantic
-      raise "Label provider key :semantic must be set to produce the text of the message!" unless @data[:semantic]
+      raise Puppet::Error, 'Label provider key :semantic must be set to produce the text of the message!' unless @data[:semantic]
       @data[:semantic]
     end
   end
@@ -166,7 +178,7 @@ module Puppet::Pops::Issues
 
   # Variables are immutable, cannot reassign in the same assignment scope
   ILLEGAL_REASSIGNMENT = hard_issue :ILLEGAL_REASSIGNMENT, :name do
-    if Puppet::Pops::Validation::Checker4_0::RESERVED_PARAMETERS[name]
+    if Validation::Checker4_0::RESERVED_PARAMETERS[name]
       "Cannot reassign built in (or already assigned) variable '$#{name}'"
     else
       "Cannot reassign variable '$#{name}'"
@@ -347,6 +359,12 @@ module Puppet::Pops::Issues
     "Attempt to use unsupported range in #{label.a_an(semantic)}, #{count} values given for max 1"
   end
 
+  # Issues when expressions that are not implemented or activated in the current version are used.
+  #
+  UNSUPPORTED_EXPRESSION = issue :UNSUPPORTED_EXPRESSION do
+    "Expressions of type #{label.a_an(semantic)} are not supported in this version of Puppet"
+  end
+
   ILLEGAL_RELATIONSHIP_OPERAND_TYPE = issue :ILLEGAL_RELATIONSHIP_OPERAND_TYPE, :operand do
     "Illegal relationship operand, can not form a relationship with #{label.a_an(operand)}. A Catalog type is required."
   end
@@ -488,7 +506,7 @@ module Puppet::Pops::Issues
   end
 
   DUPLICATE_ATTRIBUTE = issue :DUPLICATE_ATTRIBUE, :attribute  do
-    "The attribute '#{attribute}' has already been set in this resource body"
+    "The attribute '#{attribute}' has already been set"
   end
 
   MISSING_TITLE = hard_issue :MISSING_TITLE do
@@ -687,4 +705,9 @@ module Puppet::Pops::Issues
   HEREDOC_MULTIPLE_AT_ESCAPES = hard_issue :HEREDOC_MULTIPLE_AT_ESCAPES, :escapes do
     "An escape char for @() may only appear once. Got '#{escapes.join(', ')}'"
   end
+
+  ILLEGAL_BOM = hard_issue :ILLEGAL_BOM, :format_name, :bytes do
+    "Illegal #{format_name} Byte Order mark at beginning of input: #{bytes} - remove these from the puppet source"
+  end
+end
 end