puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/pops/parser/evaluating_parser.rb

@@ -45,11 +45,19 @@ class Puppet::Pops::Parser::EvaluatingParser
     @acceptor = nil
   end
 
+  # Create a closure that can be called in the given scope
+  def closure(model, scope)
+    Puppet::Pops::Evaluator::Closure.new(evaluator, model, scope)
+  end
+
   def evaluate(scope, model)
     return nil unless model
-    ast = Puppet::Pops::Model::AstTransformer.new(@file_source, nil).transform(model)
-    return nil unless ast
-    ast.safeevaluate(scope)
+    evaluator.evaluate(model, scope)
+  end
+
+  def evaluator
+    @@evaluator ||= Puppet::Pops::Evaluator::EvaluatorImpl.new()
+    @@evaluator
   end
 
   def validate(parse_result)
@@ -63,7 +71,7 @@ class Puppet::Pops::Parser::EvaluatingParser
   end
 
   def validator(acceptor)
-    Puppet::Pops::Validation::ValidatorFactory_3_1.new().validator(acceptor)
+    Puppet::Pops::Validation::ValidatorFactory_4_0.new().validator(acceptor)
   end
 
   def assert_and_report(parse_result)
@@ -73,52 +81,8 @@ class Puppet::Pops::Parser::EvaluatingParser
     end
     validation_result = validate(parse_result)
 
-    max_errors = Puppet[:max_errors]
-    max_warnings = Puppet[:max_warnings] + 1
-    max_deprecations = Puppet[:max_deprecations] + 1
-
-    # If there are warnings output them
-    warnings = validation_result.warnings
-    if warnings.size > 0
-      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
-      emitted_w = 0
-      emitted_dw = 0
-      validation_result.warnings.each {|w|
-        if w.severity == :deprecation
-          # Do *not* call Puppet.deprecation_warning it is for internal deprecation, not
-          # deprecation of constructs in manifests! (It is not designed for that purpose even if
-          # used throughout the code base).
-          #
-          Puppet.warning(formatter.format(w)) if emitted_dw < max_deprecations
-          emitted_dw += 1
-        else
-          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
-      }
-    end
-
-    # If there were errors, report the first found. Use a puppet style formatter.
-    errors = validation_result.errors
-    if errors.size > 0
-      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
-      if errors.size == 1 || max_errors <= 1
-        # raise immediately
-        raise Puppet::ParseError.new(formatter.format(errors[0]))
-      end
-      emitted = 0
-      errors.each do |e|
-        Puppet.err(formatter.format(e))
-        emitted += 1
-        break if emitted >= max_errors
-      end
-      warnings_message = warnings.size > 0 ? ", and #{warnings.size} warnings" : ""
-      giving_up_message = "Found #{errors.size} errors#{warnings_message}. Giving up"
-      exception = Puppet::ParseError.new(giving_up_message)
-      exception.file = errors[0].file
-      raise exception
-    end
+    Puppet::Pops::IssueReporter.assert_and_report(validation_result,
+                                          :emit_warnings => true)
     parse_result
   end
 
@@ -168,31 +132,7 @@ class Puppet::Pops::Parser::EvaluatingParser
     escaped << '"'
   end
 
-  # This is a temporary solution to making it possible to use the new evaluator. The main class
-  # will eventually have this behavior instead of using transformation to Puppet 3.x AST
-  class Transitional < Puppet::Pops::Parser::EvaluatingParser
-
-    def evaluator
-      @@evaluator ||= Puppet::Pops::Evaluator::EvaluatorImpl.new()
-      @@evaluator
-    end
-
-    def evaluate(scope, model)
-      return nil unless model
-      evaluator.evaluate(model, scope)
-    end
-
-    def validator(acceptor)
-      Puppet::Pops::Validation::ValidatorFactory_4_0.new().validator(acceptor)
-    end
-
-    # Create a closure that can be called in the given scope
-    def closure(model, scope)
-      Puppet::Pops::Evaluator::Closure.new(evaluator, model, scope)
-    end
-  end
-
-  class EvaluatingEppParser < Transitional
+  class EvaluatingEppParser < Puppet::Pops::Parser::EvaluatingParser
     def initialize()
       @parser = Puppet::Pops::Parser::EppParser.new()
     end

data/lib/puppet/pops/parser/lexer2.rb

@@ -128,6 +128,9 @@ class Puppet::Pops::Parser::Lexer2
     "in"       => [:IN,       'in',       2],
     "unless"   => [:UNLESS,   'unless',   6],
     "function" => [:FUNCTION, 'function', 8],
