puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/parser/lexer_support.rb

@@ -0,0 +1,113 @@
+# This is an integral part of the Lexer. It is broken out into a separate module
+# for maintainability of the code, and making the various parts of the lexer focused.
+#
+module Puppet::Pops::Parser::LexerSupport
+
+  # Formats given message by appending file, line and position if available.
+  def positioned_message(msg, pos = nil)
+    result = [msg]
+    file = @locator.file
+    line = @locator.line_for_offset(pos || @scanner.pos)
+    pos =  @locator.pos_on_line(pos || @scanner.pos)
+
+    result << "in file #{file}" if file && file.is_a?(String) && !file.empty?
+    result << "at line #{line}:#{pos}"
+    result.join(" ")
+  end
+
+  # Returns "<eof>" if at end of input, else the following 5 characters with \n \r \t escaped
+  def followed_by
+    return "<eof>" if @scanner.eos?
+    result = @scanner.rest[0,5] + "..."
+    result.gsub!("\t", '\t')
+    result.gsub!("\n", '\n')
+    result.gsub!("\r", '\r')
+    result
+  end
+
+  # Returns a quoted string using " or ' depending on the given a strings's content
+  def format_quote(q)
+    if q == "'"
+      '"\'"'
+    else
+      "'#{q}'"
+    end
+  end
+
+  # Raises a Puppet::LexError with the given message
+  def lex_error_without_pos msg
+    raise Puppet::LexError.new(msg)
+  end
+
+  # Raises a Puppet::LexError with the given message
+  def lex_error(msg, pos=nil)
+    raise Puppet::LexError.new(positioned_message(msg, pos))
+  end
+
+  # Asserts that the given string value is a float, or an integer in decimal, octal or hex form.
+  # An error is raised if the given value does not comply.
+  #
+  def assert_numeric(value, length)
+    if value =~ /^0[xX].*$/
+      lex_error("Not a valid hex number #{value}", length)     unless value =~ /^0[xX][0-9A-Fa-f]+$/
+
+    elsif value =~ /^0[^.].*$/
+      lex_error("Not a valid octal number #{value}", length)   unless value =~ /^0[0-7]+$/
+
+    else
+      lex_error("Not a valid decimal number #{value}", length) unless value =~ /0?\d+(?:\.\d+)?(?:[eE]-?\d+)?/
+    end
+  end
+
+  # A TokenValue keeps track of the token symbol, the lexed text for the token, its length
+  # and its position in its source container. There is a cost associated with computing the
+  # line and position on line information.
+  #
+  class TokenValue < Puppet::Pops::Parser::Locatable
+    attr_reader :token_array
+    attr_reader :offset
+    attr_reader :locator
+
+    def initialize(token_array, offset, locator)
+      @token_array = token_array
+      @offset = offset
+      @locator = locator
+    end
+
+    def length
+      @token_array[2]
+    end
+
+    def [](key)
+      case key
+      when :value
+        @token_array[1]
+      when :file
+        @locator.file
+      when :line
+        @locator.line_for_offset(@offset)
+      when :pos
+        @locator.pos_on_line(@offset)
+      when :length
+        @token_array[2]
+      when :locator
+        @locator
+      when :offset
+        @offset
+      else
+        nil
+      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)
+    #
+  end
+
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/parser/locatable.rb

@@ -0,0 +1,23 @@
+# Interface for something that is "locateable" (holds offset and length).
+class Puppet::Pops::Parser::Locatable
+
+  # The offset in the locator's content
+  def offset
+  end
+
+  # The length in the locator from the given offset
+  def length
+  end
+
+  # This class is useful for testing
+  class Fixed < Puppet::Pops::Parser::Locatable
+    attr_reader :offset
+    attr_reader :length
+
+    def initialize(offset, length)
+      @offset = offset
+      @length = length
+    end
+  end
+
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/parser/locator.rb

