mini-pro-gem 0.0.1

data/nokogiri-1.19.4/lib/nokogiri/xslt.rb

@@ -0,0 +1,138 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Nokogiri
+  class << self
+    # Convenience method for Nokogiri::XSLT.parse
+    def XSLT(...)
+      XSLT.parse(...)
+    end
+  end
+
+  ###
+  # See Nokogiri::XSLT::Stylesheet for creating and manipulating Stylesheet objects.
+  #
+  # 🛡 <b>Do not use this module for untrusted stylesheet documents.</b> libxslt does not support
+  # safely processing untrusted stylesheets. Untrusted stylesheets may access the file system and
+  # network, consume large amounts of CPU, memory, or other system resources, and IO and file
+  # access are not restricted. Additionally, the stylesheet is parsed by libxml2 with +NOENT+ and
+  # +DTDLOAD+ enabled (see ParseOptions::DEFAULT_XSLT), meaning that <b>external entities will be
+  # resolved and external subsets will be loaded</b> during parsing.
+  module XSLT
+    class << self
+      # :call-seq:
+      #   parse(xsl) → Nokogiri::XSLT::Stylesheet
+      #   parse(xsl, modules) → Nokogiri::XSLT::Stylesheet
+      #
+      # Parse the stylesheet in +xsl+, registering optional +modules+ as custom class handlers.
+      #
+      # 🛡 <b>Do not pass untrusted stylesheet content to this method.</b> See Nokogiri::XSLT for more
+      # information.
+      #
+      # [Parameters]
+      # - +xsl+ (String) XSL content to be parsed into a stylesheet
+      # - +modules+ (Hash<String ⇒ Class>) A hash of URI-to-handler relations for linking a
+      #   namespace to a custom function handler.
+      #
+      # ⚠ The XSLT handler classes are registered *globally*.
+      #
+      # Also see Nokogiri::XSLT.register
+      #
+      # *Example*
+      #
+      #   xml = Nokogiri.XML(<<~XML)
+      #     <nodes>
+      #       <node>Foo</node>
+      #       <node>Bar</node>
+      #     </nodes>
+      #   XML
+      #
+      #   handler = Class.new do
+      #     def reverse(node)
+      #       node.text.reverse
+      #     end
+      #   end
+      #
+      #   xsl = <<~XSL
+      #     <xsl:stylesheet version="1.0"
+      #       xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+      #       xmlns:myfuncs="http://nokogiri.org/xslt/myfuncs"
+      #       extension-element-prefixes="myfuncs">
+      #       <xsl:template match="/">
+      #         <reversed>
+      #           <xsl:for-each select="nodes/node">
+      #             <reverse><xsl:copy-of select="myfuncs:reverse(.)"/></reverse>
+      #           </xsl:for-each>
+      #         </reversed>
+      #       </xsl:template>
+      #     </xsl:stylesheet>
+      #   XSL
+      #
+      #   xsl = Nokogiri.XSLT(xsl, "http://nokogiri.org/xslt/myfuncs" => handler)
+      #   xsl.transform(xml).to_xml
+      #   # => "<?xml version=\"1.0\"?>\n" +
+      #   #    "<reversed>\n" +
+      #   #    "  <reverse>ooF</reverse>\n" +
+      #   #    "  <reverse>raB</reverse>\n" +
+      #   #    "</reversed>\n"
+      #
+      def parse(string, modules = {})
+        modules.each do |url, klass|
+          XSLT.register(url, klass)
+        end
+
+        doc = XML::Document.parse(string, nil, nil, XML::ParseOptions::DEFAULT_XSLT)
+        if Nokogiri.jruby?
+          Stylesheet.parse_stylesheet_doc(doc, string)
+        else
+          Stylesheet.parse_stylesheet_doc(doc)
+        end
+      end
+
+      # :call-seq:
+      #   quote_params(params) → Array
+      #
+      # Quote parameters in +params+ for stylesheet safety.
+      # See Nokogiri::XSLT::Stylesheet.transform for example usage.
+      #
+      # [Parameters]
+      # - +params+ (Hash, Array) XSLT parameters (key->value, or tuples of [key, value])
+      #
+      # [Returns] Array of string parameters, with quotes correctly escaped for use with XSLT::Stylesheet.transform
+      #
+      def quote_params(params)
+        params.flatten.each_slice(2).with_object([]) do |kv, quoted_params|
+          key, value = kv.map(&:to_s)
+          value = if value.include?("'")
+            "concat('#{value.gsub("'", %q{', "'", '})}')"
+          else
+            "'#{value}'"
+          end
+          quoted_params << key
+          quoted_params << value
+        end
+      end
+
+      #  call-seq:
+      #    register(uri, custom_handler_class)
+      #
+      #  Register a class that implements custom XSLT transformation functions.
+      #
+      #  ⚠ The XSLT handler classes are registered *globally*.
+      #
+      #  [Parameters}
+      #  - +uri+ (String) The namespace for the custom handlers
+      #  - +custom_handler_class+ (Class) A class with ruby methods that can be called during
+      #    transformation
+      #
+      #  See Nokogiri::XSLT.parse for usage.
+      #
+      def register(uri, custom_handler_class)
+        # NOTE: this is implemented in the C extension, see ext/nokogiri/xslt_stylesheet.c
+        raise NotImplementedError, "Nokogiri::XSLT.register is not implemented on JRuby"
+      end if Nokogiri.jruby?
+    end
+  end
+end
+
+require_relative "xslt/stylesheet"

