bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/pops/parser/epp_parser.rb

@@ -1,51 +0,0 @@
-# The EppParser is a specialized Puppet Parser that starts parsing in Epp Text mode
-class Puppet::Pops::Parser::EppParser < Puppet::Pops::Parser::Parser
-
-  # Initializes the epp parser support by creating a new instance of {Puppet::Pops::Parser::Lexer}
-  # configured to start in Epp Lexing mode.
-  # @return [void]
-  #
-  def initvars
-    self.lexer = Puppet::Pops::Parser::Lexer2.new()
-  end
-
-  # Parses a file expected to contain epp text/DSL logic.
-  def parse_file(file)
-    unless FileTest.exist?(file)
-      unless file =~ /\.epp$/
-        file = file + ".epp"
-      end
-    end
-    @lexer.file = file
-    _parse()
-  end
-
-  # Performs the parsing and returns the resulting model.
-  # The lexer holds state, and this is setup with {#parse_string}, or {#parse_file}.
-  #
-  # 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_epp)
-      # #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
-    @lexer.clear
-    @namestack = []
-    @definitions = []
-  end
-end

data/vendored/puppet/lib/puppet/pops/parser/epp_support.rb

@@ -1,264 +0,0 @@
-module Puppet::Pops
-module Parser
-# This module is an integral part of the Lexer.
-# It handles scanning of EPP (Embedded Puppet), a form of string/expression interpolation similar to ERB.
-#
-require 'strscan'
-module EppSupport
-
-  TOKEN_RENDER_STRING = [:RENDER_STRING, nil, 0]
-  TOKEN_RENDER_EXPR   = [:RENDER_EXPR, nil, 0]
-
-  # Scans all of the content and returns it in an array
-  # Note that the terminating [false, false] token is included in the result.
-  #
-  def fullscan_epp
-    result = []
-    scan_epp {|token, value| result.push([token, value]) }
-    result
-  end
-
-  # A block must be passed to scan. It will be called with two arguments, a symbol for the token,
-  # and an instance of LexerSupport::TokenValue
-  # PERFORMANCE NOTE: The TokenValue is designed to reduce the amount of garbage / temporary data
-  # and to only convert the lexer's internal tokens on demand. It is slightly more costly to create an
-  # instance of a class defined in Ruby than an Array or Hash, but the gain is much bigger since transformation
-  # logic is avoided for many of its members (most are never used (e.g. line/pos information which is only of
-  # value in general for error messages, and for some expressions (which the lexer does not know about).
-  #
-  def scan_epp
-    # PERFORMANCE note: it is faster to access local variables than instance variables.
-    # This makes a small but notable difference since instance member access is avoided for
-    # every token in the lexed content.
-    #
-    scn   = @scanner
-    ctx   = @lexing_context
-    queue = @token_queue
-
-    lex_error(Issues::EPP_INTERNAL_ERROR, :error => 'No string or file given to lexer to process.') unless scn
-
-    ctx[:epp_mode] = :text
-    enqueue_completed([:EPP_START, nil, 0], 0)
-
-    interpolate_epp
-
-    # 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] ]
-      end
-    end
-    if ctx[:epp_open_position]
-      lex_error(Issues::EPP_UNBALANCED_TAG, {}, ctx[:epp_position])
-    end
-
-    # Signals end of input
-    yield [false, false]
-  end
-
-  def interpolate_epp(skip_leading=false)
-    scn = @scanner
-    ctx = @lexing_context
-    eppscanner = EppScanner.new(scn)
-    before = scn.pos
-
-    s = eppscanner.scan(skip_leading)
-
-    case eppscanner.mode
-    when :text
-      # Should be at end of scan, or something is terribly wrong
-      unless @scanner.eos?
-        lex_error(Issues::EPP_INTERNAL_ERROR, :error => 'template scanner returns text mode and is not and end of input')
-      end
-      if s
-        # s may be nil if scanned text ends with an epp tag (i.e. no trailing text).
-        enqueue_completed([:RENDER_STRING, s, scn.pos - before], before)
-      end
-      ctx[:epp_open_position] = nil
-      # do nothing else, scanner is at the end
-
-    when :error
-      lex_error(eppscanner.issue)
-
-    when :epp
-      # It is meaningless to render empty string segments, and it is harmful to do this at
-      # the start of the scan as it prevents specification of parameters with <%- ($x, $y) -%>
-      #
-      if s && s.length > 0
-        enqueue_completed([:RENDER_STRING, s, scn.pos - before], before)
-      end
-      # switch epp_mode to general (embedded) pp logic (non rendered result)
-      ctx[:epp_mode] = :epp
-      ctx[:epp_open_position] = scn.pos
-
-    when :expr
-      # It is meaningless to render an empty string segment
-      if s && s.length > 0
-        enqueue_completed([:RENDER_STRING, s, scn.pos - before], before)
-      end
-      enqueue_completed(TOKEN_RENDER_EXPR, before)
-      # switch mode to "epp expr interpolation"
-      ctx[:epp_mode] = :expr
-      ctx[:epp_open_position] = scn.pos
-    else
-      lex_error(Issues::EPP_INTERNAL_ERROR, :error => "Unknown mode #{eppscanner.mode} returned by template scanner")
-    end
-    nil
-  end
-
-  # A scanner specialized in processing text with embedded EPP (Embedded Puppet) tags.
-  # The scanner is initialized with a StringScanner which it mutates as scanning takes place.
-  # The intent is to use one instance of EppScanner per wanted scan, and this instance represents
-  # the state after the scan.
-  #
-  # @example Sample usage
-  #   a = "some text <% pp code %> some more text"
-  #   scan = StringScanner.new(a)
-  #   eppscan = EppScanner.new(scan)
-  #   str = eppscan.scan
-  #   eppscan.mode # => :epp
-  #   eppscan.lines # => 0
-  #   eppscan
-  #
-  # The scanner supports
-  # * scanning text until <%, <%-, <%=
-  # * while scanning text:
-  #   * tokens <%% and %%> are translated to <% and %>, respectively, and is returned as text.
-  #   * tokens <%# and %> (or ending with -%>) and the enclosed text is a comment and is not included in the returned text
-  #   * text following a comment that ends with -%> gets trailing whitespace (up to and including a line break) trimmed
-  #     and this whitespace is not included in the returned text.
-  # * The continuation {#mode} is set to one of:
-  #   * `:epp` - for a <% token
-  #   * `:expr` - for a <%= token
-  #   * `:text` - when there was no continuation mode (e.g. when input ends with text)
-  #   * ':error` - if the tokens are unbalanced (reaching the end without a closing matching token). An error message
-  #     is then also available via the method {#message}.
-  #
-  # Note that the intent is to use this specialized scanner to scan the text parts, when continuation mode is `:epp` or `:expr`
-  # the pp lexer should advance scanning (using the string scanner) until it reaches and consumes a `-%>` or '%>´ token. If it
-  # finds a `-%> token it should pass this on as a `skip_leading` parameter when it performs the next {#scan}.
-  #
-  class EppScanner
-    # The original scanner used by the lexer/container using EppScanner
-    attr_reader :scanner
-
-    # The resulting mode after the scan.
-    # The mode is one of `:text` (the initial mode), `:epp` embedded code (no output), `:expr` (embedded
-    # expression), or `:error`
-    #
-    attr_reader :mode
-
-    # An error issue if `mode == :error`, `nil` otherwise.
-    attr_reader :issue
-
-    # If the first scan should skip leading whitespace (typically detected by the pp lexer when the
-    # pp mode end-token is found (i.e. `-%>`) and then passed on to the scanner.
-    #
-    attr_reader :skip_leading
-
-    # Creates an EppScanner based on a StringScanner that represents the state where EppScanner should start scanning.
-    # The given scanner will be mutated (i.e. position moved) to reflect the EppScanner's end state after a scan.
-    #
-    def initialize(scanner)
-      @scanner = scanner
-    end
-
-    # Here for backwards compatibility.
-    # @deprecated Use issue instead
-    # @return [String] the issue message
-    def message
-      @issue.nil? ? nil : @issue.format
-    end
-
-    # Scans from the current position in the configured scanner, advances this scanner's position until the end
-    # of the input, or to the first position after a mode switching token (`<%`, `<%-` or `<%=`). Number of processed
-    # lines and continuation mode can be obtained via {#lines}, and {#mode}.
-    #
-    # @return [String, nil] the scanned and processed text, or nil if at the end of the input.
-    #
-    def scan(skip_leading=false)
-      @mode = :text
-      @skip_leading = skip_leading
-
-      return nil if scanner.eos?
-      s = ""
-      until scanner.eos?
-        part = @scanner.scan_until(/(<%)|\z/)
-        if @skip_leading
-          part.sub!(/^[ \t]*\r?(?:\n|\z)?/,'')
-          @skip_leading = false
-        end
-        # The spec for %%> is to transform it into a literal %>. This is done here, as %%> otherwise would go
-        # undetected in text mode. (i.e. it is not really necessary to escape %> with %%> in text mode unless
-        # adding checks stating that a literal %> is illegal in text (unbalanced).
-        #
-        part.gsub!(/%%>/, '%>')
-        s += part
-        case @scanner.peek(1)
-        when ""
-          # at the end
-          # if s ends with <% then this is an error (unbalanced <% %>)
-          if s.end_with? "<%"
-            @mode = :error
-            @issue = Issues::EPP_UNBALANCED_EXPRESSION
-          end
-          return s
-
-        when "-"
-          # trim trailing whitespace on same line from accumulated s
-          # return text and signal switch to pp mode
-          @scanner.getch # drop the -
-          s.sub!(/[ \t]*<%\z/, '')
-          @mode = :epp
-          return s
-
-        when "%"
-          # verbatim text
-          # keep the scanned <%, and continue scanning after skipping one %
-          # (i.e. do nothing here)
-          @scanner.getch # drop the % to get a literal <% in the output
-
-        when "="
-          # expression
-          # return text and signal switch to expression mode
-          # drop the scanned <%, and skip past -%>, or %>, but also skip %%>
-          @scanner.getch # drop the =
-          s.slice!(-2..-1)
-          @mode = :expr
-          return s
-
-        when "#"
-          # template comment
-
-          # drop the scanned <%, and skip past -%>, or %>, but also skip %%>
-          s.slice!(-2..-1)
-
-          # unless there is an immediate termination i.e. <%#%> scan for the next %> that is not
-          # preceded by a % (i.e. skip %%>)
-          part = scanner.scan_until(/[^%]%>/)
-          unless part
-            @issue = Issues::EPP_UNBALANCED_COMMENT
-            @mode = :error
-            return s
-          end
-          # Trim leading whitespace on the same line when start was <%#-
-          if part[1] == '-'
-            s.sub!(/[ \t]*\z/, '')
-          end
-
-          @skip_leading = true if part.end_with?("-%>")
-          # Continue scanning for more text
-
-        else
-          # Switch to pp after having removed the <%
-          s.slice!(-2..-1)
-          @mode = :epp
-          return s
-        end
-      end
-    end
-  end
-
-end
-end
-end

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

