cloudsmith-api 2.0.6 → 2.0.8

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

@@ -1,205 +0,0 @@
-# frozen_string_literal: false
-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
-    # The normalized value of this attribute.  That is, the attribute with
-    # entities intact.
-    attr_writer :normalized
-    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
-      if @element and @element.context and @element.context[:attribute_quote] == :quote
-        %Q^#@expanded_name="#{to_s().gsub(/"/, '&quot;')}"^
-      else
-        "#@expanded_name='#{to_s().gsub(/'/, '&apos;')}'"
-      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 )
-      @unnormalized = nil
-      @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 )
-      @normalized = nil
-      @unnormalized
-    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.5/lib/rexml/document.rb

@@ -1,451 +0,0 @@
-# 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 chidren)
-    # 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