data/nokogiri-1.19.4/lib/nokogiri.rb

@@ -0,0 +1,128 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+  require_relative "nokogiri/jruby/dependencies"
+end
+
+require_relative "nokogiri/extension"
+
+# Nokogiri parses and searches XML/HTML very quickly, and also has
+# correctly implemented CSS3 selector support as well as XPath 1.0
+# support.
+#
+# Parsing a document returns either a Nokogiri::XML::Document, or a
+# Nokogiri::HTML4::Document depending on the kind of document you parse.
+#
+# Here is an example:
+#
+#     require 'nokogiri'
+#     require 'open-uri'
+#
+#     # Get a Nokogiri::HTML4::Document for the page we’re interested in...
+#
+#     doc = Nokogiri::HTML4(URI.open('http://www.google.com/search?q=tenderlove'))
+#
+#     # Do funky things with it using Nokogiri::XML::Node methods...
+#
+#     ####
+#     # Search for nodes by css
+#     doc.css('h3.r a.l').each do |link|
+#       puts link.content
+#     end
+#
+# See also:
+#
+# - Nokogiri::XML::Searchable#css for more information about CSS searching
+# - Nokogiri::XML::Searchable#xpath for more information about XPath searching
+module Nokogiri
+  class << self
+    ###
+    # Parse an HTML or XML document.  +string+ contains the document.
+    def parse(string, url = nil, encoding = nil, options = nil)
+      if string.respond_to?(:read) ||
+          /^\s*<(?:!DOCTYPE\s+)?html[\s>]/i.match?(string[0, 512])
+        # Expect an HTML indicator to appear within the first 512
+        # characters of a document. (<?xml ?> + <?xml-stylesheet ?>
+        # shouldn't be that long)
+        Nokogiri.HTML4(
+          string,
+          url,
+          encoding,
+          options || XML::ParseOptions::DEFAULT_HTML,
+        )
+      else
+        Nokogiri.XML(
+          string,
+          url,
+          encoding,
+          options || XML::ParseOptions::DEFAULT_XML,
+        )
+      end.tap do |doc|
+        yield doc if block_given?
+      end
+    end
+
+    ###
+    # Create a new Nokogiri::XML::DocumentFragment
+    def make(input = nil, opts = {}, &blk)
+      if input
+        Nokogiri::HTML4.fragment(input).children.first
+      else
+        Nokogiri(&blk)
+      end
+    end
+
+    ###
+    # Parse a document and add the Slop decorator.  The Slop decorator
+    # implements method_missing such that methods may be used instead of CSS
+    # or XPath.  For example:
+    #
+    #   doc = Nokogiri::Slop(<<-eohtml)
+    #     <html>
+    #       <body>
+    #         <p>first</p>
+    #         <p>second</p>
+    #       </body>
+    #     </html>
+    #   eohtml
+    #   assert_equal('second', doc.html.body.p[1].text)
+    #
+    def Slop(*args, &block)
+      Nokogiri(*args, &block).slop!
+    end
+
+    # :nodoc:
+    def install_default_aliases
+      warn("Nokogiri.install_default_aliases is deprecated. Please call Nokogiri::EncodingHandler.install_default_aliases instead. This will become an error in Nokogiri v1.17.0.", uplevel: 1, category: :deprecated) # deprecated in v1.14.0, remove in v1.17.0
+      Nokogiri::EncodingHandler.install_default_aliases
+    end
+  end
+end
+
+###
+# Parse a document contained in +args+.  Nokogiri will try to guess what type of document you are
+# attempting to parse.  For more information, see Nokogiri.parse
+#
+# To specify the type of document, use {Nokogiri.XML}, {Nokogiri.HTML4}, or {Nokogiri.HTML5}.
+def Nokogiri(*args, &block)
+  if block
+    Nokogiri::HTML4::Builder.new(&block).doc.root
+  else
+    Nokogiri.parse(*args)
+  end
+end
+
+require_relative "nokogiri/version"
+require_relative "nokogiri/class_resolver"
+require_relative "nokogiri/syntax_error"
+require_relative "nokogiri/xml"
+require_relative "nokogiri/xslt"
+require_relative "nokogiri/html4"
+require_relative "nokogiri/html"
+require_relative "nokogiri/decorators/slop"
+require_relative "nokogiri/css"
+require_relative "nokogiri/html4/builder"
+require_relative "nokogiri/encoding_handler"
+
+require_relative "nokogiri/html5" if Nokogiri.uses_gumbo?