+    "type"     => [:TYPE,     'type',     4],
+    "attr"     => [:ATTR,     'attr',     4],
+    "private"  => [:PRIVATE,  'private',  7],
   }
   KEYWORDS.each {|k,v| v[1].freeze; v.freeze }
   KEYWORDS.freeze
@@ -278,7 +281,8 @@ class Puppet::Pops::Parser::Lexer2
     # This is the lexer's main loop
     until queue.empty? && scn.eos? do
       if token = queue.shift || lex_token
-        yield [ ctx[:after] = token[0], token[1] ]
+        ctx[:after] = token[0]
+        yield token
       end
     end
 
@@ -325,7 +329,7 @@ class Puppet::Pops::Parser::Lexer2
       emit(TOKEN_COMMA, before)
 
     when '['
-      if ctx[:after] == :NAME && (before == 0 || scn.string[before-1,1] =~ /[[:blank:]\r\n]+/)
+      if (before == 0 || scn.string[before-1,1] =~ /[[:blank:]\r\n]+/)
         emit(TOKEN_LISTSTART, before)
       else
         emit(TOKEN_LBRACK, before)
@@ -525,7 +529,7 @@ class Puppet::Pops::Parser::Lexer2
           value = scn.scan(PATTERN_CLASSREF)
           if value
             after = scn.pos
-            emit_completed([:CLASSREF, value, after-before], before)
+            emit_completed([:CLASSREF, value.freeze, after-before], before)
           else
             # move to faulty position ('::<uc-letter>' was ok)
             scn.pos = scn.pos + 3
@@ -535,7 +539,7 @@ class Puppet::Pops::Parser::Lexer2
           # NAME or error
           value = scn.scan(PATTERN_NAME)
           if value
-            emit_completed([:NAME, value, scn.pos-before], before)
+            emit_completed([:NAME, value.freeze, scn.pos-before], before)
           else
             # move to faulty position ('::' was ok)
             scn.pos = scn.pos + 2
@@ -548,7 +552,7 @@ class Puppet::Pops::Parser::Lexer2
 
     when '$'
       if value = scn.scan(PATTERN_DOLLAR_VAR)
-        emit_completed([:VARIABLE, value[1..-1], scn.pos - before], before)
+        emit_completed([:VARIABLE, value[1..-1].freeze, scn.pos - before], before)
       else
         # consume the $ and let higher layer complain about the error instead of getting a syntax error
         emit(TOKEN_VARIABLE_EMPTY, before)
@@ -560,14 +564,14 @@ class Puppet::Pops::Parser::Lexer2
       interpolate_dq
 
     when "'"
-      emit_completed([:STRING, slurp_sqstring, before-scn.pos], before)
+      emit_completed([:STRING, slurp_sqstring.freeze, scn.pos - before], before)
 
     when '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
       value = scn.scan(PATTERN_NUMBER)
       if value
         length = scn.pos - before
         assert_numeric(value, length)
-        emit_completed([:NUMBER, value, length], before)
+        emit_completed([:NUMBER, value.freeze, length], before)
       else
         # move to faulty position ([0-9] was ok)
         scn.pos = scn.pos + 1
@@ -579,14 +583,14 @@ class Puppet::Pops::Parser::Lexer2
       value = scn.scan(PATTERN_NAME)
       # NAME or false start because followed by hyphen(s), underscore or word
       if value && !scn.match?(/^-+\w/)
-        emit_completed(KEYWORDS[value] || [:NAME, value, scn.pos - before], before)
+        emit_completed(KEYWORDS[value] || [:NAME, value.freeze, scn.pos - before], before)
       else
         # Restart and check entire pattern (for ease of detecting non allowed trailing hyphen)
         scn.pos = before
         value = scn.scan(PATTERN_BARE_WORD)
         # If the WORD continues with :: it must be a correct fully qualified name
         if value && !(fully_qualified = scn.match?(/::/))
-          emit_completed([:WORD, value, scn.pos - before], before)
+          emit_completed([:WORD, value.freeze, scn.pos - before], before)
         else
           # move to faulty position ([a-z_] was ok)
           scn.pos = scn.pos + 1
@@ -602,7 +606,7 @@ class Puppet::Pops::Parser::Lexer2
     'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
       value = scn.scan(PATTERN_CLASSREF)
       if value
-        emit_completed([:CLASSREF, value, scn.pos - before], before)
+        emit_completed([:CLASSREF, value.freeze, scn.pos - before], before)
       else
         # move to faulty position ([A-Z] was ok)
         scn.pos = scn.pos + 1

data/lib/puppet/pops/parser/lexer_support.rb

