json-ld 3.2.4 → 3.2.5

data/lib/json/ld/html/nokogiri.rb

@@ -1,151 +1,153 @@
-module JSON::LD
-  class API
-    ##
-    # Nokogiri implementation of an HTML parser.
-    #
-    # @see http://nokogiri.org/
-    module Nokogiri
+# frozen_string_literal: true
+
+module JSON
+  module LD
+    class API
       ##
-      # Returns the name of the underlying XML library.
+      # Nokogiri implementation of an HTML parser.
       #
-      # @return [Symbol]
-      def self.library
-        :nokogiri
-      end
-
-      # Proxy class to implement uniform element accessors
-      class NodeProxy
-        attr_reader :node
-        attr_reader :parent
-
-        def initialize(node, parent = nil)
-          @node = node
-          @parent = parent
-        end
-
+      # @see http://nokogiri.org/
+      module Nokogiri
         ##
-        # Return xml:base on element, if defined
+        # Returns the name of the underlying XML library.
         #
-        # @return [String]
-        def base
-          @node.attribute_with_ns("base", RDF::XML.to_s) || @node.attribute('xml:base')
+        # @return [Symbol]
+        def self.library
+          :nokogiri
         end
 
-        def display_path
-          @display_path ||= begin
-            path = []
-            path << parent.display_path if parent
-            path << @node.name
-            case @node
-            when ::Nokogiri::XML::Element then path.join("/")
-            when ::Nokogiri::XML::Attr    then path.join("@")
-            else path.join("?")
+        # Proxy class to implement uniform element accessors
+        class NodeProxy
+          attr_reader :node, :parent
+
+          def initialize(node, parent = nil)
+            @node = node
+            @parent = parent
+          end
+
+          ##
+          # Return xml:base on element, if defined
+          #
+          # @return [String]
+          def base
+            @node.attribute_with_ns("base", RDF::XML.to_s) || @node.attribute('xml:base')
+          end
+
+          def display_path
+            @display_path ||= begin
+              path = []
+              path << parent.display_path if parent
+              path << @node.name
+              case @node
+              when ::Nokogiri::XML::Element then path.join("/")
+              when ::Nokogiri::XML::Attr    then path.join("@")
+              else path.join("?")
+              end
             end
           end
-        end
 
-        ##
-        # Return true of all child elements are text
-        #
-        # @return [Array<:text, :element, :attribute>]
-        def text_content?
-          @node.children.all? {|c| c.text?}
-        end
+          ##
+          # Return true of all child elements are text
+          #
+          # @return [Array<:text, :element, :attribute>]
+          def text_content?
+            @node.children.all?(&:text?)
+          end
 
-        ##
-        # Children of this node
-        #
-        # @return [NodeSetProxy]
-        def children
-          NodeSetProxy.new(@node.children, self)
-        end
+          ##
+          # Children of this node
+          #
+          # @return [NodeSetProxy]
+          def children
+            NodeSetProxy.new(@node.children, self)
+          end
 
-        # Ancestors of this element, in order
-        def ancestors
-          @ancestors ||= parent ? parent.ancestors + [parent] : []
-        end
+          # Ancestors of this element, in order
+          def ancestors
+            @ancestors ||= parent ? parent.ancestors + [parent] : []
+          end
 
-        ##
-        # Inner text of an element. Decode Entities
-        #
-        # @return [String]
-        #def inner_text
-        #  coder = HTMLEntities.new
-        #  coder.decode(@node.inner_text)
-        #end
-
-        def attribute_nodes
-          @attribute_nodes ||= NodeSetProxy.new(@node.attribute_nodes, self)
-        end
+          ##
+          # Inner text of an element. Decode Entities
+          #
+          # @return [String]
+          # def inner_text
+          #  coder = HTMLEntities.new
+          #  coder.decode(@node.inner_text)
+          # end
+
+          def attribute_nodes
+            @attribute_nodes ||= NodeSetProxy.new(@node.attribute_nodes, self)
+          end
 
