micromicro 1.0.0 → 2.0.1

data/lib/micro_micro/item.rb

@@ -1,7 +1,38 @@
+# frozen_string_literal: true
+
 module MicroMicro
   class Item
     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]
+    # rubocop:disable Metrics
+    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.item_nodes?(context.ancestors) && Helpers.property_node?(context)
+        else
+          node_set_from(context.element_children, node_set)
+        end
+      end
+
+      node_set
+    end
+    # rubocop:enable Metrics
+
     # Parse a node for microformats2-encoded data.
     #
     # @param node [Nokogiri::XML::Element]
@@ -15,11 +46,11 @@ module MicroMicro
 
     # A collection of child items parsed from the node.
     #
-    # @see http://microformats.org/wiki/microformats2-parsing#parse_an_element_for_class_microformats
+    # @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.
@@ -29,28 +60,33 @@ module MicroMicro
       @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 ||= Collections::PropertiesCollection.new(properties.select { |property| property.prefix == 'p' })
+      @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
 
     # Return the parsed item as a Hash.
     #
-    # @see http://microformats.org/wiki/microformats2-parsing#parse_an_element_for_class_microformats
+    # @see https://microformats.org/wiki/microformats2-parsing#parse_an_element_for_class_microformats
     #
     # @return [Hash]
     def to_h
@@ -69,62 +105,14 @@ module MicroMicro
     #
     # @return [Array<String>]
     def types
-      @types ||= self.class.types_from(node)
+      @types ||= Helpers.root_class_names_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
+      @url_properties ||= properties.url_properties
     end
 
     private
@@ -133,7 +121,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]
@@ -143,7 +131,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 +141,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,17 +151,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,25 +9,15 @@ module MicroMicro
         @node = property.node
       end
 
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_a_p-_property
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_an_e-_property
+      # @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 ||= 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

data/lib/micro_micro/parsers/date_time_parser.rb

@@ -1,78 +1,113 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class DateTimeParser
-      # @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 if normalized_date || normalized_time || normalized_timezone
+        @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,3 +1,5 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class DateTimePropertyParser < BasePropertyParser
@@ -7,7 +9,7 @@ module MicroMicro
         'value'    => %w[data input]
       }.freeze
 
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_a_dt-_property
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_a_dt-_property
       #
       # @return [String]
       def value
@@ -16,20 +18,19 @@ module MicroMicro
 
       private
 
-      # @see http://microformats.org/wiki/value-class-pattern#microformats2_parsers_implied_date
+      # @see https://microformats.org/wiki/value-class-pattern#microformats2_parsers_implied_date
       #
       # @return [MicroMicro::Parsers::DateTimeParser, nil]
       def adopted_date_time_parser
-        @adopted_date_time_parser ||= begin
-          date_time_siblings = (property.prev_all.reverse + property.next_all).select { |prop| prop.prefix == 'dt' }
-
-          date_time_siblings.map { |prop| DateTimeParser.new(prop.value) }.find(&:normalized_date)
-        end
+        @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 [String, nil]
       def attribute_value
-        self.class.attribute_value_from(node, HTML_ATTRIBUTES_MAP)
+        Helpers.attribute_value_from(node, HTML_ATTRIBUTES_MAP)
       end
 
       # @return [MicroMicro::Parsers::DateTimeParser]
@@ -37,7 +38,7 @@ module MicroMicro
         @date_time_parser ||= DateTimeParser.new(ValueClassPatternParser.new(node, ' ').value)
       end
 
-      # @see http://microformats.org/wiki/value-class-pattern#microformats2_parsers_implied_date
+      # @see https://microformats.org/wiki/value-class-pattern#microformats2_parsers_implied_date
       #
       # @return [Boolean]
       def imply_date?

data/lib/micro_micro/parsers/embedded_markup_property_parser.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class EmbeddedMarkupPropertyParser < BasePropertyParser
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_an_e-_property
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_an_e-_property
       #
       # @return [Hash{Symbol => String}]
       def value
-        @value ||= begin
+        @value ||=
           {
             html: node.inner_html.strip,
             value: super
           }
-        end
       end
     end
   end

