zine_brewer 1.5.0 → 1.8.0

data/vendor/bundle/ruby/2.7.0/gems/rexml-3.2.4/lib/rexml/attlistdecl.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: false
-#vim:ts=2 sw=2 noexpandtab:
-require_relative 'child'
-require_relative 'source'
-
-module REXML
-  # This class needs:
-  # * Documentation
-  # * Work!  Not all types of attlists are intelligently parsed, so we just
-  # spew back out what we get in.  This works, but it would be better if
-  # we formatted the output ourselves.
-  #
-  # AttlistDecls provide *just* enough support to allow namespace
-  # declarations.  If you need some sort of generalized support, or have an
-  # interesting idea about how to map the hideous, terrible design of DTD
-  # AttlistDecls onto an intuitive Ruby interface, let me know.  I'm desperate
-  # for anything to make DTDs more palateable.
-  class AttlistDecl < Child
-    include Enumerable
-
-    # What is this?  Got me.
-    attr_reader :element_name
-
-    # Create an AttlistDecl, pulling the information from a Source.  Notice
-    # that this isn't very convenient; to create an AttlistDecl, you basically
-    # have to format it yourself, and then have the initializer parse it.
-    # Sorry, but for the foreseeable future, DTD support in REXML is pretty
-    # weak on convenience.  Have I mentioned how much I hate DTDs?
-    def initialize(source)
-      super()
-      if (source.kind_of? Array)
-        @element_name, @pairs, @contents = *source
-      end
-    end
-
-    # Access the attlist attribute/value pairs.
-    #  value = attlist_decl[ attribute_name ]
-    def [](key)
-      @pairs[key]
-    end
-
-    # Whether an attlist declaration includes the given attribute definition
-    #  if attlist_decl.include? "xmlns:foobar"
-    def include?(key)
-      @pairs.keys.include? key
-    end
-
-    # Iterate over the key/value pairs:
-    #  attlist_decl.each { |attribute_name, attribute_value| ... }
-    def each(&block)
-      @pairs.each(&block)
-    end
-
-    # Write out exactly what we got in.
-    def write out, indent=-1
-      out << @contents
-    end
-
-    def node_type
-      :attlistdecl
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rexml-3.2.4/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.7.0/gems/rexml-3.2.4/lib/rexml/cdata.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: false
-require_relative "text"
-
-module REXML
-  class CData < Text
-    START = '<![CDATA['
-    STOP = ']]>'
-    ILLEGAL = /(\]\]>)/
-
-    #   Constructor.  CData is data between <![CDATA[ ... ]]>
-    #
-    # _Examples_
-    #  CData.new( source )
-    #  CData.new( "Here is some CDATA" )
-    #  CData.new( "Some unprocessed data", respect_whitespace_TF, parent_element )
-    def initialize( first, whitespace=true, parent=nil )
-      super( first, whitespace, parent, false, true, ILLEGAL )
-    end
-
-    # Make a copy of this object
-    #
-    # _Examples_
-    #  c = CData.new( "Some text" )
-    #  d = c.clone
-    #  d.to_s        # -> "Some text"
-    def clone
-      CData.new self
-    end
-
-    # Returns the content of this CData object
-    #
-    # _Examples_
-    #  c = CData.new( "Some text" )
-    #  c.to_s        # -> "Some text"
-    def to_s
-      @string
-    end
-
-    def value
-      @string
-    end
-
-    # == DEPRECATED
-    # See the rexml/formatters package
-    #
-    # Generates XML output of this object
-    #
-    # output::
-    #   Where to write the string.  Defaults to $stdout
-    # indent::
-    #   The amount to indent this node by
-    # transitive::
-    #   Ignored
-    # ie_hack::
-    #   Ignored
-    #
-    # _Examples_
-    #  c = CData.new( " Some text " )
-    #  c.write( $stdout )     #->  <![CDATA[ Some text ]]>
-    def write( output=$stdout, indent=-1, transitive=false, ie_hack=false )
-      Kernel.warn( "#{self.class.name}.write is deprecated", uplevel: 1)
-      indent( output, indent )
-      output << START
-      output << @string
-      output << STOP
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rexml-3.2.4/lib/rexml/child.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: false
-require_relative "node"
-
-module REXML
-  ##
-  # A Child object is something contained by a parent, and this class
-  # contains methods to support that.  Most user code will not use this
-  # class directly.
-  class Child
-    include Node
-    attr_reader :parent         # The Parent of this object
-
-    # Constructor.  Any inheritors of this class should call super to make
-    # sure this method is called.
-    # parent::
-    #   if supplied, the parent of this child will be set to the
-    #   supplied value, and self will be added to the parent
-    def initialize( parent = nil )
-      @parent = nil
-      # Declare @parent, but don't define it.  The next line sets the
-      # parent.
-      parent.add( self ) if parent
-    end
-
-    # Replaces this object with another object.  Basically, calls
-    # Parent.replace_child
-    #
-    # Returns:: self
-    def replace_with( child )
-      @parent.replace_child( self, child )
-      self
-    end
-
-    # Removes this child from the parent.
-    #
-    # Returns:: self
-    def remove
-      unless @parent.nil?
-        @parent.delete self
-      end
-      self
-    end
-
-    # Sets the parent of this child to the supplied argument.
-    #
-    # other::
-    #   Must be a Parent object.  If this object is the same object as the
-    #   existing parent of this child, no action is taken. Otherwise, this
-    #   child is removed from the current parent (if one exists), and is added
-    #   to the new parent.
-    # Returns:: The parent added
-    def parent=( other )
-      return @parent if @parent == other
-      @parent.delete self if defined? @parent and @parent
-      @parent = other
-    end
-
-    alias :next_sibling :next_sibling_node
-    alias :previous_sibling :previous_sibling_node
-
-    # Sets the next sibling of this child.  This can be used to insert a child
-    # after some other child.
-    #  a = Element.new("a")
-    #  b = a.add_element("b")
-    #  c = Element.new("c")
-    #  b.next_sibling = c
-    #  # => <a><b/><c/></a>
-    def next_sibling=( other )
-      parent.insert_after self, other
-    end
-
-    # Sets the previous sibling of this child.  This can be used to insert a
-    # child before some other child.
-    #  a = Element.new("a")
-    #  b = a.add_element("b")
-    #  c = Element.new("c")
-    #  b.previous_sibling = c
-    #  # => <a><b/><c/></a>
-    def previous_sibling=(other)
-      parent.insert_before self, other
-    end
-
-    # Returns:: the document this child belongs to, or nil if this child
-    # belongs to no document
-    def document
-      return parent.document unless parent.nil?
-      nil
-    end
-
-    # This doesn't yet handle encodings
-    def bytes
-      document.encoding
-
-      to_s
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rexml-3.2.4/lib/rexml/comment.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: false
-require_relative "child"
-
-module REXML
-  ##
-  # Represents an XML comment; that is, text between \<!-- ... -->
-  class Comment < Child
-    include Comparable
-    START = "<!--"
-    STOP = "-->"
-
-    # The content text
-
-    attr_accessor :string
-
-    ##
-    # Constructor.  The first argument can be one of three types:
-    # @param first If String, the contents of this comment are set to the
-    # argument.  If Comment, the argument is duplicated.  If
-    # Source, the argument is scanned for a comment.
-    # @param second If the first argument is a Source, this argument
-    # should be nil, not supplied, or a Parent to be set as the parent
-    # of this object
-    def initialize( first, second = nil )
-      super(second)
-      if first.kind_of? String
-        @string = first
-      elsif first.kind_of? Comment
-        @string = first.string
-      end
-    end
-
-    def clone
-      Comment.new self
-    end
-
-    # == DEPRECATED
-    # See REXML::Formatters
-    #
-    # output::
-    #    Where to write the string
-    # indent::
-    #    An integer.    If -1, no indenting will be used; otherwise, the
-    #    indentation will be this number of spaces, and children will be
-    #    indented an additional amount.
-    # transitive::
-    #    Ignored by this class. The contents of comments are never modified.
-    # ie_hack::
-    #    Needed for conformity to the child API, but not used by this class.
-    def write( output, indent=-1, transitive=false, ie_hack=false )
-      Kernel.warn("Comment.write is deprecated.  See REXML::Formatters", uplevel: 1)
-      indent( output, indent )
-      output << START
-      output << @string
-      output << STOP
-    end
-
-    alias :to_s :string
-
-    ##
-    # Compares this Comment to another; the contents of the comment are used
-    # in the comparison.
-    def <=>(other)
-      other.to_s <=> @string
-    end
-
-    ##
-    # Compares this Comment to another; the contents of the comment are used
-    # in the comparison.
-    def ==( other )
-      other.kind_of? Comment and
-      (other <=> self) == 0
-    end
-
-    def node_type
-      :comment
-    end
-  end
-end
-#vim:ts=2 sw=2 noexpandtab: