puppet 4.10.12 → 5.0.0

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

@@ -23,16 +23,11 @@ class CollectorTransformer
 
     fail "Resource type #{type} doesn't exist" unless resource_type
 
-    adapter = Adapters::SourcePosAdapter.adapt(o)
-    line_num = adapter.line
-    position = adapter.pos
-    file_path = adapter.locator.file
-
     if !o.operations.empty?
       overrides = {
         :parameters => o.operations.map{ |x| @@evaluator.evaluate(x, scope)}.flatten,
-        :file       => file_path,
-        :line       => [line_num, position],
+        :file       => o.file,
+        :line       => [o.line, o.pos],
         :source     => scope.source,
         :scope      => scope
       }
@@ -96,7 +91,7 @@ protected
     right_code = query(o.right_expr, scope)
 
     case o.operator
-    when :'=='
+    when '=='
       if left_code == "tag"
         # Ensure that to_s and downcase is done once, i.e. outside the proc block and
         # then use raw_tagged? instead of tagged?
@@ -106,7 +101,7 @@ protected
           tags = [ right_code ]
         end
         tags = tags.collect do |t|
-          raise ArgumentError, 'Cannot transform a number to a tag' if t.is_a?(Numeric)
+          raise ArgumentError, _('Cannot transform a number to a tag') if t.is_a?(Numeric)
           t.to_s.downcase
         end
         proc do |resource|
@@ -121,7 +116,7 @@ protected
           end
         end
       end
-    when :'!='
+    when '!='
       proc do |resource|
         !@@compare_operator.equals(resource[left_code], right_code)
       end
@@ -169,7 +164,7 @@ protected
   end
 
   def query_Object(o, scope)
-    raise ArgumentError, "Cannot transform object of class #{o.class}"
+    raise ArgumentError, _("Cannot transform object of class %{klass}") % { klass: o.class }
   end
 
   def match_AccessExpression(o, scope)
@@ -231,7 +226,7 @@ protected
   end
 
   def match_Object(o, scope)
-    raise ArgumentError, "Cannot transform object of class #{o.class}"
+    raise ArgumentError, _("Cannot transform object of class %{klass}") % { klass: o.class }
   end
 end
 end

data/lib/puppet/pops/evaluator/collectors/exported_collector.rb

@@ -47,7 +47,7 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
         if existing = @scope.findresource(item.resource_type, item.title)
           unless existing.collector_id == item.collector_id
             raise Puppet::ParseError,
-              "A duplicate resource was found while collecting exported resources, with the type and title #{item.ref}"
+              _("A duplicate resource was found while collecting exported resources, with the type and title %{title}") % { title: item.ref }
           end
         else
           item.exported = false

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

@@ -47,7 +47,7 @@ class CompareOperator
 
   def cmp_String(a, b)
     return a.casecmp(b) if b.is_a?(String)
-    raise ArgumentError.new("A String is not comparable to a non String")
+    raise ArgumentError.new(_("A String is not comparable to a non String"))
   end
 
   # Equality is case independent.
@@ -60,7 +60,7 @@ class CompareOperator
     if b.is_a?(Numeric)
       a <=> b
     else
-      raise ArgumentError.new("A Numeric is not comparable to non Numeric")
+      raise ArgumentError.new(_("A Numeric is not comparable to non Numeric"))
     end
   end
 
@@ -88,27 +88,27 @@ class CompareOperator
     if b.is_a?(Symbol)
       a <=> b
     else
-      raise ArgumentError.new("Symbol not comparable to non Symbol")
+      raise ArgumentError.new(_("Symbol not comparable to non Symbol"))
     end
   end
 
   def cmp_Timespan(a, b)
-    raise ArgumentError.new('Timespans are only comparable to Timespans, Integers, and Floats') unless b.is_a?(Time::Timespan) ||  b.is_a?(Integer) || b.is_a?(Float)
+    raise ArgumentError.new(_('Timespans are only comparable to Timespans, Integers, and Floats')) unless b.is_a?(Time::Timespan) ||  b.is_a?(Integer) || b.is_a?(Float)
     a <=> b
   end
 
   def cmp_Timestamp(a, b)
-    raise ArgumentError.new('Timestamps are only comparable to Timestamps, Integers, and Floats') unless b.is_a?(Time::Timestamp) ||  b.is_a?(Integer) || b.is_a?(Float)
+    raise ArgumentError.new(_('Timestamps are only comparable to Timestamps, Integers, and Floats')) unless b.is_a?(Time::Timestamp) ||  b.is_a?(Integer) || b.is_a?(Float)
     a <=> b
   end
 
   def cmp_Version(a, b)
