iron_admin 0.4.1 → 0.6.0

data/vendor/bundle/ruby/3.2.0/gems/rexml-3.4.4/lib/rexml/xmldecl.rb

@@ -0,0 +1,130 @@
+# 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/3.2.0/gems/rexml-3.4.4/lib/rexml/xmltokens.rb

@@ -0,0 +1,85 @@
+# 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/3.2.0/gems/rexml-3.4.4/lib/rexml/xpath.rb

@@ -0,0 +1,70 @@
+# 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)
+      match(element, path, namespaces, variables, options).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)
+      match(element, path, namespaces, variables, options).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
+      parser.parse(path,element)
+    end
+  end
+end