@@ -99,6 +99,12 @@ module Puppet::Pops::Parser::LexerSupport
       end
     end
 
+    def to_s
+      # This format is very compact and is intended for debugging output from racc parsser in
+      # debug mode. If this is made more elaborate the output from a debug run becomes very hard to read.
+      #
+      "'#{self[:value]} #{@token_array[0]}'"
+    end
     # TODO: Make this comparable for testing
     # vs symbolic, vs array with symbol and non hash, array with symbol and hash)
     #

data/lib/puppet/pops/parser/locator.rb

@@ -61,7 +61,7 @@ class Puppet::Pops::Parser::Locator
   def char_offset(byte_offset)
   end
 
-  # Returns the length measured in number of characters from the given start and end reported offseta
+  # Returns the length measured in number of characters from the given start and end reported offset
   def char_length(offset, end_offset)
   end
 

data/lib/puppet/pops/parser/parser_support.rb

@@ -43,21 +43,15 @@ class Puppet::Pops::Parser::Parser
   # before evaluation-time.
   #
   def classname(name)
-    [namespace, name].join("::").sub(/^::/, '')
+    [namespace, name].join('::').sub(/^::/, '')
   end
 
-#  # Reinitializes variables (i.e. creates a new lexer instance
-#  #
-#  def clear
-#    initvars
-#  end
-
   # Raises a Parse error.
   def error(value, message, options = {})
     except = Puppet::ParseError.new(message)
     except.line = options[:line] || value[:line]
-    except.file = options[:file] || value[:file] # @lexer.file
-    except.pos = options[:pos]   || value[:pos] # @lexer.pos
+    except.file = options[:file] || value[:file]
+    except.pos = options[:pos]   || value[:pos]
 
     raise except
   end
@@ -74,24 +68,12 @@ class Puppet::Pops::Parser::Parser
   end
 
   def initialize()
-    # Since the parser is not responsible for importing (removed), and does not perform linking,
-    # and there is no syntax that requires knowing if something referenced exists, it is safe
-    # to assume that no environment is needed when parsing. (All that comes later).
-    #
     @lexer = Puppet::Pops::Parser::Lexer2.new
     @namestack = []
     @definitions = []
   end
 
-#  # Initializes the parser support by creating a new instance of {Puppet::Pops::Parser::Lexer}
-#  # @return [void]
-#  #
-#  def initvars
-#  end
-
-  # This is a callback from the generated grammar (when an error occurs while parsing)
-  # TODO Picks up origin information from the lexer, probably needs this from the caller instead
-  #   (for code strings, and when start line is not line 1 in a code string (or file), etc.)
+  # This is a callback from the generated parser (when an error occurs while parsing)
   #
   def on_error(token,value,stack)
     if token == 0 # denotes end of file
@@ -99,8 +81,13 @@ class Puppet::Pops::Parser::Parser
     else
       value_at = "'#{value[:value]}'"
     end
-    error = "Syntax error at #{value_at}"
+    if @yydebug
+      error = "Syntax error at #{value_at}, token: #{token}"
+    else
+      error = "Syntax error at #{value_at}"
+    end
 
+    # Note, old parser had processing of "expected token here" - do not try to reinstate:
     # The 'expected' is only of value at end of input, otherwise any parse error involving a
     # start of a pair will be reported as expecting the close of the pair - e.g. "$x.each |$x {|", would
     # report that "seeing the '{', the '}' is expected. That would be wrong.
@@ -111,9 +98,6 @@ class Puppet::Pops::Parser::Parser
     # must be handled by the grammar. The lexer may have enqueued tokens far ahead - the lexer's opinion about this
     # is not trustworthy.
     #
-#    if token == 0 && brace = @lexer.expected
-#      error += "; expected '#{brace}'"
-#    end
 
     except = Puppet::ParseError.new(error)
     if token != 0
@@ -138,7 +122,6 @@ class Puppet::Pops::Parser::Parser
   end
 
   # Mark the factory wrapped model object with location information
-  # @todo the lexer produces :line for token, but no offset or length
   # @return [Puppet::Pops::Model::Factory] the given factory
   # @api private
   #
@@ -146,15 +129,12 @@ class Puppet::Pops::Parser::Parser
     factory.record_position(start_locateable, end_locateable)
   end
 
-  def heredoc_loc(factory, start_locateabke, end_locateable = nil)
-    factory.record_heredoc_position(start_locatable, end_locatable)
-  end
-
-  # Associate documentation with the factory wrapped model object.
+  # Mark the factory wrapped heredoc model object with location information
   # @return [Puppet::Pops::Model::Factory] the given factory
   # @api private
