puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/lib/puppet/pops/utils.rb

@@ -115,29 +115,5 @@ module Utils
   def self.relativize_name name
     is_absolute?(name) ? name[2..-1] : name
   end
-
-  # Finds an existing adapter for o or for one of its containers, or nil, if none of the containers
-  # was adapted with the given adapter.
-  # This method can only be used with objects that respond to `:eContainer`.
-  # with true.
-  #
-  # @see #find_closest_positioned
-  #
-  def self.find_adapter(o, adapter)
-    return nil if o.nil? || (o.is_a?(Array) && o.empty?)
-    a = adapter.get(o)
-    return a if a
-    return find_adapter(o.eContainer, adapter)
-  end
-
-  # Finds the closest positioned Model::Positioned object, or object decorated with
-  # a SourcePosAdapter, and returns
-  # a SourcePosAdapter for the first found, or nil if not found.
-  #
-  def self.find_closest_positioned(o)
-    return nil if o.nil? || o.is_a?(Model::Program) || (o.is_a?(Array) && o.empty?)
-    return find_adapter(o, Adapters::SourcePosAdapter) unless o.is_a?(Model::Positioned)
-    o.offset.nil? ? find_closest_positioned(o.eContainer) : Adapters::SourcePosAdapter.adapt(o)
-  end
 end
 end

data/lib/puppet/pops/validation.rb

@@ -205,17 +205,11 @@ module Validation
         unless semantic.respond_to?(:file) && semantic.respond_to?(:line) && semantic.respond_to?(:pos)
           raise Puppet::DevError("Issue #{issue.issue_code}: Cannot pass a #{semantic.class} as a semantic object when it does not support #pos(), #file() and #line()")
         end
-        source_pos = semantic
-        file = semantic.file
-
-      elsif semantic.is_a?(Puppet::Parser::Resource)
-        source_pos = semantic
-        file = semantic.file
-      else
-        source_pos = Utils.find_closest_positioned(semantic)
-        file = source_pos ? source_pos.locator.file : nil
       end
 
+      source_pos = semantic
+      file = semantic.file unless semantic.nil?
+
       severity = @severity_producer.severity(issue)
       @acceptor.accept(Diagnostic.new(severity, issue, file, source_pos, arguments, except))
     end

data/lib/puppet/pops/validation/checker4_0.rb

@@ -25,7 +25,6 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     @@hostname_visitor    ||= Visitor.new(nil, "hostname", 1, 2)
     @@assignment_visitor  ||= Visitor.new(nil, "assign", 0, 1)
     @@query_visitor       ||= Visitor.new(nil, "query", 0, 0)
-    @@top_visitor         ||= Visitor.new(nil, "top", 1, 1)
     @@relation_visitor    ||= Visitor.new(nil, "relation", 0, 0)
     @@idem_visitor        ||= Visitor.new(self, "idem", 0, 0)
 
@@ -41,8 +40,13 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   #
   def validate(model)
     # tree iterate the model, and call check for each element
+    @path = []
     check(model)
-    model.eAllContents.each {|m| check(m) }
+    model._pcore_all_contents(@path) { |element| check(element) }
+  end
+
+  def container(index = -1)
+    @path[index]
   end
 
   # Performs regular validity check
@@ -71,9 +75,34 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     @@rvalue_visitor.visit_this_0(self, o)
   end
 
+  #---TOP CHECK
   # Performs check if this is valid as a container of a definition (class, define, node)
