micromicro 1.1.0 → 3.0.0

data/lib/micro_micro/parsers/date_time_parser.rb

@@ -1,78 +1,114 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class DateTimeParser
-      # @see https://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
+      #   microformats.org: 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
@@ -8,6 +10,7 @@ module MicroMicro
       }.freeze
 
       # @see https://microformats.org/wiki/microformats2-parsing#parsing_a_dt-_property
+      #   microformats.org: microformats2 parsing specification § Parsing a +dt-+ property
       #
       # @return [String]
       def value
@@ -17,19 +20,19 @@ module MicroMicro
       private
 
       # @see https://microformats.org/wiki/value-class-pattern#microformats2_parsers_implied_date
+      #   microformats.org: 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]
@@ -38,6 +41,7 @@ module MicroMicro
       end
 
       # @see https://microformats.org/wiki/value-class-pattern#microformats2_parsers_implied_date
+      #   microformats.org: 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,18 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class EmbeddedMarkupPropertyParser < BasePropertyParser
       # @see https://microformats.org/wiki/microformats2-parsing#parsing_an_e-_property
+      #   microformats.org: microformats2 parsing specification § 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,16 @@
+# 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 https://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+      #   microformats.org: microformats2 parsing specification § Parsing for implied properties
       #
       # @return [String]
       def value
@@ -15,24 +19,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,42 @@
+# 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 https://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+      #   microformats.org: microformats2 parsing specification § Parsing for implied properties
       # @see https://microformats.org/wiki/microformats2-parsing#parse_an_img_element_for_src_and_alt
+      #   microformats.org: microformats2 parsing specification § 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

data/lib/micro_micro/parsers/implied_url_property_parser.rb

@@ -1,50 +1,32 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
-    class ImpliedUrlPropertyParser < BasePropertyParser
+    class ImpliedUrlPropertyParser < BaseImpliedPropertyParser
+      CSS_SELECTORS_ARRAY = ['> a[href]:only-of-type', '> area[href]:only-of-type'].freeze
+
       HTML_ELEMENTS_MAP = {
         'a'    => 'href',
         'area' => 'href'
       }.freeze
 
       # @see https://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+      #   microformats.org: microformats2 parsing specification § Parsing for implied properties
       #
       # @return [String, nil]
       def value
-        @value ||= value_node[HTML_ELEMENTS_MAP[value_node.name]] if value_node
+        @value ||= attribute_value
       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 [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 [Array]
+      def child_nodes
+        nodes = [node.at_css(*CSS_SELECTORS_ARRAY)]
 
-              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

data/lib/micro_micro/parsers/plain_text_property_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class PlainTextPropertyParser < BasePropertyParser
@@ -8,6 +10,7 @@ module MicroMicro
       }.freeze
 
       # @see https://microformats.org/wiki/microformats2-parsing#parsing_a_p-_property
+      #   microformats.org: microformats2 parsing specification § Parsing a +p-+ property
       #
       # @return [String]
       def value
@@ -18,7 +21,7 @@ module MicroMicro
 
       # @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 [String, nil]

data/lib/micro_micro/parsers/url_property_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class UrlPropertyParser < BasePropertyParser
@@ -14,40 +16,48 @@ module MicroMicro
       }.freeze
 
       # @see https://microformats.org/wiki/microformats2-parsing#parsing_a_u-_property
+      #   microformats.org: microformats2 parsing specification § Parsing a +u-+ property
       # @see https://microformats.org/wiki/microformats2-parsing#parse_an_img_element_for_src_and_alt
+      #   microformats.org: microformats2 parsing specification § Parse an img element for src and alt
       #
       # @return [String, Hash{Symbol => String}]
       def value
-        @value ||= begin
-          return resolved_value unless node.matches?('img[alt]')
-
-          {
-            value: resolved_value,
-            alt: node['alt'].strip
-          }
-        end
+        @value ||=
+          if node.matches?('img[alt]')
+            {
+              value: resolved_value,
+              alt: node['alt'].strip
+            }
+          else
+            resolved_value
+          end
       end
 
       private
 
       # @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 [String, nil]
       def extended_attribute_value
