zine_brewer 1.3.0 → 1.3.1

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

@@ -1,144 +0,0 @@
-# frozen_string_literal: false
-require_relative 'validationexception'
-
-module REXML
-  module Validation
-    module Validator
-      NILEVENT = [ nil ]
-      def reset
-        @current = @root
-        @root.reset
-        @root.previous = true
-        @attr_stack = []
-        self
-      end
-      def dump
-        puts @root.inspect
-      end
-      def validate( event )
-        @attr_stack = [] unless defined? @attr_stack
-        match = @current.next(event)
-        raise ValidationException.new( "Validation error.  Expected: "+
-          @current.expected.join( " or " )+" from #{@current.inspect} "+
-          " but got #{Event.new( event[0], event[1] ).inspect}" ) unless match
-        @current = match
-
-        # Check for attributes
-        case event[0]
-        when :start_element
-          @attr_stack << event[2]
-          begin
-            sattr = [:start_attribute, nil]
-            eattr = [:end_attribute]
-            text = [:text, nil]
-            k, = event[2].find { |key,value|
-              sattr[1] = key
-              m = @current.next( sattr )
-              if m
-                # If the state has text children...
-                if m.matches?( eattr )
-                  @current = m
-                else
-                  text[1] = value
-                  m = m.next( text )
-                  text[1] = nil
-                  return false unless m
-                  @current = m if m
-                end
-                m = @current.next( eattr )
-                if m
-                  @current = m
-                  true
-                else
-                  false
-                end
-              else
-                false
-              end
-            }
-            event[2].delete(k) if k
-          end while k
-        when :end_element
-          attrs = @attr_stack.pop
-          raise ValidationException.new( "Validation error.  Illegal "+
-            " attributes: #{attrs.inspect}") if attrs.length > 0
-        end
-      end
-    end
-
-    class Event
-      def initialize(event_type, event_arg=nil )
-        @event_type = event_type
-        @event_arg = event_arg
-      end
-
-      attr_reader :event_type
-      attr_accessor :event_arg
-
-      def done?
-        @done
-      end
-
-      def single?
-        return (@event_type != :start_element and @event_type != :start_attribute)
-      end
-
-      def matches?( event )
-        return false unless event[0] == @event_type
-        case event[0]
-        when nil
-          return true
-        when :start_element
-          return true if event[1] == @event_arg
-        when :end_element
-          return true
-        when :start_attribute
-          return true if event[1] == @event_arg
-        when :end_attribute
-          return true
-        when :end_document
-          return true
-        when :text
-          return (@event_arg.nil? or @event_arg == event[1])
-=begin
-        when :processing_instruction
-          false
-        when :xmldecl
-          false
-        when :start_doctype
-          false
-        when :end_doctype
-          false
-        when :externalentity
-          false
-        when :elementdecl
-          false
-        when :entity
-          false
-        when :attlistdecl
-          false
-        when :notationdecl
-          false
-        when :end_doctype
-          false
-=end
-        else
-          false
-        end
-      end
-
-      def ==( other )
-        return false unless other.kind_of? Event
-        @event_type == other.event_type and @event_arg == other.event_arg
-      end
-
-      def to_s
-        inspect
-      end
-
-      def inspect
-        "#{@event_type.inspect}( #@event_arg )"
-      end
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-# frozen_string_literal: false
-module REXML
-  module Validation
-    class ValidationException < RuntimeError
-      def initialize msg
-        super
-      end
-    end
-  end
-end

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

