puppet 3.4.3 → 3.5.0.rc1

data/lib/puppet/pops/issue_reporter.rb

@@ -13,7 +13,7 @@ class Puppet::Pops::IssueReporter
     max_warnings = Puppet[:max_warnings] + 1
     max_deprecations = Puppet[:max_deprecations] + 1
     emit_warnings = options[:emit_warnings] || false
-    emit_errors = options[:emit_errors] || true
+    emit_errors = options[:emit_errors].nil? ? true : !!options[:emit_errors]
     emit_message = options[:message]
     emit_exception = options[:exception_class] || Puppet::ParseError
 
@@ -48,7 +48,12 @@ class Puppet::Pops::IssueReporter
       formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
       if errors.size == 1 || max_errors <= 1
         # raise immediately
-        raise emit_exception.new(format_with_prefix(emit_message, formatter.format(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)
+        end
+        raise exception
       end
       emitted = 0
       if emit_message
@@ -65,11 +70,10 @@ class Puppet::Pops::IssueReporter
       exception.file = errors[0].file
       raise exception
     end
-    parse_result
   end
 
   def self.format_with_prefix(prefix, message)
     return message unless prefix
     [prefix, message].join(' ')
   end
-end
+end

data/lib/puppet/pops/issues.rb

@@ -48,6 +48,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
         raise RuntimeError, "Error while reporting issue: #{issue_code}. #{e.message}", caller
       end
     end
@@ -73,10 +74,12 @@ module Puppet::Pops::Issues
     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)
     #
-    def label
+    def label(it = nil)
       raise "Label provider key :label must be set to produce the text of the message!" unless @data[:label]
-      @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.
@@ -157,11 +160,28 @@ module Puppet::Pops::Issues
     "Illegal attempt to assign to '#{label.a_an(semantic)}'. Not an assignable reference"
   end
 
+  # Variables are immutable, cannot reassign in the same assignment scope
+  ILLEGAL_REASSIGNMENT = hard_issue :ILLEGAL_REASSIGNMENT, :name do
+    "Cannot reassign variable #{name}"
+  end
+
+  ILLEGAL_RESERVED_ASSIGNMENT = hard_issue :ILLEGAL_RESERVED_ASSIGNMENT, :name do
+    "Attempt to assign to a reserved variable name: '#{name}'"
+  end
+
   # Assignment cannot be made to numeric match result variables
   ILLEGAL_NUMERIC_ASSIGNMENT = issue :ILLEGAL_NUMERIC_ASSIGNMENT, :varname do
     "Illegal attempt to assign to the numeric match result variable '$#{varname}'. Numeric variables are not assignable"
   end
 
+  APPEND_FAILED = issue :APPEND_FAILED, :message do
+    "Append assignment += failed with error: #{message}"
+  end
+
+  DELETE_FAILED = issue :DELETE_FAILED, :message do
+    "'Delete' assignment -= failed with error: #{message}"
+  end
+
   # parameters cannot have numeric names, clashes with match result variables
   ILLEGAL_NUMERIC_PARAMETER = issue :ILLEGAL_NUMERIC_PARAMETER, :name do
     "The numeric parameter name '$#{varname}' cannot be used (clashes with numeric match result variables)"
@@ -182,6 +202,30 @@ module Puppet::Pops::Issues
     "Illegal attempt to assign to #{label.a_an(semantic)} via [index/key]. Not an assignable reference"
   end
 
+  # For unsupported operators (e.g. -= in puppet 3).
+  #
+  UNSUPPORTED_OPERATOR = hard_issue :UNSUPPORTED_OPERATOR, :operator do
+    "The operator '#{operator}' in #{label.a_an(semantic)} is not supported."
+  end
+
+  # For non applicable operators (e.g. << on Hash).
+  #
+  OPERATOR_NOT_APPLICABLE = hard_issue :OPERATOR_NOT_APPLICABLE, :operator, :left_value do
+    "Operator '#{operator}' is not applicable to #{label.a_an(left_value)}."
+  end
+
+  COMPARISON_NOT_POSSIBLE = hard_issue :COMPARISON_NOT_POSSIBLE, :operator, :left_value, :right_value, :detail do
+    "Comparison of: #{label(left_value)} #{operator} #{label(right_value)}, is not possible. Caused by '#{detail}'."
+  end
+
+  MATCH_NOT_REGEXP = hard_issue :MATCH_NOT_REGEXP, :detail do
+    "Can not convert right match operand to a regular expression. Caused by '#{detail}'."
+  end
+
+  MATCH_NOT_STRING = hard_issue :MATCH_NOT_STRING, :left_value do
+    "Left match operand must result in a String value. Got #{label.a_an(left_value)}."
+  end
+
   # Some expressions/statements may not produce a value (known as right-value, or rvalue).
   # This may vary between puppet versions.
   #
@@ -196,7 +240,15 @@ 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((::)?[a-z0-9]\w*)(::[a-z0-9]\w*)*\\z"
+    "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*)$/"
+  end
+
+  ILLEGAL_NUMERIC_VAR_NAME = hard_issue :ILLEGAL_NUMERIC_VAR_NAME, :name do
+    "Illegal numeric variable name, The given name '#{name}' must be a decimal value if it starts with a digit 0-9"
   end
 
   # In case a model is constructed programmatically, it must create valid type references.
@@ -240,6 +292,13 @@ module Puppet::Pops::Issues
     "Illegal expression. #{label.a_an_uc(semantic)} is unacceptable as #{feature} in #{label.a_an(container)}"
   end
 
+  # Issues when an expression is used where it is not legal.
+  # E.g. an arithmetic expression where a hostname is expected.
+  #
+  ILLEGAL_VARIABLE_EXPRESSION = hard_issue :ILLEGAL_VARIABLE_EXPRESSION do
+    "Illegal variable expression. #{label.a_an_uc(semantic)} did not produce a variable name (String or Numeric)."
+  end
+
   # Issues when an expression is used illegaly in a query.
   # query only supports == and !=, and not <, > etc.
   #
@@ -254,7 +313,7 @@ module Puppet::Pops::Issues
   end
 
   # When an attempt is made to use multiple keys (to produce a range in Ruby - e.g. $arr[2,-1]).
-  # This is currently not supported, but may be in future versions
+  # This is not supported in 3x, but it allowed in 4x.
   #
   UNSUPPORTED_RANGE = issue :UNSUPPORTED_RANGE, :count do
     "Attempt to use unsupported range in #{label.a_an(semantic)}, #{count} values given for max 1"
@@ -263,4 +322,140 @@ module Puppet::Pops::Issues
   DEPRECATED_NAME_AS_TYPE = issue :DEPRECATED_NAME_AS_TYPE, :name do
     "Resource references should now be capitalized. The given '#{name}' does not have the correct form"
   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
+
+  NOT_CATALOG_TYPE = issue :NOT_CATALOG_TYPE, :type do
+    "Illegal relationship operand, can not form a relationship with something of type #{type}. A Catalog type is required."
+  end
+
+  BAD_STRING_SLICE_ARITY = issue :BAD_STRING_SLICE_ARITY, :actual do
+    "String supports [] with one or two arguments. Got #{actual}"
+  end
+
+  BAD_STRING_SLICE_TYPE = issue :BAD_STRING_SLICE_TYPE, :actual do
+    "String-Type [] requires all arguments to be integers (or default). Got #{actual}"
+  end
+
+  BAD_ARRAY_SLICE_ARITY = issue :BAD_ARRAY_SLICE_ARITY, :actual do
+    "Array supports [] with one or two arguments. Got #{actual}"
+  end
+
+  BAD_HASH_SLICE_ARITY = issue :BAD_HASH_SLICE_ARITY, :actual do
+    "Hash supports [] with one or more arguments. Got #{actual}"
+  end
+
+  BAD_INTEGER_SLICE_ARITY = issue :BAD_INTEGER_SLICE_ARITY, :actual do
+    "Integer-Type supports [] with one or two arguments (from, to). Got #{actual}"
+  end
+
+  BAD_INTEGER_SLICE_TYPE = issue :BAD_INTEGER_SLICE_TYPE, :actual do
+    "Integer-Type [] requires all arguments to be integers (or default). Got #{actual}"
+  end
+
+  BAD_COLLECTION_SLICE_TYPE = issue :BAD_COLLECTION_SLICE_TYPE, :actual do
+    "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got #{label.a_an(actual)}"
+  end
+
+  BAD_FLOAT_SLICE_ARITY = issue :BAD_INTEGER_SLICE_ARITY, :actual do
+    "Float-Type supports [] with one or two arguments (from, to). Got #{actual}"
+  end
+
+  BAD_FLOAT_SLICE_TYPE = issue :BAD_INTEGER_SLICE_TYPE, :actual do
+    "Float-Type [] requires all arguments to be floats, or integers (or default). Got #{actual}"
+  end
+
+  BAD_SLICE_KEY_TYPE = issue :BAD_SLICE_KEY_TYPE, :left_value, :expected_classes, :actual do
+    expected_text = if expected_classes.size > 1
+      "one of #{expected_classes.join(', ')} are"
+    else
+      "#{expected_classes[0]} is"
+    end
+    "#{label.a_an_uc(left_value)}[] cannot use #{actual} where #{expected_text} expected"
+  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
+      "#{base_type_label}[] accepts #{min} or more arguments. Got #{actual}"
+    elsif max
+      "#{base_type_label}[] accepts #{min} to #{max} arguments. Got #{actual}"
+    else
+      "#{base_type_label}[] accepts #{min} #{label.plural_s(min, 'argument')}. Got #{actual}"
+    end
+  end
+
+  BAD_TYPE_SPECIALIZATION = hard_issue :BAD_TYPE_SPECIALIZATION, :type, :message do
+    "Error creating type specialization of #{label.a_an(type)}, #{message}"
+  end
+
+  ILLEGAL_TYPE_SPECIALIZATION = issue :ILLEGAL_TYPE_SPECIALIZATION, :kind do
+    "Cannot specialize an already specialized #{kind} type"
+  end
+
+  ILLEGAL_RESOURCE_SPECIALIZATION = issue :ILLEGAL_RESOURCE_SPECIALIZATION, :actual do
+    "First argument to Resource[] must be a resource type or a String. Got #{actual}."
+  end
+
+  ILLEGAL_HOSTCLASS_NAME = hard_issue :ILLEGAL_HOSTCLASS_NAME, :name do
+    "Illegal Class name in class reference. #{label.a_an_uc(name)} cannot be used where a String is expected"
+  end
+
+  # Issues when an expression is used where it is not legal.
+  # E.g. an arithmetic expression where a hostname is expected.
+  #
+  ILLEGAL_DEFINITION_NAME = hard_issue :ILLEGAL_DEFINTION_NAME, :name do
+    "Unacceptable name. The name '#{name}' is unacceptable as the name of #{label.a_an(semantic)}"
+  end
+
+  NOT_NUMERIC = issue :NOT_NUMERIC, :value do
+    "The value '#{value}' cannot be converted to Numeric."
+  end
+
+  UNKNOWN_FUNCTION = issue :UNKNOWN_FUNCTION, :name do
+    "Unknown function: '#{name}'."
+  end
+
+  UNKNOWN_VARIABLE = issue :UNKNOWN_VARIABLE, :name do
+    "Unknown variable: '#{name}'."
+  end
+
+  RUNTIME_ERROR = issue :RUNTIME_ERROR, :detail do
+    "Error while evaluating #{label.a_an(semantic)}, #{detail}"
+  end
+
+  UNKNOWN_RESOURCE_TYPE = issue :UNKNOWN_RESOURCE_TYPE, :type_name do
+    "Resource type not found: #{type_name.capitalize}"
+  end
+
+  UNKNOWN_RESOURCE = issue :UNKNOWN_RESOURCE, :type_name, :title do
+    "Resource not found: #{type_name.capitalize}['#{title}']"
+  end
+
+  UNKNOWN_RESOURCE_PARAMETER = issue :UNKNOWN_RESOURCE_PARAMETER, :type_name, :title, :param_name do
+    "The resource #{type_name.capitalize}['#{title}'] does not have a parameter called '#{param_name}'"
+  end
+
+  DIV_BY_ZERO = hard_issue :DIV_BY_ZERO do
+    "Division by 0"
+  end
+
+  RESULT_IS_INFINITY = hard_issue :RESULT_IS_INFINITY, :operator do
+    "The result of the #{operator} expression is Infinity"
+  end
+
+  # TODO_HEREDOC
+  EMPTY_HEREDOC_SYNTAX_SEGMENT = issue :EMPTY_HEREDOC_SYNTAX_SEGMENT, :syntax do
+    "Heredoc syntax specification has empty segment between '+' : '#{syntax}'"
+  end
+
+  ILLEGAL_EPP_PARAMETERS = issue :ILLEGAL_EPP_PARAMETERS do
+    "Ambiguous EPP parameter expression. Probably missing '<%-' before parameters to remove leading whitespace"
+  end
 end

data/lib/puppet/pops/label_provider.rb

@@ -35,6 +35,11 @@ class Puppet::Pops::LabelProvider
     "The #{label(o)}"
   end
 
+  # Appends 's' to (optional) text if count != 1 else an empty string
+  def plural_s(count, text = '')
+    count == 1 ? text : "#{text}s"
+  end
+
   private
 
   # Produces an *indefinite article* (a/an) for the given text ('a' if

data/lib/puppet/pops/model/ast_transformer.rb

@@ -33,10 +33,16 @@ class Puppet::Pops::Model::AstTransformer
     klass.new(merge_location(hash, o))
   end
 
+  # THIS IS AN EXPENSIVE OPERATION
+  # The 3x AST requires line, pos etc. to be recorded directly in the AST nodes and this information
+  # must be computed.
+  # (Newer implementation only computes the information that is actually needed; typically when raising an
+  # exception).
+  #
   def merge_location(hash, o)
     if o
       pos = {}
-      source_pos = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::SourcePosAdapter)
+      source_pos = Puppet::Pops::Utils.find_closest_positioned(o)
       if source_pos
         pos[:line] = source_pos.line
         pos[:pos]  = source_pos.pos
@@ -49,7 +55,14 @@ class Puppet::Pops::Model::AstTransformer
 
   # Transforms pops expressions into AST 3.1 statements/expressions
   def transform(o)
+    begin
     @@transform_visitor.visit_this(self,o)
+    rescue StandardError => e
+      loc_data = {}
+      merge_location(loc_data, o)
+      raise Puppet::ParseError.new("Error while transforming to Puppet 3 AST: #{e.message}", 
+        loc_data[:file], loc_data[:line], loc_data[:pos], e)
+    end
   end
 
   # Transforms pops expressions into AST 3.1 query expressions
@@ -62,7 +75,12 @@ class Puppet::Pops::Model::AstTransformer
     @@hostname_transform_visitor.visit_this(self, o)
   end
 
-  def transform_LiteralNumber(o)
+  def transform_LiteralFloat(o)
+    # Numbers are Names in the AST !! (Name a.k.a BareWord)
+    ast o, AST::Name, :value => o.value.to_s
+  end
+
+  def transform_LiteralInteger(o)
     s = case o.radix
     when 10
       o.value.to_s
@@ -157,6 +175,14 @@ class Puppet::Pops::Model::AstTransformer
     ast o, AST::Collection, args
   end
 
+  def transform_EppExpression(o)
+    # TODO: Not supported in 3x TODO_EPP
+    parameters = o.parameters.collect {|p| transform(p) }
+    args = { :parameters => parameters }
+    args[:children] = transform(o.body) unless is_nop?(o.body)
+    Puppet::Parser::AST::Epp.new(merge_location(args, o))
+  end
+
   def transform_ExportedQuery(o)
     if is_nop?(o.expr)
       result = :exported