-  def top(o, definition)
-    @@top_visitor.visit_this_1(self, o, definition)
+  def top(definition, idx = -1)
+    o = container(idx)
+    idx -= 1
+    case o
+    when NilClass, Model::HostClassDefinition, Model::Program
+      # ok, stop scanning parents
+    when Model::BlockExpression
+      c = container(idx)
+      if !c.is_a?(Model::Program) &&
+        (definition.is_a?(Model::FunctionDefinition) || definition.is_a?(Model::TypeAlias) || definition.is_a?(Model::TypeDefinition))
+
+        # not ok. These can never be nested in a block
+        acceptor.accept(Issues::NOT_ABSOLUTE_TOP_LEVEL, definition)
+      else
+        # ok, if this is a block representing the body of a class, or is top level
+        top(definition, idx)
+      end
+    when Model::LambdaExpression
+      # A LambdaExpression is a BlockExpression, and this check is needed to prevent the polymorph method for BlockExpression
+      # to accept a lambda.
+      # A lambda can not iteratively create classes, nodes or defines as the lambda does not have a closure.
+      acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
+    else
+      # fail, reached a container that is not top level
+      acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
+    end
   end
 
   # Checks the LHS of an assignment (is it assignable?).
@@ -147,7 +176,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def check_Factory(o)
-    check(o.current)
+    check(o.model)
   end
 
   def check_AccessExpression(o)
@@ -160,10 +189,10 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   def check_AssignmentExpression(o)
     case o.operator
-    when :'='
+    when '='
       assign(o.left_expr)
       rvalue(o.right_expr)
-    when :'+=', :'-='
+    when '+=', '-='
       acceptor.accept(Issues::APPENDS_DELETES_NO_LONGER_SUPPORTED, o, {:operator => o.operator})
     else
       acceptor.accept(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
@@ -179,11 +208,11 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   # * ResourceDefaults (ILLEGAL)
   #
   def check_AttributeOperation(o)
-    if o.operator == :'+>'
+    if o.operator == '+>'
       # Append operator use is constrained
-      parent = o.eContainer
-      unless parent.is_a?(Model::CollectExpression) || parent.is_a?(Model::ResourceOverrideExpression)
-        acceptor.accept(Issues::ILLEGAL_ATTRIBUTE_APPEND, o, {:name=>o.attribute_name, :parent=>parent})
+      p = container
+      unless p.is_a?(Model::CollectExpression) || p.is_a?(Model::ResourceOverrideExpression)
+        acceptor.accept(Issues::ILLEGAL_ATTRIBUTE_APPEND, o, {:name=>o.attribute_name, :parent=>p})
       end
     end
     rvalue(o.value_expr)
@@ -191,16 +220,16 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   def check_AttributesOperation(o)
     # Append operator use is constrained
-    parent1 = o.eContainer
-    case parent1
+    p = container
+    case p
     when Model::AbstractResource
     when Model::CollectExpression
     when Model::CapabilityMapping
-      acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, parent1, :operator=>'* =>')
+      acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, p, :operator=>'* =>')
     else
       # protect against just testing a snippet that has no parent, error message will be a bit strange
       # but it is not for a real program.
-      parent2 = parent1.nil? ? o : parent1.eContainer
+      parent2 = p.nil? ? o : container(-2)
       unless parent2.is_a?(Model::AbstractResource)
         acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, parent2, :operator=>'* =>')
       end
@@ -237,7 +266,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   def check_CallNamedFunctionExpression(o)
     functor = o.functor_expr
-    if functor.is_a?(Model::QualifiedReference) || 
+    if functor.is_a?(Model::QualifiedReference) ||
       functor.is_a?(Model::AccessExpression) && functor.left_expr.is_a?(Model::QualifiedReference)
       # ok (a call to a type)
       return nil
@@ -281,9 +310,10 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def check_EppExpression(o)
-    if o.eContainer.is_a?(Model::LambdaExpression)
-      internal_check_no_capture(o.eContainer, o)
-      internal_check_parameter_name_uniqueness(o.eContainer)
+    p = container
+    if p.is_a?(Model::LambdaExpression)
+      internal_check_no_capture(p, o)
+      internal_check_parameter_name_uniqueness(p)
     end
   end
 
@@ -296,10 +326,15 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def check_CaseExpression(o)
     rvalue(o.test)
     # There can only be one LiteralDefault case option value