-        def xpath(*args)
-          @node.xpath(*args).map do |n|
-            # Get node ancestors
-            parent = n.ancestors.reverse.inject(nil) do |p,node|
-              NodeProxy.new(node, p)
+          def xpath(*args)
+            @node.xpath(*args).map do |n|
+              # Get node ancestors
+              parent = n.ancestors.reverse.inject(nil) do |p, node|
+                NodeProxy.new(node, p)
+              end
+              NodeProxy.new(n, parent)
             end
-            NodeProxy.new(n, parent)
+          end
+
+          ##
+          # Proxy for everything else to @node
+          def method_missing(method, *args)
+            @node.send(method, *args)
           end
         end
 
         ##
-        # Proxy for everything else to @node
-        def method_missing(method, *args)
-          @node.send(method, *args)
-        end
-      end
+        # NodeSet proxy
+        class NodeSetProxy
+          attr_reader :node_set, :parent
 
-      ##
-      # NodeSet proxy
-      class NodeSetProxy
-        attr_reader :node_set
-        attr_reader :parent
-
-        def initialize(node_set, parent)
-          @node_set = node_set
-          @parent = parent
-        end
+          def initialize(node_set, parent)
+            @node_set = node_set
+            @parent = parent
+          end
 
-        ##
-        # Return a proxy for each child
-        #
-        # @yield child
-        # @yieldparam [NodeProxy]
-        def each
-          @node_set.each do |c|
-            yield NodeProxy.new(c, parent)
+          ##
+          # Return a proxy for each child
+          #
+          # @yield child
+          # @yieldparam [NodeProxy]
+          def each
+            @node_set.each do |c|
+              yield NodeProxy.new(c, parent)
+            end
           end
-        end
 
-        ##
-        # Proxy for everything else to @node_set
-        def method_missing(method, *args)
-          @node_set.send(method, *args)
+          ##
+          # Proxy for everything else to @node_set
+          def method_missing(method, *args)
+            @node_set.send(method, *args)
+          end
         end
-      end
 
-      ##
-      # Initializes the underlying XML library.
-      #
-      # @param  [Hash{Symbol => Object}] options
-      # @return [NodeProxy] of root element
-      def initialize_html_nokogiri(input, options = {})
-        require 'nokogiri' unless defined?(::Nokogiri)
-        doc = case input
-        when ::Nokogiri::HTML::Document, ::Nokogiri::XML::Document
-          input
-        else
-          begin
-            input = input.read if input.respond_to?(:read)
-            ::Nokogiri::HTML5(input.force_encoding('utf-8'), max_parse_errors: 1000)
-          rescue LoadError, NoMethodError
-            ::Nokogiri::HTML.parse(input, base_uri.to_s, 'utf-8')
+        ##
+        # Initializes the underlying XML library.
+        #
+        # @param  [Hash{Symbol => Object}] options
+        # @return [NodeProxy] of root element
+        def initialize_html_nokogiri(input, _options = {})
+          require 'nokogiri' unless defined?(::Nokogiri)
+          doc = case input
+          when ::Nokogiri::HTML::Document, ::Nokogiri::XML::Document
+            input
+          else
+            begin
+              input = input.read if input.respond_to?(:read)
+              ::Nokogiri::HTML5(input.force_encoding('utf-8'), max_parse_errors: 1000)
+            rescue LoadError, NoMethodError
+              ::Nokogiri::HTML.parse(input, base_uri.to_s, 'utf-8')
+            end
           end
-        end
 
-        NodeProxy.new(doc.root) if doc && doc.root
+          NodeProxy.new(doc.root) if doc&.root
+        end
+        alias initialize_html initialize_html_nokogiri
       end
-      alias_method :initialize_html, :initialize_html_nokogiri
     end
   end
 end

data/lib/json/ld/html/rexml.rb

@@ -1,187 +1,191 @@
+# frozen_string_literal: true
+
 require 'htmlentities'
 
-module JSON::LD
-  class API
-    ##
-    # REXML implementation of an XML parser.
-    #
-    # @see http://www.germane-software.com/software/rexml/
-    module REXML
+module JSON
+  module LD
+    class API
       ##
-      # Returns the name of the underlying XML library.
+      # REXML implementation of an XML parser.
       #