data/nokogiri-1.19.4/lib/xsd/xmlparser/nokogiri.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module XSD
+  module XMLParser
+    ###
+    # Nokogiri XML parser for soap4r.
+    #
+    # Nokogiri may be used as the XML parser in soap4r. Require 'xsd/xmlparser/nokogiri' in your
+    # soap4r applications, and soap4r will use Nokogiri as its XML parser. No other changes should
+    # be required to use Nokogiri as the XML parser.
+    #
+    # Example (using UW ITS Web Services):
+    #
+    #   require 'rubygems'
+    #   require 'nokogiri'
+    #   gem 'soap4r'
+    #   require 'defaultDriver'
+    #   require 'xsd/xmlparser/nokogiri'
+    #
+    #   obj = AvlPortType.new
+    #   obj.getLatestByRoute(obj.getAgencies.first, 8).each do |bus|
+    #     p "#{bus.routeID}, #{bus.longitude}, #{bus.latitude}"
+    #   end
+    #
+    class Nokogiri < XSD::XMLParser::Parser
+      ###
+      # Create a new XSD parser with +host+ and +opt+
+      def initialize(host, opt = {})
+        super
+        @parser = ::Nokogiri::XML::SAX::Parser.new(self, @charset || "UTF-8")
+      end
+
+      ###
+      # Start parsing +string_or_readable+
+      def do_parse(string_or_readable)
+        @parser.parse(string_or_readable)
+      end
+
+      ###
+      # Handle the start_element event with +name+ and +attrs+
+      def start_element(name, attrs = [])
+        super(name, Hash[*attrs.flatten])
+      end
+
+      ###
+      # Handle the end_element event with +name+
+      def end_element(name)
+        super
+      end
+
+      ###
+      # Handle errors with message +msg+
+      def error(msg)
+        raise ParseError, msg
+      end
+      alias_method :warning, :error
+
+      ###
+      # Handle cdata_blocks containing +string+
+      def cdata_block(string)
+        characters(string)
+      end
+
+      ###
+      # Called at the beginning of an element
+      # +name+ is the element name
+      # +attrs+ is a list of attributes
+      # +prefix+ is the namespace prefix for the element
+      # +uri+ is the associated namespace URI
+      # +ns+ is a hash of namespace prefix:urls associated with the element
+      def start_element_namespace(name, attrs = [], prefix = nil, uri = nil, ns = []) # rubocop:disable Metrics/ParameterLists
+        ###
+        # Deal with SAX v1 interface
+        name = [prefix, name].compact.join(":")
+        attributes = ns.map do |ns_prefix, ns_uri|
+          [["xmlns", ns_prefix].compact.join(":"), ns_uri]
+        end + attrs.map do |attr|
+          [[attr.prefix, attr.localname].compact.join(":"), attr.value]
+        end.flatten
+        start_element(name, attributes)
+      end
+
+      ###
+      # Called at the end of an element
+      # +name+ is the element's name
+      # +prefix+ is the namespace prefix associated with the element
+      # +uri+ is the associated namespace URI
+      def end_element_namespace(name, prefix = nil, uri = nil)
+        ###
+        # Deal with SAX v1 interface
+        end_element([prefix, name].compact.join(":"))
+      end
+
+      ["xmldecl", "start_document", "end_document", "comment"].each do |name|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{name}(*args); end
+        RUBY
+      end
+
+      add_factory(self)
+    end
+  end
+end

