bolt 0.19.1 → 0.20.0

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

@@ -1,117 +0,0 @@
-module Puppet::Pops
-module Parser
-# This module is an integral part of the Lexer.
-# It defines the string slurping behavior - finding the string and non string parts in interpolated
-# strings, translating escape sequences in strings to their single character equivalence.
-#
-# PERFORMANCE NOTE: The various kinds of slurping could be made even more generic, but requires
-# additional parameter passing and evaluation of conditional logic.
-# TODO: More detailed performance analysis of excessive character escaping and interpolation.
-#
-module SlurpSupport
-  include LexerSupport
-
-  SLURP_SQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*[']/
-  SLURP_DQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*(["]|[$]\{?)/
-  SLURP_UQ_PATTERN  = /(?:[^\\]|^)(?:[\\]{2})*([$]\{?|\z)/
-  # unquoted, no escapes
-  SLURP_UQNE_PATTERN  = /(\$\{?|\z)/m
-  SLURP_ALL_PATTERN = /.*(\z)/m
-  SQ_ESCAPES = %w{ \\ ' }
-  DQ_ESCAPES = %w{ \\  $ ' " r n t s u}+["\r\n", "\n"]
-  UQ_ESCAPES = %w{ \\  $ r n t s u}+["\r\n", "\n"]
-
-  def slurp_sqstring
-    # skip the leading '
-    @scanner.pos += 1
-    str = slurp(@scanner, SLURP_SQ_PATTERN, SQ_ESCAPES, :ignore_invalid_escapes)
-    lex_error(Issues::UNCLOSED_QUOTE, :after => "\"'\"", :followed_by => followed_by) unless str
-    str[0..-2] # strip closing "'" from result
-  end
-
-  def slurp_dqstring
-    scn = @scanner
-    last = scn.matched
-    str = slurp(scn, SLURP_DQ_PATTERN, DQ_ESCAPES, false)
-    unless str
-      lex_error(Issues::UNCLOSED_QUOTE, :after => format_quote(last), :followed_by => followed_by)
-    end
-
-    # Terminator may be a single char '"', '$', or two characters '${' group match 1 (scn[1]) from the last slurp holds this
-    terminator = scn[1]
-    [str[0..(-1 - terminator.length)], terminator]
-  end
-
-   # Copy from old lexer - can do much better
-   def slurp_uqstring
-     scn = @scanner
-     str = slurp(scn, @lexing_context[:uq_slurp_pattern], @lexing_context[:escapes], :ignore_invalid_escapes)
-
-     # Terminator may be a single char '$', two characters '${', or empty string '' at the end of intput.
-     # Group match 1 holds this.
-     # The exceptional case is found by looking at the subgroup 1 of the most recent match made by the scanner (i.e. @scanner[1]).
-     # This is the last match made by the slurp method (having called scan_until on the scanner).
-     # If there is a terminating character is must be stripped and returned separately.
-     #
-     terminator = scn[1]
-     [str[0..(-1 - terminator.length)], terminator]
-   end
-
-  # Slurps a string from the given scanner until the given pattern and then replaces any escaped
-  # characters given by escapes into their control-character equivalent or in case of line breaks, replaces the
-  # pattern \r?\n with an empty string.
-  # The returned string contains the terminating character. Returns nil if the scanner can not scan until the given
-  # pattern.
-  #
-  def slurp(scanner, pattern, escapes, ignore_invalid_escapes)
-    str = scanner.scan_until(pattern) || return
-
-    return str unless str.include?('\\')
-
-    return str.gsub!(/\\(\\|')/m, '\1') || str if escapes.equal?(SQ_ESCAPES)
-
-    # Process unicode escapes first as they require getting 4 hex digits
-    # If later a \u is found it is warned not to be a unicode escape
-    if escapes.include?('u')
-      # gsub must be repeated to cater for adjacent escapes
-      while(str.gsub!(/((?:[^\\]|^)(?:[\\]{2})*)\\u(?:([\da-fA-F]{4})|\{([\da-fA-F]{1,6})\})/m) { $1 + [($2 || $3).hex].pack("U") })
-        # empty block. Everything happens in the gsub block
-      end
-    end
-
-    begin
-    str.gsub!(/\\([^\r\n]|(?:\r?\n))/m) {
-      ch = $1
-      if escapes.include? ch
-        case ch
-        when 'r'   ; "\r"
-        when 'n'   ; "\n"
-        when 't'   ; "\t"
-        when 's'   ; ' '
-        when 'u'
-          lex_warning(Issues::ILLEGAL_UNICODE_ESCAPE)
-          "\\u"
-        when "\n"  ; ''
-        when "\r\n"; ''
-        else      ch
-        end
-      else
-        lex_warning(Issues::UNRECOGNIZED_ESCAPE, :ch => ch) unless ignore_invalid_escapes
-        "\\#{ch}"
-      end
-    }
-    rescue ArgumentError => e
-      # A invalid byte sequence may be the result of faulty input as well, but that could not possibly
-      # have reached this far... Unfortunately there is no more specific error and a match on message is
-      # required to differentiate from other internal problems.
-      if e.message =~ /invalid byte sequence/
-        lex_error(Issues::ILLEGAL_UNICODE_ESCAPE)
-      else
-        raise e
-      end
-    end
-    str
-  end
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/patterns.rb

@@ -1,60 +0,0 @@
-# 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 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 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{\A[[:blank:]]*([-+]?)[[:blank:]]*((0[xX][0-9A-Fa-f]+)|(0?\d+)((?:\.\d+)?(?:[eE]-?\d+)?))[[:blank:]]*\z}
-
-  # Special expression that tests if there is whitespace between sign and number. The expression is used
-  # to strip such whitespace when normal Float or Integer conversion fails.
-  WS_BETWEEN_SIGN_AND_NUMBER = %r{\A([+-])[[:blank:]]+(.*)\z}
-
-  # ILLEGAL_P3_1_HOSTNAME matches if a hostname contains illegal characters.
-  # This check does not prevent pathological names like 'a....b', '.....', "---". etc.
-  ILLEGAL_HOSTNAME_CHARS = %r{[^-\w.]}
-
-  # NAME matches a name the same way as the lexer.
-  NAME = %r{\A((::)?[a-z]\w*)(::[a-z]\w*)*\z}
-
-  # 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.
-  #
-  CLASSREF_EXT = %r{\A((::){0,1}[A-Z][\w]*)+\z}
-
-  # Same as CLASSREF_EXT but cannot start with '::'
-  #
-  CLASSREF_EXT_DECL = %r{\A[A-Z][\w]*(?:::[A-Z][\w]*)*\z}
-
-  # CLASSREF matches a class reference the way it is represented internally in the
-  # model (i.e. in lower case).
-  #
-  CLASSREF = %r{\A((::){0,1}[a-z][\w]*)+\z}
-
-  # Same as CLASSREF but cannot start with '::'
-  #
-  CLASSREF_DECL = %r{\A[a-z][\w]*(?:::[a-z][\w]*)*\z}
-
-  # DOLLAR_VAR matches a variable name including the initial $ character
-  DOLLAR_VAR     = %r{\$(::)?(\w+::)*\w+}
-
-  # VAR_NAME matches the name part of a variable (The $ character is not included)
-  # Note, that only the final segment may start with an underscore.
-  # Note, regexp sensitive to backtracking
-  VAR_NAME = %r{\A(?:::)?(?:[a-z]\w*::)*[a-z_]\w*\z}
-
-  # PARAM_NAME matches the name part of a parameter (The $ character is not included)
-  PARAM_NAME = %r{\A[a-z_]\w*\z}
-
-  # A Numeric var name must be the decimal number 0, or a decimal number not starting with 0
-  NUMERIC_VAR_NAME = %r{\A(?:0|(?:[1-9][0-9]*))\z}
-
-end

data/vendored/puppet/lib/puppet/pops/pcore.rb

@@ -1,147 +0,0 @@
-require 'uri'
-
-module Puppet::Pops
-module Pcore
-  include Types::PuppetObject
-
-  TYPE_URI_RX = Types::TypeFactory.regexp(URI.regexp)
-  TYPE_URI = Types::TypeFactory.pattern(TYPE_URI_RX)
-  TYPE_URI_ALIAS = Types::PTypeAliasType.new('Pcore::URI', nil, TYPE_URI)
-  TYPE_SIMPLE_TYPE_NAME = Types::TypeFactory.pattern(/\A[A-Z]\w*\z/)
-  TYPE_QUALIFIED_REFERENCE = Types::TypeFactory.pattern(/\A[A-Z][\w]*(?:::[A-Z][\w]*)*\z/)
-  TYPE_MEMBER_NAME = Types::PPatternType.new([Types::PRegexpType.new(Patterns::PARAM_NAME)])
-
-  KEY_PCORE_URI = 'pcore_uri'.freeze
-  KEY_PCORE_VERSION = 'pcore_version'.freeze
-
-  PCORE_URI = 'http://puppet.com/2016.1/pcore'
-  PCORE_VERSION = SemanticPuppet::Version.new(1,0,0)
-  PARSABLE_PCORE_VERSIONS = SemanticPuppet::VersionRange.parse('1.x')
-
-  RUNTIME_NAME_AUTHORITY = 'http://puppet.com/2016.1/runtime'
-
-  def self._pcore_type
-    @type
-  end
-
-  def self.annotate(instance, annotations_hash)
-    annotations_hash.each_pair do |type, init_hash|
-      type.implementation_class.annotate(instance) { init_hash }
-    end
-    instance
-  end
-
-  def self.init_env(loader)
-    if Puppet[:tasks]
-      add_object_type('Task', <<-PUPPET, loader)
-        {
-          attributes => {   
-            # Fully qualified name of the task
-            name => { type => Pattern[/\\A[a-z][a-z0-9_]*(?:::[a-z][a-z0-9_]*)*\\z/] },
-
-            # Full path to executable
-            executable => { type => String },
-
-            # Task description
-            description => { type => Optional[String], value => undef },
-
-            # Puppet Task version
-            puppet_task_version => { type => Integer, value => 1 },
-  
-            # Type, description, and sensitive property of each parameter 
-            parameters => {
-              type => Optional[Hash[
-                Pattern[/\\A[a-z][a-z0-9_]*\\z/],
-                Struct[
-                  Optional[description] => String,
-                  Optional[sensitive] => Boolean,
-                  type => Type]]],
-              value => undef
-            },
-
-             # Type, description, and sensitive property of each output 
-            output => {
-              type => Optional[Hash[
-                Pattern[/\\A[a-z][a-z0-9_]*\\z/],
-                Struct[
-                  Optional[description] => String,
-                  Optional[sensitive] => Boolean,
-                  type => Type]]],
-              value => undef
-            },
- 
-            supports_noop => { type => Boolean, value => false },
-            input_method => { type => String, value => 'both' },
-          }
-        }
-      PUPPET
-    end
-  end
-
-  def self.init(loader, ir)
-    add_alias('Pcore::URI_RX', TYPE_URI_RX, loader)
-    add_type(TYPE_URI_ALIAS, loader)
-    add_alias('Pcore::SimpleTypeName', TYPE_SIMPLE_TYPE_NAME, loader)
-    add_alias('Pcore::MemberName', TYPE_MEMBER_NAME, loader)
-    add_alias('Pcore::TypeName', TYPE_QUALIFIED_REFERENCE, loader)
-    add_alias('Pcore::QRef', TYPE_QUALIFIED_REFERENCE, loader)
-    Types::TypedModelObject.register_ptypes(loader, ir)
-
-    @type = create_object_type(loader, ir, Pcore, 'Pcore', nil)
-
-    ir.register_implementation_namespace('Pcore', 'Puppet::Pops::Pcore')
-    ir.register_implementation_namespace('Puppet::AST', 'Puppet::Pops::Model')
-    ir.register_implementation('Puppet::AST::Locator', 'Puppet::Pops::Parser::Locator::Locator19')
-    Resource.register_ptypes(loader, ir)
-    Lookup::Context.register_ptype(loader, ir);
-    Lookup::DataProvider.register_types(loader)
-  end
-
-  # Create and register a new `Object` type in the Puppet Type System and map it to an implementation class
-  #
-  # @param loader [Loader::Loader] The loader where the new type will be registered
-  # @param ir [ImplementationRegistry] The implementation registry that maps this class to the new type
-  # @param impl_class [Class] The class that is the implementation of the type
-  # @param type_name [String] The fully qualified name of the new type
-  # @param parent_name [String,nil] The fully qualified name of the parent type
-  # @param attributes_hash [Hash{String => Object}] A hash of attribute definitions for the new type
-  # @param functions_hash [Hash{String => Object}] A hash of function definitions for the new type
-  # @param equality [Array<String>] An array with names of attributes that participate in equality comparison
-  # @return [PObjectType] the created type. Not yet resolved
-  #
-  # @api private
-  def self.create_object_type(loader, ir, impl_class, type_name, parent_name, attributes_hash = EMPTY_HASH, functions_hash = EMPTY_HASH, equality = nil)
-    init_hash = {}
-    init_hash[Types::KEY_PARENT] = Types::PTypeReferenceType.new(parent_name) unless parent_name.nil?
-    init_hash[Types::KEY_ATTRIBUTES] = attributes_hash unless attributes_hash.empty?
-    init_hash[Types::KEY_FUNCTIONS] = functions_hash unless functions_hash.empty?
-    init_hash[Types::KEY_EQUALITY] = equality unless equality.nil?
-    ir.register_implementation(type_name, impl_class)
-    add_type(Types::PObjectType.new(type_name, init_hash), loader)
-  end
-
-  def self.add_object_type(name, body, loader)
-    add_type(Types::PObjectType.new(name, Parser::EvaluatingParser.new.parse_string(body).body), loader)
-  end
-
-  def self.add_alias(name, type, loader, name_authority = RUNTIME_NAME_AUTHORITY)
-    add_type(Types::PTypeAliasType.new(name, nil, type), loader, name_authority)
-  end
-
-  def self.add_type(type, loader, name_authority = RUNTIME_NAME_AUTHORITY)
-    loader.set_entry(Loader::TypedName.new(:type, type.name, name_authority), type)
-    type
-  end
-
-  def self.register_implementations(impls, name_authority = RUNTIME_NAME_AUTHORITY)
-    Loaders.loaders.register_implementations(impls, name_authority)
-  end
-
-  def self.register_aliases(aliases, name_authority = RUNTIME_NAME_AUTHORITY, loader = Loaders.loaders.private_environment_loader)
-    aliases.each do |name, type_string|
-      add_type(Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(type_string), nil), loader, name_authority)
-    end
-    aliases.each_key.map { |name| loader.load(:type, name).resolve(loader) }
-  end
-end
-end

data/vendored/puppet/lib/puppet/pops/pn.rb

@@ -1,236 +0,0 @@
-module Puppet::Pops
-module PN
-  KEY_PATTERN = /^[A-Za-z_-][0-9A-Za-z_-]*$/
-
-  def pnError(message)
-    raise ArgumentError, message
-  end
-
-  def as_call(name)
-    Call.new(name, self)
-  end
-
-  def as_parameters
-    [self]
-  end
-
-  def ==(o)
-    eql?(o)
-  end
-
-  def to_s
-    s = ''
-    format(nil, s)
-    s
-  end
-
-  def with_name(name)
-    Entry.new(name, self)
-  end
-
-  def double_quote(str, bld)
-    bld << '"'
-    str.each_codepoint do |codepoint|
-      case codepoint
-      when 0x09
-        bld << '\\t'
-      when 0x0a
-        bld << '\\n'
-      when 0x0d
-        bld << '\\r'
-      when 0x22
-        bld << '\\"'
-      when 0x5c
-        bld << '\\\\'
-      else
-        if codepoint < 0x20
-          bld << sprintf('\\o%3.3o', codepoint)
-        elsif codepoint <= 0x7f
-          bld << codepoint
-        else
-          bld << [codepoint].pack('U')
-        end
-      end
-    end
-    bld << '"'
-  end
-
-  def format_elements(elements, indent, b)
-    elements.each_with_index do |e, i|
-      if indent
-        b << "\n" << indent.current
-      elsif i > 0
-        b << ' '
-      end
-      e.format(indent, b)
-    end
-  end
-
-  class Indent
-    attr_reader :current
-    def initialize(indent = '  ', current = '')
-      @indent = indent
-      @current = current
-    end
-
-    def increase
-      Indent.new(@indent, @current + @indent)
-    end
-  end
-
-  class Call
-    include PN
-    attr_reader :name, :elements
-
-    def initialize(name, *elements)
-      @name = name
-      @elements = elements
-    end
-
-    def [](idx)
-      @elements[idx]
-    end
-
-    def as_call(name)
-      Call.new(name, *@elements)
-    end
-
-    def as_parameters
-      List.new(@elements)
-    end
-
-    def eql?(o)
-      o.is_a?(Call) && @name == o.name && @elements == o.elements
-    end
-
-    def format(indent, b)
-      b << '(' << @name
-      if @elements.size > 0
-        b << ' ' unless indent
-        format_elements(@elements, indent ? indent.increase : nil, b)
-      end
-      b << ')'
-    end
-
-    def to_data
-      { '^' => [@name] + @elements.map { |e| e.to_data } }
-    end
-  end
-
-  class Entry
-    attr_reader :key, :value
-    def initialize(key, value)
-      @key = key
-      @value = value
-    end
-
-    def eql?(o)
-      o.is_a?(Entry) && @key == o.key && @value == o.value
-    end
-
-    alias == eql?
-  end
-
-  class List
-    include PN
-    attr_reader :elements
-
-    def initialize(elements)
-      @elements = elements
-    end
-
-    def [](idx)
-      @elements[idx]
-    end
-
-    def as_call(name)
-      Call.new(name, *@elements)
-    end
-
-    def as_parameters
-      @elements
-    end
-
-    def eql?(o)
-      o.is_a?(List) && @elements == o.elements
-    end
-
-    def format(indent, b)
-      b << '['
-      format_elements(@elements, indent ? indent.increase : nil, b) unless @elements.empty?
-      b << ']'
-    end
-
-    def to_data
-      @elements.map { |e| e.to_data }
-    end
-  end
-
-  class Literal
-    include PN
-    attr_reader :value
-
-    def initialize(value)
-      @value = value
-    end
-
-    def format(indent, b)
-      if @value.nil?
-        b << 'nil'
-      elsif value.is_a?(String)
-        double_quote(value, b)
-      else
-        b << value.to_s
-      end
-    end
-
-    def eql?(o)
-      o.is_a?(Literal) && @value == o.value
-    end
-
-    def to_data
-      @value
-    end
-  end
-
-  class Map
-    include PN
-    attr_reader :entries
-
-    def initialize(entries)
-      entries.each { |e| pnError("key #{e.key} does not conform to pattern /#{KEY_PATTERN.source}/)") unless e.key =~ KEY_PATTERN }
-      @entries = entries
-    end
-
-    def eql?(o)
-      o.is_a?(Map) && @entries == o.entries
-    end
-
-    def format(indent, b)
-      local_indent = indent ? indent.increase : nil
-      b << '{'
-      @entries.each_with_index do |e,i|
-        if indent
-          b << "\n" << local_indent.current
-        elsif i > 0
-          b << ' '
-        end
-        b << ':' << e.key
-        b << ' '
-        e.value.format(local_indent, b)
-      end
-      b << '}'
-    end
-
-    def to_data
-      r = []
-      @entries.each { |e| r << e.key << e.value.to_data }
-      { '#' => r }
-    end
-  end
-end
-end
-
-require_relative 'model/pn_transformer'
-require_relative 'parser/pn_parser'
-