-      # @return [Symbol]
-      def self.library
-        :rexml
-      end
-
-      # Proxy class to implement uniform element accessors
-      class NodeProxy
-        attr_reader :node
-        attr_reader :parent
-
-        def initialize(node, parent = nil)
-          @node = node
-          @parent = parent
-        end
-
+      # @see http://www.germane-software.com/software/rexml/
+      module REXML
         ##
-        # Return xml:base on element, if defined
+        # Returns the name of the underlying XML library.
         #
-        # @return [String]
-        def base
-          @node.attribute("base", RDF::XML.to_s) || @node.attribute('xml:base')
+        # @return [Symbol]
+        def self.library
+          :rexml
         end
 
-        def display_path
-          @display_path ||= begin
-            path = []
-            path << parent.display_path if parent
-            path << @node.name
-            case @node
-            when ::REXML::Element   then path.join("/")
-            when ::REXML::Attribute then path.join("@")
-            else path.join("?")
+        # Proxy class to implement uniform element accessors
+        class NodeProxy
+          attr_reader :node, :parent
+
+          def initialize(node, parent = nil)
+            @node = node
+            @parent = parent
+          end
+
+          ##
+          # Return xml:base on element, if defined
+          #
+          # @return [String]
+          def base
+            @node.attribute("base", RDF::XML.to_s) || @node.attribute('xml:base')
+          end
+
+          def display_path
+            @display_path ||= begin
+              path = []
+              path << parent.display_path if parent
+              path << @node.name
+              case @node
+              when ::REXML::Element   then path.join("/")
+              when ::REXML::Attribute then path.join("@")
+              else path.join("?")
+              end
             end
           end
-        end
 
-        ##
-        # Return true of all child elements are text
-        #
-        # @return [Array<:text, :element, :attribute>]
-        def text_content?
-          @node.children.all? {|c| c.is_a?(::REXML::Text)}
-        end
+          ##
+          # Return true of all child elements are text
+          #
+          # @return [Array<:text, :element, :attribute>]
+          def text_content?
+            @node.children.all?(::REXML::Text)
+          end
 
-        ##
-        # Children of this node
-        #
-        # @return [NodeSetProxy]
-        def children
-          NodeSetProxy.new(@node.children, self)
-        end
+          ##
+          # Children of this node
+          #
+          # @return [NodeSetProxy]
+          def children
+            NodeSetProxy.new(@node.children, self)
+          end
 
-        # Ancestors of this element, in order
-        def ancestors
-          @ancestors ||= parent ? parent.ancestors + [parent] : []
-        end
+          # Ancestors of this element, in order
+          def ancestors
+            @ancestors ||= parent ? parent.ancestors + [parent] : []
+          end
 
-        ##
-        # Inner text of an element
-        #
-        # @see http://apidock.com/ruby/REXML/Element/get_text#743-Get-all-inner-texts
-        # @return [String]
-        def inner_text
-          coder = HTMLEntities.new
-          ::REXML::XPath.match(@node,'.//text()').map { |e|
-            coder.decode(e)
-          }.join
-        end
+          ##
+          # Inner text of an element
+          #
+          # @see http://apidock.com/ruby/REXML/Element/get_text#743-Get-all-inner-texts
+          # @return [String]
+          def inner_text
+            coder = HTMLEntities.new
+            ::REXML::XPath.match(@node, './/text()').map do |e|
+              coder.decode(e)
+            end.join
+          end
 
-        ##
-        # Inner text of an element
-        #
-        # @see http://apidock.com/ruby/REXML/Element/get_text#743-Get-all-inner-texts
-        # @return [String]
-        def inner_html
-          @node.children.map(&:to_s).join
-        end
+          ##
+          # Inner text of an element
+          #
+          # @see http://apidock.com/ruby/REXML/Element/get_text#743-Get-all-inner-texts
+          # @return [String]
+          def inner_html
+            @node.children.map(&:to_s).join
+          end
 
-        def attribute_nodes
-          attrs = @node.attributes.dup.keep_if do |name, attr|
-            !name.start_with?('xmlns')
+          def attribute_nodes
+            attrs = @node.attributes.dup.keep_if do |name, _attr|
+              !name.start_with?('xmlns')
+            end
+            @attribute_nodes ||= (attrs.empty? ? attrs : NodeSetProxy.new(attrs, self))
           end
