plaid 14.10.0 → 14.11.0

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.4/lib/rexml/parsers/pullparser.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: false
-require 'forwardable'
-
-require_relative '../parseexception'
-require_relative 'baseparser'
-require_relative '../xmltokens'
-
-module REXML
-  module Parsers
-    # = Using the Pull Parser
-    # <em>This API is experimental, and subject to change.</em>
-    #  parser = PullParser.new( "<a>text<b att='val'/>txet</a>" )
-    #  while parser.has_next?
-    #    res = parser.next
-    #    puts res[1]['att'] if res.start_tag? and res[0] == 'b'
-    #  end
-    # See the PullEvent class for information on the content of the results.
-    # The data is identical to the arguments passed for the various events to
-    # the StreamListener API.
-    #
-    # Notice that:
-    #  parser = PullParser.new( "<a>BAD DOCUMENT" )
-    #  while parser.has_next?
-    #    res = parser.next
-    #    raise res[1] if res.error?
-    #  end
-    #
-    # Nat Price gave me some good ideas for the API.
-    class PullParser
-      include XMLTokens
-      extend Forwardable
-
-      def_delegators( :@parser, :has_next? )
-      def_delegators( :@parser, :entity )
-      def_delegators( :@parser, :empty? )
-      def_delegators( :@parser, :source )
-
-      def initialize stream
-        @entities = {}
-        @listeners = nil
-        @parser = BaseParser.new( stream )
-        @my_stack = []
-      end
-
-      def add_listener( listener )
-        @listeners = [] unless @listeners
-        @listeners << listener
-      end
-
-      def each
-        while has_next?
-          yield self.pull
-        end
-      end
-
-      def peek depth=0
-        if @my_stack.length <= depth
-          (depth - @my_stack.length + 1).times {
-            e = PullEvent.new(@parser.pull)
-            @my_stack.push(e)
-          }
-        end
-        @my_stack[depth]
-      end
-
-      def pull
-        return @my_stack.shift if @my_stack.length > 0
-
-        event = @parser.pull
-        case event[0]
-        when :entitydecl
-          @entities[ event[1] ] =
-            event[2] unless event[2] =~ /PUBLIC|SYSTEM/
-        when :text
-          unnormalized = @parser.unnormalize( event[1], @entities )
-          event << unnormalized
-        end
-        PullEvent.new( event )
-      end
-
-      def unshift token
-        @my_stack.unshift token
-      end
-    end
-
-    # A parsing event.  The contents of the event are accessed as an +Array?,
-    # and the type is given either by the ...? methods, or by accessing the
-    # +type+ accessor.  The contents of this object vary from event to event,
-    # but are identical to the arguments passed to +StreamListener+s for each
-    # event.
-    class PullEvent
-      # The type of this event.  Will be one of :tag_start, :tag_end, :text,
-      # :processing_instruction, :comment, :doctype, :attlistdecl, :entitydecl,
-      # :notationdecl, :entity, :cdata, :xmldecl, or :error.
-      def initialize(arg)
-        @contents = arg
-      end
-
-      def []( start, endd=nil)
-        if start.kind_of? Range
-          @contents.slice( start.begin+1 .. start.end )
-        elsif start.kind_of? Numeric
-          if endd.nil?
-            @contents.slice( start+1 )
-          else
-            @contents.slice( start+1, endd )
-          end
-        else
-          raise "Illegal argument #{start.inspect} (#{start.class})"
-        end
-      end
-
-      def event_type
-        @contents[0]
-      end
-
-      # Content: [ String tag_name, Hash attributes ]
-      def start_element?
-        @contents[0] == :start_element
-      end
-
-      # Content: [ String tag_name ]
-      def end_element?
-        @contents[0] == :end_element
-      end
-
-      # Content: [ String raw_text, String unnormalized_text ]
-      def text?
-        @contents[0] == :text
-      end
-
-      # Content: [ String text ]
-      def instruction?
-        @contents[0] == :processing_instruction
-      end
-
-      # Content: [ String text ]
-      def comment?
-        @contents[0] == :comment
-      end
-
-      # Content: [ String name, String pub_sys, String long_name, String uri ]
-      def doctype?
-        @contents[0] == :start_doctype
-      end
-
-      # Content: [ String text ]
-      def attlistdecl?
-        @contents[0] == :attlistdecl
-      end
-
-      # Content: [ String text ]
-      def elementdecl?
-        @contents[0] == :elementdecl
-      end
-
-      # Due to the wonders of DTDs, an entity declaration can be just about
-      # anything.  There's no way to normalize it; you'll have to interpret the
-      # content yourself.  However, the following is true:
-      #
-      # * If the entity declaration is an internal entity:
-      #   [ String name, String value ]
-      # Content: [ String text ]
-      def entitydecl?
-        @contents[0] == :entitydecl
-      end
-
-      # Content: [ String text ]
-      def notationdecl?
-        @contents[0] == :notationdecl
-      end
-
-      # Content: [ String text ]
-      def entity?
-        @contents[0] == :entity
-      end
-
-      # Content: [ String text ]
-      def cdata?
-        @contents[0] == :cdata
-      end
-
-      # Content: [ String version, String encoding, String standalone ]
-      def xmldecl?
-        @contents[0] == :xmldecl
-      end
-
-      def error?
-        @contents[0] == :error
-      end
-
-      def inspect
-        @contents[0].to_s + ": " + @contents[1..-1].inspect
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.4/lib/rexml/parsers/sax2parser.rb