@@ -1,130 +0,0 @@
-# frozen_string_literal: false
-
-require_relative 'encoding'
-require_relative 'source'
-
-module REXML
-  # NEEDS DOCUMENTATION
-  class XMLDecl < Child
-    include Encoding
-
-    DEFAULT_VERSION = "1.0"
-    DEFAULT_ENCODING = "UTF-8"
-    DEFAULT_STANDALONE = "no"
-    START = "<?xml"
-    STOP = "?>"
-
-    attr_accessor :version, :standalone
-    attr_reader :writeencoding, :writethis
-
-    def initialize(version=DEFAULT_VERSION, encoding=nil, standalone=nil)
-      @writethis = true
-      @writeencoding = !encoding.nil?
-      if version.kind_of? XMLDecl
-        super()
-        @version = version.version
-        self.encoding = version.encoding
-        @writeencoding = version.writeencoding
-        @standalone = version.standalone
-        @writethis = version.writethis
-      else
-        super()
-        @version = version
-        self.encoding = encoding
-        @standalone = standalone
-      end
-      @version = DEFAULT_VERSION if @version.nil?
-    end
-
-    def clone
-      XMLDecl.new(self)
-    end
-
-    # indent::
-    #   Ignored.  There must be no whitespace before an XML declaration
-    # transitive::
-    #   Ignored
-    # ie_hack::
-    #   Ignored
-    def write(writer, indent=-1, transitive=false, ie_hack=false)
-      return nil unless @writethis or writer.kind_of? Output
-      writer << START
-      writer << " #{content encoding}"
-      writer << STOP
-    end
-
-    def ==( other )
-      other.kind_of?(XMLDecl) and
-      other.version == @version and
-      other.encoding == self.encoding and
-      other.standalone == @standalone
-    end
-
-    def xmldecl version, encoding, standalone
-      @version = version
-      self.encoding = encoding
-      @standalone = standalone
-    end
-
-    def node_type
-      :xmldecl
-    end
-
-    alias :stand_alone? :standalone
-    alias :old_enc= :encoding=
-
-    def encoding=( enc )
-      if enc.nil?
-        self.old_enc = "UTF-8"
-        @writeencoding = false
-      else
-        self.old_enc = enc
-        @writeencoding = true
-      end
-      self.dowrite
-    end
-
-    # Only use this if you do not want the XML declaration to be written;
-    # this object is ignored by the XML writer.  Otherwise, instantiate your
-    # own XMLDecl and add it to the document.
-    #
-    # Note that XML 1.1 documents *must* include an XML declaration
-    def XMLDecl.default
-      rv = XMLDecl.new( "1.0" )
-      rv.nowrite
-      rv
-    end
-
-    def nowrite
-      @writethis = false
-    end
-
-    def dowrite
-      @writethis = true
-    end
-
-    def inspect
-      "#{START} ... #{STOP}"
-    end
-
-    private
-    def content(enc)
-      context = nil
-      context = parent.context if parent
-      if context and context[:prologue_quote] == :quote
-        quote = "\""
-      else
-        quote = "'"
-      end
-
-      rv = "version=#{quote}#{@version}#{quote}"
-      if @writeencoding or enc !~ /\Autf-8\z/i
-        rv << " encoding=#{quote}#{enc}#{quote}"
-      end
-      if @standalone
-        rv << " standalone=#{quote}#{@standalone}#{quote}"
-      end
-      rv
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-# frozen_string_literal: false
-module REXML
-  # Defines a number of tokens used for parsing XML.  Not for general
-  # consumption.
-  module XMLTokens
-    # From http://www.w3.org/TR/REC-xml/#sec-common-syn
-    #
-    #   [4] NameStartChar ::=
-    #         ":" |
-    #         [A-Z] |
-    #         "_" |
-    #         [a-z] |
-    #         [#xC0-#xD6] |
-    #         [#xD8-#xF6] |
-    #         [#xF8-#x2FF] |
-    #         [#x370-#x37D] |
-    #         [#x37F-#x1FFF] |
-    #         [#x200C-#x200D] |
-    #         [#x2070-#x218F] |
-    #         [#x2C00-#x2FEF] |
-    #         [#x3001-#xD7FF] |
-    #         [#xF900-#xFDCF] |
-    #         [#xFDF0-#xFFFD] |
-    #         [#x10000-#xEFFFF]
-    name_start_chars = [
-      ":",
-      "A-Z",
-      "_",
-      "a-z",
-      "\\u00C0-\\u00D6",
-      "\\u00D8-\\u00F6",
-      "\\u00F8-\\u02FF",
-      "\\u0370-\\u037D",
-      "\\u037F-\\u1FFF",
-      "\\u200C-\\u200D",
-      "\\u2070-\\u218F",
-      "\\u2C00-\\u2FEF",
-      "\\u3001-\\uD7FF",
-      "\\uF900-\\uFDCF",
-      "\\uFDF0-\\uFFFD",
-      "\\u{10000}-\\u{EFFFF}",
-    ]
-    # From http://www.w3.org/TR/REC-xml/#sec-common-syn
-    #
-    #   [4a] NameChar ::=
-    #      NameStartChar |
-    #      "-" |
-    #      "." |
-    #      [0-9] |
-    #      #xB7 |
-    #      [#x0300-#x036F] |
-    #      [#x203F-#x2040]
-    name_chars = name_start_chars + [
-      "\\-",
-      "\\.",
-      "0-9",
-      "\\u00B7",
-      "\\u0300-\\u036F",
-      "\\u203F-\\u2040",
-    ]
-    NAME_START_CHAR = "[#{name_start_chars.join('')}]"
-    NAME_CHAR = "[#{name_chars.join('')}]"
-    NAMECHAR = NAME_CHAR # deprecated. Use NAME_CHAR instead.
-
-    # From http://www.w3.org/TR/xml-names11/#NT-NCName
-    #
-    #   [6] NCNameStartChar ::= NameStartChar - ':'
-    ncname_start_chars = name_start_chars - [":"]
-    # From http://www.w3.org/TR/xml-names11/#NT-NCName
-    #
-    #   [5] NCNameChar ::= NameChar - ':'
-    ncname_chars = name_chars - [":"]
-    NCNAME_STR = "[#{ncname_start_chars.join('')}][#{ncname_chars.join('')}]*"
-    NAME_STR = "(?:#{NCNAME_STR}:)?#{NCNAME_STR}"
-
-    NAME = "(#{NAME_START_CHAR}#{NAME_CHAR}*)"
-    NMTOKEN = "(?:#{NAME_CHAR})+"
-    NMTOKENS = "#{NMTOKEN}(\\s+#{NMTOKEN})*"
-    REFERENCE = "(?:&#{NAME};|&#\\d+;|&#x[0-9a-fA-F]+;)"
-
-    #REFERENCE = "(?:#{ENTITYREF}|#{CHARREF})"
-    #ENTITYREF = "&#{NAME};"
-    #CHARREF = "&#\\d+;|&#x[0-9a-fA-F]+;"
-  end
-end

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