data/lib/micro_micro/parsers/implied_name_property_parser.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
-    class ImpliedNamePropertyParser < BasePropertyParser
-      HTML_ATTRIBUTES_MAP = {
-        'alt'   => %w[area img],
-        'title' => %w[abbr]
+    class ImpliedNamePropertyParser < BaseImpliedPropertyParser
+      HTML_ELEMENTS_MAP = {
+        'img'  => 'alt',
+        'area' => 'alt',
+        'abbr' => 'title'
       }.freeze
 
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
       #
       # @return [String]
       def value
@@ -15,24 +18,19 @@ module MicroMicro
 
       private
 
-      # @return [Nokogiri::XML::NodeSet]
-      def candidate_nodes
-        @candidate_nodes ||= Nokogiri::XML::NodeSet.new(node.document, child_nodes.unshift(node))
-      end
-
       # @return [Array]
       def child_nodes
-        [node.at_css('> :only-child'), node.at_css('> :only-child > :only-child')].compact.reject { |child_node| Item.item_node?(child_node) }
-      end
-
-      # @return [String, nil]
-      def attribute_value
-        candidate_nodes.map { |node| self.class.attribute_value_from(node, HTML_ATTRIBUTES_MAP) }.compact.first
+        [
+          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 text_content
-        @text_content ||= Document.text_content_from(node) { |context| context.css('img').each { |img| img.content = img['alt'] } }
+        Helpers.text_content_from(node) do |context|
+          context.css('img').each { |img| img.content = img['alt'] }
+        end
       end
     end
   end

data/lib/micro_micro/parsers/implied_photo_property_parser.rb

@@ -1,64 +1,40 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
-    class ImpliedPhotoPropertyParser < BasePropertyParser
+    class ImpliedPhotoPropertyParser < BaseImpliedPropertyParser
+      CSS_SELECTORS_ARRAY = ['> img[src]:only-of-type', '> object[data]:only-of-type'].freeze
+
       HTML_ELEMENTS_MAP = {
         'img'    => 'src',
         'object' => 'data'
       }.freeze
 
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
-      # @see http://microformats.org/wiki/microformats2-parsing#parse_an_img_element_for_src_and_alt
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+      # @see https://microformats.org/wiki/microformats2-parsing#parse_an_img_element_for_src_and_alt
       #
       # @return [String, Hash{Symbol => String}, nil]
       def value
-        @value ||= begin
-          return unless resolved_value
-          return resolved_value unless value_node.matches?('img[alt]')
-
-          {
-            value: resolved_value,
-            alt: value_node['alt'].strip
-          }
-        end
+        @value ||=
+          if attribute_value
+            return attribute_value unless candidate_node.matches?('img[alt]')
+
+            {
+              value: attribute_value,
+              alt: candidate_node['alt'].strip
+            }
+          end
       end
 
       private
 
-      # @return [Array<String>]
-      def attribute_values
-        @attribute_values ||= begin
-          HTML_ELEMENTS_MAP.map do |element, attribute|
-            node if node.matches?("#{element}[#{attribute}]")
-          end.compact
-        end
-      end
-
-      # @return [String, nil]
-      def resolved_value
-        @resolved_value ||= value_node[HTML_ELEMENTS_MAP[value_node.name]] if value_node
-      end
+      # @return [Array]
+      def child_nodes
+        nodes = [node.at_css(*CSS_SELECTORS_ARRAY)]
 
-      # @return [Nokogiri::XML::Element, nil]
-      def value_node
-        @value_node ||= begin
-          return attribute_values.first if attribute_values.any?
-
-          HTML_ELEMENTS_MAP.each do |element, attribute|
-            child_node = node.at_css("> #{element}[#{attribute}]:only-of-type")
-
-            return child_node if child_node && !Item.item_node?(child_node) && element == child_node.name && child_node[attribute]
-          end
-
-          if node.element_children.one? && !Item.item_node?(node.first_element_child)
-            HTML_ELEMENTS_MAP.each do |element, attribute|
-              child_node = node.first_element_child.at_css("> #{element}[#{attribute}]:only-of-type")
-
-              return child_node if child_node && !Item.item_node?(child_node) && element == child_node.name && child_node[attribute]
-            end
-          end
+        nodes << node.first_element_child.at_css(*CSS_SELECTORS_ARRAY) if node.element_children.one?
 
-          nil
-        end
+        nodes.compact.reject { |child_node| Helpers.item_node?(child_node) }
       end
     end
   end