micromicro 0.1.0 → 2.0.0

data/lib/micro_micro/parsers/implied_photo_property_parser.rb

@@ -1,68 +1,40 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
-    class ImpliedPhotoPropertyParser < BasePropertyParser
-      # @see microformats2 Parsing Specification section 1.3.5
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+    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
 
-      # @return [String, nil]
+      # @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 ||= Absolutely.to_abs(base: node.document.url, relative: unresolved_value.strip) if unresolved_value
-      end
+      # @return [Array]
+      def child_nodes
+        nodes = [node.at_css(*CSS_SELECTORS_ARRAY)]
 
-      # @return [String, nil]
-      def unresolved_value
-        @unresolved_value ||= value_node[HTML_ELEMENTS_MAP[value_node.name]] if value_node
-      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 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,60 +1,31 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
-    class ImpliedUrlPropertyParser < BasePropertyParser
-      # @see microformats2 Parsing Specification section 1.3.5
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_for_implied_properties
+    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
+      #
       # @return [String, nil]
       def value
-        @value ||= resolved_value
+        @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 [String, nil]
-      def resolved_value
-        @resolved_value ||= Absolutely.to_abs(base: node.document.url, relative: unresolved_value.strip) if unresolved_value
-      end
-
-      # @return [String, nil]
-      def unresolved_value
-        @unresolved_value ||= value_node[HTML_ELEMENTS_MAP[value_node.name]] if value_node
-      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,38 +1,31 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class PlainTextPropertyParser < BasePropertyParser
-      # @see microformats2 Parsing Specification section 1.3.1
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_a_p-_property
       HTML_ATTRIBUTES_MAP = {
         'title' => %w[abbr link],
         'value' => %w[data input],
         'alt'   => %w[area img]
       }.freeze
 
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_a_p-_property
+      #
       # @return [String]
       def value
-        @value ||= begin
-          return value_class_pattern_parser.value if value_class_pattern_parser.value?
-          return attribute_values.first if attribute_values.any?
-
-          super
-        end
+        @value ||= value_class_pattern_value || attribute_value || super
       end
 
       private
 
-      # @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::ValueClassPatternParser]
-      def value_class_pattern_parser
-        @value_class_pattern_parser ||= ValueClassPatternParser.new(node)
+      # @return [String, nil]
+      def value_class_pattern_value
+        ValueClassPatternParser.new(node).value
       end
     end
   end

data/lib/micro_micro/parsers/url_property_parser.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class UrlPropertyParser < BasePropertyParser
-      # @see microformats2 Parsing Specification section 1.3.2
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_a_u-_property
       HTML_ATTRIBUTES_MAP = {
         'href'   => %w[a area link],
         'src'    => %w[audio iframe img source video],
@@ -10,65 +10,57 @@ module MicroMicro
         'data'   => %w[object]
       }.freeze
 
-      # @see microformats2 Parsing Specification section 1.3.2
-      # @see http://microformats.org/wiki/microformats2-parsing#parsing_a_u-_property
       EXTENDED_HTML_ATTRIBUTES_MAP = {
         'title' => %w[abbr],
         'value' => %w[data input]
       }.freeze
 
-      # @see microformats2 Parsing Specification section 1.5
-      # @see http://microformats.org/wiki/microformats2-parsing#parse_an_img_element_for_src_and_alt
+      # @see https://microformats.org/wiki/microformats2-parsing#parsing_a_u-_property
+      # @see https://microformats.org/wiki/microformats2-parsing#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
 
-      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
 
-      def extended_attribute_values
-        @extended_attribute_values ||= begin
-          EXTENDED_HTML_ATTRIBUTES_MAP.map do |attribute, names|
-            node[attribute] if names.include?(node.name) && node[attribute]
-          end
-        end.compact
+      # @return [String, nil]
+      def extended_attribute_value
+        Helpers.attribute_value_from(node, EXTENDED_HTML_ATTRIBUTES_MAP)
       end
 
       # @return [String]
       def resolved_value
