tdiary 5.2.1 → 5.2.2

data/vendor/bundle/ruby/3.1.0/gems/nokogiri-1.13.3-x86_64-linux/lib/nokogiri/xml/node_set.rb

@@ -1,364 +0,0 @@
-# frozen_string_literal: true
-
-module Nokogiri
-  module XML
-    ####
-    # A NodeSet contains a list of Nokogiri::XML::Node objects.  Typically
-    # a NodeSet is return as a result of searching a Document via
-    # Nokogiri::XML::Searchable#css or Nokogiri::XML::Searchable#xpath
-    class NodeSet
-      include Nokogiri::XML::Searchable
-      include Enumerable
-
-      # The Document this NodeSet is associated with
-      attr_accessor :document
-
-      alias_method :clone, :dup
-
-      # Create a NodeSet with +document+ defaulting to +list+
-      def initialize(document, list = [])
-        @document = document
-        document.decorate(self)
-        list.each { |x| self << x }
-        yield self if block_given?
-      end
-
-      ###
-      # Get the first element of the NodeSet.
-      def first(n = nil)
-        return self[0] unless n
-        list = []
-        [n, length].min.times { |i| list << self[i] }
-        list
-      end
-
-      ###
-      # Get the last element of the NodeSet.
-      def last
-        self[-1]
-      end
-
-      ###
-      # Is this NodeSet empty?
-      def empty?
-        length == 0
-      end
-
-      ###
-      # Returns the index of the first node in self that is == to +node+ or meets the given block. Returns nil if no match is found.
-      def index(node = nil)
-        if node
-          warn("given block not used") if block_given?
-          each_with_index { |member, j| return j if member == node }
-        elsif block_given?
-          each_with_index { |member, j| return j if yield(member) }
-        end
-        nil
-      end
-
-      ###
-      # Insert +datum+ before the first Node in this NodeSet
-      def before(datum)
-        first.before(datum)
-      end
-
-      ###
-      # Insert +datum+ after the last Node in this NodeSet
-      def after(datum)
-        last.after(datum)
-      end
-
-      alias_method :<<, :push
-      alias_method :remove, :unlink
-
-      ###
-      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
-      #
-      # Search this node set for CSS +rules+. +rules+ must be one or more CSS
-      # selectors. For example:
-      #
-      # For more information see Nokogiri::XML::Searchable#css
-      def css(*args)
-        rules, handler, ns, _ = extract_params(args)
-        paths = css_rules_to_xpath(rules, ns)
-
-        inject(NodeSet.new(document)) do |set, node|
-          set + xpath_internal(node, paths, handler, ns, nil)
-        end
-      end
-
-      ###
-      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
-      #
-      # Search this node set for XPath +paths+. +paths+ must be one or more XPath
-      # queries.
-      #
-      # For more information see Nokogiri::XML::Searchable#xpath
-      def xpath(*args)
-        paths, handler, ns, binds = extract_params(args)
-
-        inject(NodeSet.new(document)) do |set, node|
-          set + xpath_internal(node, paths, handler, ns, binds)
-        end
-      end
-
-      ###
-      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
-      #
-      # Search this object for +paths+, and return only the first
-      # result. +paths+ must be one or more XPath or CSS queries.
-      #
-      # See Searchable#search for more information.
-      #
-      # Or, if passed an integer, index into the NodeSet:
-      #
-      #   node_set.at(3) # same as node_set[3]
-      #
-      def at(*args)
-        if args.length == 1 && args.first.is_a?(Numeric)
-          return self[args.first]
-        end
-
-        super(*args)
-      end
-      alias_method :%, :at
-
-      ###
-      # Filter this list for nodes that match +expr+
-      def filter(expr)
-        find_all { |node| node.matches?(expr) }
-      end
-
-      ###
-      # Add the class attribute +name+ to all Node objects in the
-      # NodeSet.
-      #
-      # See Nokogiri::XML::Node#add_class for more information.
-      def add_class(name)
-        each do |el|
-          el.add_class(name)
-        end
-        self
-      end
-
-      ###
-      # Append the class attribute +name+ to all Node objects in the
-      # NodeSet.
-      #
-      # See Nokogiri::XML::Node#append_class for more information.
-      def append_class(name)
-        each do |el|
-          el.append_class(name)
-        end
-        self
-      end
-
-      ###
-      # Remove the class attribute +name+ from all Node objects in the
-      # NodeSet.
-      #
-      # See Nokogiri::XML::Node#remove_class for more information.
-      def remove_class(name = nil)
-        each do |el|
-          el.remove_class(name)
-        end
-        self
-      end
-
-      ###
-      # Set attributes on each Node in the NodeSet, or get an
-      # attribute from the first Node in the NodeSet.
-      #
-      # To get an attribute from the first Node in a NodeSet:
-      #
-      #   node_set.attr("href") # => "https://www.nokogiri.org"
-      #
-      # Note that an empty NodeSet will return nil when +#attr+ is called as a getter.
-      #
-      # To set an attribute on each node, +key+ can either be an
-      # attribute name, or a Hash of attribute names and values. When
-      # called as a setter, +#attr+ returns the NodeSet.
-      #
-      # If +key+ is an attribute name, then either +value+ or +block+
-      # must be passed.
-      #
-      # If +key+ is a Hash then attributes will be set for each
-      # key/value pair:
-      #
-      #   node_set.attr("href" => "https://www.nokogiri.org", "class" => "member")
-      #
-      # If +value+ is passed, it will be used as the attribute value
-      # for all nodes:
-      #
-      #   node_set.attr("href", "https://www.nokogiri.org")
-      #
-      # If +block+ is passed, it will be called on each Node object in
-      # the NodeSet and the return value used as the attribute value
-      # for that node:
-      #
-      #   node_set.attr("class") { |node| node.name }
-      #
-      def attr(key, value = nil, &block)
-        unless key.is_a?(Hash) || (key && (value || block))
-          return first ? first.attribute(key) : nil
-        end
-
-        hash = key.is_a?(Hash) ? key : { key => value }
-
-        hash.each do |k, v|
-          each do |node|
-            node[k] = v || yield(node)
-          end
-        end
-
-        self
-      end
-      alias_method :set, :attr
-      alias_method :attribute, :attr
-
-      ###
-      # Remove the attributed named +name+ from all Node objects in the NodeSet
-      def remove_attr(name)
-        each { |el| el.delete(name) }
-        self
-      end
-      alias_method :remove_attribute, :remove_attr
-
-      ###
-      # Iterate over each node, yielding  to +block+
-      def each
-        return to_enum unless block_given?
-
-        0.upto(length - 1) do |x|
-          yield self[x]
-        end
-        self
-      end
-
-      ###
-      # Get the inner text of all contained Node objects
-      #
-      # Note: This joins the text of all Node objects in the NodeSet:
-      #
-      #    doc = Nokogiri::XML('<xml><a><d>foo</d><d>bar</d></a></xml>')
-      #    doc.css('d').text # => "foobar"
-      #
-      # Instead, if you want to return the text of all nodes in the NodeSet:
-      #
-      #    doc.css('d').map(&:text) # => ["foo", "bar"]
-      #
-      # See Nokogiri::XML::Node#content for more information.
-      def inner_text
-        collect(&:inner_text).join("")
-      end
-      alias_method :text, :inner_text
-
-      ###
-      # Get the inner html of all contained Node objects
-      def inner_html(*args)
-        collect { |j| j.inner_html(*args) }.join("")
-      end
-
-      ###
-      # Wrap this NodeSet with +html+
-      def wrap(html)
-        map { |node| node.wrap(html) }
-      end
-
-      ###
-      # Convert this NodeSet to a string.
-      def to_s
-        map(&:to_s).join
-      end
-
-      ###
-      # Convert this NodeSet to HTML
-      def to_html(*args)
-        if Nokogiri.jruby?
-          options = args.first.is_a?(Hash) ? args.shift : {}
-          unless options[:save_with]
-            options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_HTML
-          end
-          args.insert(0, options)
-        end
-        map { |x| x.to_html(*args) }.join
-      end
-
-      ###
-      # Convert this NodeSet to XHTML
-      def to_xhtml(*args)
-        map { |x| x.to_xhtml(*args) }.join
-      end
-
-      ###
-      # Convert this NodeSet to XML
-      def to_xml(*args)
-        map { |x| x.to_xml(*args) }.join
-      end
-
-      alias_method :size, :length
-      alias_method :to_ary, :to_a
-
-      ###
-      # Removes the last element from set and returns it, or +nil+ if
-      # the set is empty
-      def pop
-        return nil if length == 0
-        delete(last)
-      end
-
-      ###
-      # Returns the first element of the NodeSet and removes it.  Returns
-      # +nil+ if the set is empty.
-      def shift
-        return nil if length == 0
-        delete(first)
-      end
-
-      ###
-      # Equality -- Two NodeSets are equal if the contain the same number
-      # of elements and if each element is equal to the corresponding
-      # element in the other NodeSet
-      def ==(other)
-        return false unless other.is_a?(Nokogiri::XML::NodeSet)
-        return false unless length == other.length
-        each_with_index do |node, i|
-          return false unless node == other[i]
-        end
-        true
-      end
-
-      ###
-      # Returns a new NodeSet containing all the children of all the nodes in
-      # the NodeSet
-      def children
-        node_set = NodeSet.new(document)
-        each do |node|
-          node.children.each { |n| node_set.push(n) }
-        end
-        node_set
-      end
-
-      ###
-      # Returns a new NodeSet containing all the nodes in the NodeSet
-      # in reverse order
-      def reverse
-        node_set = NodeSet.new(document)
-        (length - 1).downto(0) do |x|
-          node_set.push(self[x])
-        end
-        node_set
-      end
-
-      ###
-      # Return a nicely formated string representation
-      def inspect
-        "[#{map(&:inspect).join(", ")}]"
-      end
-
-      alias_method :+, :|
-
-      IMPLIED_XPATH_CONTEXTS = [".//", "self::"].freeze # :nodoc:
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/nokogiri-1.13.3-x86_64-linux/lib/nokogiri/xml/parse_options.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module Nokogiri
-  module XML
-    ###
-    # Parse options for passing to Nokogiri.XML or Nokogiri.HTML
-    #
-    # == Building combinations of parse options
-    # You can build your own combinations of these parse options by using any of the following methods:
-    # *Note*: All examples attempt to set the +RECOVER+ & +NOENT+ options.
-    # [Ruby's bitwise operators] You can use the Ruby bitwise operators to set various combinations.
-    #   Nokogiri.XML('<content>Chapter 1</content', nil, nil, Nokogiri::XML::ParseOptions.new((1 << 0) | (1 << 1)))
-    # [Method chaining] Every option has an equivalent method in lowercase. You can chain these methods together to set various combinations.
-    #   Nokogiri.XML('<content>Chapter 1</content', nil, nil, Nokogiri::XML::ParseOptions.new.recover.noent)
-    # [Using Ruby Blocks] You can also setup parse combinations in the block passed to Nokogiri.XML or Nokogiri.HTML
-    #   Nokogiri.XML('<content>Chapter 1</content') {|config| config.recover.noent}
-    #
-    # == Removing particular parse options
-    # You can also remove options from an instance of +ParseOptions+ dynamically.
-    # Every option has an equivalent <code>no{option}</code> method in lowercase. You can call these methods on an instance of +ParseOptions+ to remove the option.
-    # Note that this is not available for +STRICT+.
-    #
-    #   # Setting the RECOVER & NOENT options...
-    #   options = Nokogiri::XML::ParseOptions.new.recover.noent
-    #   # later...
-    #   options.norecover # Removes the Nokogiri::XML::ParseOptions::RECOVER option
-    #   options.nonoent # Removes the Nokogiri::XML::ParseOptions::NOENT option
-    #
-    class ParseOptions
-      # Strict parsing
-      STRICT      = 0
-      # Recover from errors
-      RECOVER     = 1 << 0
-      # Substitute entities
-      NOENT       = 1 << 1
-      # Load external subsets
-      DTDLOAD     = 1 << 2
-      # Default DTD attributes
-      DTDATTR     = 1 << 3
-      # validate with the DTD
-      DTDVALID    = 1 << 4
-      # suppress error reports
-      NOERROR     = 1 << 5
-      # suppress warning reports
-      NOWARNING   = 1 << 6
-      # pedantic error reporting
-      PEDANTIC    = 1 << 7
-      # remove blank nodes
-      NOBLANKS    = 1 << 8
-      # use the SAX1 interface internally
-      SAX1        = 1 << 9
-      # Implement XInclude substitution
-      XINCLUDE    = 1 << 10
-      # Forbid network access. Recommended for dealing with untrusted documents.
-      NONET       = 1 << 11
-      # Do not reuse the context dictionary
-      NODICT      = 1 << 12
-      # remove redundant namespaces declarations
-      NSCLEAN     = 1 << 13
-      # merge CDATA as text nodes
-      NOCDATA     = 1 << 14
-      # do not generate XINCLUDE START/END nodes
-      NOXINCNODE  = 1 << 15
-      # compact small text nodes; no modification of the tree allowed afterwards (will possibly crash if you try to modify the tree)
-      COMPACT     = 1 << 16
-      # parse using XML-1.0 before update 5
-      OLD10       = 1 << 17
-      # do not fixup XINCLUDE xml:base uris
-      NOBASEFIX   = 1 << 18
-      # relax any hardcoded limit from the parser
-      HUGE        = 1 << 19
-      # line numbers stored as long int (instead of a short int)
-      BIG_LINES   = 1 << 22
-
-      # the default options used for parsing XML documents
-      DEFAULT_XML  = RECOVER | NONET | BIG_LINES
-      # the default options used for parsing XSLT stylesheets
-      DEFAULT_XSLT = RECOVER | NONET | NOENT | DTDLOAD | DTDATTR | NOCDATA | BIG_LINES
-      # the default options used for parsing HTML documents
-      DEFAULT_HTML = RECOVER | NOERROR | NOWARNING | NONET | BIG_LINES
-      # the default options used for parsing XML schemas
-      DEFAULT_SCHEMA = NONET | BIG_LINES
-
-      attr_accessor :options
-
-      def initialize(options = STRICT)
-        @options = options
-      end
-
-      constants.each do |constant|
-        next if constant.to_sym == :STRICT
-        class_eval %{
-          def #{constant.downcase}
-            @options |= #{constant}
-            self
-          end
-
-          def no#{constant.downcase}
-            @options &= ~#{constant}
-            self
-          end
-
-          def #{constant.downcase}?
-            #{constant} & @options == #{constant}
-          end
-        }
-      end
-
-      def strict
-        @options &= ~RECOVER
-        self
-      end
-
-      def strict?
-        @options & RECOVER == STRICT
-      end
-
-      def ==(other)
-        other.to_i == to_i
-      end
-
-      alias_method :to_i, :options
-
-      def inspect
-        options = []
-        self.class.constants.each do |k|
-          options << k.downcase if send(:"#{k.downcase}?")
-        end
-        super.sub(/>$/, " " + options.join(", ") + ">")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/nokogiri-1.13.3-x86_64-linux/lib/nokogiri/xml/processing_instruction.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Nokogiri
-  module XML
-    class ProcessingInstruction < Node
-      def initialize(document, name, content)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/nokogiri-1.13.3-x86_64-linux/lib/nokogiri/xml/sax/parser.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Nokogiri
-  module XML
-    module SAX
-      ###
-      # This parser is a SAX style parser that reads it's input as it
-      # deems necessary.  The parser takes a Nokogiri::XML::SAX::Document,
-      # an optional encoding, then given an XML input, sends messages to
-      # the Nokogiri::XML::SAX::Document.
-      #
-      # Here is an example of using this parser:
-      #
-      #   # Create a subclass of Nokogiri::XML::SAX::Document and implement
-      #   # the events we care about:
-      #   class MyDoc < Nokogiri::XML::SAX::Document
-      #     def start_element name, attrs = []
-      #       puts "starting: #{name}"
-      #     end
-      #
-      #     def end_element name
-      #       puts "ending: #{name}"
-      #     end
-      #   end
-      #
-      #   # Create our parser
-      #   parser = Nokogiri::XML::SAX::Parser.new(MyDoc.new)
-      #
-      #   # Send some XML to the parser
-      #   parser.parse(File.open(ARGV[0]))
-      #
-      # For more information about SAX parsers, see Nokogiri::XML::SAX.  Also
-      # see Nokogiri::XML::SAX::Document for the available events.
-      class Parser
-        class Attribute < Struct.new(:localname, :prefix, :uri, :value)
-        end
-
-        # Encodinds this parser supports
-        ENCODINGS = {
-          "NONE" => 0, # No char encoding detected
-          "UTF-8" => 1, # UTF-8
-          "UTF16LE" => 2, # UTF-16 little endian
-          "UTF16BE" => 3, # UTF-16 big endian
-          "UCS4LE" => 4, # UCS-4 little endian
-          "UCS4BE" => 5, # UCS-4 big endian
-          "EBCDIC" => 6, # EBCDIC uh!
-          "UCS4-2143" => 7, # UCS-4 unusual ordering
-          "UCS4-3412" => 8, # UCS-4 unusual ordering
-          "UCS2" => 9, # UCS-2
-          "ISO-8859-1" => 10, # ISO-8859-1 ISO Latin 1
-          "ISO-8859-2" => 11, # ISO-8859-2 ISO Latin 2
-          "ISO-8859-3" => 12, # ISO-8859-3
-          "ISO-8859-4" => 13, # ISO-8859-4
-          "ISO-8859-5" => 14, # ISO-8859-5
-          "ISO-8859-6" => 15, # ISO-8859-6
-          "ISO-8859-7" => 16, # ISO-8859-7
-          "ISO-8859-8" => 17, # ISO-8859-8
-          "ISO-8859-9" => 18, # ISO-8859-9
-          "ISO-2022-JP" => 19, # ISO-2022-JP
-          "SHIFT-JIS" => 20, # Shift_JIS
-          "EUC-JP" => 21, # EUC-JP
-          "ASCII" => 22, # pure ASCII
-        }
-
-        # The Nokogiri::XML::SAX::Document where events will be sent.
-        attr_accessor :document
-
-        # The encoding beings used for this document.
-        attr_accessor :encoding
-
-        # Create a new Parser with +doc+ and +encoding+
-        def initialize(doc = Nokogiri::XML::SAX::Document.new, encoding = "UTF-8")
-          @encoding = check_encoding(encoding)
-          @document = doc
-          @warned   = false
-        end
-
-        ###
-        # Parse given +thing+ which may be a string containing xml, or an
-        # IO object.
-        def parse(thing, &block)
-          if thing.respond_to?(:read) && thing.respond_to?(:close)
-            parse_io(thing, &block)
-          else
-            parse_memory(thing, &block)
-          end
-        end
-
-        ###
-        # Parse given +io+
-        def parse_io(io, encoding = "ASCII")
-          @encoding = check_encoding(encoding)
-          ctx = ParserContext.io(io, ENCODINGS[@encoding])
-          yield ctx if block_given?
-          ctx.parse_with(self)
-        end
-
-        ###
-        # Parse a file with +filename+
-        def parse_file(filename)
-          raise ArgumentError unless filename
-          raise Errno::ENOENT unless File.exist?(filename)
-          raise Errno::EISDIR if File.directory?(filename)
-          ctx = ParserContext.file(filename)
-          yield ctx if block_given?
-          ctx.parse_with(self)
-        end
-
-        def parse_memory(data)
-          ctx = ParserContext.memory(data)
-          yield ctx if block_given?
-          ctx.parse_with(self)
-        end
-
-        private
-
-        def check_encoding(encoding)
-          encoding.upcase.tap do |enc|
-            raise ArgumentError, "'#{enc}' is not a valid encoding" unless ENCODINGS[enc]
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/nokogiri-1.13.3-x86_64-linux/lib/nokogiri/xml/syntax_error.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Nokogiri
-  module XML
-    ###
-    # This class provides information about XML SyntaxErrors.  These
-    # exceptions are typically stored on Nokogiri::XML::Document#errors.
-    class SyntaxError < ::Nokogiri::SyntaxError
-      attr_reader :domain
-      attr_reader :code
-      attr_reader :level
-      attr_reader :file
-      attr_reader :line
-      attr_reader :str1
-      attr_reader :str2
-      attr_reader :str3
-      attr_reader :int1
-      attr_reader :column
-
-      ###
-      # return true if this is a non error
-      def none?
-        level == 0
-      end
-
-      ###
-      # return true if this is a warning
-      def warning?
-        level == 1
-      end
-
-      ###
-      # return true if this is an error
-      def error?
-        level == 2
-      end
-
-      ###
-      # return true if this error is fatal
-      def fatal?
-        level == 3
-      end
-
-      def to_s
-        message = super.chomp
-        [location_to_s, level_to_s, message]
-          .compact.join(": ")
-          .force_encoding(message.encoding)
-      end
-
-      private
-
-      def level_to_s
-        case level
-        when 3 then "FATAL"
-        when 2 then "ERROR"
-        when 1 then "WARNING"
-        end
-      end
-
-      def nil_or_zero?(attribute)
-        attribute.nil? || attribute.zero?
-      end
-
-      def location_to_s
-        return nil if nil_or_zero?(line) && nil_or_zero?(column)
-        "#{line}:#{column}"
-      end
-    end
-  end
-end