data/nokogiri-1.19.4/patches/libxml2/0001-Remove-script-macro-support.patch

@@ -0,0 +1,40 @@
+From 27e4aa8d885e47a296ea78d114dbbe8fc7aa3508 Mon Sep 17 00:00:00 2001
+From: Kevin Solorio <soloriok@gmail.com>
+Date: Fri, 1 Feb 2019 14:32:42 -0800
+Subject: [PATCH] Revert-support-html-h-b-7-1
+
+---
+ entities.c | 17 -----------------
+ 1 file changed, 17 deletions(-)
+
+diff --git a/entities.c b/entities.c
+index 43549bc5..82652f6d 100644
+--- a/entities.c
++++ b/entities.c
+@@ -623,23 +623,6 @@ xmlEncodeEntitiesInternal(xmlDocPtr doc, const xmlChar *input, int attr) {
+ 	    *out++ = 't';
+ 	    *out++ = ';';
+ 	} else if (*cur == '&') {
+-	    /*
+-	     * Special handling of &{...} construct from HTML 4, see
+-	     * http://www.w3.org/TR/html401/appendix/notes.html#h-B.7.1
+-	     */
+-	    if (html && attr && (cur[1] == '{') &&
+-	        (strchr((const char *) cur, '}'))) {
+-	        while (*cur != '}') {
+-		    *out++ = *cur++;
+-		    indx = out - buffer;
+-		    if (indx + 100 > buffer_size) {
+-			growBufferReentrant();
+-			out = &buffer[indx];
+-		    }
+-		}
+-		*out++ = *cur++;
+-		continue;
+-	    }
+ 	    *out++ = '&';
+ 	    *out++ = 'a';
+ 	    *out++ = 'm';
+-- 
+2.16.2
+

data/nokogiri-1.19.4/patches/libxml2/0002-Update-entities-to-remove-handling-of-ssi.patch

@@ -0,0 +1,44 @@
+From ffc08467744bd2305d41ca882c37fa30adf3a067 Mon Sep 17 00:00:00 2001
+From: Kevin Solorio <soloriok@gmail.com>
+Date: Wed, 27 Feb 2019 14:34:17 -0800
+Subject: [PATCH 2/2] update entities.c to remove handling of ssi
+
+---
+ entities.c | 21 ---------------------
+ 1 file changed, 21 deletions(-)
+
+diff --git a/entities.c b/entities.c
+index 43549bc5..5c4a2a60 100644
+--- a/entities.c
++++ b/entities.c
+@@ -592,27 +592,6 @@ xmlEncodeEntitiesInternal(xmlDocPtr doc, const xmlChar *input, int attr) {
+ 	 * By default one have to encode at least '<', '>', '"' and '&' !
+ 	 */
+ 	if (*cur == '<') {
+-	    const xmlChar *end;
+-
+-	    /*
+-	     * Special handling of server side include in HTML attributes
+-	     */
+-	    if (html && attr &&
+-	        (cur[1] == '!') && (cur[2] == '-') && (cur[3] == '-') &&
+-	        ((end = xmlStrstr(cur, BAD_CAST "-->")) != NULL)) {
+-	        while (cur != end) {
+-		    *out++ = *cur++;
+-		    indx = out - buffer;
+-		    if (indx + 100 > buffer_size) {
+-			growBufferReentrant();
+-			out = &buffer[indx];
+-		    }
+-		}
+-		*out++ = *cur++;
+-		*out++ = *cur++;
+-		*out++ = *cur++;
+-		continue;
+-	    }
+ 	    *out++ = '&';
+ 	    *out++ = 'l';
+ 	    *out++ = 't';
+-- 
+2.16.2
+

data/nokogiri-1.19.4/patches/libxml2/0009-allow-wildcard-namespaces.patch

@@ -0,0 +1,77 @@
+From 74c95ec5932c737d4fcb06b8646b0017364ada14 Mon Sep 17 00:00:00 2001
+From: Mike Dalessio <mike.dalessio@gmail.com>
+Date: Fri, 24 Dec 2021 19:08:01 -0500
+Subject: [PATCH] attempt to hack in wildcard namespaces to xpath
+
+I'm not confident this is a bulletproof patch.
+---
+ xpath.c | 24 ++++++++++++++++++------
+ 1 file changed, 18 insertions(+), 6 deletions(-)
+
+diff --git a/xpath.c b/xpath.c
+index 1aa2f1a..c7f0885 100644
+--- a/xpath.c
++++ b/xpath.c
+@@ -146,6 +146,9 @@
+ #define XPATH_MAX_RECURSION_DEPTH 5000
+ #endif
+ 
++#define WILDCARD_PREFIX "*"
++#define IS_WILDCARD_PREFIX(p) xmlStrEqual((xmlChar*)WILDCARD_PREFIX, p)
++
+ /*
+  * TODO:
+  * There are a few spots where some tests are done which depend upon ascii
+@@ -11073,12 +11076,15 @@ xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
+     SKIP_BLANKS;
+ 
+     if ((name == NULL) && (CUR == '*')) {
+-	/*
+-	 * All elements
+-	 */
+ 	NEXT;
+-	*test = NODE_TEST_ALL;
+-	return(NULL);
++	if (CUR != ':') {
++	    /*
++	     * All elements
++	     */
++	    *test = NODE_TEST_ALL;
++	    return(NULL);
++	}
++	name = xmlCharStrdup(WILDCARD_PREFIX);
+     }
+ 
+     if (name == NULL)
+@@ -11327,6 +11333,10 @@ xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
+ 	}
+ #endif
+ 	if (CUR == '*') {
++	    if (NXT(1) == ':') {
++		NEXT;
++		name = xmlCharStrdup(WILDCARD_PREFIX);
++	    }
+ 	    axis = AXIS_CHILD;
+ 	} else {
+ 	    if (name == NULL)
+@@ -12030,7 +12040,7 @@ xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
+     /*
+     * Setup namespaces.
+     */
+-    if (prefix != NULL) {
++    if (prefix != NULL && !IS_WILDCARD_PREFIX(prefix)) {
+         URI = xmlXPathNsLookup(xpctxt, prefix);
+         if (URI == NULL) {
+ 	    xmlXPathReleaseObject(xpctxt, obj);
+@@ -12369,6 +12379,8 @@ xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
+ 				    {
+ 					XP_TEST_HIT
+                                     }
++                                } else if (IS_WILDCARD_PREFIX(prefix)) {
++                                    XP_TEST_HIT
+                                 } else {
+                                     if ((cur->ns != NULL) &&
+                                         (xmlStrEqual(URI, cur->ns->href)))
+-- 
+2.31.0
+