micromicro 1.1.0 → 3.0.0

data/lib/micro_micro/document.rb

@@ -1,35 +1,13 @@
+# frozen_string_literal: true
+
 module MicroMicro
   class Document
-    # A map of HTML `srcset` attributes and their associated element names
-    #
-    # @see https://html.spec.whatwg.org/#srcset-attributes
-    # @see https://html.spec.whatwg.org/#attributes-3
-    HTML_IMAGE_CANDIDATE_STRINGS_ATTRIBUTES_MAP = {
-      'imagesrcset' => %w[link],
-      'srcset'      => %w[img source]
-    }.freeze
-
-    # A map of HTML URL attributes and their associated element names
-    #
-    # @see https://html.spec.whatwg.org/#attributes-3
-    HTML_URL_ATTRIBUTES_MAP = {
-      'action'     => %w[form],
-      'cite'       => %w[blockquote del ins q],
-      'data'       => %w[object],
-      'formaction' => %w[button input],
-      'href'       => %w[a area base link],
-      'manifest'   => %w[html],
-      'ping'       => %w[a area],
-      'poster'     => %w[video],
-      'src'        => %w[audio embed iframe img input script source track video]
-    }.freeze
-
     # Parse a string of HTML for microformats2-encoded data.
     #
+    # @example Parse a String of markup
     #   MicroMicro::Document.new('<a href="/" class="h-card" rel="me">Jason Garber</a>', 'https://sixtwothree.org')
     #
-    # Or, pull the source HTML of a page on the Web:
-    #
+    # @example Parse a String of markup from a URL
     #   url = 'https://tantek.com'
     #   markup = Net::HTTP.get(URI.parse(url))
     #
@@ -38,34 +16,41 @@ module MicroMicro
     # @param markup [String] The HTML to parse for microformats2-encoded data.
     # @param base_url [String] The URL associated with markup. Used for relative URL resolution.
     def initialize(markup, base_url)
-      @markup = markup
-      @base_url = base_url
-
-      resolve_relative_urls
+      @document = Nokogiri::HTML(markup, base_url).resolve_relative_urls!
     end
 
     # @return [String]
+    #
+    # :nocov:
     def inspect