@@ -1,273 +0,0 @@
-# frozen_string_literal: false
-require_relative 'baseparser'
-require_relative '../parseexception'
-require_relative '../namespace'
-require_relative '../text'
-
-module REXML
-  module Parsers
-    # SAX2Parser
-    class SAX2Parser
-      def initialize source
-        @parser = BaseParser.new(source)
-        @listeners = []
-        @procs = []
-        @namespace_stack = []
-        @has_listeners = false
-        @tag_stack = []
-        @entities = {}
-      end
-
-      def source
-        @parser.source
-      end
-
-      def add_listener( listener )
-        @parser.add_listener( listener )
-      end
-
-      # Listen arguments:
-      #
-      # Symbol, Array, Block
-      #         Listen to Symbol events on Array elements
-      # Symbol, Block
-      #   Listen to Symbol events
-      # Array, Listener
-      #         Listen to all events on Array elements
-      # Array, Block
-      #         Listen to :start_element events on Array elements
-      # Listener
-      #         Listen to All events
-      #
-      # Symbol can be one of: :start_element, :end_element,
-      # :start_prefix_mapping, :end_prefix_mapping, :characters,
-      # :processing_instruction, :doctype, :attlistdecl, :elementdecl,
-      # :entitydecl, :notationdecl, :cdata, :xmldecl, :comment
-      #
-      # There is an additional symbol that can be listened for: :progress.
-      # This will be called for every event generated, passing in the current
-      # stream position.
-      #
-      # Array contains regular expressions or strings which will be matched
-      # against fully qualified element names.
-      #
-      # Listener must implement the methods in SAX2Listener
-      #
-      # Block will be passed the same arguments as a SAX2Listener method would
-      # be, where the method name is the same as the matched Symbol.
-      # See the SAX2Listener for more information.
-      def listen( *args, &blok )
-        if args[0].kind_of? Symbol
-          if args.size == 2
-            args[1].each { |match| @procs << [args[0], match, blok] }
-          else
-            add( [args[0], nil, blok] )
-          end
-        elsif args[0].kind_of? Array
-          if args.size == 2
-            args[0].each { |match| add( [nil, match, args[1]] ) }
-          else
-            args[0].each { |match| add( [ :start_element, match, blok ] ) }
-          end
-        else
-          add([nil, nil, args[0]])
-        end
-      end
-
-      def deafen( listener=nil, &blok )
-        if listener
-          @listeners.delete_if {|item| item[-1] == listener }
-          @has_listeners = false if @listeners.size == 0
-        else
-          @procs.delete_if {|item| item[-1] == blok }
-        end
-      end
-
-      def parse
-        @procs.each { |sym,match,block| block.call if sym == :start_document }
-        @listeners.each { |sym,match,block|
-          block.start_document if sym == :start_document or sym.nil?
-        }
-        context = []
-        while true
-          event = @parser.pull
-          case event[0]
-          when :end_document
-            handle( :end_document )
-            break
-          when :start_doctype
-            handle( :doctype, *event[1..-1])
-          when :end_doctype
-            context = context[1]
-          when :start_element
-            @tag_stack.push(event[1])
-            # find the observers for namespaces
-            procs = get_procs( :start_prefix_mapping, event[1] )
-            listeners = get_listeners( :start_prefix_mapping, event[1] )
-            if procs or listeners
-              # break out the namespace declarations
-              # The attributes live in event[2]
-              event[2].each {|n, v| event[2][n] = @parser.normalize(v)}
-              nsdecl = event[2].find_all { |n, value| n =~ /^xmlns(:|$)/ }
-              nsdecl.collect! { |n, value| [ n[6..-1], value ] }
-              @namespace_stack.push({})
-              nsdecl.each do |n,v|
-                @namespace_stack[-1][n] = v
-                # notify observers of namespaces
-                procs.each { |ob| ob.call( n, v ) } if procs
-                listeners.each { |ob| ob.start_prefix_mapping(n, v) } if listeners
-              end
-            end
-            event[1] =~ Namespace::NAMESPLIT
-            prefix = $1
-            local = $2
-            uri = get_namespace(prefix)
-            # find the observers for start_element
-            procs = get_procs( :start_element, event[1] )
-            listeners = get_listeners( :start_element, event[1] )
-            # notify observers
-            procs.each { |ob| ob.call( uri, local, event[1], event[2] ) } if procs
-            listeners.each { |ob|
-              ob.start_element( uri, local, event[1], event[2] )
-            } if listeners
-          when :end_element
-            @tag_stack.pop
-            event[1] =~ Namespace::NAMESPLIT
-            prefix = $1
-            local = $2
-            uri = get_namespace(prefix)
-            # find the observers for start_element
-            procs = get_procs( :end_element, event[1] )
-            listeners = get_listeners( :end_element, event[1] )
-            # notify observers
-            procs.each { |ob| ob.call( uri, local, event[1] ) } if procs
-            listeners.each { |ob|
-              ob.end_element( uri, local, event[1] )
-            } if listeners
-
-            namespace_mapping = @namespace_stack.pop
-            # find the observers for namespaces
-            procs = get_procs( :end_prefix_mapping, event[1] )
-            listeners = get_listeners( :end_prefix_mapping, event[1] )
-            if procs or listeners
-              namespace_mapping.each do |ns_prefix, ns_uri|
-                # notify observers of namespaces
-                procs.each { |ob| ob.call( ns_prefix ) } if procs
-                listeners.each { |ob| ob.end_prefix_mapping(ns_prefix) } if listeners
-              end
-            end
-          when :text
-            #normalized = @parser.normalize( event[1] )
-            #handle( :characters, normalized )
-            copy = event[1].clone
-
-            esub = proc { |match|
-              if @entities.has_key?($1)
-                @entities[$1].gsub(Text::REFERENCE, &esub)
-              else
-                match
-              end
-            }
-
-            copy.gsub!( Text::REFERENCE, &esub )
-            copy.gsub!( Text::NUMERICENTITY ) {|m|
-              m=$1
-              m = "0#{m}" if m[0] == ?x
-              [Integer(m)].pack('U*')
-            }
-            handle( :characters, copy )
-          when :entitydecl
-            handle_entitydecl( event )
-          when :processing_instruction, :comment, :attlistdecl,
-            :elementdecl, :cdata, :notationdecl, :xmldecl
-            handle( *event )
-          end
-          handle( :progress, @parser.position )
-        end
-      end
-
-      private
-      def handle( symbol, *arguments )
-        tag = @tag_stack[-1]
-        procs = get_procs( symbol, tag )
-        listeners = get_listeners( symbol, tag )
-        # notify observers
-        procs.each { |ob| ob.call( *arguments ) } if procs
-        listeners.each { |l|
-          l.send( symbol.to_s, *arguments )
-        } if listeners
-      end
-
-      def handle_entitydecl( event )
-        @entities[ event[1] ] = event[2] if event.size == 3
-        parameter_reference_p = false
-        case event[2]
-        when "SYSTEM"
-          if event.size == 5
-            if event.last == "%"
-              parameter_reference_p = true
-            else
-              event[4, 0] = "NDATA"
-            end
-          end
-        when "PUBLIC"
-          if event.size == 6
-            if event.last == "%"
-              parameter_reference_p = true
-            else
-              event[5, 0] = "NDATA"
-            end
-          end
-        else
-          parameter_reference_p = (event.size == 4)
-        end
-        event[1, 0] = event.pop if parameter_reference_p
-        handle( event[0], event[1..-1] )
-      end
-
-      # The following methods are duplicates, but it is faster than using
-      # a helper
-      def get_procs( symbol, name )
-        return nil if @procs.size == 0
-        @procs.find_all do |sym, match, block|
-          (
-            (sym.nil? or symbol == sym) and
-            ((name.nil? and match.nil?) or match.nil? or (
-              (name == match) or
-              (match.kind_of? Regexp and name =~ match)
-              )
-            )
-          )
-        end.collect{|x| x[-1]}
-      end
-      def get_listeners( symbol, name )
-        return nil if @listeners.size == 0
-        @listeners.find_all do |sym, match, block|
-          (
-            (sym.nil? or symbol == sym) and
-            ((name.nil? and match.nil?) or match.nil? or (
-              (name == match) or
-              (match.kind_of? Regexp and name =~ match)
-              )
-            )
-          )
-        end.collect{|x| x[-1]}
-      end
-
-      def add( pair )
-        if pair[-1].respond_to? :call
-          @procs << pair unless @procs.include? pair
-        else
-          @listeners << pair unless @listeners.include? pair
-          @has_listeners = true
-        end
-      end
-
-      def get_namespace( prefix )
-        uris = (@namespace_stack.find_all { |ns| not ns[prefix].nil? }) ||
-          (@namespace_stack.find { |ns| not ns[nil].nil? })
-        uris[-1][prefix] unless uris.nil? or 0 == uris.size
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.4/lib/rexml/parsers/streamparser.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: false
-require_relative "baseparser"
-
-module REXML
-  module Parsers
-    class StreamParser
-      def initialize source, listener
-        @listener = listener
-        @parser = BaseParser.new( source )
-        @tag_stack = []
-      end
-
-      def add_listener( listener )
-        @parser.add_listener( listener )
-      end
-
-      def parse
-        # entity string
-        while true
-          event = @parser.pull
-          case event[0]
-          when :end_document
-            unless @tag_stack.empty?
-              tag_path = "/" + @tag_stack.join("/")
-              raise ParseException.new("Missing end tag for '#{tag_path}'",
-                                       @parser.source)
-            end
-            return
-          when :start_element
-            @tag_stack << event[1]
-            attrs = event[2].each do |n, v|
-              event[2][n] = @parser.unnormalize( v )
-            end
-            @listener.tag_start( event[1], attrs )
-          when :end_element
-            @listener.tag_end( event[1] )
-            @tag_stack.pop
-          when :text
-            normalized = @parser.unnormalize( event[1] )
-            @listener.text( normalized )
-          when :processing_instruction
-            @listener.instruction( *event[1,2] )
-          when :start_doctype
-            @listener.doctype( *event[1..-1] )
-          when :end_doctype
-            # FIXME: remove this condition for milestone:3.2
-            @listener.doctype_end if @listener.respond_to? :doctype_end
-          when :comment, :attlistdecl, :cdata, :xmldecl, :elementdecl
-            @listener.send( event[0].to_s, *event[1..-1] )
-          when :entitydecl, :notationdecl
-            @listener.send( event[0].to_s, event[1..-1] )
-          when :externalentity
-            entity_reference = event[1]
-            content = entity_reference.gsub(/\A%|;\z/, "")
-            @listener.entity(content)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.4/lib/rexml/parsers/treeparser.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: false
-require_relative '../validation/validationexception'
-require_relative '../undefinednamespaceexception'
-
-module REXML
-  module Parsers
-    class TreeParser
-      def initialize( source, build_context = Document.new )
-        @build_context = build_context
-        @parser = Parsers::BaseParser.new( source )
-      end
-
-      def add_listener( listener )
-        @parser.add_listener( listener )
-      end
-
-      def parse
-        tag_stack = []
-        in_doctype = false
-        entities = nil
-        begin
-          while true
-            event = @parser.pull
-            #STDERR.puts "TREEPARSER GOT #{event.inspect}"
-            case event[0]
-            when :end_document
-              unless tag_stack.empty?
-                raise ParseException.new("No close tag for #{@build_context.xpath}",
-                                         @parser.source, @parser)
-              end
-              return
-            when :start_element
-              tag_stack.push(event[1])
-              el = @build_context = @build_context.add_element( event[1] )
-              event[2].each do |key, value|
-                el.attributes[key]=Attribute.new(key,value,self)
-              end
-            when :end_element
-              tag_stack.pop
-              @build_context = @build_context.parent
-            when :text
-              if not in_doctype
-                if @build_context[-1].instance_of? Text
-                  @build_context[-1] << event[1]
-                else
-                  @build_context.add(
-                    Text.new(event[1], @build_context.whitespace, nil, true)
-                  ) unless (
-                    @build_context.ignore_whitespace_nodes and
-                    event[1].strip.size==0
-                  )
-                end
-              end
-            when :comment
-              c = Comment.new( event[1] )
-              @build_context.add( c )
-            when :cdata
-              c = CData.new( event[1] )
-              @build_context.add( c )
-            when :processing_instruction
-              @build_context.add( Instruction.new( event[1], event[2] ) )
-            when :end_doctype
-              in_doctype = false
-              entities.each { |k,v| entities[k] = @build_context.entities[k].value }
-              @build_context = @build_context.parent
-            when :start_doctype
-              doctype = DocType.new( event[1..-1], @build_context )
-              @build_context = doctype
-              entities = {}
-              in_doctype = true
-            when :attlistdecl
-              n = AttlistDecl.new( event[1..-1] )
-              @build_context.add( n )
-            when :externalentity
-              n = ExternalEntity.new( event[1] )
-              @build_context.add( n )
-            when :elementdecl
-              n = ElementDecl.new( event[1] )
-              @build_context.add(n)
-            when :entitydecl
-              entities[ event[1] ] = event[2] unless event[2] =~ /PUBLIC|SYSTEM/
-              @build_context.add(Entity.new(event))
-            when :notationdecl
-              n = NotationDecl.new( *event[1..-1] )
-              @build_context.add( n )
-            when :xmldecl
-              x = XMLDecl.new( event[1], event[2], event[3] )
-              @build_context.add( x )
-            end
-          end
-        rescue REXML::Validation::ValidationException
-          raise
-        rescue REXML::ParseException
-          raise
-        rescue
-          raise ParseException.new( $!.message, @parser.source, @parser, $! )
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.4/lib/rexml/parsers/ultralightparser.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: false
-require_relative 'streamparser'
-require_relative 'baseparser'
-
-module REXML
-  module Parsers
-    class UltraLightParser
-      def initialize stream
-        @stream = stream
-        @parser = REXML::Parsers::BaseParser.new( stream )
-      end
-
-      def add_listener( listener )
-        @parser.add_listener( listener )
-      end
-
-      def rewind
-        @stream.rewind
-        @parser.stream = @stream
-      end
-
-      def parse
-        root = context = []
-        while true
-          event = @parser.pull
-          case event[0]
-          when :end_document
-            break
-          when :end_doctype
-            context = context[1]
-          when :start_element, :start_doctype
-            context << event
-            event[1,0] = [context]
-            context = event
-          when :end_element
-            context = context[1]
-          else
-            context << event
-          end
-        end
-        root
-      end
-    end
-
-    # An element is an array.  The array contains:
-    #  0                        The parent element
-    #  1                        The tag name
-    #  2                        A hash of attributes
-    #  3..-1    The child elements
-    # An element is an array of size > 3
-    # Text is a String
-    # PIs are [ :processing_instruction, target, data ]
-    # Comments are [ :comment, data ]
-    # DocTypes are DocType structs
-    # The root is an array with XMLDecls, Text, DocType, Array, Text
-  end
-end