@@ -1,81 +0,0 @@
-# frozen_string_literal: false
-require_relative 'functions'
-require_relative 'xpath_parser'
-
-module REXML
-  # Wrapper class.  Use this class to access the XPath functions.
-  class XPath
-    include Functions
-    # A base Hash object, supposing to be used when initializing a
-    # default empty namespaces set, but is currently unused.
-    # TODO: either set the namespaces=EMPTY_HASH, or deprecate this.
-    EMPTY_HASH = {}
-
-    # Finds and returns the first node that matches the supplied xpath.
-    # element::
-    #   The context element
-    # path::
-    #   The xpath to search for.  If not supplied or nil, returns the first
-    #   node matching '*'.
-    # namespaces::
-    #   If supplied, a Hash which defines a namespace mapping.
-    # variables::
-    #   If supplied, a Hash which maps $variables in the query
-    #   to values. This can be used to avoid XPath injection attacks
-    #   or to automatically handle escaping string values.
-    #
-    #  XPath.first( node )
-    #  XPath.first( doc, "//b"} )
-    #  XPath.first( node, "a/x:b", { "x"=>"http://doofus" } )
-    #  XPath.first( node, '/book/publisher/text()=$publisher', {}, {"publisher"=>"O'Reilly"})
-    def XPath::first(element, path=nil, namespaces=nil, variables={}, options={})
-      raise "The namespaces argument, if supplied, must be a hash object." unless namespaces.nil? or namespaces.kind_of?(Hash)
-      raise "The variables argument, if supplied, must be a hash object." unless variables.kind_of?(Hash)
-      parser = XPathParser.new(**options)
-      parser.namespaces = namespaces
-      parser.variables = variables
-      path = "*" unless path
-      element = [element] unless element.kind_of? Array
-      parser.parse(path, element).flatten[0]
-    end
-
-    # Iterates over nodes that match the given path, calling the supplied
-    # block with the match.
-    # element::
-    #   The context element
-    # path::
-    #   The xpath to search for.  If not supplied or nil, defaults to '*'
-    # namespaces::
-    #   If supplied, a Hash which defines a namespace mapping
-    # variables::
-    #   If supplied, a Hash which maps $variables in the query
-    #   to values. This can be used to avoid XPath injection attacks
-    #   or to automatically handle escaping string values.
-    #
-    #  XPath.each( node ) { |el| ... }
-    #  XPath.each( node, '/*[@attr='v']' ) { |el| ... }
-    #  XPath.each( node, 'ancestor::x' ) { |el| ... }
-    #  XPath.each( node, '/book/publisher/text()=$publisher', {}, {"publisher"=>"O'Reilly"}) \
-    #    {|el| ... }
-    def XPath::each(element, path=nil, namespaces=nil, variables={}, options={}, &block)
-      raise "The namespaces argument, if supplied, must be a hash object." unless namespaces.nil? or namespaces.kind_of?(Hash)
-      raise "The variables argument, if supplied, must be a hash object." unless variables.kind_of?(Hash)
-      parser = XPathParser.new(**options)
-      parser.namespaces = namespaces
-      parser.variables = variables
-      path = "*" unless path
-      element = [element] unless element.kind_of? Array
-      parser.parse(path, element).each( &block )
-    end
-
-    # Returns an array of nodes matching a given XPath.
-    def XPath::match(element, path=nil, namespaces=nil, variables={}, options={})
-      parser = XPathParser.new(**options)
-      parser.namespaces = namespaces
-      parser.variables = variables
-      path = "*" unless path
-      element = [element] unless element.kind_of? Array
-      parser.parse(path,element)
-    end
-  end
-end