-    defaults = o.options.values.select {|v| v.is_a?(Model::LiteralDefault) }
-    unless defaults.size <= 1
-      # Flag the second default as 'unreachable'
-      acceptor.accept(Issues::DUPLICATE_DEFAULT, defaults[1], :container => o)
+    found_default = false
+    o.options.each do |option|
+      option.values.each do |value|
+        if value.is_a?(Model::LiteralDefault)
+          # Flag the second default as 'unreachable'
+          acceptor.accept(Issues::DUPLICATE_DEFAULT, value, :container => o) if found_default
+          found_default = true
+        end
+      end
     end
   end
 
@@ -318,7 +353,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def check_NamedAccessExpression(o)
     name = o.right_expr
     unless name.is_a? Model::QualifiedName
-      acceptor.accept(Issues::ILLEGAL_EXPRESSION, name, :feature=> 'function name', :container => o.eContainer)
+      acceptor.accept(Issues::ILLEGAL_EXPRESSION, name, :feature=> 'function name', :container => container)
     end
   end
 
@@ -352,7 +387,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   # for 'class', 'define', and function
   def check_NamedDefinition(o)
-    top(o.eContainer, o)
+    top(o)
     if o.name !~ Patterns::CLASSREF_DECL
       acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, {:name=>o.name})
     end
@@ -361,7 +396,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def check_TypeAlias(o)
-    top(o.eContainer, o)
+    top(o)
     if o.name !~ Patterns::CLASSREF_EXT_DECL
       acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, {:name=>o.name})
     end
@@ -370,7 +405,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def check_TypeMapping(o)
-    top(o.eContainer, o)
+    top(o)
     lhs = o.type_expr
     lhs_type = 0 # Not Runtime
     if lhs.is_a?(Model::AccessExpression)
@@ -414,7 +449,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def check_TypeDefinition(o)
-    top(o.eContainer, o)
+    top(o)
     internal_check_reserved_type_name(o, o.name)
     # TODO: Check TypeDefinition body. For now, just error out
     acceptor.accept(Issues::UNSUPPORTED_EXPRESSION, o)
@@ -520,7 +555,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     rvalue(o.key)
     rvalue(o.value)
     # In case there are additional things to forbid than non-rvalues
-    # acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.key, :feature => 'hash key', :container => o.eContainer)
+    # acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.key, :feature => 'hash key', :container => container)
   end
 
   def check_LambdaExpression(o)
@@ -532,6 +567,13 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     o.values.each {|v| rvalue(v) }
   end
 
+  def check_LiteralInteger(o)
+    v = o.value
+    if v < MIN_INTEGER || v > MAX_INTEGER
+      acceptor.accept(Issues::NUMERIC_OVERFLOW, o, {:value => v})
+    end
+  end
+
   def check_LiteralHash(o)
     # the keys of a literal hash may be non-literal expressions. They cannot be checked.
     unique = Set.new
@@ -546,7 +588,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def check_NodeDefinition(o)
     # Check that hostnames are valid hostnames (or regular expressions)
     hostname(o.host_matches, o)
-    top(o.eContainer, o)
+    top(o)
     if violator = ends_with_idem(o.body)
       acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o}) unless resource_without_title?(violator)
     end
@@ -603,7 +645,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     else
       # recursively check all contents unless it's a lambda expression. A lambda may contain
       # local assignments
-      o.eContents.each {|model| internal_check_illegal_assignment(model) } unless o.is_a?(Model::LambdaExpression)
+      o._pcore_contents {|model| internal_check_illegal_assignment(model) } unless o.is_a?(Model::LambdaExpression)
     end
   end
 
@@ -627,7 +669,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     # (This can be revised as there are static constructs that are illegal, but require updating many
     # tests that expect the detailed reporting).
     type_name_expr = o.type_name
