microformats2 1.0.2 → 2.0.0.pre1

data/lib/microformats2/collection.rb

@@ -0,0 +1,71 @@
+module Microformats2
+  class Collection
+    attr_reader :all
+
+    def initialize(element)
+      @element = element
+      @format_names = []
+    end
+
+    def parse
+      all
+      self
+    end
+
+    def all
+      @all ||= FormatParser.parse(@element).each do |format|
+        save_format_name(format.method_name)
+        define_method(format.method_name)
+        set_value(format.method_name, format)
+      end
+    end
+
+    def first
+      all.first
+    end
+
+    def last
+      all.last
+    end
+
+    def to_hash
+      hash = { items: [] }
+      all.each do |format|
+        hash[:items] << format.to_hash
+      end
+      hash
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    private
+
+    def save_format_name(format_name)
+      unless @format_names.include?(format_name)
+        @format_names << format_name
+      end
+    end
+
+    def define_method(mn)
+      unless respond_to?(mn)
+        self.class.class_eval { attr_accessor mn }
+      end
+      unless respond_to?(mn.pluralize)
+        self.class.class_eval { attr_accessor mn.pluralize }
+      end
+    end
+
+    def set_value(mn, value)
+      unless current = send(mn)
+        send("#{mn}=", value)
+      end
+      if current = send(mn.pluralize)
+        current << value
+      else
+        send("#{mn.pluralize}=", [value])
+      end
+    end
+  end
+end

data/lib/microformats2/format.rb

@@ -0,0 +1,101 @@
+module Microformats2
+  class Format
+    CLASS_REG_EXP = /^(h-)/
+
+    attr_reader :method_name
+
+    def initialize(element)
+      @element = element
+      @method_name = to_method_name(format_types.first)
+      @property_names = []
+    end
+
+    def parse
+      format_types
+      properties
+      self
+    end
+
+    def format_types
+      @format_types ||= @element.attribute("class").to_s.split.select do |html_class|
+        html_class =~ Format::CLASS_REG_EXP
+      end
+    end
+
+    def properties
+      @properties ||= parse_properties.concat parse_implied_properties
+    end
+
+    def parse_properties
+      PropertyParser.parse(@element.children).each do |property|
+        save_property_name(property.method_name)
+        define_method(property.method_name)
+        set_value(property.method_name, property)
+      end
+    end
+
+    def parse_implied_properties
+      ip = []
+      ip << ImpliedProperty::Name.new(@element).parse unless property_present?(:name)
+      ip << ImpliedProperty::Url.new(@element).parse unless property_present?(:url)
+      ip << ImpliedProperty::Photo.new(@element).parse unless property_present?(:photo)
+      ip.compact.each do |property|
+        save_property_name(property.method_name)
+        define_method(property.method_name)
+        set_value(property.method_name, property)
+      end
+    end
+
+    def property_present?(property)
+      !! respond_to?(property) && send(property)
+    end
+
+    def to_hash
+      hash = { type: format_types, properties: {} }
+      @property_names.each do |method_name|
+        hash[:properties][method_name.to_sym] = send(method_name.pluralize).map(&:to_hash)
+      end
+      hash
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    private
+
+    def to_method_name(html_class)
+      # p-class-name -> class_name
+      mn = html_class.downcase.split("-")[1..-1].join("_")
+      # avoid overriding Object#class
+      mn = "klass" if mn == "class"
+      mn
+    end
+
+    def save_property_name(property_name)
+      unless @property_names.include?(property_name)
+        @property_names << property_name
+      end
+    end
+
+    def define_method(mn)
+      unless respond_to?(mn)
+        self.class.class_eval { attr_accessor mn }
+      end
+      unless respond_to?(mn.pluralize)
+        self.class.class_eval { attr_accessor mn.pluralize }
+      end
+    end
+
+    def set_value(mn, value)
+      unless current = send(mn)
+        send("#{mn}=", value)
+      end
+      if current = send(mn.pluralize)
+        current << value
+      else
+        send("#{mn.pluralize}=", [value])
+      end
+    end
+  end
+end