@@ -0,0 +1,291 @@
+# Helper class that keeps track of where line breaks are located and can answer questions about positions.
+#
+class Puppet::Pops::Parser::Locator
+
+  RUBY_1_9_3 = (1 << 16 | 9 << 8 | 3)
+  RUBY_2_0_0 = (2 << 16 | 0 << 8 | 0)
+  RUBYVER_ARRAY = RUBY_VERSION.split(".").collect {|s| s.to_i }
+  RUBYVER = (RUBYVER_ARRAY[0] << 16 | RUBYVER_ARRAY[1] << 8 | RUBYVER_ARRAY[2])
+
+  # Computes a symbol representing which ruby runtime this is running on
+  # This implementation will fail if there are more than 255 minor or micro versions of ruby
+  #
+  def self.locator_version
+    if RUBYVER >= RUBY_2_0_0
+      :ruby20
+    elsif RUBYVER >= RUBY_1_9_3
+      :ruby19
+    else
+      :ruby18
+    end
+  end
+  LOCATOR_VERSION = locator_version
+
+  # Constant set to true if multibyte is supported (includes multibyte extended regular expressions)
+  MULTIBYTE = !!(LOCATOR_VERSION == :ruby19 || LOCATOR_VERSION == :ruby20)
+
+  # Creates, or recreates a Locator. A Locator is created if index is not given (a scan is then
+  # performed of the given source string.
+  #
+  def self.locator(string, file, index = nil)
+    case LOCATOR_VERSION
+    when :ruby20, :ruby19
+      Locator19.new(string, file, index)
+    else
+      Locator18.new(string, file, index)
+    end
+  end
+
+  # Returns the file name associated with the string content
+  def file
+  end
+
+  # Returns the string content
+  def string
+  end
+
+  # Returns the position on line (first position on a line is 1)
+  def pos_on_line(offset)
+  end
+
+  # Returns the line number (first line is 1) for the given offset
+  def line_for_offset(offset)
+  end
+
+  # Returns the offset on line (first offset on a line is 0).
+  #
+  def offset_on_line(offset)
+  end
+
+  # Returns the character offset for a given reported offset
+  def char_offset(byte_offset)
+  end
+
+  # Returns the length measured in number of characters from the given start and end reported offset
+  def char_length(offset, end_offset)
+  end
+
+  # Returns the line index - an array of line offsets for the start position of each line, starting at 0 for
+  # the first line.
+  #
+  def line_index()
+  end
+
+  # A Sublocator locates a concrete locator (subspace) in a virtual space.
+  # The `leading_line_count` is the (virtual) number of lines preceding the first line in the concrete locator.
+  # The `leading_offset` is the (virtual) byte offset of the first byte in the concrete locator.
+  # The `leading_line_offset` is the (virtual) offset / margin in characters for each line.
+  #
+  # This illustrates characters in the sublocator (`.`) inside the subspace (`X`):
+  #
+  #      1:XXXXXXXX
+  #      2:XXXX.... .. ... ..
+  #      3:XXXX. . .... ..
+  #      4:XXXX............
+  #
+  # This sublocator would be configured with leading_line_count = 1,
+  # leading_offset=8, and leading_line_offset=4
+  #
+  # Note that leading_offset must be the same for all lines and measured in characters.
+  #
+  class SubLocator < Puppet::Pops::Parser::Locator
+    attr_reader :locator
+    attr_reader :leading_line_count
+    attr_reader :leading_offset
+    attr_reader :leading_line_offset
+
+    def self.sub_locator(string, file, leading_line_count, leading_offset, leading_line_offset)
+      self.new(Puppet::Pops::Parser::Locator.locator(string, file),
+        leading_line_count,
+        leading_offset,
+        leading_line_offset)
+    end
+
+    def initialize(locator, leading_line_count, leading_offset, leading_line_offset)
+      @locator = locator
+      @leading_line_count = leading_line_count
+      @leading_offset = leading_offset
+      @leading_line_offset = leading_line_offset
+    end
+
+    def file
+      @locator.file
+    end
+
+    def string
+      @locator.string
+    end
+
+    # Given offset is offset in the subspace
+    def line_for_offset(offset)
+      @locator.line_for_offset(offset) + @leading_line_count
+    end
+
+    # Given offset is offset in the subspace
+    def offset_on_line(offset)
+      @locator.offset_on_line(offset) + @leading_line_offset
+    end
+
+    # Given offset is offset in the subspace
+    def char_offset(offset)
+      effective_line = @locator.line_for_offset(offset)
+      locator.char_offset(offset) + (effective_line * @leading_line_offset) + @leading_offset
+    end
+
+    # Given offsets are offsets in the subspace
+    def char_length(offset, end_offset)
+      effective_line = @locator.line_for_offset(end_offset) - @locator.line_for_offset(offset)
+      locator.char_length(offset, end_offset) + (effective_line * @leading_line_offset)
+    end
+
+    def pos_on_line(offset)
+      offset_on_line(offset) +1
+    end
+  end
+
+  private
+
+  class AbstractLocator < Puppet::Pops::Parser::Locator
+    attr_accessor :line_index
+    attr_accessor :string
+    attr_accessor :prev_offset
+    attr_accessor :prev_line
+    attr_reader   :string
+    attr_reader   :file
+
+    # Create a locator based on a content string, and a boolean indicating if ruby version support multi-byte strings
+    # or not.
+    #
+    def initialize(string, file, index = nil)
+      @string = string.freeze
+      @file = file.freeze
+      @prev_offset = nil
+      @prev_line = nil
+      @line_index = index
+      compute_line_index unless !index.nil?
+    end
+
+    # Returns the position on line (first position on a line is 1)
+    def pos_on_line(offset)
+      offset_on_line(offset) +1
+    end
+
+    def to_location_hash(reported_offset, end_offset)
+      pos        = pos_on_line(reported_offset)
+      offset     = char_offset(reported_offset)
+      length     = char_length(reported_offset, end_offset)
+      start_line = line_for_offset(reported_offset)
+      { :line => start_line, :pos => pos, :offset => offset, :length => length}
+    end
+
+    # Returns the index of the smallest item for which the item > the given value
+    # This is a min binary search. Although written in Ruby it is only slightly slower than
+    # the corresponding method in C in Ruby 2.0.0 - the main benefit to use this method over
+    # the Ruby C version is that it returns the index (not the value) which means there is not need
+    # to have an additional structure to get the index (or record the index in the structure). This
+    # saves both memory and CPU. It also does not require passing a block that is called since this
+    # method is specialized to search the line index.
+    #
+    def ary_bsearch_i(ary, value)
+      low = 0
+      high = ary.length
+      mid = nil
+      smaller = false
+      satisfied = false
+      v = nil
+
+      while low < high do
+          mid = low + ((high - low) / 2)
+          v = (ary[mid] > value)
+          if v == true
+            satisfied = true
+            smaller = true
+          elsif !v
+            smaller = false
+          else
+            raise TypeError, "wrong argument, must be boolean or nil, got '#{v.class}'"
+          end
+
+          if smaller
+            high = mid
+          else
+            low = mid + 1;
+          end
+      end
+
+      return nil if low == ary.length
+      return nil if !satisfied
+      return low
+    end
+
+    # Common impl for 18 and 19 since scanner is byte based
+    def compute_line_index
+      scanner = StringScanner.new(string)
+      result = [0] # first line starts at 0
+      while scanner.scan_until(/\n/)
+        result << scanner.pos
+      end
+      self.line_index = result.freeze
+    end
+
+    # Returns the line number (first line is 1) for the given offset
+    def line_for_offset(offset)
+      if prev_offset == offset
+        # use cache
+        return prev_line
+      end
+      if line_nbr = ary_bsearch_i(line_index, offset)
+        # cache
+        prev_offset = offset
+        prev_line = line_nbr
+        return line_nbr
+      end
+      # If not found it is after last
+      # clear cache
+      prev_offset = prev_line = nil
+      return line_index.size
+    end
+  end
+
+  class Locator18 < AbstractLocator
+
+    def offset_on_line(offset)
+      line_offset = line_index[ line_for_offset(offset)-1 ]
+      offset - line_offset
+    end
+
+    def char_offset(char_offset)
+      char_offset
+    end
+
+    def char_length(offset, end_offset)
+      end_offset - offset
+    end
+
+  end
+
+  # This implementation is for Ruby19 and Ruby20. It uses byteslice to get strings from byte based offsets.
+  # For Ruby20 this is faster than using the Stringscanner.charpos method (byteslice outperforms it, when
+  # strings are frozen).
+  #
+  class Locator19 < AbstractLocator
+
+    # Returns the offset on line (first offset on a line is 0).
+    # Ruby 19 is multibyte but has no character position methods, must use byteslice
+    def offset_on_line(offset)
+      line_offset = line_index[ line_for_offset(offset)-1 ]
+      string.byteslice(line_offset, offset-line_offset).length
+    end
+
+    # Returns the character offset for a given byte offset
+    # Ruby 19 is multibyte but has no character position methods, must use byteslice
+    def char_offset(byte_offset)
+      string.byteslice(0, byte_offset).length
+    end
+
+    # Returns the length measured in number of characters from the given start and end byte offseta
+    def char_length(offset, end_offset)
+      string.byteslice(offset, end_offset - offset).length
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/parser/parser_support.rb