-    if o.form && o.form != :regular && type_name_expr.is_a?(Model::QualifiedName) && type_name_expr.value == 'class'
+    if o.form && o.form != 'regular' && type_name_expr.is_a?(Model::QualifiedName) && type_name_expr.value == 'class'
       acceptor.accept(Issues::CLASS_NOT_VIRTUALIZABLE, o)
     end
   end
@@ -646,13 +688,13 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def check_ResourceDefaultsExpression(o)
-    if o.form && o.form != :regular
+    if o.form != 'regular'
       acceptor.accept(Issues::NOT_VIRTUALIZEABLE, o)
     end
   end
 
   def check_ResourceOverrideExpression(o)
-    if o.form && o.form != :regular
+    if o.form != 'regular'
       acceptor.accept(Issues::NOT_VIRTUALIZEABLE, o)
     end
   end
@@ -779,7 +821,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   # Puppet AST only allows == and !=
   #
   def query_ComparisonExpression(o)
-    acceptor.accept(Issues::ILLEGAL_QUERY_EXPRESSION, o) unless [:'==', :'!='].include? o.operator
+    acceptor.accept(Issues::ILLEGAL_QUERY_EXPRESSION, o) unless ['==', '!='].include? o.operator
   end
 
   # Allows AND, OR, and checks if left/right are allowed in query.
@@ -809,52 +851,20 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   #
   def rvalue_Expression(o); end
 
-  def rvalue_CollectExpression(o)         ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
-
-  def rvalue_Definition(o)                ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
-
-  def rvalue_NodeDefinition(o)            ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
-
-  def rvalue_UnaryExpression(o)           ; rvalue o.expr                 ; end
-
-  #---TOP CHECK
-
-  def top_NilClass(o, definition)
-    # ok, reached the top, no more parents
-  end
-
-  def top_Object(o, definition)
-    # fail, reached a container that is not top level
-    acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
+  def rvalue_CollectExpression(o)
+    acceptor.accept(Issues::NOT_RVALUE, o)
   end
 
-  def top_BlockExpression(o, definition)
-    if !o.eContainer.is_a?(Model::Program) &&
-      (definition.is_a?(Model::FunctionDefinition) || definition.is_a?(Model::TypeAlias) || definition.is_a?(Model::TypeDefinition))
-
-      # not ok. These can never be nested in a block
-      acceptor.accept(Issues::NOT_ABSOLUTE_TOP_LEVEL, definition)
-    else
-      # ok, if this is a block representing the body of a class, or is top level
-      top o.eContainer, definition
-    end
+  def rvalue_Definition(o)
+    acceptor.accept(Issues::NOT_RVALUE, o)
   end
 
-  def top_HostClassDefinition(o, definition)
-    # ok, stop scanning parents
+  def rvalue_NodeDefinition(o)
+    acceptor.accept(Issues::NOT_RVALUE, o)
   end
 
-  def top_Program(o, definition)
-    # ok
-  end
-
-  # A LambdaExpression is a BlockExpression, and this method is needed to prevent the polymorph method for BlockExpression
-  # to accept a lambda.
-  # A lambda can not iteratively create classes, nodes or defines as the lambda does not have a closure.
-  #
-  def top_LambdaExpression(o, definition)
-    # fail, stop scanning parents
-    acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
+  def rvalue_UnaryExpression(o)
+    rvalue o.expr
   end
 
   #--IDEM CHECK
@@ -883,7 +893,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def idem_Factory(o)
-    idem(o.current)
+    idem(o.model)
   end
 
   def idem_AccessExpression(o)

data/lib/puppet/pops/validation/validator_factory_4_0.rb

@@ -28,7 +28,6 @@ class ValidatorFactory_4_0 < Factory
     p[Issues::FUTURE_RESERVED_WORD]          = :deprecation
 
     p[Issues::DUPLICATE_KEY]                 = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
-    p[Issues::DUPLICATE_DEFAULT]             = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
     p[Issues::NAME_WITH_HYPHEN]              = :error
     p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
     p[Issues::CLASS_NOT_VIRTUALIZABLE]      = Puppet[:strict] == :off ? :warning : Puppet[:strict]

