micromicro 0.1.0 → 2.0.0

data/lib/micro_micro/item.rb

@@ -1,7 +1,38 @@
+# frozen_string_literal: true
+
 module MicroMicro
   class Item
-    attr_accessor :value
+    include Collectible
+
+    # Extract items from a context.
+    #
+    # @param context [Nokogiri::HTML::Document, Nokogiri::XML::NodeSet, Nokogiri::XML::Element]
+    # @return [Array<MicroMicro::Item>]
+    def self.from_context(context)
+      node_set_from(context).map { |node| new(node) }
+    end
+
+    # Extract item nodes from a context.
+    #
+    # @param context [Nokogiri::XML::NodeSet, Nokogiri::XML::Element]
+    # @param node_set [Nokogiri::XML::NodeSet]
+    # @return [Nokogiri::XML::NodeSet]
+    def self.node_set_from(context, node_set = Nokogiri::XML::NodeSet.new(context.document, []))
+      context.each { |node| node_set_from(node, node_set) } 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.property_node?(context)
+        else
+          node_set_from(context.element_children, node_set)
+        end
+      end
+
+      node_set
+    end
 
+    # Parse a node for microformats2-encoded data.
+    #
     # @param node [Nokogiri::XML::Element]
     def initialize(node)
       @node = node
@@ -11,28 +42,49 @@ module MicroMicro
       properties << implied_url if implied_url?
     end
 
+    # A collection of child items parsed from the node.
+    #
+    # @see https://microformats.org/wiki/microformats2-parsing#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.
+    #
     # @return [String, nil]
     def id
       @id ||= node['id']&.strip
     end
 
+    # :nocov:
     # @return [String]
     def inspect
-      format(%(#<#{self.class.name}:%#0x types: #{types.inspect}, properties: #{properties.count}, children: #{children.count}>), object_id)
+      "#<#{self.class}:#{format('%#0x', object_id)} " \
+        "types: #{types.inspect}, " \
+        "properties: #{properties.count}, " \
+        "children: #{children.count}>"
+    end
+    # :nocov:
+
+    # A collection of plain text properties parsed from the node.
+    #
+    # @return [MicroMicro::Collections::PropertiesCollection]
+    def plain_text_properties
+      @plain_text_properties ||= properties.plain_text_properties
     end
 
+    # A collection of properties 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
 
-    # @see microformats2 Parsing Specification section 1.2
-    # @see http://microformats.org/wiki/microformats2-parsing#parse_an_element_for_class_microformats
+    # Return the parsed item as a Hash.
+    #
+    # @see https://microformats.org/wiki/microformats2-parsing#parse_an_element_for_class_microformats
     #
     # @return [Hash]
     def to_h
@@ -43,55 +95,22 @@ module MicroMicro
 
       hash[:id] = id if id.present?
       hash[:children] = children.to_a if children.any?
-      hash[:value] = value if value.present?
 
       hash
     end
 
+    # An array of root class names parsed from the node's `class` attribute.
+    #
     # @return [Array<String>]
     def types
-      @types ||= self.class.types_from(node)
+      @types ||= Helpers.root_class_names_from(node)
     end
 
-    # @param node [Nokogiri::XML::Element]
-    # @return [Boolean]
-    def self.item_node?(node)
-      types_from(node).any?
-    end
-
-    # @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
-
-    # @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
-
-    # @param node [Nokogiri::XML::Element]
-    # @return [Array<String>]
+    # A collection of url properties parsed from the node.
     #
-    # @example
-    #   node = Nokogiri::HTML('<div class="h-card">Jason Garber</div>').at_css('div')
-    #   MicroMicro::Item.types_from(node) #=> ['h-card']
-    def self.types_from(node)
-      node.classes.select { |token| token.match?(/^h(?:\-[0-9a-z]+)?(?:\-[a-z]+)+$/) }.uniq.sort
+    # @return [MicroMicro::Collections::PropertiesCollection]
+    def url_properties
+      @url_properties ||= properties.url_properties
     end
 
     private
@@ -100,7 +119,7 @@ module MicroMicro
 
     # @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]
@@ -110,7 +129,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]
@@ -120,7 +139,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]
@@ -130,17 +149,24 @@ 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]

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
@@ -7,27 +9,20 @@ module MicroMicro
         @node = property.node
       end
 
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_a_p-_property
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_an_e-_property
+      #
       # @return [String]
       def value
-        @value ||= serialized_node.text.strip
+        @value ||=
+          Helpers.text_content_from(node) do |context|
+            context.css('img').each { |img| img.content = " #{img['alt'] || img['src']} " }
+          end
       end
 
       private
 
       attr_reader :node, :property