-  def doc factory, doc_string
-    factory.doc = doc_string
+  #
+  def heredoc_loc(factory, start_locateabke, end_locateable = nil)
+    factory.record_heredoc_position(start_locatable, end_locatable)
   end
 
   def aryfy(o)
@@ -191,35 +171,37 @@ class Puppet::Pops::Parser::Parser
     Factory.transform_resource_wo_title(left, resource)
   end
 
-  # If there are definitions that require initialization a Program is produced, else the body
+  # Creates a program with the given body.
+  #
   def create_program(body)
     locator = @lexer.locator
     Factory.PROGRAM(body, definitions, locator)
   end
 
+  # Creates an empty program with a single No-op at the input's EOF offset with 0 length.
+  #
+  def create_empty_program()
+    locator = @lexer.locator
+    no_op = Factory.literal(nil)
+    # Create a synthetic NOOP token at EOF offset with 0 size. The lexer does not produce an EOF token that is
+    # visible to the grammar rules. Creating this token is mainly to reuse the positioning logic as it
+    # expects a token decorated with location information.
+    token_sym, token = @lexer.emit_completed([:NOOP,'',0], locator.string.bytesize)
+    loc(no_op, token)
+    # Program with a Noop
+    program = Factory.PROGRAM(no_op, [], locator)
+    program
+  end
+
   # Performs the parsing and returns the resulting model.
   # The lexer holds state, and this is setup with {#parse_string}, or {#parse_file}.
   #
-  # TODO: Drop support for parsing a ruby file this way (should be done where it is decided
-  #   which file to load/run (i.e. loaders), and initial file to run
-  # TODO: deal with options containing origin (i.e. parsing a string from externally known location).
-  # TODO: should return the model, not a Hostclass
-  #
   # @api private
   #
   def _parse()
     begin
       @yydebug = false
       main = yyparse(@lexer,:scan)
-      # #Commented out now because this hides problems in the racc grammar while developing
-      # # TODO include this when test coverage is good enough.
-      #      rescue Puppet::ParseError => except
-      #        except.line ||= @lexer.line
-      #        except.file ||= @lexer.file
-      #        except.pos  ||= @lexer.pos
-      #        raise except
-      #      rescue => except
-      #        raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, @lexer.pos, except)
     end
     return main
   ensure

data/lib/puppet/pops/patterns.rb

@@ -1,16 +1,18 @@
 # The Patterns module contains common regular expression patters for the Puppet DSL language
 module Puppet::Pops::Patterns
 
-  # NUMERIC matches hex, octal, decimal, and floating point and captures three parts
-  # 0 = entire matched number, leading and trailing whitespace included
-  # 1 = hexadecimal number
-  # 2 = non hex integer portion, possibly with leading 0 (octal)
-  # 3 = floating point part, starts with ".", decimals and optional exponent
+  # NUMERIC matches hex, octal, decimal, and floating point and captures several parts
+  # 0 = entire matched number, leading and trailing whitespace and sign included
+  # 1 = sign, +, - or nothing
+  # 2 = entire numeric part
+  # 3 = hexadecimal number
+  # 4 = non hex integer portion, possibly with leading 0 (octal)
+  # 5 = floating point part, starts with ".", decimals and optional exponent
   #
-  # Thus, a hex number has group 1 value, an octal value has group 2 (if it starts with 0), and no group 3
-  # and a floating point value has group 2 and group 3.
+  # Thus, a hex number has group 3 value, an octal value has group 4 (if it starts with 0), and no group 3
+  # and a floating point value has group 4 and group 5.
   #
-  NUMERIC = %r{^\s*(?:(0[xX][0-9A-Fa-f]+)|(0?\d+)((?:\.\d+)?(?:[eE]-?\d+)?))\s*$}
+  NUMERIC = %r{\A[[:blank:]]*([-+]?)[[:blank:]]*((0[xX][0-9A-Fa-f]+)|(0?\d+)((?:\.\d+)?(?:[eE]-?\d+)?))[[:blank:]]*\z}
 
   # ILLEGAL_P3_1_HOSTNAME matches if a hostname contains illegal characters.
   # This check does not prevent pathological names like 'a....b', '.....', "---". etc.
@@ -21,13 +23,11 @@ module Puppet::Pops::Patterns
 
   # CLASSREF_EXT matches a class reference the same way as the lexer - i.e. the external source form
   # where each part must start with a capital letter A-Z.
-  # This name includes hyphen, which may be illegal in some cases.
   #
   CLASSREF_EXT = %r{\A((::){0,1}[A-Z][\w]*)+\z}
 
   # CLASSREF matches a class reference the way it is represented internally in the
   # model (i.e. in lower case).