-        @resolved_value ||= Absolutely.to_abs(base: node.document.url, relative: unresolved_value.strip)
+        @resolved_value ||= node.document.resolve_relative_url(unresolved_value.strip)
       end
 
       # @return [String]
-      def unresolved_value
-        @unresolved_value ||= begin
-          return attribute_values.first if attribute_values.any?
-          return value_class_pattern_parser.value if value_class_pattern_parser.value?
-          return extended_attribute_values.first if extended_attribute_values.any?
+      def text_content
+        Helpers.text_content_from(node)
+      end
 
-          serialized_node.text
-        end
+      # @return [String]
+      def unresolved_value
+        attribute_value || value_class_pattern_value || extended_attribute_value || text_content
       end
 
-      # @return [MicroMicro::Parsers::ValueClassPatternParser]
-      def value_class_pattern_parser
-        @value_class_pattern_parser ||= ValueClassPatternParser.new(node)
+      # @return [String, nil]
+      def value_class_pattern_value
+        ValueClassPatternParser.new(node).value
       end
     end
   end

data/lib/micro_micro/parsers/value_class_pattern_parser.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 module MicroMicro
   module Parsers
     class ValueClassPatternParser
-      # @see Value Class Pattern sections 3 and 4
-      # @see http://microformats.org/wiki/value-class-pattern#Basic_Parsing
-      # @see http://microformats.org/wiki/value-class-pattern#Date_and_time_values
+      # @see https://microformats.org/wiki/value-class-pattern#Basic_Parsing
+      # @see https://microformats.org/wiki/value-class-pattern#Date_and_time_values
       HTML_ATTRIBUTES_MAP = {
         'alt'      => %w[area img],
         'value'    => %w[data],
@@ -11,82 +12,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?
-      end
-
-      # @return [Boolean]
-      def value?
-        value.present?
-      end
-
-      # @return [Array<String>]
-      def values
-        @values ||= value_nodes.map { |value_node| self.class.value_from(value_node) }.select(&:present?)
-      end
-
-      # @return [Boolean]
-      def values?
-        values.any?
-      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
+        Helpers.attribute_value_from(node, HTML_ATTRIBUTES_MAP) || node.text
+      end
+
+      # @param context [Nokogiri::XML::Element]
+      # @param separator [String]
+      def initialize(node, separator = '')
+        @node = node
+        @separator = separator
+      end
 
-        node.text
+      # @return [String, nil]
+      def value
+        @value ||= values.join(separator).strip if values.any?
       end
 
-      # @param node [Nokogiri::XML::Element]
-      # @return [Boolean]
-      def self.value_title_node?(node)
-        node.classes.include?('value-title')
+      # @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

data/lib/micro_micro/property.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 module MicroMicro
   class Property
+    include Collectible
+
     PROPERTY_PARSERS_MAP = {
       'dt' => Parsers::DateTimePropertyParser,
       'e'  => Parsers::EmbeddedMarkupPropertyParser,
@@ -7,16 +11,46 @@ module MicroMicro
       'u'  => Parsers::UrlPropertyParser
     }.freeze
 
-    attr_accessor :collection
     attr_reader :name, :node, :prefix
 
+    # @param context [Nokogiri::XML::NodeSet, Nokogiri::XML::Element]
+    # @return [Array<MicroMicro::Property>]
+    def self.from_context(context)
+      node_set_from(context).flat_map do |node|
+        Helpers.property_class_names_from(node).map { |token| new(node, token) }
+      end
+    end
+
+    # @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)
+        node_set << context if Helpers.property_node?(context)
+
+        node_set_from(context.element_children, node_set) unless Helpers.item_node?(context)
+      end
+
+      node_set
+    end
+
     # @param node [Nokogiri::XML::Element]
-    # @param name [String]
-    # @param prefix [String<dt, e, p, u>]
-    def initialize(node, name:, prefix:)
+    # @param token [String]
+    def initialize(node, token)
       @node = node
-      @name = name
-      @prefix = prefix
+      @prefix, @name = token.split(/-/, 2)
+    end
+
+    # @return [Boolean]
+    def date_time_property?
+      prefix == 'dt'
+    end
+
+    # @return [Boolean]
+    def embedded_markup_property?
+      prefix == 'e'
     end
 
     # @return [Boolean]
@@ -24,91 +58,62 @@ module MicroMicro
       false
     end
 
+    # :nocov:
     # @return [String]
     def inspect
-      format(%(#<#{self.class.name}:%#0x name: #{name.inspect}, prefix: #{prefix.inspect}, value: #{value.inspect}>), object_id)
+      "#<#{self.class}:#{format('%#0x', object_id)} " \
+        "name: #{name.inspect}, " \
+        "prefix: #{prefix.inspect}, " \
+        "value: #{value.inspect}>"
+    end
+    # :nocov:
+
+    # @return [MicroMicro::Item, nil]
+    def item
+      @item ||= Item.new(node) if item_node?
     end
 
     # @return [Boolean]
     def item_node?
-      @item_node ||= Item.item_node?(node)
+      @item_node ||= Helpers.item_node?(node)
     end
 
-    # @return [String, Hash, MicroMicro::Item]
-    def value
-      @value ||= begin
-        return parser.value unless item_node?
-
-        item.value = item_value
-
-        item
-      end
+    # @return [Boolean]
+    def plain_text_property?
+      prefix == 'p'
     end
 
     # @return [Boolean]
-    def value?
-      value.present?
+    def url_property?
+      prefix == 'u'
     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)
+    # @return [String, Hash]
+    # rubocop:disable Metrics
+    def value
+      @value ||=
+        if item_node?
+          hash = item.to_h
 
-      if context.is_a?(Nokogiri::XML::Element) && !Document.ignore_node?(context)
-        node_set << context if property_node?(context)
+          return hash.merge(parser.value) if embedded_markup_property?
 
-        nodes_from(context.element_children, node_set) unless Item.item_node?(context)
-      end
+          p_property = item.properties.find { |property| property.name == 'name' } if plain_text_property?
+          u_property = item.properties.find { |property| property.name == 'url' } if url_property?
 
-      node_set
-    end
-
-    # @param context [Nokogiri::XML::NodeSet, Nokogiri::XML::Element]
-    # @return [Array<MicroMicro::Property>]
-    def self.properties_from(context)
-      nodes_from(context).map do |node|
-        types_from(node).map { |prefix, name| new(node, name: name, prefix: prefix) }
-      end.flatten
+          hash.merge(value: (p_property || u_property || parser).value)
+        else
+          parser.value
+        end
     end
+    # rubocop:enable Metrics
 
-    # @param node [Nokogiri::XML::Element]
     # @return [Boolean]
-    def self.property_node?(node)
-      types_from(node).any?
-    end
-
-    # @param node [Nokogiri::XML::Element]
-    # @return [Array<Array(String, String)>]
-    #
-    # @example
-    #   node = Nokogiri::HTML('<a href="https://sixtwothree.org" class="p-name u-url">Jason Garber</a>').at_css('a')
-    #   MicroMicro::Property.types_from(node) #=> [['p', 'name'], ['u', 'url']]
-    def self.types_from(node)
-      node.classes.select { |token| token.match?(/^(?:dt|e|p|u)(?:\-[0-9a-z]+)?(?:\-[a-z]+)+$/) }.map { |token| token.split(/\-/, 2) }.uniq
+    def value?
+      value.present?
     end
 
     private
 
-    # @return [MicroMicro::Item, nil]
-    def item
-      @item ||= Item.new(node) if item_node?
-    end
-
-    # @reutrn [String, nil]
-    def item_value
-      return unless item_node?
-
-      obj_by_prefix = case prefix
-                      when 'e' then item
-                      when 'p' then item.properties.find { |property| property.name == 'name' }
-                      when 'u' then item.properties.find { |property| property.name == 'url' }
-                      end
-
-      (obj_by_prefix || parser).value
-    end
-
     def parser
       @parser ||= PROPERTY_PARSERS_MAP[prefix].new(self)
     end