data/lib/microformats2/format_parser.rb

@@ -0,0 +1,59 @@
+module Microformats2
+  class FormatParser
+    class << self
+      def parse(element)
+        parse_node(element).flatten.compact
+      end
+
+      def parse_node(node)
+        case
+        when node.is_a?(Nokogiri::HTML::Document) then parse_node(node.children)
+        when node.is_a?(Nokogiri::XML::NodeSet)   then parse_nodeset(node)
+        when node.is_a?(Nokogiri::XML::Element)   then [parse_for_microformats(node)]
+        end
+      end
+
+      def parse_nodeset(nodeset)
+        nodeset.map { |node| parse_node(node) }
+      end
+
+      def parse_for_microformats(element)
+        if format_classes(element).length >= 1
+          parse_microformat(element)
+        else
+          parse_nodeset(element.children)
+        end
+      end
+
+      def parse_microformat(element)
+        # only create ruby object for first format class
+        html_class = format_classes(element).first
+        const_name = constant_name(html_class)
+        klass = find_or_create_ruby_class(const_name)
+
+        klass.new(element).parse
+      end
+
+      def format_classes(element)
+        element.attribute("class").to_s.split.select do |html_class|
+          html_class =~ Format::CLASS_REG_EXP
+        end
+      end
+
+      def constant_name(html_class)
+        # html-Class -> html-class -> html_class -> Html_class -> HtmlClass
+        html_class.downcase.gsub("-","_").gsub(/^([a-z])/){$1.upcase}.gsub(/_(.)/){$1.upcase}
+      end
+
+      def find_or_create_ruby_class(const_name)
+        if Object.const_defined?(const_name)
+          klass = Object.const_get(const_name)
+        else
+          klass = Class.new(Microformats2::Format)
+          Object.const_set const_name, klass
+        end
+        klass
+      end
+    end # class << self
+  end
+end

data/lib/microformats2/implied_property/foundation.rb

@@ -0,0 +1,58 @@
+module Microformats2
+  module ImpliedProperty
+    class Foundation
+
+      def initialize(element)
+        @element = element
+      end
+
+      def parse
+        self if to_s
+      end
+
+      def method_name
+        "foundation"
+      end
+
+      def to_s
+        @to_s ||= element_value || selector_value
+      end
+
+      def to_hash
+        to_s
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      protected
+
+      def element_value
+        name_map.each_pair do |elname, attr|
+          if elname == @element.name && @element.attribute(attr)
+            return @element.attribute(attr).to_s
+          end
+        end
+        nil
+      end
+
+      def name_map
+        {}
+      end
+
+      def selector_value
+        selector_map.each_pair do |sel, attr|
+          if selected_element = @element.css(sel).first
+            return selected_element.attribute(attr).to_s
+          end
+        end
+        nil
+      end
+
+      def selector_map
+        {}
+      end
+    end
+  end
+end

data/lib/microformats2/implied_property/name.rb

@@ -0,0 +1,34 @@
+module Microformats2
+  module ImpliedProperty
+    class Name < Foundation
+
+      def method_name
+        "name"
+      end
+
+      def to_s
+        @to_s ||= element_value || selector_value || text_value
+      end
+
+      protected
+
+      def name_map
+        { "img" => "alt",
+          "abbr" => "title" }
+      end
+
+      def selector_map
+        { ">img[alt]:only-of-type" => "alt",
+          ">abbr[title]:only-of-type" => "title",
+          ">:only-of-type>img[alt]:only-of-type" => "alt",
+          ">:only-of-type>abbr[title]:only-of-type" => "title" }
+      end
+
+      private
+
+      def text_value
+        @element.inner_text.gsub(/\n+/, " ").gsub(/\s+/, " ").strip
+      end
+    end
+  end
+end

data/lib/microformats2/implied_property/photo.rb