@@ -251,33 +277,16 @@ class Puppet::Pops::Model::AstTransformer
     ast o, AST::InOperator, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
   end
 
-  # This is a complex transformation from a modeled import to a Nop result (where the import took place),
-  # and calls to perform import/parsing etc. during the transformation.
-  # When testing syntax, the @importer does not have to be set, but it is not possible to check
-  # the actual import without inventing a new AST::ImportExpression with nop effect when evaluating.
-  def transform_ImportExpression(o)
-    if importer
-      o.files.each {|f|
-        unless f.is_a? Model::LiteralString
-          raise "Illegal import file expression. Must be a single quoted string"
-        end
-        importer.import(f.value)
-      }
-    end
-    # Crazy stuff
-    # Transformation of "import" needs to parse the other files at the time of transformation.
-    # Then produce a :nop, since nothing should be evaluated.
-    ast o, AST::Nop, {}
-  end
-
-  def transform_InstanceReferences(o)
-    ast o, AST::ResourceReference, :type => o.type_name.value, :title => transform(o.names)
-  end
-
   # Assignment in AST 3.1 is to variable or hasharray accesses !!! See Bug #16116
   def transform_AssignmentExpression(o)
     args = {:value => transform(o.right_expr) }
-    args[:append] = true if o.operator == :'+='
+    case o.operator
+    when :'+='
+      args[:append] = true
+    when :'='
+    else
+      raise "The operator #{o.operator} is not supported by Puppet 3."
+    end
 
     args[:name] = case o.left_expr
     when Model::VariableExpression