@@ -0,0 +1,242 @@
+require 'puppet/parser/functions'
+require 'puppet/parser/files'
+require 'puppet/resource/type_collection'
+require 'puppet/resource/type_collection_helper'
+require 'puppet/resource/type'
+require 'monitor'
+
+# Supporting logic for the parser.
+# This supporting logic has slightly different responsibilities compared to the original Puppet::Parser::Parser.
+# It is only concerned with parsing.
+#
+class Puppet::Pops::Parser::Parser
+  # Note that the name of the contained class and the file name (currently parser_support.rb)
+  # needs to be different as the class is generated by Racc, and this file (parser_support.rb) is included as a mix in
+  #
+
+  # Simplify access to the Model factory
+  # Note that the parser/parser support does not have direct knowledge about the Model.
+  # All model construction/manipulation is made by the Factory.
+  #
+  Factory = Puppet::Pops::Model::Factory
+  Model = Puppet::Pops::Model
+
+  include Puppet::Resource::TypeCollectionHelper
+
+  attr_accessor :lexer
+  attr_reader :definitions
+
+  # Returns the token text of the given lexer token, or nil, if token is nil
+  def token_text t
+    return t if t.nil?
+    t = t.current if t.respond_to?(:current)
+    return t.value if t.is_a? Model::QualifiedName
+
+    # else it is a lexer token
+    t[:value]
+  end
+
+  # Produces the fully qualified name, with the full (current) namespace for a given name.
+  #
+  # This is needed because class bodies are lazily evaluated and an inner class' container(s) may not
+  # have been evaluated before some external reference is made to the inner class; its must therefore know its complete name
+  # before evaluation-time.
+  #
+  def classname(name)
+    [namespace, name].join('::').sub(/^::/, '')
+  end
+
+  # Raises a Parse error with location information. Information about file is always obtained from the
+  # lexer. Line and position is produced if the given semantic is a Positioned object and have been given an offset.
+  #
+  def error(semantic, message)
+    semantic = semantic.current() if semantic.is_a?(Puppet::Pops::Model::Factory)
+    # Adapt the model so it is possible to get location information.
+    # The model may not have been added to the source tree, so give it the lexer's locator
+    # directly instead of searching for the root Program where the locator is normally stored.
+    #
+    if semantic.is_a?(Puppet::Pops::Model::Positioned)
+      adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(semantic)
+      adapter.locator = @lexer.locator
+    else
+      adapter = nil
+    end
+    except = Puppet::ParseError.new(message)
+    except.file = @lexer.locator.file
+    except.line = adapter.line if adapter
+    except.pos = adapter.pos if adapter
+    raise except
+  end
+
+  # Parses a file expected to contain pp DSL logic.
+  def parse_file(file)
+    unless Puppet::FileSystem.exist?(file)
+      unless file =~ /\.pp$/
+        file = file + ".pp"
+      end
+    end
+    @lexer.file = file
+    _parse()
+  end
+
+  def initialize()
+    @lexer = Puppet::Pops::Parser::Lexer2.new
+    @namestack = []
+    @definitions = []
+  end
+
+  # 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
+      value_at = 'end of file'
+    else
+      value_at = "'#{value[:value]}'"
+    end
+    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.
+    # Real "expected" tokens are very difficult to compute (would require parsing of racc output data). Output of the stack
+    # could help, but can require extensive backtracking and produce many options.
+    #
+    # The lexer should handle the "expected instead of end of file for strings, and interpolation", other expectancies
+    # must be handled by the grammar. The lexer may have enqueued tokens far ahead - the lexer's opinion about this
+    # is not trustworthy.
+    #
+
+    except = Puppet::ParseError.new(error)
+    if token != 0
+      path        = value[:file]
+      except.line = value[:line]
+      except.pos  = value[:pos]
+    else
+      # At end of input, use what the lexer thinks is the source file
+      path        = lexer.file
+    end
+    except.file = path if path.is_a?(String) && !path.empty?
+
+    raise except
+  end
+
+  # Parses a String of pp DSL code.
+  #
+  def parse_string(code, path = '')
+    @lexer.lex_string(code, path)
+    _parse()
+  end
+
+  # Mark the factory wrapped model object with location information
+  # @return [Puppet::Pops::Model::Factory] the given factory
+  # @api private
+  #
+  def loc(factory, start_locateable, end_locateable = nil)
+    factory.record_position(start_locateable, end_locateable)
+  end
+
+  # Mark the factory wrapped heredoc model object with location information
+  # @return [Puppet::Pops::Model::Factory] the given factory
+  # @api private
+  #
+  def heredoc_loc(factory, start_locateabke, end_locateable = nil)
+    factory.record_heredoc_position(start_locatable, end_locatable)
+  end
+
+  def aryfy(o)
+    o = [o] unless o.is_a?(Array)
+    o
+  end
+
+  def namespace
+    @namestack.join('::')
+  end
+
+  def namestack(name)
+    @namestack << name
+  end
+
+  def namepop()
+    @namestack.pop
+  end
+
+  def add_definition(definition)
+    @definitions << definition.current
+    definition
+  end
+
+  # Transforms an array of expressions containing literal name expressions to calls if followed by an
+  # expression, or expression list
+  #
+  def transform_calls(expressions)
+    # Factory transform raises an error if a non qualified name is followed by an argument list
+    # since there is no way that that can be transformed back to sanity. This occurs in situations like this:
+    #
+    #  $a = 10, notice hello
+    #
+    # where the "10, notice" forms an argument list. The parser builds an Array with the expressions and includes
+    # the comma tokens to enable the error to be reported against the first comma.
+    #
+    begin
+      Factory.transform_calls(expressions)
+    rescue Puppet::Pops::Model::Factory::ArgsToNonCallError => e
+      # e.args[1] is the first comma token in the list
+      # e.name_expr is the function name expression
+      if e.name_expr.is_a?(Puppet::Pops::Model::QualifiedName)
+        error(e.args[1], "attempt to pass argument list to the function '#{e.name_expr.value}' which cannot be called without parentheses")
+      else
+        error(e.args[1], "illegal comma separated argument list")
+      end
+    end
+  end
+
+  # Transforms a LEFT followed by the result of attribute_operations, this may be a call or an invalid sequence
+  def transform_resource_wo_title(left, resource)
+    Factory.transform_resource_wo_title(left, resource)
+  end
+
+  # 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}.
+  #
+  # @api private
+  #
+  def _parse()
+    begin
+      @yydebug = false
+      main = yyparse(@lexer,:scan)
+    end
+    return main
+  ensure
+    @lexer.clear
+    @namestack = []
+    @definitions = []
+  end
+
+end