-
-      # @see microformats2 Parsing Specification sections 1.3.1 and 1.3.4
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_a_p-_property
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_an_e-_property
-      def serialized_node
-        @serialized_node ||= begin
-          node.css(*Document.ignored_node_names).unlink
-
-          node.css('img').each { |img| img.content = " #{img['alt'] || Absolutely.to_abs(base: node.document.url, relative: img['src'])} " }
-
-          node
-        end
-      end
     end
   end
 end

data/lib/micro_micro/parsers/date_time_parser.rb

@@ -1,84 +1,113 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class DateTimeParser
-      # @see Value Class Pattern section 4.2
-      # @see http://microformats.org/wiki/value-class-pattern#Date_and_time_parsing
-      #
       # Regexp pattern matching YYYY-MM-DD and YYY-DDD
-      DATE_REGEXP_PATTERN = '(?<year>\d{4})-((?<ordinal>3[0-6]{2}|[0-2]\d{2})|(?<month>0\d|1[0-2])-(?<day>3[0-1]|[0-2]\d))'.freeze
-      # Regexp pattern matching HH:MM and HH:MM:SS
-      TIME_REGEXP_PATTERN = '(?<hours>2[0-3]|[0-1]?\d)(?::(?<minutes>[0-5]\d))?(?::(?<seconds>[0-5]\d))?(?:\s*?(?<abbreviation>[apPP]\.?[mM]\.?))?'.freeze
-      # Regexp pattern matching +/-(XX:YY|XXYY|XX) or the literal string Z
-      TIMEZONE_REGEXP_PATTERN = '(?<zulu>Z)|(?<offset>(?:\+|-)(?:1[0-2]|0?\d)(?::?[0-5]\d)?)'.freeze
+      DATE_REGEXP_PATTERN = '(?<year>\d{4})-' \
+                            '((?<ordinal>3[0-6]{2}|[0-2]\d{2})|(?<month>0\d|1[0-2])-' \
+                            '(?<day>3[0-1]|[0-2]\d))'
 
-      CAPTURE_NAMES = [:year, :ordinal, :month, :day, :hours, :minutes, :seconds, :abbreviation, :zulu, :offset].freeze
+      # Regexp pattern matching HH:MM and HH:MM:SS
+      TIME_REGEXP_PATTERN = '(?<hours>2[0-3]|[0-1]?\d)' \
+                            '(?::(?<minutes>[0-5]\d))?' \
+                            '(?::(?<seconds>[0-5]\d))?' \
+                            '(?:\s*?(?<abbreviation>[apPP]\.?[mM]\.?))?'
 