@@ -1,165 +0,0 @@
-module Puppet::Pops
-module Parser
-
-# Does not support "import" and parsing ruby files
-#
-class EvaluatingParser
-
-  attr_reader :parser
-
-  def initialize()
-    @parser = Parser.new()
-  end
-
-  def self.singleton
-    @instance ||= new
-  end
-
-  def parse_string(s, file_source = nil)
-    @file_source = file_source
-    clear()
-    # Handling of syntax error can be much improved (in general), now it bails out of the parser
-    # and does not have as rich information (when parsing a string), need to update it with the file source
-    # (ideally, a syntax error should be entered as an issue, and not just thrown - but that is a general problem
-    # and an improvement that can be made in the eparser (rather than here).
-    # Also a possible improvement (if the YAML parser returns positions) is to provide correct output of position.
-    #
-    begin
-      assert_and_report(parser.parse_string(s, file_source)).model
-    rescue Puppet::ParseErrorWithIssue => e
-      raise e
-    rescue Puppet::ParseError => e
-      # TODO: This is not quite right, why does not the exception have the correct file?
-      e.file = @file_source unless e.file.is_a?(String) && !e.file.empty?
-      raise e
-    end
-  end
-
-  def parse_file(file)
-    @file_source = file
-    clear()
-    assert_and_report(parser.parse_file(file)).model
-  end
-
-  def evaluate_string(scope, s, file_source = nil)
-    evaluate(scope, parse_string(s, file_source))
-  end
-
-  def evaluate_file(scope, file)
-    evaluate(scope, parse_file(file))
-  end
-
-  def clear()
-    @acceptor = nil
-  end
-
-  # Create a closure that can be called in the given scope
-  def closure(model, scope)
-    Evaluator::Closure::Dynamic.new(evaluator, model, scope)
-  end
-
-  def evaluate(scope, model)
-    return nil unless model
-    evaluator.evaluate(model, scope)
-  end
-
-  # Evaluates the given expression in a local scope with the given variable bindings
-  # set in this local scope, returns what the expression returns.
-  #
-  def evaluate_expression_with_bindings(scope, variable_bindings, expression)
-    evaluator.evaluate_block_with_bindings(scope, variable_bindings, expression)
-  end
-
-  def evaluator
-    # Do not use the cached evaluator if this is a migration run
-    if (Puppet.lookup(:migration_checker) { nil })
-      return Evaluator::EvaluatorImpl.new()
-    end
-    @@evaluator ||= Evaluator::EvaluatorImpl.new()
-    @@evaluator
-  end
-
-  def convert_to_3x(object, scope)
-    evaluator.convert(object, scope, nil)
-  end
-
-  def validate(parse_result)
-    resulting_acceptor = acceptor()
-    validator(resulting_acceptor).validate(parse_result)
-    resulting_acceptor
-  end
-
-  def acceptor()
-    Validation::Acceptor.new
-  end
-
-  def validator(acceptor)
-    Validation::ValidatorFactory_4_0.new().validator(acceptor)
-  end
-
-  def assert_and_report(parse_result)
-    return nil unless parse_result
-    if parse_result['source_ref'].nil? || parse_result['source_ref'] == ''
-      parse_result['source_ref'] = @file_source
-    end
-    validation_result = validate(parse_result.model)
-
-    IssueReporter.assert_and_report(validation_result,
-                                          :emit_warnings => true)
-    parse_result
-  end
-
-  def quote(x)
-    self.class.quote(x)
-  end
-
-  # Translates an already parsed string that contains control characters, quotes
-  # and backslashes into a quoted string where all such constructs have been escaped.
-  # Parsing the return value of this method using the puppet parser should yield
-  # exactly the same string as the argument passed to this method
-  #
-  # The method makes an exception for the two character sequences \$ and \s. They
-  # will not be escaped since they have a special meaning in puppet syntax.
-  #
-  # TODO: Handle \uXXXX characters ??
-  #
-  # @param x [String] The string to quote and "unparse"
-  # @return [String] The quoted string
-  #
-  def self.quote(x)
-    escaped = '"'
-    p = nil
-    x.each_char do |c|
-      case p
-      when nil
-        # do nothing
-      when "\t"
-        escaped << '\\t'
-      when "\n"
-        escaped << '\\n'
-      when "\f"
-        escaped << '\\f'
-      # TODO: \cx is a range of characters - skip for now
-      #      when "\c"
-      #        escaped << '\\c'
-      when '"'
-        escaped << '\\"'
-      when '\\'
-        escaped << if c == '$' || c == 's'; p; else '\\\\'; end # don't escape \ when followed by s or $
-      else
-        escaped << p
-      end
-      p = c
-    end
-    escaped << p unless p.nil?
-    escaped << '"'
-  end
-
-  class EvaluatingEppParser < EvaluatingParser
-    def initialize()
-      @parser = EppParser.new()
-    end
-  end
-end
-end
-end