-    raise ArgumentError.new('Versions not comparable to non Versions') unless b.is_a?(SemanticPuppet::Version)
+    raise ArgumentError.new(_('Versions not comparable to non Versions')) unless b.is_a?(SemanticPuppet::Version)
     a <=> b
   end
 
   def cmp_Object(a, b)
-    raise ArgumentError.new('Only Strings, Numbers, Timespans, Timestamps, and Versions are comparable')
+    raise ArgumentError.new(_('Only Strings, Numbers, Timespans, Timestamps, and Versions are comparable'))
   end
 
 

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

@@ -33,7 +33,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
     scope.debug "Retrieving epp template #{file}"
     template_file = Puppet::Parser::Files.find_template(file, env_name)
     if template_file.nil? ||  !Puppet::FileSystem.exist?(template_file)
-      raise Puppet::ParseError, "Could not find template '#{file}'"
+      raise Puppet::ParseError, _("Could not find template '%{file}'") % { file: file }
     end
 
     # Parse and validate the source

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

@@ -1,4 +1,3 @@
-require 'rgen/ecore/ecore'
 require 'puppet/parser/scope'
 require 'puppet/pops/evaluator/compare_operator'
 require 'puppet/pops/evaluator/relationship_operator'
@@ -264,7 +263,7 @@ class EvaluatorImpl
   end
 
   def eval_Factory(o, scope)
-    evaluate(o.current, scope)
+    evaluate(o.model, scope)
   end
 
   # Evaluates any object not evaluated to something else to itself.
@@ -358,7 +357,7 @@ class EvaluatorImpl
     name = lvalue(o.left_expr, scope)
     value = evaluate(o.right_expr, scope)
 
-    if o.operator == :'='
+    if o.operator == '='
       assign(name, value, o, scope)
     else
       fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
@@ -366,8 +365,8 @@ class EvaluatorImpl
     value
   end
 
-  ARITHMETIC_OPERATORS = [:'+', :'-', :'*', :'/', :'%', :'<<', :'>>']
-  COLLECTION_OPERATORS = [:'+', :'-', :'<<']
+  ARITHMETIC_OPERATORS = ['+', '-', '*', '/', '%', '<<', '>>'].freeze
+  COLLECTION_OPERATORS = ['+', '-', '<<'].freeze
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
@@ -376,7 +375,7 @@ class EvaluatorImpl
     right = evaluate(o.right_expr, scope)
 
     begin
-      result = calculate(left, right, o.operator, o.left_expr, o.right_expr, scope)
+      result = calculate(left, right, o, scope)
     rescue ArgumentError => e
       fail(Issues::RUNTIME_ERROR, o, {:detail => e.message}, e)
     end
@@ -386,19 +385,21 @@ class EvaluatorImpl
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
-  def calculate(left, right, operator, left_o, right_o, scope)
+  def calculate(left, right, bin_expr, scope)
+    operator = bin_expr.operator
     unless ARITHMETIC_OPERATORS.include?(operator)
-      fail(Issues::UNSUPPORTED_OPERATOR, left_o.eContainer, {:operator => o.operator})
+      fail(Issues::UNSUPPORTED_OPERATOR, bin_expr, {:operator => operator})
     end
 
+    left_o = bin_expr.left_expr
     if (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
       # Handle operation on collections
       case operator
-      when :'+'
+      when '+'
         concatenate(left, right)
-      when :'-'
+      when '-'
         delete(left, right)
-      when :'<<'
+      when '<<'
         unless left.is_a?(Array)
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
@@ -407,20 +408,20 @@ class EvaluatorImpl
     else
       # Handle operation on numeric
       left = coerce_numeric(left, left_o, scope)
-      right = coerce_numeric(right, right_o, scope)
+      right = coerce_numeric(right, bin_expr.right_expr, scope)
       begin
-        if operator == :'%' && (left.is_a?(Float) || right.is_a?(Float))
+        if operator == '%' && (left.is_a?(Float) || right.is_a?(Float))
           # Deny users the fun of seeing severe rounding errors and confusing results
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left}) if left.is_a?(Float)
           fail(Issues::OPERATOR_NOT_APPLICABLE_WHEN, left_o, {:operator => operator, :left_value => left, :right_value => right})
         end
         if right.is_a?(Time::TimeData) && !left.is_a?(Time::TimeData)