-      format(%(#<#{self.class.name}:%#0x items: #{items.inspect}, relationships: #{relationships.inspect}>), object_id)
+      "#<#{self.class}:#{format('%#0x', object_id)} " \
+        "items: #{items.inspect}, " \
+        "relationships: #{relationships.inspect}>"
     end
+    # :nocov:
 
-    # A collection of items parsed from the provided markup.
+    # A collection of {MicroMicro::Item}s parsed from the provided markup.
     #
     # @return [MicroMicro::Collections::ItemsCollection]
     def items
-      @items ||= Collections::ItemsCollection.new(Item.items_from(document))
+      @items ||= Collections::ItemsCollection.new(Item.from_context(document.element_children))
     end
 
-    # A collection of relationships parsed from the provided markup.
+    # A collection of {MicroMicro::Relationship}s parsed from the provided markup.
     #
     # @return [MicroMicro::Collections::RelationshipsCollection]
     def relationships
-      @relationships ||= Collections::RelationshipsCollection.new(Relationship.relationships_from(document))
+      @relationships ||= Collections::RelationshipsCollection.new(Relationship.from_context(document))
     end
 
     # Return the parsed document as a Hash.
     #
     # @see https://microformats.org/wiki/microformats2-parsing#parse_a_document_for_microformats
+    #   microformats.org: Parse a document for microformats
+    #
+    # @see MicroMicro::Collections::ItemsCollection#to_a
+    # @see MicroMicro::Collections::RelationshipsCollection#group_by_rel
+    # @see MicroMicro::Collections::RelationshipsCollection#group_by_url
     #
     # @return [Hash{Symbol => Array, Hash}]
     def to_h
@@ -76,76 +61,9 @@ module MicroMicro
       }
     end
 
-    # Ignore this node?
-    #
-    # @param node [Nokogiri::XML::Element]
-    # @return [Boolean]
-    def self.ignore_node?(node)
-      ignored_node_names.include?(node.name)
-    end
-
-    # A list of HTML element names the parser should ignore.
-    #
-    # @return [Array<String>]
-    def self.ignored_node_names
-      %w[script style template]
-    end
-
-    # @see https://microformats.org/wiki/microformats2-parsing#parse_an_element_for_properties
-    # @see https://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
-    #
-    # @param context [Nokogiri::HTML::Document, Nokogiri::XML::NodeSet, Nokogiri::XML::Element]
-    # @yield [context]
-    # @return [String]
-    def self.text_content_from(context)
-      context.css(*ignored_node_names).unlink
-
-      yield(context) if block_given?
-
-      context.text.strip
-    end
-
     private
 
-    attr_reader :base_url, :markup
-
-    # @return [Nokogiri::XML::Element, nil]
-    def base_element
-      @base_element ||= Nokogiri::HTML(markup).at('//base[@href]')
-    end
-
     # @return [Nokogiri::HTML::Document]
-    def document
-      @document ||= Nokogiri::HTML(markup, resolved_base_url)
-    end
-
-    def resolve_relative_urls
-      HTML_URL_ATTRIBUTES_MAP.each do |attribute, names|
-        document.xpath(*names.map { |name| "//#{name}[@#{attribute}]" }).each do |node|
-          node[attribute] = Addressable::URI.join(resolved_base_url, node[attribute].strip).normalize.to_s
-        end
-      end
-
-      HTML_IMAGE_CANDIDATE_STRINGS_ATTRIBUTES_MAP.each do |attribute, names|
-        document.xpath(*names.map { |name| "//#{name}[@#{attribute}]" }).each do |node|
-          candidates = node[attribute].split(',').map(&:strip).map { |candidate| candidate.match(/^(?<url>.+?)(?<descriptor>\s+.+)?$/) }
-
-          node[attribute] = candidates.map { |candidate| "#{Addressable::URI.join(resolved_base_url, candidate[:url]).normalize}#{candidate[:descriptor]}" }.join(', ')
-        end
-      end
-
-      self
-    end
-
-    # @return [String]
-    def resolved_base_url
-      @resolved_base_url ||= begin
-        if base_element
-          Addressable::URI.join(base_url, base_element['href'].strip).normalize.to_s
-        else
-          base_url
-        end
-      end
-    end
+    attr_reader :document
   end
 end

data/lib/micro_micro/helpers.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module MicroMicro
+  module Helpers
+    IGNORED_NODE_NAMES = %w[script style template].freeze
+
+    private_constant :IGNORED_NODE_NAMES
+
+    # @param node [Nokogiri::XML::Element]
+    # @param attributes_map [Hash{String => Array}]
+    # @return [String, nil]
+    def self.attribute_value_from(node, attributes_map)
+      attributes_map.filter_map do |attribute, names|
+        node[attribute] if names.include?(node.name) && node[attribute]
+      end.first
+    end
+
+    # @param node [Nokogiri::XML::Element]
+    # @return [Boolean]
+    def self.ignore_node?(node)
+      IGNORED_NODE_NAMES.include?(node.name)
+    end
+
+    # @param nodes [Nokogiri::XML::NodeSet]
+    # @return [Boolean]
+    def self.ignore_nodes?(nodes)
+      (nodes.map(&:name) & IGNORED_NODE_NAMES).any?
+    end
+
+    # @param node [Nokogiri::XML::Element]
+    # @return [Boolean]
+    def self.item_node?(node)
+      root_class_names_from(node).any?
+    end
+
+    # @param nodes [Nokogiri::XML::NodeSet]
+    # @return [Boolean]
+    def self.item_nodes?(nodes)
+      nodes.filter_map { |node| item_node?(node) }.any?
+    end
+
+    # @param node [Nokogiri::XML::Element]
+    # @return [Array<String>]
+    def self.property_class_names_from(node)
+      node.classes.grep(/^(?:dt|e|p|u)(?:-[0-9a-z]+)?(?:-[a-z]+)+$/).uniq
+    end
+
+    # @param node [Nokogiri::XML::Element]
+    # @return [Boolean]
+    def self.property_node?(node)
+      property_class_names_from(node).any?
+    end
+
+    # @param node [Nokogiri::XML::Element]
+    # @return [Array<String>]
+    def self.root_class_names_from(node)
+      node.classes.grep(/^h(?:-[0-9a-z]+)?(?:-[a-z]+)+$/).uniq.sort
+    end
+
+    # @see https://microformats.org/wiki/microformats2-parsing#parse_an_element_for_properties
+    #   microformats.org: microformats2 parsing specification § Parse an element for properties
+    # @see https://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+    #   microformats.org: microformats2 parsing specification § Parsing for implied properties
+    #
+    # @param context [Nokogiri::HTML::Document, Nokogiri::XML::NodeSet, Nokogiri::XML::Element]
+    # @yield [context]
+    # @return [String]
+    def self.text_content_from(context)
+      context.css(*IGNORED_NODE_NAMES).unlink
+
+      yield(context) if block_given?
+
+      context.text.strip
+    end
+
+    # @see https://microformats.org/wiki/value-class-pattern#Basic_Parsing
+    #   microformats.org: Value Class Pattern § Basic Parsing
+    #
+    # @param node [Nokogiri::XML::Element]
+    # @return [Boolean]
+    def self.value_class_node?(node)
+      node.classes.include?('value')
+    end
+
+    # @see https://microformats.org/wiki/value-class-pattern#Parsing_value_from_a_title_attribute
+    #   microformats.org: Value Class Pattern § Parsing value from a title attribute
+    #
+    # @param node [Nokogiri::XML::Element]
+    # @return [Boolean]
+    def self.value_title_node?(node)
+      node.classes.include?('value-title')
+    end
+  end
+end

data/lib/micro_micro/implied_property.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MicroMicro
   class ImpliedProperty < Property
     IMPLIED_PROPERTY_PARSERS_MAP = {
@@ -6,11 +8,24 @@ module MicroMicro
       'url'   => Parsers::ImpliedUrlPropertyParser
     }.freeze
 
+    private_constant :IMPLIED_PROPERTY_PARSERS_MAP
+
+    # Always return +true+ when asked if this {MicroMicro::ImpliedProperty} is
+    # an implied property.
+    #
+    # @see https://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+    #   microformats.org: microformats2 parsing specification § Parsing for implied properties
+    #
+    # @see MicroMicro::Property#implied?
+    #
     # @return [Boolean]
     def implied?
       true
     end
 
+    # Always return +false+ when asked if this {MicroMicro::ImpliedProperty} is
+    # a {MicroMicro::Item} node.
+    #
     # @return [Boolean]
     def item_node?
       false

data/lib/micro_micro/item.rb

@@ -1,10 +1,50 @@
+# frozen_string_literal: true
+
 module MicroMicro
   class Item
     include Collectible
 
+    class ItemNodeSearch
+      attr_reader :node_set
+
+      def initialize(document)
+        @node_set = Nokogiri::XML::NodeSet.new(document, [])
+      end
+
+      # rubocop:disable Metrics
+      def search(context)
+        context.each { |node| search(node) } if context.is_a?(Nokogiri::XML::NodeSet)
+
+        if context.is_a?(Nokogiri::XML::Element) && !Helpers.ignore_node?(context)
+          if Helpers.item_node?(context)
+            node_set << context unless Helpers.item_nodes?(context.ancestors) && Helpers.property_node?(context)
+          else
+            search(context.element_children)
+          end
+        end
+
+        node_set
+      end
+      # rubocop:enable Metrics
+    end
+
+    private_constant :ItemNodeSearch
+
+    # Extract {MicroMicro::Item}s from a context.
+    #
+    # @param context [Nokogiri::HTML::Document, Nokogiri::XML::NodeSet, Nokogiri::XML::Element]
+    # @return [Array<MicroMicro::Item>]
+    def self.from_context(context)
+      ItemNodeSearch
+        .new(context.document)
+        .search(context)
+        .map { |node| new(node) }
+    end
+
     # Parse a node for microformats2-encoded data.
     #
     # @param node [Nokogiri::XML::Element]
+    # @return [MicroMicro::Item]
     def initialize(node)
       @node = node
 
@@ -13,44 +53,65 @@ module MicroMicro
       properties << implied_url if implied_url?
     end
 
-    # A collection of child items parsed from the node.
+    # A collection of child {MicroMicro::Item}s parsed from the node.
     #
     # @see https://microformats.org/wiki/microformats2-parsing#parse_an_element_for_class_microformats
+    #   microformats.org: microformats2 parsing specification § Parse an element for class microformats
     #
     # @return [MicroMicro::Collections::ItemsCollection]
     def children
-      @children ||= Collections::ItemsCollection.new(Item.items_from(node.element_children))
+      @children ||= Collections::ItemsCollection.new(self.class.from_context(node.element_children))
     end
 
-    # The value of the node's `id` attribute, if present.
+    # Does this {MicroMicro::Item} contain any child {MicroMicro::Item}s?
+    #
+    # @return [Boolean]
+    def children?
+      children.any?
+    end
+
+    # The value of the node's +id+ attribute, if present.
     #
     # @return [String, nil]
     def id
       @id ||= node['id']&.strip
     end
 
-    # @return [String]
-    def inspect
-      format(%(#<#{self.class.name}:%#0x types: #{types.inspect}, properties: #{properties.count}, children: #{children.count}>), object_id)
+    # Does this {MicroMicro::Item} have an +id+ attribute value?
+    #
+    # @return [Boolean]
+    def id?
+      id.present?
     end
 
-    # A collection of plain text properties parsed from the node.
+    # @return [String]
     #
-    # @return [MicroMicro::Collections::PropertiesCollection]
-    def plain_text_properties
-      @plain_text_properties ||= Collections::PropertiesCollection.new(properties.select { |property| property.prefix == 'p' })
+    # :nocov:
+    def inspect
+      "#<#{self.class}:#{format('%#0x', object_id)} " \
+        "types: #{types.inspect}, " \
+        "properties: #{properties.count}, " \
+        "children: #{children.count}>"
     end
+    # :nocov:
 
-    # A collection of properties parsed from the node.
+    # A collection of {MicroMicro::Property}s parsed from the node.
     #
     # @return [MicroMicro::Collections::PropertiesCollection]
     def properties
-      @properties ||= Collections::PropertiesCollection.new(Property.properties_from(node.element_children))
+      @properties ||= Collections::PropertiesCollection.new(Property.from_context(node.element_children))
     end
 
-    # Return the parsed item as a Hash.
+    # Return the parsed {MicroMicro::Item} as a Hash.
     #
     # @see https://microformats.org/wiki/microformats2-parsing#parse_an_element_for_class_microformats
+    #   microformats.org: microformats2 parsing specification § Parse an element for class microformats
+    #
+    # @see MicroMicro::Item#children
+    # @see MicroMicro::Item#id
+    # @see MicroMicro::Item#properties
+    # @see MicroMicro::Item#types
+    # @see MicroMicro::Collections::PropertiesCollection#to_h
     #
     # @return [Hash]
     def to_h
@@ -59,81 +120,27 @@ module MicroMicro
         properties: properties.to_h
       }
 
-      hash[:id] = id if id.present?
-      hash[:children] = children.to_a if children.any?
+      hash[:id] = id if id?
+      hash[:children] = children.to_a if children?
 
       hash
     end
 
-    # An array of root class names parsed from the node's `class` attribute.
+    # An Array of root class names parsed from the node's +class+ attribute.
     #
     # @return [Array<String>]
     def types
-      @types ||= self.class.types_from(node)
-    end
-
-    # A collection of url properties parsed from the node.
-    #
-    # @return [MicroMicro::Collections::PropertiesCollection]
-    def url_properties
-      @url_properties ||= Collections::PropertiesCollection.new(properties.select { |property| property.prefix == 'u' })
-    end
-
-    # Does this node's `class` attribute contain root class names?
-    #
-    # @param node [Nokogiri::XML::Element]
-    # @return [Boolean]
-    def self.item_node?(node)
-      types_from(node).any?
-    end
-
-    # Extract items from a context.
-    #
-    # @param context [Nokogiri::HTML::Document, Nokogiri::XML::NodeSet, Nokogiri::XML::Element]
-    # @return [Array<MicroMicro::Item>]
-    def self.items_from(context)
-      nodes_from(context).map { |node| new(node) }
-    end
-
-    # Extract item nodes from a context.
-    #
-    # @param context [Nokogiri::HTML::Document, Nokogiri::XML::NodeSet, Nokogiri::XML::Element]
-    # @param node_set [Nokogiri::XML::NodeSet]
-    # @return [Nokogiri::XML::NodeSet]
-    def self.nodes_from(context, node_set = Nokogiri::XML::NodeSet.new(context.document, []))
-      return nodes_from(context.element_children, node_set) if context.is_a?(Nokogiri::HTML::Document)
-
-      context.each { |node| nodes_from(node, node_set) } if context.is_a?(Nokogiri::XML::NodeSet)
-
-      if context.is_a?(Nokogiri::XML::Element) && !Document.ignore_node?(context)
-        if item_node?(context)
-          node_set << context unless Property.property_node?(context)
-        else
-          nodes_from(context.element_children, node_set)
-        end
-      end
-
-      node_set
-    end
-
-    # Extract root class names from a node.
-    #
-    #   node = Nokogiri::HTML('<div class="h-card">Jason Garber</div>').at_css('div')
-    #   MicroMicro::Item.types_from(node) #=> ['h-card']
-    #
-    # @param node [Nokogiri::XML::Element]
-    # @return [Array<String>]
-    def self.types_from(node)
-      node.classes.select { |token| token.match?(/^h(?:-[0-9a-z]+)?(?:-[a-z]+)+$/) }.uniq.sort
+      @types ||= Helpers.root_class_names_from(node)
     end
 
     private
 
+    # @return [Nokogiri::XML::Element]
     attr_reader :node
 
     # @return [MicroMicro::ImpliedProperty]
     def implied_name
-      @implied_name ||= ImpliedProperty.new(node, name: 'name', prefix: 'p')
+      @implied_name ||= ImpliedProperty.new(node, 'p-name')
     end
 
     # @return [Boolean]
@@ -143,7 +150,7 @@ module MicroMicro
 
     # @return [MicroMicro::ImpliedProperty]
     def implied_photo
-      @implied_photo ||= ImpliedProperty.new(node, name: 'photo', prefix: 'u')
+      @implied_photo ||= ImpliedProperty.new(node, 'u-photo')
     end
 
     # @return [Boolean]
@@ -153,7 +160,7 @@ module MicroMicro
 
     # @return [MicroMicro::ImpliedProperty]
     def implied_url
-      @implied_url ||= ImpliedProperty.new(node, name: 'url', prefix: 'u')
+      @implied_url ||= ImpliedProperty.new(node, 'u-url')
     end
 
     # @return [Boolean]
@@ -163,22 +170,29 @@ module MicroMicro
 
     # @return [Boolean]
     def imply_name?
-      properties.none? { |prop| prop.name == 'name' } && properties.none? { |prop| %w[e p].include?(prop.prefix) } && !nested_items?
+      properties.names.none?('name') &&
+        properties.none?(&:embedded_markup_property?) &&
+        properties.none?(&:plain_text_property?) &&
+        !nested_items?
     end
 
     # @return [Boolean]
     def imply_photo?
-      properties.none? { |prop| prop.name == 'photo' } && properties.reject(&:implied?).none? { |prop| prop.prefix == 'u' } && !nested_items?
+      properties.names.none?('photo') &&
+        properties.reject(&:implied?).none?(&:url_property?) &&
+        !nested_items?
     end
 
     # @return [Boolean]
     def imply_url?
-      properties.none? { |prop| prop.name == 'url' } && properties.reject(&:implied?).none? { |prop| prop.prefix == 'u' } && !nested_items?
+      properties.names.none?('url') &&
+        properties.reject(&:implied?).none?(&:url_property?) &&
+        !nested_items?
     end
 
     # @return [Boolean]
     def nested_items?
-      @nested_items ||= properties.find(&:item_node?) || children.any?
+      @nested_items ||= properties.find(&:item_node?) || children?
     end
   end
 end

data/lib/micro_micro/parsers/base_implied_property_parser.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module MicroMicro
+  module Parsers
+    class BaseImpliedPropertyParser < BasePropertyParser
+      private
+
+      # @return [String, nil]
+      def attribute_value
+        candidate_node[self.class::HTML_ELEMENTS_MAP[candidate_node.name]] if candidate_node
+      end
+
+      # @return [Nokogiri::XML::Element, nil]
+      def candidate_node
+        @candidate_node ||=
+          candidate_nodes.find do |node|
+            self.class::HTML_ELEMENTS_MAP.filter_map do |name, attribute|
+              node if name == node.name && node[attribute]
+            end.any?
+          end
+      end
+
+      # @return [Nokogiri::XML::NodeSet]
+      def candidate_nodes
+        Nokogiri::XML::NodeSet.new(node.document, child_nodes.unshift(node))
+      end
+    end
+  end
+end

data/lib/micro_micro/parsers/base_property_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class BasePropertyParser
@@ -8,24 +10,16 @@ module MicroMicro
       end
 
       # @see https://microformats.org/wiki/microformats2-parsing#parsing_a_p-_property
+      #   microformats.org: microformats2 parsing specification § Parsing a +p-+ property
       # @see https://microformats.org/wiki/microformats2-parsing#parsing_an_e-_property
+      #   microformats.org: microformats2 parsing specification § Parsing an +e-+ property
       #
       # @return [String]
       def value
-        @value ||= begin
-          Document.text_content_from(node) do |context|
+        @value ||=
+          Helpers.text_content_from(node) do |context|
             context.css('img').each { |img| img.content = " #{img['alt'] || img['src']} " }
           end
-        end
-      end
-
-      # @param node [Nokogiri::XML::Element]
-      # @param attributes_map [Hash{String => Array}]
-      # @return [Array]
-      def self.attribute_value_from(node, attributes_map)
-        attributes_map.map do |attribute, names|
-          node[attribute] if names.include?(node.name) && node[attribute]
-        end.compact.first
       end
 
       private