@@ -346,11 +355,6 @@ class Puppet::Pops::Model::AstTransformer
     ast o, AST::String, :value => o.value
   end
 
-  # Literal text in a concatenated string
-  def transform_LiteralText(o)
-    ast o, AST::String, :value => o.value
-  end
-
   def transform_LambdaExpression(o)
     astargs = { :parameters => o.parameters.collect {|p| transform(p) } }
     astargs.merge!({ :children => transform(o.body) }) if o.body         # do not want children if it is nil/nop
@@ -432,6 +436,12 @@ class Puppet::Pops::Model::AstTransformer
     Puppet::Parser::AST::Hostclass.new(o.name, merge_location(args, o))
   end
 
+  def transform_HeredocExpression(o)
+    # TODO_HEREDOC Not supported in 3x
+    args = {:syntax=> o.syntax(), :expr => transform(o.text_expr()) }
+    Puppet::Parser::AST::Heredoc.new(merge_location(args, o))
+  end
+
   def transform_NodeDefinition(o)
     # o.host_matches are expressions, and 3.1 AST requires special object AST::HostName
     # where a HostName is one of NAME, STRING, DEFAULT or Regexp - all of these are strings except regexp
@@ -479,6 +489,16 @@ class Puppet::Pops::Model::AstTransformer
     Puppet::Parser::AST::Relationship.new(transform(o.left_expr), transform(o.right_expr), o.operator.to_s, merge_location({}, o))
   end
 
+  def transform_RenderStringExpression(o)
+    # TODO_EPP Not supported in 3x
+    ast o, AST::RenderString, :value => o.value
+  end
+
+  def transform_RenderExpression(o)
+    # TODO_EPP Not supported in 3x
+    ast o, AST::RenderExpression, :value => transform(o.expr)
+  end
+
   def transform_ResourceTypeDefinition(o)
     parameters = o.parameters.collect {|p| transform(p) }
     args = { :arguments => parameters }
@@ -533,6 +553,10 @@ class Puppet::Pops::Model::AstTransformer
     transform(o.expr)
   end
 
+  def transform_Program(o)
+    transform(o.body)
+  end
+
   def transform_IfExpression(o)
     args = { :test => transform(o.test), :statements => transform(o.then_expr) }
     args[:else] = transform(o.else_expr) # Tests say Nop should be there (unless is_nop? o.else_expr), probably not needed