-          if operator == :'+' || operator == :'*' && right.is_a?(Time::Timespan)
+          if operator == '+' || operator == '*' && right.is_a?(Time::Timespan)
             # Switch places. Let the TimeData do the arithmetic
             x = left
             left = right
             right = x
-          elsif operator == :'-' && right.is_a?(Time::Timespan)
+          elsif operator == '-' && right.is_a?(Time::Timespan)
             left = Time::Timespan.new((left * Time::NSECS_PER_SEC).to_i)
           else
             fail(Issues::OPERATOR_NOT_APPLICABLE_WHEN, left_o, {:operator => operator, :left_value => left, :right_value => right})
@@ -430,10 +431,17 @@ class EvaluatorImpl
       rescue NoMethodError => e
         fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
       rescue ZeroDivisionError => e
-        fail(Issues::DIV_BY_ZERO, right_o)
+        fail(Issues::DIV_BY_ZERO, bin_expr.right_expr)
       end
-      if result == Float::INFINITY || result == -Float::INFINITY
-        fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
+      case result
+      when Float
+        if result == Float::INFINITY || result == -Float::INFINITY
+          fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
+        end
+      when Integer
+        if result < MIN_INTEGER || result > MAX_INTEGER
+          fail(Issues::NUMERIC_OVERFLOW, bin_expr, {:value => result})
+        end
       end
       result
     end
@@ -492,22 +500,22 @@ class EvaluatorImpl
     # Left is a type
     if left.is_a?(Types::PAnyType)
       case o.operator
-      when :'=='
+      when '=='
         @@type_calculator.equals(left,right)
 
-      when :'!='
+      when '!='
         !@@type_calculator.equals(left,right)
 
-      when :'<'
+      when '<'
         # left can be assigned to right, but they are not equal
         @@type_calculator.assignable?(right, left) && ! @@type_calculator.equals(left,right)
-      when :'<='
+      when '<='
         # left can be assigned to right
         @@type_calculator.assignable?(right, left)
-      when :'>'
+      when '>'
         # right can be assigned to left, but they are not equal
         @@type_calculator.assignable?(left,right) && ! @@type_calculator.equals(left,right)
-      when :'>='
+      when '>='
         # right can be assigned to left
         @@type_calculator.assignable?(left, right)
       else
@@ -515,17 +523,17 @@ class EvaluatorImpl
       end
     else
       case o.operator
-      when :'=='
+      when '=='
         @@compare_operator.equals(left,right)
-      when :'!='
+      when '!='
         ! @@compare_operator.equals(left,right)
-      when :'<'
+      when '<'
         @@compare_operator.compare(left,right) < 0
-      when :'<='
+      when '<='
         @@compare_operator.compare(left,right) <= 0
-      when :'>'
+      when '>'
         @@compare_operator.compare(left,right) > 0
-      when :'>='
+      when '>='
         @@compare_operator.compare(left,right) >= 0
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
@@ -567,13 +575,13 @@ class EvaluatorImpl
       # evaluate as instance? of type check
       matched = pattern.instance?(left)
       # convert match result to Boolean true, or false
-      return o.operator == :'=~' ? !!matched : !matched
+      return o.operator == '=~' ? !!matched : !matched
     end
 
     if pattern.is_a?(SemanticPuppet::VersionRange)
       # evaluate if range includes version
       matched = Types::PSemVerRangeType.include?(pattern, left)
-      return o.operator == :'=~' ? matched : !matched
+      return o.operator == '=~' ? matched : !matched
     end
 
     begin
@@ -589,7 +597,7 @@ class EvaluatorImpl
     set_match_data(matched,scope) # creates ephemeral
 
     # convert match result to Boolean true, or false
-    o.operator == :'=~' ? !!matched : !matched
+    o.operator == '=~' ? !!matched : !matched
   end
 
   # Evaluates Puppet DSL `in` expression
@@ -861,7 +869,7 @@ class EvaluatorImpl
       actual = type_calculator.generalize(type_calculator.infer(hashed_params)).to_s
       fail(Issues::TYPE_MISMATCH, o.expr, {:expected => 'Hash', :actual => actual})
     end
-    hashed_params.map { |k,v| create_resource_parameter(o, scope, k, v, :'=>') }
+    hashed_params.map { |k,v| create_resource_parameter(o, scope, k, v, '=>') }
   end
 
   # Sets default parameter values for a type, produces the type
@@ -1087,7 +1095,7 @@ class EvaluatorImpl
   end
 
   def string_Regexp(o, scope)
-    Types::PRegexpType.regexp_to_s_with_delimiters(o)
+    "/#{o.source}/"
   end
 
   def string_PAnyType(o, scope)