-          @attribute_nodes ||= (attrs.empty? ? attrs : NodeSetProxy.new(attrs, self))
-        end
 
-        ##
-        # Node type accessors
-        #
-        # @return [Boolean]
-        def text?
-          @node.is_a?(::REXML::Text)
-        end
+          ##
+          # Node type accessors
+          #
+          # @return [Boolean]
+          def text?
+            @node.is_a?(::REXML::Text)
+          end
 
-        def element?
-          @node.is_a?(::REXML::Element)
-        end
+          def element?
+            @node.is_a?(::REXML::Element)
+          end
 
-        def blank?
-          @node.is_a?(::REXML::Text) && @node.empty?
-        end
+          def blank?
+            @node.is_a?(::REXML::Text) && @node.empty?
+          end
 
-        def to_s; @node.to_s; end
+          def to_s
+            @node.to_s
+          end
 
-        def xpath(*args)
-          ::REXML::XPath.match(@node, *args).map do |n|
-            NodeProxy.new(n, parent)
+          def xpath(*args)
+            ::REXML::XPath.match(@node, *args).map do |n|
+              NodeProxy.new(n, parent)
+            end
+          end
+
+          def at_xpath(*args)
+            xpath(*args).first
           end
-        end
 
-        def at_xpath(*args)
-          xpath(*args).first
+          ##
+          # Proxy for everything else to @node
+          def method_missing(method, *args)
+            @node.send(method, *args)
+          end
         end
 
         ##
-        # Proxy for everything else to @node
-        def method_missing(method, *args)
-          @node.send(method, *args)
-        end
-      end
+        # NodeSet proxy
+        class NodeSetProxy
+          attr_reader :node_set, :parent
 
-      ##
-      # NodeSet proxy
-      class NodeSetProxy
-        attr_reader :node_set
-        attr_reader :parent
-
-        def initialize(node_set, parent)
-          @node_set = node_set
-          @parent = parent
-        end
+          def initialize(node_set, parent)
+            @node_set = node_set
+            @parent = parent
+          end
 
-        ##
-        # Return a proxy for each child
-        #
-        # @yield child
-        # @yieldparam [NodeProxy]
-        def each
-          @node_set.each do |c|
-            yield NodeProxy.new(c, parent)
+          ##
+          # Return a proxy for each child
+          #
+          # @yield child
+          # @yieldparam [NodeProxy]
+          def each
+            @node_set.each do |c|
+              yield NodeProxy.new(c, parent)
+            end
           end
-        end
 
-        ##
-        def to_html
-          node_set.map(&:to_s).join("")
+          ##
+          def to_html
+            node_set.map(&:to_s).join
+          end
+
+          ##
+          # Proxy for everything else to @node_set
+          def method_missing(method, *args)
+            @node_set.send(method, *args)
+          end
         end
 
         ##
-        # Proxy for everything else to @node_set
-        def method_missing(method, *args)
-          @node_set.send(method, *args)
-        end
-      end
+        # Initializes the underlying XML library.
+        #
+        # @param  [Hash{Symbol => Object}] options
+        # @return [NodeProxy] of document root
+        def initialize_html_rexml(input, _options = {})
+          require 'rexml/document' unless defined?(::REXML)
+          doc = case input
+          when ::REXML::Document
+            input
+          else
+            # Only parse as XML, no HTML mode
+            ::REXML::Document.new(input.respond_to?(:read) ? input.read : input.to_s)
+          end
 
-      ##
-      # Initializes the underlying XML library.
-      #
-      # @param  [Hash{Symbol => Object}] options
-      # @return [NodeProxy] of document root
-      def initialize_html_rexml(input, options = {})
-        require 'rexml/document' unless defined?(::REXML)
-        doc = case input
-        when ::REXML::Document
-          input
-        else
-          # Only parse as XML, no HTML mode
-          ::REXML::Document.new(input.respond_to?(:read) ? input.read : input.to_s)
+          NodeProxy.new(doc.root) if doc&.root
         end
-
-        NodeProxy.new(doc.root) if doc && doc.root
+        alias initialize_html initialize_html_rexml
       end
-      alias_method :initialize_html, :initialize_html_rexml
     end
   end
 end