cloudsmith-api 2.0.13 → 2.0.14

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

@@ -0,0 +1,209 @@
+# 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 entity_expansion_count
+        @parser.entity_expansion_count
+      end
+
+      def entity_expansion_limit=( limit )
+        @parser.entity_expansion_limit = limit
+      end
+
+      def entity_expansion_text_limit=( limit )
+        @parser.entity_expansion_text_limit = limit
+      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.3.8/lib/rexml/parsers/sax2parser.rb

@@ -0,0 +1,270 @@
+# 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 entity_expansion_count
+        @parser.entity_expansion_count
+      end
+
+      def entity_expansion_limit=( limit )
+        @parser.entity_expansion_limit = limit
+      end
+
+      def entity_expansion_text_limit=( limit )
+        @parser.entity_expansion_text_limit = limit
+      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
+            unnormalized = @parser.unnormalize( event[1], @entities )
+            handle( :characters, unnormalized )
+          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 )
+        return nil if @namespace_stack.empty?
+
+        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.3.8/lib/rexml/parsers/streamparser.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: false
+require_relative "baseparser"
+
+module REXML
+  module Parsers
+    class StreamParser
+      def initialize source, listener
+        @listener = listener
+        @parser = BaseParser.new( source )
+        @entities = {}
+      end
+
+      def add_listener( listener )
+        @parser.add_listener( listener )
+      end
+
+      def entity_expansion_count
+        @parser.entity_expansion_count
+      end
+
+      def entity_expansion_limit=( limit )
+        @parser.entity_expansion_limit = limit
+      end
+
+      def entity_expansion_text_limit=( limit )
+        @parser.entity_expansion_text_limit = limit
+      end
+
+      def parse
+        # entity string
+        while true
+          event = @parser.pull
+          case event[0]
+          when :end_document
+            return
+          when :start_element
+            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] )
+          when :text
+            unnormalized = @parser.unnormalize( event[1], @entities )
+            @listener.text( unnormalized )
+          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
+            @entities[ event[1] ] = event[2] if event.size == 3
+            @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.3.8/lib/rexml/parsers/treeparser.rb

@@ -0,0 +1,89 @@
+# 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
+        entities = nil
+        begin
+          while true
+            event = @parser.pull
+            #STDERR.puts "TREEPARSER GOT #{event.inspect}"
+            case event[0]
+            when :end_document
+              return
+            when :start_element
+              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
+              @build_context = @build_context.parent
+            when :text
+              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
+            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
+              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 = {}
+            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.3.8/lib/rexml/rexml.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: false
+#
+# \Module \REXML provides classes and methods for parsing,
+# editing, and generating XML.
+#
+# == Implementation
+#
+# \REXML:
+# - Is pure Ruby.
+# - Provides tree, stream, SAX2, pull, and lightweight APIs.
+# - Conforms to {XML version 1.0}[https://www.w3.org/TR/REC-xml/].
+# - Fully implements {XPath version 1.0}[http://www.w3c.org/tr/xpath].
+# - Is {non-validating}[https://www.w3.org/TR/xml/].
+# - Passes 100% of the non-validating {Oasis tests}[http://www.oasis-open.org/committees/xml-conformance/xml-test-suite.shtml].
+#
+# == In a Hurry?
+#
+# If you're somewhat familiar with XML
+# and have a particular task in mind,
+# you may want to see {the tasks pages}[doc/rexml/tasks/tocs/master_toc_rdoc.html].
+#
+# == API
+#
+# Among the most important classes for using \REXML are:
+# - REXML::Document.
+# - REXML::Element.
+#
+# There's also an {REXML tutorial}[doc/rexml/tutorial_rdoc.html].
+#
+module REXML
+  COPYRIGHT = "Copyright © 2001-2008 Sean Russell <ser@germane-software.com>"
+  DATE = "2008/019"
+  VERSION = "3.3.8"
+  REVISION = ""
+
+  Copyright = COPYRIGHT
+  Version = VERSION
+end