-  # This name includes hyphen, which may be illegal in some cases.
   #
   CLASSREF = %r{\A((::){0,1}[a-z][\w]*)+\z}
 

data/lib/puppet/pops/semantic_error.rb

@@ -7,7 +7,7 @@ class Puppet::Pops::SemanticError < RuntimeError
 
   # @param issue [Puppet::Pops::Issues::Issue] the issue describing the severity and message
   # @param semantic [Puppet::Pops::Model::Locatable, nil] the expression causing the failure, or nil if unknown
-  # @param options [Hash] an options hash with Symbol to valu mapping - these are the arguments to the issue
+  # @param options [Hash] an options hash with Symbol to value mapping - these are the arguments to the issue
   #
   def initialize(issue, semantic=nil, options = {})
     @issue = issue

data/lib/puppet/pops/types/class_loader.rb

@@ -9,8 +9,8 @@ class Puppet::Pops::Types::ClassLoader
 
   # Returns a Class given a fully qualified class name.
   # Lookup of class is never relative to the calling namespace.
-  # @param name [String, Array<String>, Array<Symbol>, Puppet::Pops::Types::PObjectType] A fully qualified
-  #   class name String (e.g. '::Foo::Bar', 'Foo::Bar'), a PObjectType, or a fully qualified name in Array form where each part
+  # @param name [String, Array<String>, Array<Symbol>, Puppet::Pops::Types::PAnyType] A fully qualified
+  #   class name String (e.g. '::Foo::Bar', 'Foo::Bar'), a PAnyType, or a fully qualified name in Array form where each part
   #   is either a String or a Symbol, e.g. `%w{Puppetx Puppetlabs SomeExtension}`.
   # @return [Class, nil] the looked up class or nil if no such class is loaded
   # @raise ArgumentError If the given argument has the wrong type
@@ -24,7 +24,7 @@ class Puppet::Pops::Types::ClassLoader
     when Array
       provide_from_name_path(name.join('::'), name)
 
-    when Puppet::Pops::Types::PObjectType, Puppet::Pops::Types::PType
+    when Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::PType
       provide_from_type(name)
 
     else
@@ -36,27 +36,38 @@ class Puppet::Pops::Types::ClassLoader
 
   def self.provide_from_type(type)
     case type
-    when Puppet::Pops::Types::PRubyType
-      provide_from_string(type.ruby_class)
+    when Puppet::Pops::Types::PRuntimeType
+      raise ArgumentError.new("Only Runtime type 'ruby' is supported, got #{type.runtime}") unless type.runtime == :ruby
+      provide_from_string(type.runtime_type_name)
 
     when Puppet::Pops::Types::PBooleanType
       # There is no other thing to load except this Enum meta type
       RGen::MetamodelBuilder::MMBase::Boolean
 
     when Puppet::Pops::Types::PType
-      # TODO: PType should have a type argument (a PObjectType)
+      # TODO: PType should has a type argument (a PAnyType) so the Class' class could be returned
+      #       (but this only matters in special circumstances when meta programming has been used).
       Class
 
+    when Puppet::Pops::Type::POptionalType
+      # cannot make a distinction between optional and its type
+      provide_from_type(type.optional_type)
+
     # Although not expected to be the first choice for getting a concrete class for these
     # types, these are of value if the calling logic just has a reference to type.
     #
-    when Puppet::Pops::Types::PArrayType   ; Array
-    when Puppet::Pops::Types::PHashType    ; Hash
-    when Puppet::Pops::Types::PRegexpType ; Regexp
-    when Puppet::Pops::Types::PIntegerType ; Integer
-    when Puppet::Pops::Types::PStringType  ; String
-    when Puppet::Pops::Types::PFloatType   ; Float
-    when Puppet::Pops::Types::PNilType     ; NilClass
+    when Puppet::Pops::Types::PArrayType    ; Array
+    when Puppet::Pops::Types::PTupleType    ; Array
+    when Puppet::Pops::Types::PHashType     ; Hash
+    when Puppet::Pops::Types::PStructType   ; Hash
+    when Puppet::Pops::Types::PRegexpType   ; Regexp
+    when Puppet::Pops::Types::PIntegerType  ; Integer
+    when Puppet::Pops::Types::PStringType   ; String
+    when Puppet::Pops::Types::PPatternType  ; String
+    when Puppet::Pops::Types::PEnumType     ; String
+    when Puppet::Pops::Types::PFloatType    ; Float
+    when Puppet::Pops::Types::PNilType      ; NilClass
+    when Puppet::Pops::Types::PCallableType ; Proc
     else
       nil
     end