@@ -0,0 +1,24 @@
+module Microformats2
+  module ImpliedProperty
+    class Photo < Foundation
+
+      def method_name
+        "photo"
+      end
+
+      protected
+
+      def name_map
+        { "img" => "src",
+          "object" => "data" }
+      end
+
+      def selector_map
+        { ">img[src]:only-of-type" => "src",
+          ">object[data]:only-of-type" => "data",
+          ">:only-child>img[src]:only-of-type" => "src",
+          ">:only-child>object[data]:only-of-type" => "data" }
+      end
+    end
+  end
+end

data/lib/microformats2/implied_property/url.rb

@@ -0,0 +1,20 @@
+module Microformats2
+  module ImpliedProperty
+    class Url < Foundation
+
+      def method_name
+        "url"
+      end
+
+      protected
+
+      def name_map
+        { "a" => "href" }
+      end
+
+      def selector_map
+        { ">a[href]:only-of-type" => "href" }
+      end
+    end
+  end
+end

data/lib/microformats2/property.rb

@@ -0,0 +1,10 @@
+module Microformats2
+  module Property
+    CLASS_REG_EXP = /^(p-|u-|dt-|e-)/
+    PREFIX_CLASS_MAP = {
+      "p" => Text,
+      "u" => Url,
+      "dt" => DateTime,
+      "e" => Embedded }
+  end
+end

data/lib/microformats2/property/date_time.rb

@@ -0,0 +1,31 @@
+module Microformats2
+  module Property
+    class DateTime < Foundation
+      def to_s
+        @to_s ||= value_class_pattern || element_value || text_value
+      end
+
+      def value
+        ::DateTime.parse(to_s)
+      end
+
+      def to_hash
+        if formats.empty?
+          to_s
+        else
+          { value: to_s }.merge(formats.first.to_hash)
+        end
+      end
+
+      protected
+
+      def attr_map
+        @attr_map ||= {
+          "time" => "datetime",
+          "ins" => "datetime",
+          "abbr" => "title",
+          "data" => "value" }
+      end
+    end
+  end
+end

data/lib/microformats2/property/embedded.rb

@@ -0,0 +1,9 @@
+module Microformats2
+  module Property
+    class Embedded < Foundation
+      def to_s
+        @to_s ||= @element.inner_html.strip
+      end
+    end
+  end
+end

data/lib/microformats2/property/foundation.rb

@@ -0,0 +1,80 @@
+module Microformats2
+  module Property
+    class Foundation
+      attr_reader :method_name
+
+      def initialize(element, html_class)
+        @element = element
+        @method_name = to_method_name(html_class)
+      end
+
+      def parse
+        to_s
+        formats
+        self
+      end
+
+      def to_s
+        @to_s ||= value_class_pattern || element_value || text_value
+      end
+
+      def format
+        formats.first
+      end
+
+      def formats
+        @formats ||= format_classes.length >=1 ? FormatParser.parse(@element) : []
+      end
+
+      def to_hash
+        if formats.empty?
+          to_s
+        else
+          { value: to_s }.merge(formats.first.to_hash)
+        end
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      protected
+
+      def value_class_pattern
+        # TODO
+      end
+
+      def element_value
+        @element.attribute(attribute).to_s if attribute && @element.attribute(attribute)
+      end
+
+      def text_value
+        @element.inner_text.gsub(/\n+/, " ").gsub(/\s+/, " ").strip
+      end
+
+      def attribute
+        attr_map[@element.name]
+      end
+
+      def attr_map
+        {}
+      end
+
+      private
+
+      def to_method_name(html_class)
+        # p-class-name -> class_name
+        mn = html_class.downcase.split("-")[1..-1].join("_")
+        # avoid overriding Object#class
+        mn = "klass" if mn == "class"
+        mn
+      end
+
+      def format_classes
+        @format_classes = @element.attribute("class").to_s.split.select do |html_class|
+          html_class =~ Format::CLASS_REG_EXP
+        end
+      end
+    end
+  end
+end