-        self.class.attribute_value_from(node, EXTENDED_HTML_ATTRIBUTES_MAP)
+        Helpers.attribute_value_from(node, EXTENDED_HTML_ATTRIBUTES_MAP)
       end
 
       # @return [String]
       def resolved_value
-        @resolved_value ||= Addressable::URI.join(node.document.url, unresolved_value.strip).to_s
+        @resolved_value ||= node.document.resolve_relative_url(unresolved_value.strip)
+      end
+
+      # @return [String]
+      def text_content
+        Helpers.text_content_from(node)
       end
 
       # @return [String]
       def unresolved_value
-        attribute_value || value_class_pattern_value || extended_attribute_value || Document.text_content_from(node)
+        attribute_value || value_class_pattern_value || extended_attribute_value || text_content
       end
 
       # @return [String, nil]

data/lib/micro_micro/parsers/value_class_pattern_parser.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class ValueClassPatternParser
       # @see https://microformats.org/wiki/value-class-pattern#Basic_Parsing
+      #   microformats.org: Value Class Pattern § Basic Parsing
       # @see https://microformats.org/wiki/value-class-pattern#Date_and_time_values
+      #   microformats.org: Value Class Pattern § Date and time values
       HTML_ATTRIBUTES_MAP = {
         'alt'      => %w[area img],
         'value'    => %w[data],
@@ -10,72 +14,55 @@ module MicroMicro
         'datetime' => %w[del ins time]
       }.freeze
 
-      # @param context [Nokogiri::XML::Element]
-      # @param separator [String]
-      def initialize(node, separator = '')
-        @node = node
-        @separator = separator
-      end
-
-      # @return [String, nil]
-      def value
-        @value ||= values.join(separator).strip if values.any?
-      end
-
-      # @return [Array<String>]
-      def values
-        @values ||= value_nodes.map { |value_node| self.class.value_from(value_node) }.select(&:present?)
-      end
-
       # @param context [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, []))
-        context.each { |node| nodes_from(node, node_set) } if context.is_a?(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) && !Document.ignore_node?(context)
-          if value_class_node?(context) || value_title_node?(context)
+        if context.is_a?(Nokogiri::XML::Element) && !Helpers.ignore_node?(context)
+          if Helpers.value_class_node?(context) || Helpers.value_title_node?(context)
             node_set << context
           else
-            nodes_from(context.element_children, node_set)
+            node_set_from(context.element_children, node_set)
           end
         end
 
         node_set
       end
 
-      # @param node [Nokogiri::XML::Element]
-      # @return [Boolean]
-      def self.value_class_node?(node)
-        node.classes.include?('value')
-      end
-
       # @param node [Nokogiri::XML::Element]
       # @return [String, nil]
       def self.value_from(node)
-        return node['title'] if value_title_node?(node)
+        return node['title'] if Helpers.value_title_node?(node)
 
-        HTML_ATTRIBUTES_MAP.each do |attribute, names|
-          return node[attribute] if names.include?(node.name) && node[attribute]
-        end
-
-        node.text
+        Helpers.attribute_value_from(node, HTML_ATTRIBUTES_MAP) || node.text
       end
 
       # @param node [Nokogiri::XML::Element]
-      # @return [Boolean]
-      def self.value_title_node?(node)
-        node.classes.include?('value-title')
+      # @param separator [String]
+      def initialize(node, separator = '')
+        @node = node
+        @separator = separator
+      end
+
+      # @return [String, nil]
+      def value
+        @value ||= values.join(separator).strip if values.any?
+      end
+
+      # @return [Array<String>]
+      def values
+        @values ||=
+          self.class
+              .node_set_from(node)
+              .map { |value_node| self.class.value_from(value_node) }
+              .select(&:present?)
       end
 
       private
 
       attr_reader :node, :separator
-
-      # @return [Nokogiri::XML::NodeSet]
-      def value_nodes
-        @value_nodes ||= self.class.nodes_from(node)
-      end
     end
   end
 end