data/lib/puppet/pops/visitor.rb

@@ -51,6 +51,27 @@ class Visitor
     raise "Visitor Error: the configured receiver (#{receiver.class}) can't handle instance of: #{thing.class}"
   end
 
+  # Visit an explicit receiver
+  def visit_this_class(receiver, clazz, args)
+    raise "Visitor Error: Too few arguments passed. min = #{@min_args}" unless args.length >= @min_args
+    if @max_args
+      raise "Visitor Error: Too many arguments passed. max = #{@max_args}" unless args.length <= @max_args
+    end
+    if method_name = @cache[clazz]
+      return receiver.send(method_name, clazz, *args)
+    else
+      clazz.ancestors().each do |ancestor|
+        name = ancestor.name
+        next if name.nil?
+        method_name = :"#{@message}_#{name.split(DOUBLE_COLON).last}"
+        next unless receiver.respond_to?(method_name, true)
+        @cache[clazz] = method_name
+        return receiver.send(method_name, clazz, *args)
+      end
+    end
+    raise "Visitor Error: the configured receiver (#{receiver.class}) can't handle instance of: #{clazz}"
+  end
+
   # Visit an explicit receiver with 0 args
   # (This is ~30% faster than calling the general method)
   #

data/lib/puppet/property.rb

@@ -202,11 +202,11 @@ class Puppet::Property < Puppet::Parameter
   def change_to_s(current_value, newvalue)
     begin
       if current_value == :absent
-        return "defined '#{name}' as #{self.class.format_value_for_display should_to_s(newvalue)}"
+        return "defined '#{name}' as #{should_to_s(newvalue)}"
       elsif newvalue == :absent or newvalue == [:absent]
-        return "undefined '#{name}' from #{self.class.format_value_for_display is_to_s(current_value)}"
+        return "undefined '#{name}' from #{is_to_s(current_value)}"
       else
-        return "#{name} changed #{self.class.format_value_for_display is_to_s(current_value)} to #{self.class.format_value_for_display should_to_s(newvalue)}"
+        return "#{name} changed #{is_to_s(current_value)} to #{should_to_s(newvalue)}"
       end
     rescue Puppet::Error, Puppet::DevError
       raise
@@ -396,12 +396,13 @@ class Puppet::Property < Puppet::Parameter
   end
 
   # Produces a pretty printing string for the given value.
-  # This default implementation simply returns the given argument. A derived implementation
-  # may perform property specific pretty printing when the _is_ and _should_ values are not
-  # already in suitable form.
+  # This default implementation calls {#format_value_for_display} on the class. A derived
+  # implementation may perform property specific pretty printing when the _is_ values
+  # are not already in suitable form.
+  # @param value [Object] the value to format as a string
   # @return [String] a pretty printing string
-  def is_to_s(currentvalue)
-    currentvalue
+  def is_to_s(value)
+    self.class.format_value_for_display(value)
   end
 
   # Emits a log message at the log level specified for the associated resource.
@@ -544,12 +545,14 @@ class Puppet::Property < Puppet::Parameter
     @should = values.collect { |val| self.munge(val) }
   end
 
-  # Formats the given newvalue (following _should_ type conventions) for inclusion in a string describing a change.
-  # @return [String] Returns the given newvalue in string form with space separated entries if it is an array.
-  # @see #change_to_s
-  #
-  def should_to_s(newvalue)
-    [newvalue].flatten.join(" ")
+  # Produces a pretty printing string for the given value.
+  # This default implementation calls {#format_value_for_display} on the class. A derived
+  # implementation may perform property specific pretty printing when the _should_ values
+  # are not already in suitable form.
+  # @param value [Object] the value to format as a string
+  # @return [String] a pretty printing string
+  def should_to_s(value)
+    self.class.format_value_for_display(value)
   end
 
   # Synchronizes the current value _(is)_ and the wanted value _(should)_ by calling {#set}.