micromicro 0.1.0

data/lib/micro_micro/parsers/implied_name_property_parser.rb

@@ -0,0 +1,78 @@
+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
+      HTML_ELEMENTS_MAP = {
+        'area' => 'alt',
+        'img'  => 'alt',
+        'abbr' => 'title'
+      }.freeze
+
+      # @return [String]
+      def value
+        @value ||= unresolved_value.strip
+      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)
+      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
+      end
+    end
+  end
+end

data/lib/micro_micro/parsers/implied_photo_property_parser.rb

@@ -0,0 +1,69 @@
+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
+      HTML_ELEMENTS_MAP = {
+        'img'    => 'src',
+        'object' => 'data'
+      }.freeze
+
+      # @return [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
+      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 child_node if child_node && !Item.item_node?(child_node) && element == child_node.name && child_node[attribute]
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/micro_micro/parsers/implied_url_property_parser.rb

@@ -0,0 +1,61 @@
+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
+      HTML_ELEMENTS_MAP = {
+        'a'    => 'href',
+        'area' => 'href'
+      }.freeze
+
+      # @return [String, nil]
+      def value
+        @value ||= resolved_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 child_node if child_node && !Item.item_node?(child_node) && element == child_node.name && child_node[attribute]
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/micro_micro/parsers/plain_text_property_parser.rb

@@ -0,0 +1,39 @@
+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
+
+      # @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
+      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
+      end
+
+      # @return [MicroMicro::Parsers::ValueClassPatternParser]
+      def value_class_pattern_parser
+        @value_class_pattern_parser ||= ValueClassPatternParser.new(node)
+      end
+    end
+  end
+end

data/lib/micro_micro/parsers/url_property_parser.rb

@@ -0,0 +1,75 @@
+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],
+        'poster' => %w[video],
+        '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
+      #
+      # @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
+      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
+      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
+      end
+
+      # @return [String]
+      def resolved_value
+        @resolved_value ||= Absolutely.to_abs(base: node.document.url, relative: 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?
+
+          serialized_node.text
+        end
+      end
+
+      # @return [MicroMicro::Parsers::ValueClassPatternParser]
+      def value_class_pattern_parser
+        @value_class_pattern_parser ||= ValueClassPatternParser.new(node)
+      end
+    end
+  end
+end

data/lib/micro_micro/parsers/value_class_pattern_parser.rb

@@ -0,0 +1,92 @@
+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
+      HTML_ATTRIBUTES_MAP = {
+        'alt'      => %w[area img],
+        'value'    => %w[data],
+        'title'    => %w[abbr],
+        '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)
+
+        if context.is_a?(Nokogiri::XML::Element) && !Document.ignore_node?(context)
+          if value_class_node?(context) || value_title_node?(context)
+            node_set << context
+          else
+            nodes_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)
+
+        HTML_ATTRIBUTES_MAP.each do |attribute, names|
+          return node[attribute] if names.include?(node.name) && node[attribute]
+        end
+
+        node.text
+      end
+
+      # @param node [Nokogiri::XML::Element]
+      # @return [Boolean]
+      def self.value_title_node?(node)
+        node.classes.include?('value-title')
+      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

@@ -0,0 +1,116 @@
+module MicroMicro
+  class Property
+    PROPERTY_PARSERS_MAP = {
+      'dt' => Parsers::DateTimePropertyParser,
+      'e'  => Parsers::EmbeddedMarkupPropertyParser,
+      'p'  => Parsers::PlainTextPropertyParser,
+      'u'  => Parsers::UrlPropertyParser
+    }.freeze
+
+    attr_accessor :collection
+    attr_reader :name, :node, :prefix
+
+    # @param node [Nokogiri::XML::Element]
+    # @param name [String]
+    # @param prefix [String<dt, e, p, u>]
+    def initialize(node, name:, prefix:)
+      @node = node
+      @name = name
+      @prefix = prefix
+    end
+
+    # @return [Boolean]
+    def implied?
+      false
+    end
+
+    # @return [String]
+    def inspect
+      format(%(#<#{self.class.name}:%#0x name: #{name.inspect}, prefix: #{prefix.inspect}, value: #{value.inspect}>), object_id)
+    end
+
+    # @return [Boolean]
+    def item_node?
+      @item_node ||= Item.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
+    end
+
+    # @return [Boolean]
+    def value?
+      value.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)
+
+      if context.is_a?(Nokogiri::XML::Element) && !Document.ignore_node?(context)
+        node_set << context if property_node?(context)
+
+        nodes_from(context.element_children, node_set) unless Item.item_node?(context)
+      end
+
+      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
+    end
+
+    # @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
+    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
+  end
+end