mofo 0.1.2 → 0.2

data/CHANGELOG

@@ -1,3 +1,11 @@
+= 0.2
+  - Minor refactoring
+  - Added Geo and Adr [Andrew Turner]
+  - Added XFN [Steve Ivy, Christian Carter]
+  - Added hResume [Grant Rodgers]
+  - Added include-pattern support
+  - occurances => occurences
+
 = 0.1.2
   - Upgraded to test/spec 0.3
   - Fixed so tests run as Rails plugin 

data/README

@@ -145,17 +145,15 @@
   - hCalendar [ upcoming.org       ]
   - hReview   [ cork'd reviews     ] 
   - hEntry    [ err the blog posts ]
+  - hResume   [ linkedin.com       ]
   - xoxo      [ chowhound.com      ]
+  - geo       [ upcoming.org       ]
+  - adr       [ upcoming.org       ]
+  - xfn       [ linkedin.com       ]
 
   patterns:
   - rel-tag 
   - rel-bookmark
-
-  Here are the microformats we want soon soon soon:
-  - geo
-  - hResume
-
-  patterns:
   - include-pattern
 
 = Ruby on Rails
@@ -185,3 +183,15 @@ them in a session.
   => http://rubyforge.org/projects/scrapi/
   >> uformats
   => http://rubyforge.org/projects/uformats
+
+= Contributors
+
+  >> Steve Ivy
+  >> Olle Jonsson
+  >> Christian Carter
+  >> Grant Rodgers
+
+= Author
+
+  >> Chris Wanstrath
+  => chris[at]ozmm[dot]org

data/lib/microformat.rb

@@ -1,5 +1,5 @@
-%w[rubygems hpricot microformat/string open-uri ostruct timeout].each { |f| require f }
-require_gem 'hpricot', '>= 0.4.59'
+%w(rubygems hpricot microformat/string microformat/array open-uri ostruct timeout).each { |f| require f }
+gem 'hpricot', '>= 0.4.59'
 
 class Microformat
   module Base
@@ -8,12 +8,12 @@ class Microformat
     #
     def find(*args)
       target, @options = args
-      @options ||= Hash === target ? target : {}
+      @options ||= target.is_a?(Hash) ? target : {}
       [:first, :all].each { |key| target = @options[key] if @options[key] }
       
-      doc = build_doc(@options[:text] ? @options : target)
+      @doc = build_doc(@options[:text] ? @options : target)
 
-      microformats = find_occurances(doc)
+      microformats = find_occurences(@doc)
       raise MicroformatNotFound if @options[:strict] && microformats.empty?
       return @options[:first] ? nil : [] if microformats.empty?
 
@@ -29,6 +29,22 @@ class Microformat
       end
     end
 
+    names_and_keys = proc do |attributes| 
+      attributes.map do |att|
+        att.respond_to?(:keys) ? att.keys.first : att 
+      end
+    end
+
+    define_method :attributes do
+      names_and_keys[@attributes[:many] + @attributes[:one]]
+    end
+
+    %w(many one).each do |type|
+      define_method("#{type}s") do
+        names_and_keys[@attributes[type.intern]]
+      end
+    end
+
   protected
     ##
     # DSL Related
@@ -41,7 +57,7 @@ class Microformat
     def collector
       collector = Hash.new([])
       def collector.method_missing(method, *classes)
-        super unless %w[one many].include? method.to_s
+        super unless %w(one many).include? method.to_s
         self[method] += Microformat.send(:break_out_hashes, classes)
       end
       collector
@@ -52,7 +68,7 @@ class Microformat
     end
 
     def method_missing(method, *args, &block)
-      super unless %w[one many].include? method.to_s
+      super unless %w(one many).include? method.to_s
       (collected = collector).instance_eval(&block) if block_given?
       classes = block_given? ? [args.first => collected] : break_out_hashes(args)
       @attributes[method] += classes
@@ -60,7 +76,7 @@ class Microformat
 
     def break_out_hashes(array)
       array.inject([]) do |memo, element|
-        memo + (Hash === element ? [element.map { |k,v| { k => v } }].flatten : [element])
+        memo + (element.is_a?(Hash) ? [element.map { |k,v| { k => v } }].flatten : [element])
       end
     end
 
@@ -96,7 +112,7 @@ class Microformat
       end
     end
 
-    def find_occurances(doc)
+    def find_occurences(doc)
       doc/".#{@container}" 
     end
 
@@ -116,7 +132,7 @@ class Microformat
 
       [:one, :many].each do |name|
         attributes[name].each do |attribute|
-          is_hash = Hash === attribute
+          is_hash = attribute.is_a? Hash
           key = is_hash ? attribute.keys.first : attribute
 
           # rel="bookmark" pattern
@@ -133,7 +149,7 @@ class Microformat
           raise InvalidMicroformat if found.empty? && key.to_s =~ /!/
           next if found.empty?
 
-          if is_hash && Hash === attribute[key]
+          if is_hash && attribute[key].is_a?(Hash)
             built_hash = build_hash(found, attribute[key])
             key = key.no_bang
             if built_hash.size.zero? && found.size.nonzero?
@@ -152,15 +168,31 @@ class Microformat
               hash[key] = parse_element(found.first, target) 
             end
           end
-          hash[key] = hash[key].first if Array === hash[key] && hash[key].size == 1
+          hash[key] = hash[key].first if hash[key].is_a?(Array) && hash[key].size == 1
         end
       end
 
-      hash
+      hash.merge extract_includes(doc)
+    end
+
+    def extract_includes(doc)
+      @includes ||= {}
+
+      doc.search(".include").inject({}) do |hash, element|
+        target = element.attributes['data'] || element.attributes['href']
+
+        return @includes[target] if @includes[target]
+
+        unless (includes = @doc/target).empty?
+          hash.merge @includes[target] = build_hash(includes)
+        else
+          hash
+        end
+      end
     end
 
     def extract_bookmark(doc)
-      bookmark = doc.search("[@rel=bookmark]").first rescue nil
+      bookmark = doc.at("[@rel=bookmark]") rescue nil
       bookmark.attributes['href'] if bookmark.respond_to? :attributes
     end
 
@@ -176,24 +208,31 @@ class Microformat
         when 'a'      then element['href']
         when 'object' then element['value']
         end
-      elsif Class === target
+      elsif target.is_a? Array
+        target.inject(nil) do |found, klass|
+          klass = klass.respond_to?(:find) ? klass : nil
+
+          found || parse_element(element, klass)
+        end 
+      elsif target.is_a? Class
         target.find(:first => element)
       else
-        case element.name
+        value = case element.name
         when 'abbr' then element['title']
         when 'img'  then element['alt']
-        else element.innerHTML
-        end.strip.strip_html.coerce
+        end || ''
+
+        (value.empty? ? element.innerHTML : value).strip.strip_html.coerce
       end
     end
 
     def prepare_value(value)
-      Hash === value ? OpenStruct.new(value) : value
+      value.is_a?(Hash) ? OpenStruct.new(value) : value
     end
   end
 
   def method_missing(method, *args, &block)
-    return super(method, *args, &block) unless method == :properties || @properties.include?(method.to_s)
+    return super unless method == :properties || @properties.include?(method.to_s)
     self.class.class_eval { define_method(method) { instance_variable_get("@#{method}") } }
     instance_variable_get("@#{method}")
   end

data/lib/microformat/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def first_or_self
+    size > 1 ? self : first
+  end
+end

data/lib/microformat/simple.rb

@@ -4,29 +4,27 @@ class Microformat
   class Simple < String
     extend Microformat::Base
 
-    class << self
-      def find_first(doc)
-        find_every(doc).first
-      end
+    def self.find_first(doc)
+      find_every(doc).first
+    end
 
-      def find_occurances(doc)
-        @from ? doc/from_as_xpath : super(doc)
-      end
+    def self.find_occurences(doc)
+      @from ? doc/from_as_xpath : super(doc)
+    end
 
-      def build_class(tag)
-        new(tag.innerText) 
-      end
+    def self.build_class(tag)
+      new(tag.innerText) 
+    end
 
-      def from(options)
-        @from ||= []
-        options.each do |tag, value|
-          @from << "@#{tag}=#{value}"
-        end
+    def self.from(options)
+      @from ||= []
+      options.each do |tag, value|
+        @from << "@#{tag}=#{value}"
       end
+    end
 
-      def from_as_xpath
-        "[#{@from.to_a * "|"}]"
-      end
+    def self.from_as_xpath
+      "[#{@from.to_a * "|"}]"
     end
   end
 end

data/lib/microformat/string.rb

@@ -10,7 +10,7 @@ class String
       attempt = coercions.next
       break if !attempt.nil?
     end
-    %w[@coercions @generator].each { |i| remove_instance_variable i }
+    %w(@coercions @generator).each { |i| remove_instance_variable i }
     attempt.nil? ? self : attempt
   end
 

data/lib/mofo.rb

@@ -1,3 +1,3 @@
 $:.unshift File.join(File.dirname(__FILE__), "lib"), File.join(File.dirname(__FILE__))
 
-%w[hentry hreview hcalendar rel_tag hcard xoxo].each { |format| require "mofo/#{format}" }
+Dir['mofo/*.rb'].each { |format| require "mofo/#{format}" }

data/lib/mofo/adr.rb

@@ -0,0 +1,6 @@
+class Adr < Microformat
+  one :post_office_box, :extended_address, :street_address,
+      :locality, :region, :postal_code, :country_name, :value
+
+  many :type
+end

data/lib/mofo/geo.rb

@@ -0,0 +1,3 @@
+class Geo < Microformat
+  one :latitude, :longitude
+end

data/lib/mofo/hcalendar.rb

@@ -1,12 +1,15 @@
 # => http://microformats.org/wiki/hcalendar
 require 'microformat'
+require 'mofo/hcard'
+require 'mofo/adr'
+require 'mofo/geo'
 
 class HCalendar < Microformat
   container :vevent
 
   one :class, :description, :dtend, :dtstamp, :dtstart,
-      :duration, :location, :status, :summary, :uid,
-      :last_modified, :url => :url
+      :duration, :status, :summary, :uid, :last_modified, 
+      :url => :url, :location => [ HCard, Adr, Geo, String ]
 
   many :category
 end

data/lib/mofo/hcard.rb

@@ -1,13 +1,18 @@
 # => http://microformats.org/wiki/hcard
 require 'microformat'
+require 'mofo/geo'
+require 'mofo/adr'
 
 class HCard < Microformat
   container :vcard
 
-  one :fn, :bday, :tz, :sort_string, :uid, :class
+  one :fn, :bday, :tz, :sort_string, :uid, :class,
+      :geo => Geo
+
   many :label, :sound, :title, :role, :key, 
        :mailer, :rev, :nickname, :category, :note,
-       :logo => :url, :url => :url, :photo => :url
+       :logo => :url, :url => :url, :photo => :url,
+       :adr => Adr
 
   one :n do
     one :family_name, :given_name, :additional_name
@@ -24,16 +29,6 @@ class HCard < Microformat
     many :value
   end
 
-  many :adr do
-    one :post_office_box, :extended_address, :street_address,
-        :locality, :region, :postal_code, :country_name, :value
-    many :type
-  end
-
-  one :geo do
-    one :latitude, :longitude
-  end
-
   many :org do
     one :organization_name, :organization_unit
   end

data/lib/mofo/hentry.rb

@@ -5,7 +5,7 @@ require 'mofo/rel_tag'
 
 class HEntry < Microformat
   one :entry_title!, :entry_summary, :updated, :published,
-      :author => HCard
+      :author => HCard, :tags => RelTag 
 
   many :entry_content
 end

data/lib/mofo/hresume.rb

@@ -0,0 +1,17 @@
+# => http://microformats.org/wiki/hresume
+require 'microformat'
+require 'mofo/hcard'
+require 'mofo/hcalendar'
+require 'mofo/rel_tag'
+
+class HResume < Microformat
+  container :hresume
+
+  one :summary, :contact => HCard
+
+ # TODO: linkedin uses a comma delimited skills list rather than the rel tags in the spec
+  many :skills
+
+  many :affiliation => HCard, :education => HCalendar,
+       :experience  => HCalendar
+end

data/lib/mofo/rel_bookmark.rb

@@ -0,0 +1,6 @@
+# => http://microformats.org/wiki/rel-design-pattern
+require 'microformat/simple'
+
+class RelBookmark < Microformat::Simple
+  from :rel => :bookmark
+end

data/lib/mofo/xfn.rb

@@ -0,0 +1,66 @@
+$:.unshift 'lib'
+require 'microformat'
+
+class XFN < Microformat
+  class Link < OpenStruct
+    def initialize(*args)
+      super
+      def relation.has?(value)
+        is_a?(Array) ? include?(value) : self == value
+      end
+    end
+
+    def to_html
+      %[<a href="#{link}" rel="#{Array(relation) * ' '}">#{name}</a>]
+    end
+    
+    def inspect
+      link.inspect
+    end
+    
+    def to_s
+      link
+    end
+  end
+
+  attr_accessor :links
+
+  def self.find_occurences(doc)
+    @occurences ||= XFN.new(doc)
+  end
+
+  class << self
+    alias :find_first :find_occurences
+    alias :find_every :find_occurences
+  end
+  
+  def initialize(doc)
+    @links = doc.search("a[@rel]").map do |rl| 
+      relation = rl[:rel].include?(' ') ? rl[:rel].split(' ') : rl[:rel]
+      Link.new(:name => rl.innerHTML, :link => rl[:href], :relation => relation)
+    end
+  end
+
+  def relations
+    @relations ||= @links.map { |l| l.relation }
+  end
+  
+  def [](*rels)
+    @links.select do |link| 
+      relation = link.relation
+      relation.respond_to?(:all?) && rels.all? { |rel| relation.include? rel }
+    end.first_or_self
+  end
+
+  def method_missing(method, *args, &block)
+    method = method.to_s
+    if (rels = method.split(/_and_/)).size > 1
+      self[*rels]
+    elsif @links.class.public_instance_methods.include? method
+      @links.send(method, *args, &block)
+    else
+      check = args.first == true ? :== : :has?
+      @links.select { |link| link.relation.send(check, method) }.first_or_self
+    end
+  end
+end