-      # @param string [String]
+      # Regexp pattern matching +/-(XX:YY|XXYY|XX) or the literal string Z
+      TIMEZONE_REGEXP_PATTERN = '(?<zulu>Z)|(?<offset>(?:\+|-)(?:1[0-2]|0?\d)(?::?[0-5]\d)?)'
+
+      # Regexp for extracting named captures from a datetime-esque String.
+      DATE_TIME_TIMEZONE_REGEXP = /
+        \A
+        (?=.)
+        (?:#{DATE_REGEXP_PATTERN})?
+        (?:\s?#{TIME_REGEXP_PATTERN}(?:#{TIMEZONE_REGEXP_PATTERN})?)?
+        \z
+      /x.freeze
+
+      # Parse a string for date and/or time values according to the Microformats
+      # Value Class Pattern date and time parsing specification.
+      #
+      # @see https://microformats.org/wiki/value-class-pattern#Date_and_time_parsing
+      #
+      # @param string [String, #to_s]
       def initialize(string)
-        @string = string
+        @string = string.to_s
       end
 
-      CAPTURE_NAMES.each do |name|
+      # Define getter and predicate methods for all possible named captures
+      # returned by the DATE_TIME_TIMEZONE_REGEXP regular expression.
+      [
+        :year, :ordinal, :month, :day,
+        :hours, :minutes, :seconds,
+        :abbreviation, :zulu, :offset
+      ].each do |name|
         define_method(name) { values[name] }
         define_method("#{name}?") { public_send(name).present? }
       end
 
+      # @return [String, nil]
       def normalized_calendar_date
         @normalized_calendar_date ||= "#{year}-#{month}-#{day}" if year? && month? && day?
       end
 
+      # @return [String, nil]
       def normalized_date
         @normalized_date ||= normalized_calendar_date || normalized_ordinal_date
       end
 
+      # @return [String, nil]
       def normalized_hours
-        @normalized_hours ||= begin
-          return unless hours?
-          return (hours.to_i + 12).to_s if abbreviation&.tr('.', '')&.downcase == 'pm'
+        @normalized_hours ||=
+          if hours?
+            return (hours.to_i + 12).to_s if abbreviation&.tr('.', '')&.downcase == 'pm'
 
-          format('%<hours>02d', hours: hours)
-        end
+            format('%<hours>02d', hours: hours)
+          end
       end
 
+      # @return [String]
       def normalized_minutes
         @normalized_minutes ||= minutes || '00'
       end
 
+      # @return [String, nil]
       def normalized_ordinal_date
         @normalized_ordinal_date ||= "#{year}-#{ordinal}" if year? && ordinal?
       end
 
+      # @return [String, nil]
       def normalized_time
         @normalized_time ||= [normalized_hours, normalized_minutes, seconds].compact.join(':') if normalized_hours
       end
 
+      # @return [String, nil]
       def normalized_timezone
         @normalized_timezone ||= zulu || offset&.tr(':', '')
       end
 
-      # @return [String]
+      # @return [String, nil]
       def value
-        @value ||= "#{normalized_date} #{normalized_time}#{normalized_timezone}".strip
-      end
-
-      # @return [Boolean]
-      def value?
-        value.present?
+        @value ||=
+          if normalized_date || normalized_time || normalized_timezone
+            "#{normalized_date} #{normalized_time}#{normalized_timezone}".strip
+          end
       end
 
       # @return [Hash{Symbol => String, nil}]
       def values
-        @values ||= self.class.values_from(string)
-      end
-
-      # @param string [String]
-      # @return [Hash{Symbol => String, nil}]
-      def self.values_from(string)
-        string&.match(/^(?:#{DATE_REGEXP_PATTERN})?(?:\s?#{TIME_REGEXP_PATTERN}(?:#{TIMEZONE_REGEXP_PATTERN})?)?$/)&.named_captures.to_h.symbolize_keys
+        @values ||=
+          if string.match?(DATE_TIME_TIMEZONE_REGEXP)
+            string.match(DATE_TIME_TIMEZONE_REGEXP).named_captures.symbolize_keys
+          else
+            {}
+          end
       end
 
       private
 
+      # @return [String]
       attr_reader :string
     end
   end

data/lib/micro_micro/parsers/date_time_property_parser.rb

@@ -1,65 +1,56 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class DateTimePropertyParser < BasePropertyParser
-      # @see microformats2 Parsing Specification section 1.3.3
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_a_dt-_property
       HTML_ATTRIBUTES_MAP = {
         'datetime' => %w[del ins time],
         'title'    => %w[abbr],
         'value'    => %w[data input]
       }.freeze
 
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_a_dt-_property
+      #
       # @return [String]
       def value
-        @value ||= begin
-          return resolved_value if date_time_parser.value?
-          return attribute_values.first if attribute_values.any?
-
-          super
-        end
+        @value ||= resolved_value || attribute_value || super
       end
 
       private
 
+      # @see https://microformats.org/wiki/value-class-pattern#microformats2_parsers_implied_date
+      #
       # @return [MicroMicro::Parsers::DateTimeParser, nil]
-      def adopted_date_time
-        @adopted_date_time ||= begin
-          collections = property.collection.select { |prop| prop.prefix == 'dt' }.split(property)
-
-          (collections.shift.reverse + collections).flatten.map { |prop| DateTimeParser.new(prop.value) }.find(&:normalized_date)
-        end
+      def adopted_date_time_parser
+        @adopted_date_time_parser ||=
+          (property.prev_all.reverse + property.next_all).filter_map do |prop|
+            DateTimeParser.new(prop.value) if prop.date_time_property?
+          end.find(&:normalized_date)
       end
 
-      # @return [Array<String>]
-      def attribute_values
-        @attribute_values ||= begin
-          HTML_ATTRIBUTES_MAP.map do |attribute, names|
-            node[attribute] if names.include?(node.name) && node[attribute]
-          end.compact
-        end
+      # @return [String, nil]
+      def attribute_value
+        Helpers.attribute_value_from(node, HTML_ATTRIBUTES_MAP)
       end
 
       # @return [MicroMicro::Parsers::DateTimeParser]
       def date_time_parser
-        @date_time_parser ||= DateTimeParser.new(value_class_pattern_parser.value)
+        @date_time_parser ||= DateTimeParser.new(ValueClassPatternParser.new(node, ' ').value)
       end
 
+      # @see https://microformats.org/wiki/value-class-pattern#microformats2_parsers_implied_date
+      #
       # @return [Boolean]
       def imply_date?
-        date_time_parser.normalized_time && !date_time_parser.normalized_date
+        date_time_parser.normalized_time && !date_time_parser.normalized_date && adopted_date_time_parser
       end
 
       # @return [String]
       def resolved_value
-        return "#{adopted_date_time.normalized_date} #{date_time_parser.value}" if imply_date? && adopted_date_time
+        return "#{adopted_date_time_parser.normalized_date} #{date_time_parser.value}" if imply_date?
 
         date_time_parser.value
       end
-
-      # @return [MicroMicro::Parsers::ValueClassPatternParser]
-      def value_class_pattern_parser
-        ValueClassPatternParser.new(node, ' ')
-      end
     end
   end
 end

data/lib/micro_micro/parsers/embedded_markup_property_parser.rb

@@ -1,27 +1,17 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class EmbeddedMarkupPropertyParser < BasePropertyParser
-      HTML_ATTRIBUTE_NAMES = %w[action cite code codebase data href poster src].freeze
-
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_an_e-_property
+      #
+      # @return [Hash{Symbol => String}]
       def value
-        @value ||= begin
+        @value ||=
           {
-            html: resolved_node.inner_html.strip,
+            html: node.inner_html.strip,
             value: super
           }
-        end
-      end
-
-      private
-
-      def resolved_node
-        @resolved_node ||= begin
-          HTML_ATTRIBUTE_NAMES.each do |attribute|
-            node.css("[#{attribute}]").each { |element| element[attribute] = Absolutely.to_abs(base: node.document.url, relative: element[attribute].strip) }
-          end
-
-          node
-        end
       end
     end
   end

data/lib/micro_micro/parsers/implied_name_property_parser.rb

@@ -1,77 +1,36 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
-    class ImpliedNamePropertyParser < BasePropertyParser
-      # @see microformats2 Parsing Specification section 1.3.5
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+    class ImpliedNamePropertyParser < BaseImpliedPropertyParser
       HTML_ELEMENTS_MAP = {
-        'area' => 'alt',
         'img'  => 'alt',
+        'area' => 'alt',
         'abbr' => 'title'
       }.freeze
 
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+      #
       # @return [String]
       def value
-        @value ||= unresolved_value.strip
+        @value ||= attribute_value || text_content
       end
 
       private
 
-      # @return [Array<String>]
-      def attribute_values
-        @attribute_values ||= begin
-          HTML_ELEMENTS_MAP.map do |element, attribute|
-            node[attribute] if node.matches?("#{element}[#{attribute}]")
-          end.compact
-        end
-      end
-
-      # @return [Nokogiri::XML::Element, nil]
-      def child_node
-        @child_node ||= node.at_css('> :only-child')
-      end
-
-      # @return [Array<String>]
-      def child_node_attribute_values
-        @child_node_attribute_values ||= begin
-          HTML_ELEMENTS_MAP.map do |element, attribute|
-            child_node[attribute] if child_node.matches?("#{element}[#{attribute}]")
-          end.compact
-        end
-      end
-
-      # @return [Nokogiri::XML::Element, nil]
-      def grandchild_node
-        @grandchild_node ||= child_node.at_css('> :only-child')
-      end
-
-      # @return [Array<String>]
-      def grandchild_node_attribute_values
-        @grandchild_node_attribute_values ||= begin
-          HTML_ELEMENTS_MAP.map do |element, attribute|
-            grandchild_node[attribute] if grandchild_node.matches?("#{element}[#{attribute}]")
-          end.compact
-        end
-      end
-
-      # @return [Boolean]
-      def parse_child_node?
-        child_node && !Item.item_node?(child_node)
-      end
-
-      # @return [Boolean]
-      def parse_grandchild_node?
-        parse_child_node? && grandchild_node && !Item.item_node?(grandchild_node)
+      # @return [Array]
+      def child_nodes
+        [
+          node.at_css('> :only-child'),
+          node.at_css('> :only-child > :only-child')
+        ].compact.reject { |child_node| Helpers.item_node?(child_node) }
       end
 
       # @return [String]
-      def unresolved_value
-        return attribute_values.first if attribute_values.any?
-        return child_node_attribute_values.first if parse_child_node? && child_node_attribute_values.any?
-        return grandchild_node_attribute_values.first if parse_grandchild_node? && grandchild_node_attribute_values.any?
-
-        serialized_node.css('img').each { |img| img.content = img['alt'] }
-
-        serialized_node.text
+      def text_content
+        Helpers.text_content_from(node) do |context|
+          context.css('img').each { |img| img.content = img['alt'] }
+        end
       end
     end
   end