cloudsmith-api 2.0.7 → 2.0.8

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.6/lib/rexml/attribute.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+require_relative "namespace"
+require_relative 'text'
+
+module REXML
+  # Defines an Element Attribute; IE, a attribute=value pair, as in:
+  # <element attribute="value"/>.  Attributes can be in their own
+  # namespaces.  General users of REXML will not interact with the
+  # Attribute class much.
+  class Attribute
+    include Node
+    include Namespace
+
+    # The element to which this attribute belongs
+    attr_reader :element
+    PATTERN = /\s*(#{NAME_STR})\s*=\s*(["'])(.*?)\2/um
+
+    NEEDS_A_SECOND_CHECK = /(<|&((#{Entity::NAME});|(#0*((?:\d+)|(?:x[a-fA-F0-9]+)));)?)/um
+
+    # Constructor.
+    # FIXME: The parser doesn't catch illegal characters in attributes
+    #
+    # first::
+    #   Either: an Attribute, which this new attribute will become a
+    #   clone of; or a String, which is the name of this attribute
+    # second::
+    #   If +first+ is an Attribute, then this may be an Element, or nil.
+    #   If nil, then the Element parent of this attribute is the parent
+    #   of the +first+ Attribute.  If the first argument is a String,
+    #   then this must also be a String, and is the content of the attribute.
+    #   If this is the content, it must be fully normalized (contain no
+    #   illegal characters).
+    # parent::
+    #   Ignored unless +first+ is a String; otherwise, may be the Element
+    #   parent of this attribute, or nil.
+    #
+    #
+    #  Attribute.new( attribute_to_clone )
+    #  Attribute.new( attribute_to_clone, parent_element )
+    #  Attribute.new( "attr", "attr_value" )
+    #  Attribute.new( "attr", "attr_value", parent_element )
+    def initialize( first, second=nil, parent=nil )
+      @normalized = @unnormalized = @element = nil
+      if first.kind_of? Attribute
+        self.name = first.expanded_name
+        @unnormalized = first.value
+        if second.kind_of? Element
+          @element = second
+        else
+          @element = first.element
+        end
+      elsif first.kind_of? String
+        @element = parent
+        self.name = first
+        @normalized = second.to_s
+      else
+        raise "illegal argument #{first.class.name} to Attribute constructor"
+      end
+    end
+
+    # Returns the namespace of the attribute.
+    #
+    #  e = Element.new( "elns:myelement" )
+    #  e.add_attribute( "nsa:a", "aval" )
+    #  e.add_attribute( "b", "bval" )
+    #  e.attributes.get_attribute( "a" ).prefix   # -> "nsa"
+    #  e.attributes.get_attribute( "b" ).prefix   # -> ""
+    #  a = Attribute.new( "x", "y" )
+    #  a.prefix                                   # -> ""
+    def prefix
+      super
+    end
+
+    # Returns the namespace URL, if defined, or nil otherwise
+    #
+    #  e = Element.new("el")
+    #  e.add_namespace("ns", "http://url")
+    #  e.add_attribute("ns:a", "b")
+    #  e.add_attribute("nsx:a", "c")
+    #  e.attribute("ns:a").namespace # => "http://url"
+    #  e.attribute("nsx:a").namespace # => nil
+    #
+    # This method always returns "" for no namespace attribute. Because
+    # the default namespace doesn't apply to attribute names.
+    #
+    # From https://www.w3.org/TR/xml-names/#uniqAttrs
+    #
+    # > the default namespace does not apply to attribute names
+    #
+    #  e = REXML::Element.new("el")
+    #  e.add_namespace("", "http://example.com/")
+    #  e.namespace # => "http://example.com/"
+    #  e.add_attribute("a", "b")
+    #  e.attribute("a").namespace # => ""
+    def namespace arg=nil
+      arg = prefix if arg.nil?
+      if arg == ""
+        ""
+      else
+        @element.namespace(arg)
+      end
+    end
+
+    # Returns true if other is an Attribute and has the same name and value,
+    # false otherwise.
+    def ==( other )
+      other.kind_of?(Attribute) and other.name==name and other.value==value
+    end
+
+    # Creates (and returns) a hash from both the name and value
+    def hash
+      name.hash + value.hash
+    end
+
+    # Returns this attribute out as XML source, expanding the name
+    #
+    #  a = Attribute.new( "x", "y" )
+    #  a.to_string     # -> "x='y'"
+    #  b = Attribute.new( "ns:x", "y" )
+    #  b.to_string     # -> "ns:x='y'"
+    def to_string
+      value = to_s
+      if @element and @element.context and @element.context[:attribute_quote] == :quote
+        value = value.gsub('"', '&quot;') if value.include?('"')
+        %Q^#@expanded_name="#{value}"^
+      else
+        value = value.gsub("'", '&apos;') if value.include?("'")
+        "#@expanded_name='#{value}'"
+      end
+    end
+
+    def doctype
+      if @element
+        doc = @element.document
+        doc.doctype if doc
+      end
+    end
+
+    # Returns the attribute value, with entities replaced
+    def to_s
+      return @normalized if @normalized
+
+      @normalized = Text::normalize( @unnormalized, doctype )
+      @normalized
+    end
+
+    # Returns the UNNORMALIZED value of this attribute.  That is, entities
+    # have been expanded to their values
+    def value
+      return @unnormalized if @unnormalized
+      @unnormalized = Text::unnormalize( @normalized, doctype )
+      @unnormalized
+    end
+
+    # The normalized value of this attribute.  That is, the attribute with
+    # entities intact.
+    def normalized=(new_normalized)
+      @normalized = new_normalized
+      @unnormalized = nil
+    end
+
+    # Returns a copy of this attribute
+    def clone
+      Attribute.new self
+    end
+
+    # Sets the element of which this object is an attribute.  Normally, this
+    # is not directly called.
+    #
+    # Returns this attribute
+    def element=( element )
+      @element = element
+
+      if @normalized
+        Text.check( @normalized, NEEDS_A_SECOND_CHECK, doctype )
+      end
+
+      self
+    end
+
+    # Removes this Attribute from the tree, and returns true if successful
+    #
+    # This method is usually not called directly.
+    def remove
+      @element.attributes.delete self.name unless @element.nil?
+    end
+
+    # Writes this attribute (EG, puts 'key="value"' to the output)
+    def write( output, indent=-1 )
+      output << to_string
+    end
+
+    def node_type
+      :attribute
+    end
+
+    def inspect
+      rv = +""
+      write( rv )
+      rv
+    end
+
+    def xpath
+      path = @element.xpath
+      path += "/@#{self.expanded_name}"
+      return path
+    end
+  end
+end
+#vim:ts=2 sw=2 noexpandtab:

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.6/lib/rexml/document.rb

@@ -0,0 +1,451 @@
+# frozen_string_literal: false
+require_relative "security"
+require_relative "element"
+require_relative "xmldecl"
+require_relative "source"
+require_relative "comment"
+require_relative "doctype"
+require_relative "instruction"
+require_relative "rexml"
+require_relative "parseexception"
+require_relative "output"
+require_relative "parsers/baseparser"
+require_relative "parsers/streamparser"
+require_relative "parsers/treeparser"
+
+module REXML
+  # Represents an XML document.
+  #
+  # A document may have:
+  #
+  # - A single child that may be accessed via method #root.
+  # - An XML declaration.
+  # - A document type.
+  # - Processing instructions.
+  #
+  # == 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],
+  # and in particular, the
+  # {tasks page for documents}[../doc/rexml/tasks/tocs/document_toc_rdoc.html].
+  #
+  class Document < Element
+    # A convenient default XML declaration. Use:
+    #
+    #   mydoc << XMLDecl.default
+    #
+    DECLARATION = XMLDecl.default
+
+    # :call-seq:
+    #   new(string = nil, context = {}) -> new_document
+    #   new(io_stream = nil, context = {}) -> new_document
+    #   new(document = nil, context = {}) -> new_document
+    #
+    # Returns a new \REXML::Document object.
+    #
+    # When no arguments are given,
+    # returns an empty document:
+    #
+    #   d = REXML::Document.new
+    #   d.to_s # => ""
+    #
+    # When argument +string+ is given, it must be a string
+    # containing a valid XML document:
+    #
+    #   xml_string = '<root><foo>Foo</foo><bar>Bar</bar></root>'
+    #   d = REXML::Document.new(xml_string)
+    #   d.to_s # => "<root><foo>Foo</foo><bar>Bar</bar></root>"
+    #
+    # When argument +io_stream+ is given, it must be an \IO object
+    # that is opened for reading, and when read must return a valid XML document:
+    #
+    #   File.write('t.xml', xml_string)
+    #   d = File.open('t.xml', 'r') do |io|
+    #     REXML::Document.new(io)
+    #   end
+    #   d.to_s # => "<root><foo>Foo</foo><bar>Bar</bar></root>"
+    #
+    # When argument +document+ is given, it must be an existing
+    # document object, whose context and attributes (but not children)
+    # are cloned into the new document:
+    #
+    #   d = REXML::Document.new(xml_string)
+    #   d.children    # => [<root> ... </>]
+    #   d.context = {raw: :all, compress_whitespace: :all}
+    #   d.add_attributes({'bar' => 0, 'baz' => 1})
+    #   d1 = REXML::Document.new(d)
+    #   d1.children   # => []
+    #   d1.context    # => {:raw=>:all, :compress_whitespace=>:all}
+    #   d1.attributes # => {"bar"=>bar='0', "baz"=>baz='1'}
+    #
+    # When argument +context+ is given, it must be a hash
+    # containing context entries for the document;
+    # see {Element Context}[../doc/rexml/context_rdoc.html]:
+    #
+    #   context = {raw: :all, compress_whitespace: :all}
+    #   d = REXML::Document.new(xml_string, context)
+    #   d.context # => {:raw=>:all, :compress_whitespace=>:all}
+    #
+    def initialize( source = nil, context = {} )
+      @entity_expansion_count = 0
+      super()
+      @context = context
+      return if source.nil?
+      if source.kind_of? Document
+        @context = source.context
+        super source
+      else
+        build(  source )
+      end
+    end
+
+    # :call-seq:
+    #   node_type -> :document
+    #
+    # Returns the symbol +:document+.
+    #
+    def node_type
+      :document
+    end
+
+    # :call-seq:
+    #   clone -> new_document
+    #
+    # Returns the new document resulting from executing
+    # <tt>Document.new(self)</tt>.  See Document.new.
+    #
+    def clone
+      Document.new self
+    end
+
+    # :call-seq:
+    #   expanded_name -> empty_string
+    #
+    # Returns an empty string.
+    #
+    def expanded_name
+      ''
+      #d = doc_type
+      #d ? d.name : "UNDEFINED"
+    end
+    alias :name :expanded_name
+
+    # :call-seq:
+    #   add(xml_decl) -> self
+    #   add(doc_type) -> self
+    #   add(object) -> self
+    #
+    # Adds an object to the document; returns +self+.
+    #
+    # When argument +xml_decl+ is given,
+    # it must be an REXML::XMLDecl object,
+    # which becomes the XML declaration for the document,
+    # replacing the previous XML declaration if any:
+    #
+    #   d = REXML::Document.new
+    #   d.xml_decl.to_s # => ""
+    #   d.add(REXML::XMLDecl.new('2.0'))
+    #   d.xml_decl.to_s # => "<?xml version='2.0'?>"
+    #
+    # When argument +doc_type+ is given,
+    # it must be an REXML::DocType object,
+    # which becomes the document type for the document,
+    # replacing the previous document type, if any:
+    #
+    #   d = REXML::Document.new
+    #   d.doctype.to_s # => ""
+    #   d.add(REXML::DocType.new('foo'))
+    #   d.doctype.to_s # => "<!DOCTYPE foo>"
+    #
+    # When argument +object+ (not an REXML::XMLDecl or REXML::DocType object)
+    # is given it is added as the last child:
+    #
+    #   d = REXML::Document.new
+    #   d.add(REXML::Element.new('foo'))
+    #   d.to_s # => "<foo/>"
+    #
+    def add( child )
+      if child.kind_of? XMLDecl
+        if @children[0].kind_of? XMLDecl
+          @children[0] = child
+        else
+          @children.unshift child
+        end
+        child.parent = self
+      elsif child.kind_of? DocType
+        # Find first Element or DocType node and insert the decl right
+        # before it.  If there is no such node, just insert the child at the
+        # end.  If there is a child and it is an DocType, then replace it.
+        insert_before_index = @children.find_index { |x|
+          x.kind_of?(Element) || x.kind_of?(DocType)
+        }
+        if insert_before_index # Not null = not end of list
+          if @children[ insert_before_index ].kind_of? DocType
+            @children[ insert_before_index ] = child
+          else
+            @children[ insert_before_index-1, 0 ] = child
+          end
+        else  # Insert at end of list
+          @children << child
+        end
+        child.parent = self
+      else
+        rv = super
+        raise "attempted adding second root element to document" if @elements.size > 1
+        rv
+      end
+    end
+    alias :<< :add
+
+    # :call-seq:
+    #   add_element(name_or_element = nil, attributes = nil) -> new_element
+    #
+    # Adds an element to the document by calling REXML::Element.add_element:
+    #
+    #   REXML::Element.add_element(name_or_element, attributes)
+    def add_element(arg=nil, arg2=nil)
+      rv = super
+      raise "attempted adding second root element to document" if @elements.size > 1
+      rv
+    end
+
+    # :call-seq:
+    #   root -> root_element or nil
+    #
+    # Returns the root element of the document, if it exists, otherwise +nil+:
+    #
+    #   d = REXML::Document.new('<root></root>')
+    #   d.root # => <root/>
+    #   d = REXML::Document.new('')
+    #   d.root # => nil
+    #
+    def root
+      elements[1]
+      #self
+      #@children.find { |item| item.kind_of? Element }
+    end
+
+    # :call-seq:
+    #   doctype -> doc_type or nil
+    #
+    # Returns the DocType object for the document, if it exists, otherwise +nil+:
+    #
+    #   d = REXML::Document.new('<!DOCTYPE document SYSTEM "subjects.dtd">')
+    #   d.doctype.class # => REXML::DocType
+    #   d = REXML::Document.new('')
+    #   d.doctype.class # => nil
+    #
+    def doctype
+      @children.find { |item| item.kind_of? DocType }
+    end
+
+    # :call-seq:
+    #   xml_decl -> xml_decl
+    #
+    # Returns the XMLDecl object for the document, if it exists,
+    # otherwise the default XMLDecl object:
+    #
+    #   d = REXML::Document.new('<?xml version="1.0" encoding="UTF-8"?>')
+    #   d.xml_decl.class # => REXML::XMLDecl
+    #   d.xml_decl.to_s  # => "<?xml version='1.0' encoding='UTF-8'?>"
+    #   d = REXML::Document.new('')
+    #   d.xml_decl.class # => REXML::XMLDecl
+    #   d.xml_decl.to_s  # => ""
+    #
+    def xml_decl
+      rv = @children[0]
+      return rv if rv.kind_of? XMLDecl
+      @children.unshift(XMLDecl.default)[0]
+    end
+
+    # :call-seq:
+    #   version -> version_string
+    #
+    # Returns the XMLDecl version of this document as a string,
+    # if it has been set, otherwise the default version:
+    #
+    #   d = REXML::Document.new('<?xml version="2.0" encoding="UTF-8"?>')
+    #   d.version # => "2.0"
+    #   d = REXML::Document.new('')
+    #   d.version # => "1.0"
+    #
+    def version
+      xml_decl().version
+    end
+
+    # :call-seq:
+    #   encoding -> encoding_string
+    #
+    # Returns the XMLDecl encoding of the document,
+    # if it has been set, otherwise the default encoding:
+    #
+    #   d = REXML::Document.new('<?xml version="1.0" encoding="UTF-16"?>')
+    #   d.encoding # => "UTF-16"
+    #   d = REXML::Document.new('')
+    #   d.encoding # => "UTF-8"
+    #
+    def encoding
+      xml_decl().encoding
+    end
+
+    # :call-seq:
+    #   stand_alone?
+    #
+    # Returns the XMLDecl standalone value of the document as a string,
+    # if it has been set, otherwise the default standalone value:
+    #
+    #   d = REXML::Document.new('<?xml standalone="yes"?>')
+    #   d.stand_alone? # => "yes"
+    #   d = REXML::Document.new('')
+    #   d.stand_alone? # => nil
+    #
+    def stand_alone?
+      xml_decl().stand_alone?
+    end
+
+    # :call-seq:
+    #    doc.write(output=$stdout, indent=-1, transtive=false, ie_hack=false, encoding=nil)
+    #    doc.write(options={:output => $stdout, :indent => -1, :transtive => false, :ie_hack => false, :encoding => nil})
+    #
+    # Write the XML tree out, optionally with indent.  This writes out the
+    # entire XML document, including XML declarations, doctype declarations,
+    # and processing instructions (if any are given).
+    #
+    # A controversial point is whether Document should always write the XML
+    # declaration (<?xml version='1.0'?>) whether or not one is given by the
+    # user (or source document).  REXML does not write one if one was not
+    # specified, because it adds unnecessary bandwidth to applications such
+    # as XML-RPC.
+    #
+    # Accept Nth argument style and options Hash style as argument.
+    # The recommended style is options Hash style for one or more
+    # arguments case.
+    #
+    # _Examples_
+    #   Document.new("<a><b/></a>").write
+    #
+    #   output = ""
+    #   Document.new("<a><b/></a>").write(output)
+    #
+    #   output = ""
+    #   Document.new("<a><b/></a>").write(:output => output, :indent => 2)
+    #
+    # See also the classes in the rexml/formatters package for the proper way
+    # to change the default formatting of XML output.
+    #
+    # _Examples_
+    #
+    #   output = ""
+    #   tr = Transitive.new
+    #   tr.write(Document.new("<a><b/></a>"), output)
+    #
+    # output::
+    #   output an object which supports '<< string'; this is where the
+    #   document will be written.
+    # indent::
+    #   An integer.  If -1, no indenting will be used; otherwise, the
+    #   indentation will be twice this number of spaces, and children will be
+    #   indented an additional amount.  For a value of 3, every item will be
+    #   indented 3 more levels, or 6 more spaces (2 * 3). Defaults to -1
+    # transitive::
+    #   If transitive is true and indent is >= 0, then the output will be
+    #   pretty-printed in such a way that the added whitespace does not affect
+    #   the absolute *value* of the document -- that is, it leaves the value
+    #   and number of Text nodes in the document unchanged.
+    # ie_hack::
+    #   This hack inserts a space before the /> on empty tags to address
+    #   a limitation of Internet Explorer.  Defaults to false
+    # encoding::
+    #   Encoding name as String. Change output encoding to specified encoding
+    #   instead of encoding in XML declaration.
+    #   Defaults to nil. It means encoding in XML declaration is used.
+    def write(*arguments)
+      if arguments.size == 1 and arguments[0].class == Hash
+        options = arguments[0]
+
+        output     = options[:output]
+        indent     = options[:indent]
+        transitive = options[:transitive]
+        ie_hack    = options[:ie_hack]
+        encoding   = options[:encoding]
+      else
+        output, indent, transitive, ie_hack, encoding, = *arguments
+      end
+
+      output   ||= $stdout
+      indent   ||= -1
+      transitive = false if transitive.nil?
+      ie_hack    = false if ie_hack.nil?
+      encoding ||= xml_decl.encoding
+
+      if encoding != 'UTF-8' && !output.kind_of?(Output)
+        output = Output.new( output, encoding )
+      end
+      formatter = if indent > -1
+          if transitive
+            require_relative "formatters/transitive"
+            REXML::Formatters::Transitive.new( indent, ie_hack )
+          else
+            REXML::Formatters::Pretty.new( indent, ie_hack )
+          end
+        else
+          REXML::Formatters::Default.new( ie_hack )
+        end
+      formatter.write( self, output )
+    end
+
+
+    def Document::parse_stream( source, listener )
+      Parsers::StreamParser.new( source, listener ).parse
+    end
+
+    # Set the entity expansion limit. By default the limit is set to 10000.
+    #
+    # Deprecated. Use REXML::Security.entity_expansion_limit= instead.
+    def Document::entity_expansion_limit=( val )
+      Security.entity_expansion_limit = val
+    end
+
+    # Get the entity expansion limit. By default the limit is set to 10000.
+    #
+    # Deprecated. Use REXML::Security.entity_expansion_limit= instead.
+    def Document::entity_expansion_limit
+      return Security.entity_expansion_limit
+    end
+
+    # Set the entity expansion limit. By default the limit is set to 10240.
+    #
+    # Deprecated. Use REXML::Security.entity_expansion_text_limit= instead.
+    def Document::entity_expansion_text_limit=( val )
+      Security.entity_expansion_text_limit = val
+    end
+
+    # Get the entity expansion limit. By default the limit is set to 10240.
+    #
+    # Deprecated. Use REXML::Security.entity_expansion_text_limit instead.
+    def Document::entity_expansion_text_limit
+      return Security.entity_expansion_text_limit
+    end
+
+    attr_reader :entity_expansion_count
+
+    def record_entity_expansion
+      @entity_expansion_count += 1
+      if @entity_expansion_count > Security.entity_expansion_limit
+        raise "number of entity expansions exceeded, processing aborted."
+      end
+    end
+
+    def document
+      self
+    end
+
+    private
+    def build( source )
+      Parsers::TreeParser.new( source, self ).parse
+    end
+  end
+end