@@ -1169,11 +1177,11 @@ class EvaluatorImpl
           Hash[*y]
         end
       else
-        raise ArgumentError.new("Can only append Array or Hash to a Hash")
+        raise ArgumentError.new(_("Can only append Array or Hash to a Hash"))
       end
       x.merge y # new hash with overwrite
     else
-      raise ArgumentError.new("Can only append to an Array or a Hash.")
+      raise ArgumentError.new(_("Can only append to an Array or a Hash."))
     end
   end
 
@@ -1203,7 +1211,7 @@ class EvaluatorImpl
       end
       y.each {|e| result.delete(e) }
     else
-      raise ArgumentError.new("Can only delete from an Array or Hash.")
+      raise ArgumentError.new(_("Can only delete from an Array or Hash."))
     end
     result
   end

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

@@ -3,13 +3,7 @@
 #
 require 'puppet/plugins/syntax_checkers'
 module Puppet::Pops::Evaluator::ExternalSyntaxSupport
-  # 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(SERVICE_TYPE))
     # ignore 'unspecified syntax'
     return if syntax.nil? || syntax == ''
 
@@ -20,8 +14,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
     # Call checker and give it the location information from the expression
     # (as opposed to where the heredoc tag is (somewhere on the line above)).
     acceptor = Puppet::Pops::Validation::Acceptor.new()
-    source_pos = Puppet::Pops::Utils.find_closest_positioned(reference_expr)
-    checker.check(result, syntax, acceptor, source_pos)
+    checker.check(result, syntax, acceptor, reference_expr)
 
     if acceptor.error_count > 0
       checker_message = "Invalid produced text having syntax: '#{syntax}'."
@@ -34,7 +27,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, SERVICE_NAME) || {}
+    checkers_hash = Puppet.lookup(:plugins)[Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_KEY]
     checkers_hash[lookup_keys_for_syntax(syntax).find {|x| checkers_hash[x] }]
   end
 

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

@@ -1,5 +1,3 @@
-require 'rgen/ecore/ecore'
-
 # Literal values for
 #
 #   * String

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

@@ -56,7 +56,7 @@ class Puppet::Pops::Evaluator::PuppetProc < Proc
     end
   end
 
-  # @return [Fixnum] the arity of the block
+  # @return [Integer] the arity of the block
   # @overrides Block.arity
   # @api public
   def arity

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

@@ -103,14 +103,14 @@ class RelationshipOperator
     o
   end
 
-  RELATIONSHIP_OPERATORS = [:'->', :'~>', :'<-', :'<~']
-  REVERSE_OPERATORS      = [:'<-', :'<~']
+  RELATIONSHIP_OPERATORS = ['->', '~>', '<-', '<~'].freeze
+  REVERSE_OPERATORS      = ['<-', '<~'].freeze
   RELATION_TYPE = {
-    :'->' => :relationship,
-    :'<-' => :relationship,
-    :'~>' => :subscription,
-    :'<~' => :subscription
-  }
+    '->' => :relationship,
+    '<-' => :relationship,
+    '~>' => :subscription,
+    '<~' => :subscription
+  }.freeze
 
   # Evaluate a relationship.
   # TODO: The error reporting is not fine grained since evaluation has already taken place
@@ -151,8 +151,25 @@ class RelationshipOperator
       # Add the relationships to the catalog
       source.each {|s| target.each {|t| add_relationship(s, t, RELATION_TYPE[relationship_expression.operator], scope) }}
 
-      # Produce the transformed source RHS (if this is a chain, this does not need to be done again)
-      real.slice(1)
+      # The result is the transformed source RHS unless it is empty, in which case the transformed LHS is returned.
+      # This closes the gap created by an empty set of references in a chain of relationship
+      # such that X -> [ ] -> Y results in  X -> Y.
+      #result = real[1].empty? ? real[0] : real[1]
+      if real[1].empty?
+        # right side empty, simply use the left (whatever it may be)
+        result = real[0]
+      else
+        right = real[1]
+        if right.size == 1 && right[0].is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+          # the collector when evaluated later may result in an empty set, if so, the
+          # lazy relationship forming logic needs to have access to the left value.
+          adapter = Puppet::Pops::Adapters::EmptyAlternativeAdapter.adapt(right[0])
+          adapter.empty_alternative = real[0]
+        end
+        result = right
+      end
+      result
+
     rescue NotCatalogTypeError => e
       fail(Issues::NOT_CATALOG_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
     rescue IllegalRelationshipOperandError => e