micromicro 0.1.0

data/lib/micro_micro/document.rb

@@ -0,0 +1,71 @@
+module MicroMicro
+  class Document
+    # @param markup [String] the HTML to parse
+    # @param base_url [String] the URL associated with the provided markup
+    def initialize(markup, base_url)
+      @markup = markup
+      @base_url = base_url
+    end
+
+    # @return [String]
+    def inspect
+      format(%(#<#{self.class.name}:%#0x items: #{items.inspect}, relations: #{relations.inspect}>), object_id)
+    end
+
+    # @return [MicroMicro::Collections::ItemsCollection]
+    def items
+      @items ||= Collections::ItemsCollection.new(Item.items_from(document))
+    end
+
+    # @return [MicroMicro::Collections::RelationsCollection]
+    def relations
+      @relations ||= Collections::RelationsCollection.new(Relation.relations_from(document))
+    end
+
+    # @see microformats2 Parsing Specification section 1.1
+    # @see http://microformats.org/wiki/microformats2-parsing#parse_a_document_for_microformats
+    #
+    # @return [Hash]
+    def to_h
+      {
+        items: items.to_a,
+        rels: relations.group_by_rel,
+        'rel-urls': relations.group_by_url
+      }
+    end
+
+    # @param node [Nokogiri::XML::Element]
+    # @return [Boolean]
+    def self.ignore_node?(node)
+      ignored_node_names.include?(node.name)
+    end
+
+    # @return [Array<String>]
+    def self.ignored_node_names
+      %w[script style template]
+    end
+
+    private
+
+    attr_reader :base_url, :markup
+
+    # @return [Nokogiri::XML::Element, nil]
+    def base_element
+      @base_element ||= Nokogiri::HTML(markup).at_css('base[href]')
+    end
+
+    # @return [Nokogiri::HTML::Document]
+    def document
+      @document ||= Nokogiri::HTML(markup, resolved_base_url)
+    end
+
+    # @return [String]
+    def resolved_base_url
+      @resolved_base_url ||= begin
+        return base_url unless base_element
+
+        Absolutely.to_abs(base: base_url, relative: base_element['href'])
+      end
+    end
+  end
+end

data/lib/micro_micro/implied_property.rb

@@ -0,0 +1,25 @@
+module MicroMicro
+  class ImpliedProperty < Property
+    IMPLIED_PROPERTY_PARSERS_MAP = {
+      'name'  => Parsers::ImpliedNamePropertyParser,
+      'photo' => Parsers::ImpliedPhotoPropertyParser,
+      'url'   => Parsers::ImpliedUrlPropertyParser
+    }.freeze
+
+    # @return [Boolean]
+    def implied?
+      true
+    end
+
+    # @return [Boolean]
+    def item_node?
+      false
+    end
+
+    private
+
+    def parser
+      @parser ||= IMPLIED_PROPERTY_PARSERS_MAP[name].new(self)
+    end
+  end
+end

data/lib/micro_micro/item.rb

@@ -0,0 +1,151 @@
+module MicroMicro
+  class Item
+    attr_accessor :value
+
+    # @param node [Nokogiri::XML::Element]
+    def initialize(node)
+      @node = node
+
+      properties << implied_name if implied_name?
+      properties << implied_photo if implied_photo?
+      properties << implied_url if implied_url?
+    end
+
+    # @return [MicroMicro::Collections::ItemsCollection]
+    def children
+      @children ||= Collections::ItemsCollection.new(Item.items_from(node.element_children))
+    end
+
+    # @return [String, nil]
+    def id
+      @id ||= node['id']&.strip
+    end
+
+    # @return [String]
+    def inspect
+      format(%(#<#{self.class.name}:%#0x types: #{types.inspect}, properties: #{properties.count}, children: #{children.count}>), object_id)
+    end
+
+    # @return [MicroMicro::Collections::PropertiesCollection]
+    def properties
+      @properties ||= Collections::PropertiesCollection.new(Property.properties_from(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 [Hash]
+    def to_h
+      hash = {
+        type: types,
+        properties: properties.to_h
+      }
+
+      hash[:id] = id if id.present?
+      hash[:children] = children.to_a if children.any?
+      hash[:value] = value if value.present?
+
+      hash
+    end
+
+    # @return [Array<String>]
+    def types
+      @types ||= self.class.types_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>]
+    #
+    # @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
+    end
+
+    private
+
+    attr_reader :node
+
+    # @return [MicroMicro::ImpliedProperty]
+    def implied_name
+      @implied_name ||= ImpliedProperty.new(node, name: 'name', prefix: 'p')
+    end
+
+    # @return [Boolean]
+    def implied_name?
+      imply_name? && implied_name.value?
+    end
+
+    # @return [MicroMicro::ImpliedProperty]
+    def implied_photo
+      @implied_photo ||= ImpliedProperty.new(node, name: 'photo', prefix: 'u')
+    end
+
+    # @return [Boolean]
+    def implied_photo?
+      imply_photo? && implied_photo.value?
+    end
+
+    # @return [MicroMicro::ImpliedProperty]
+    def implied_url
+      @implied_url ||= ImpliedProperty.new(node, name: 'url', prefix: 'u')
+    end
+
+    # @return [Boolean]
+    def implied_url?
+      imply_url? && implied_url.value?
+    end
+
+    # @return [Boolean]
+    def imply_name?
+      properties.none? { |prop| prop.name == 'name' } && properties.none? { |prop| %w[e p].include?(prop.prefix) } && !nested_items?
+    end
+
+    # @return [Boolean]
+    def imply_photo?
+      properties.none? { |prop| prop.name == 'photo' } && properties.reject(&:implied?).none? { |prop| prop.prefix == 'u' } && !nested_items?
+    end
+
+    # @return [Boolean]
+    def imply_url?
+      properties.none? { |prop| prop.name == 'url' } && properties.reject(&:implied?).none? { |prop| prop.prefix == 'u' } && !nested_items?
+    end
+
+    # @return [Boolean]
+    def nested_items?
+      @nested_items ||= properties.find(&:item_node?) || children.any?
+    end
+  end
+end

data/lib/micro_micro/parsers/base_property_parser.rb

@@ -0,0 +1,33 @@
+module MicroMicro
+  module Parsers
+    class BasePropertyParser
+      # @param property [MicroMicro::Property, MicroMicro::ImpliedProperty]
+      def initialize(property)
+        @property = property
+        @node = property.node
+      end
+
+      # @return [String]
+      def value
+        @value ||= serialized_node.text.strip
+      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

@@ -0,0 +1,85 @@
+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
+
+      CAPTURE_NAMES = [:year, :ordinal, :month, :day, :hours, :minutes, :seconds, :abbreviation, :zulu, :offset].freeze
+
+      # @param string [String]
+      def initialize(string)
+        @string = string
+      end
+
+      CAPTURE_NAMES.each do |name|
+        define_method(name) { values[name] }
+        define_method("#{name}?") { public_send(name).present? }
+      end
+
+      def normalized_calendar_date
+        @normalized_calendar_date ||= "#{year}-#{month}-#{day}" if year? && month? && day?
+      end
+
+      def normalized_date
+        @normalized_date ||= normalized_calendar_date || normalized_ordinal_date
+      end
+
+      def normalized_hours
+        @normalized_hours ||= begin
+          return unless hours?
+          return (hours.to_i + 12).to_s if abbreviation&.tr('.', '')&.downcase == 'pm'
+
+          format('%<hours>02d', hours: hours)
+        end
+      end
+
+      def normalized_minutes
+        @normalized_minutes ||= minutes || '00'
+      end
+
+      def normalized_ordinal_date
+        @normalized_ordinal_date ||= "#{year}-#{ordinal}" if year? && ordinal?
+      end
+
+      def normalized_time
+        @normalized_time ||= [normalized_hours, normalized_minutes, seconds].compact.join(':') if normalized_hours
+      end
+
+      def normalized_timezone
+        @normalized_timezone ||= zulu || offset&.tr(':', '')
+      end
+
+      # @return [String]
+      def value
+        @value ||= "#{normalized_date} #{normalized_time}#{normalized_timezone}".strip
+      end
+
+      # @return [Boolean]
+      def value?
+        value.present?
+      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
+      end
+
+      private
+
+      attr_reader :string
+    end
+  end
+end

data/lib/micro_micro/parsers/date_time_property_parser.rb

@@ -0,0 +1,65 @@
+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
+
+      # @return [String]
+      def value
+        @value ||= begin
+          return resolved_value if date_time_parser.value?
+          return attribute_values.first if attribute_values.any?
+
+          super
+        end
+      end
+
+      private
+
+      # @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
+      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
+      end
+
+      # @return [MicroMicro::Parsers::DateTimeParser]
+      def date_time_parser
+        @date_time_parser ||= DateTimeParser.new(value_class_pattern_parser.value)
+      end
+
+      # @return [Boolean]
+      def imply_date?
+        date_time_parser.normalized_time && !date_time_parser.normalized_date
+      end
+
+      # @return [String]
+      def resolved_value
+        return "#{adopted_date_time.normalized_date} #{date_time_parser.value}" if imply_date? && adopted_date_time
+
+        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

@@ -0,0 +1,28 @@
+module MicroMicro
+  module Parsers
+    class EmbeddedMarkupPropertyParser < BasePropertyParser
+      HTML_ATTRIBUTE_NAMES = %w[action cite code codebase data href poster src].freeze
+
+      def value
+        @value ||= begin
+          {
+            html: resolved_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
+end