mofo 0.1

data/CHANGELOG

@@ -0,0 +1,2 @@
+= 0.1
+  - First release.

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2006 Chris Wanstrath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
+the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,187 @@
+  mofo.          
+- a ruby microformat parser -
+                     engine
+                     dsl
+                     helper
+                     toy
+
+= Get Started Immediately
+
+  $ irb -rubygems 
+  >> require 'mofo'
+  => true
+
+  >> fireball = HCard.find 'http://flickr.com/people/gruber/'
+  => #<HCard:0x6db898 ... >
+
+  >> fireball.nickname
+  => "gruber"
+
+  >> fireball.url
+  => "http://daringfireball.net/"
+
+  >> fireball.n.family_name
+  => "Gruber"
+
+  >> fireball.title
+  => "Raconteur"
+
+  >> fireball.adr.locality
+  => "Philadelphia"
+
+  >> fireball.logo
+  => "http://static.flickr.com/9/buddyicons/44621776@N00.jpg?1117572751"
+
+= Microwhozit?
+
+  Microformats are tiny little markup definitions built on top of, usually, 
+  HTML or XHTML.  
+
+  You have a blog.  You have recent posts on your blog's index page.  You have
+  an Atom feed.  You have recent posts on your blog's Atom feed.  See where I'm
+  going with this?
+
+  The hAtom microformat (or uformat) can be embedded in your existing HTML by
+  setting CSS classes with semantic meaning inside of your posts.  A class to signify
+  a post is contained within this div, a class to signify the contents of this
+  h3 are the post's title, a class to signify the contents of this span is the
+  blog post's author, etc.
+
+  You can then use a microformat parser (like, say, mofo) to extract this information
+  as you would from an Atom feed.  Hell, you can even convert hAtom to Atom.  It's an
+  insta-feed!  No extra code required!
+
+  You're already doing the work, you see.  Microformats are everywhere.  We just need
+  to set them free.
+
+  Check it:
+
+    <div class="post">
+      <h3>Megadeth Show Last Night</h3>
+      <span class="subtitle">Posted by Chris on June 4th</span>
+      <div class="content">Went to a show last night.  Megadeth.  It was alright.</div>
+    </div>
+
+  Right?  Normal.  Here's the same post marked up with hAtom:
+
+    <div class="post hentry">
+      <h3 class="entry-title">Megadeth Show Last Night</h3>
+      <span class="subtitle">Posted by <span class="author vcard fn">Chris</span> on 
+      <abbr class="updated" title="2006-06-04T10:32:10Z">June 4th</abbr></span>
+      <div class="content entry-content">Went to a show last night.  Megadeth.  It was alright.</div>
+    </div>
+
+  All I did was add the hentry, entry-title, and entry-content classes to existing containers.  Then I
+  went ahead and wrapped the date in an <abbr> tag giving it a title in the microformat-standard way.  Finally
+  I put a div around Chris signifying it as the author field of the hEntry and making it a valid hCard by
+  including the vcard and fn classes.  It's really not all that hard.  Did I mess it up?  Maybe, but I'm sure I got
+  close.  And I didn't even use a reference.  Practice.
+
+  How'd we parse this, tho?
+
+    $ irb -rubygems
+    >> require 'mofo'
+    => true
+
+    >> post = HEntry.find 'http://milesofstyle.org/posts/351-megadeth-show-last-night.html'
+    => #<HEntry:0x6db898 ... > 
+
+    >> post.entry_title
+    => "Megadeth Show Last Night"
+
+    >> post.properties
+    => ["entry_content", "updated", "author", "entry_title"]
+
+    >> post.updated
+    => Sun Jun 04 10:32:10 UTC 2006
+
+    >> post.updated.class
+    => Time
+
+    >> post.author
+    => #<HCard:0x6e7b98 @properties=["fn"], @fn="Chris">
+
+    >> post.author.fn
+    => "Chris"
+
+    >> post.entry_content
+    => "Went to a show last night.  Megadeth.  It was alright."
+
+  That's, like, stupid easy.  If HEntry.find gets back more than one hEntry, you'll get an array.
+
+= Mofo#find
+
+  Everything revolves around the #find method.  Sound familiar?  Yeah.
+
+    >> Microformat.find "http://valid-url.com"
+    >> Microformat.find "/path/to/existing/file"
+    >> Microformat.find :text => "microformat text"
+   
+  Also, #find can be told explicitly to find all (returning an array on failure) or only find
+  the first (returning nil on failure).
+
+    >> Microformat.find :all => "/existing/file"
+    => [ array of microformat objects ] 
+
+    >> Microformat.find :first => "/existing/file"
+    => microformat object
+
+    >> Microformat.find "/existing/file"
+    => either an array of objects or just one object
+
+  :all and :first go outside of :text.
+
+    >> Microformat.find :all => { :text => 'mfin text' } 
+
+  That's it.  Some microformats take specific options.
+
+= Microformats
+
+  Here are the currently implemented microformats, along with a site you
+  can use them on today.  We want more, better, faster, stat.
+
+  formats:
+  - hCard     [ flickr profiles    ]
+  - hCalendar [ upcoming.org       ]
+  - hReview   [ cork'd reviews     ] 
+  - hEntry    [ err the blog posts ]
+  - xoxo      [ chowhound.com      ]
+
+  patterns:
+  - rel-tag 
+  - rel-bookmark
+
+  Here are the microformats we want soon soon soon:
+  - geo
+  - hResume
+
+  patterns:
+  - include-pattern
+
+= Ruby on Rails
+
+mofo doubles as a Rails plugin.  Just drop it into vendor/plugins and you are good to go, with all the 
+available microformat parsers loaded into your application.
+
+mofo classes are YAML and Marshal approved.  This means you can cache them with DRb or memcached, or store
+them in a session.
+
+= More Info
+
+  >> http://microformats.org/ 
+  => "The homepage, check"
+  >> http://microformats.org/wiki/
+  => "The wiki, check"
+  >> http://blog.labnotes.org/category/microformats/
+  => "Assaf Arkin knows his MFin' stuff"
+  >> http://allinthehead.com/
+  => "Drew McClellan, Microformat wizard"
+  >> http://mofo.rubyforge.org/
+  => "mofo HQ"
+
+= Other Parsers
+
+  >> Scrapi
+  => http://rubyforge.org/projects/scrapi/
+  >> uformats
+  => http://rubyforge.org/projects/uformats

data/lib/microformat.rb

@@ -0,0 +1,199 @@
+%w[rubygems hpricot microformat/string open-uri ostruct timeout].each { |f| require f }
+require_gem 'hpricot', '>= 0.4.59'
+
+class Microformat
+  module Base
+    ##
+    # The Gateway
+    #
+    def find(*args)
+      target, @options = args
+      @options ||= Hash === target ? target : {}
+      [:first, :all].each { |key| target = @options[key] if @options[key] }
+      
+      doc = build_doc(@options[:text] ? @options : target)
+
+      microformats = find_occurances(doc)
+      raise MicroformatNotFound if @options[:strict] && microformats.empty?
+      return @options[:first] ? nil : [] if microformats.empty?
+
+      if @options[:first] || @options[:all]
+        return @options[:first] ? find_first(microformats) : find_every(microformats)
+      end
+
+      object = find_every(microformats)
+      case object.size
+      when 1 then object.first
+      when 0 then nil
+      else object
+      end
+    end
+
+  protected
+    ##
+    # DSL Related
+    # 
+    def inherited(klass)
+      klass.instance_variable_set("@container",  klass.name.downcase)
+      klass.instance_variable_set("@attributes", Hash.new([]))
+    end
+
+    def collector
+      collector = Hash.new([])
+      def collector.method_missing(method, *classes)
+        super unless %w[one many].include? method.to_s
+        self[method] += Microformat.send(:break_out_hashes, classes)
+      end
+      collector
+    end
+
+    def container(container)
+      @container = container.to_s
+    end
+
+    def method_missing(method, *args, &block)
+      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
+    end
+
+    def break_out_hashes(array)
+      array.inject([]) do |memo, element|
+        memo + (Hash === element ? [element.map { |k,v| { k => v } }].flatten : [element])
+      end
+    end
+
+    def aliases(hash)
+      define_method(hash.keys.first) do
+        send(hash[hash.keys.first])
+      end
+    end
+
+    ##
+    # The Functionality
+    #
+    def find_first(doc)
+      build_class(doc.first)
+    end
+
+    def find_every(doc)
+      doc.inject([]) do |array, entry|
+        array + [build_class(entry)]
+      end
+    end
+
+    def build_doc(source)
+      case source
+      when String, File, StringIO     
+        result = ''
+        Timeout::timeout(3) { result = open(source) }
+        Hpricot(result)
+      when Hpricot, Hpricot::Elements 
+        source
+      when Hash                       
+        Hpricot(source[:text]) if source[:text]
+      end
+    end
+
+    def find_occurances(doc)
+      doc/".#{@container}" 
+    end
+
+    def build_class(microformat)
+      hash = build_hash(microformat)
+      class_eval { attr_reader *(hash.keys << :properties) }
+      klass = new
+      klass.instance_variable_set("@properties", hash.keys.map { |i| i.to_s } )
+      hash.each do |key, value|
+        klass.instance_variable_set("@#{key}", prepare_value(value) )
+      end
+      klass
+    end
+
+    def build_hash(doc, attributes = @attributes)
+      hash = {}
+
+      [:one, :many].each do |name|
+        attributes[name].each do |attribute|
+          is_hash = Hash === attribute
+          key = is_hash ? attribute.keys.first : attribute
+
+          # rel="bookmark" pattern
+          if bookmark = extract_bookmark(doc)
+            hash[:bookmark] = bookmark
+          end
+
+          found = doc/".#{key.no_bang.to_s.gsub('_','-')}"
+          raise InvalidMicroformat if found.empty? && key.to_s =~ /!/
+          next if found.empty?
+
+          if is_hash && Hash === attribute[key]
+            built_hash = build_hash(found, attribute[key])
+            key = key.no_bang
+            if built_hash.size.zero? && found.size.nonzero?
+              hash[key] = found.map { |f| parse_element(f) }
+              hash[key] = hash[key].first if name == :one
+            else
+              hash[key] = built_hash
+            end
+          else
+            target = is_hash ? attribute[key] : nil
+            key = key.no_bang
+            if name == :many
+              hash[key] ||= [] 
+              hash[key] += found.map { |f| parse_element(f, target) }
+            else
+              hash[key] = parse_element(found.first, target) 
+            end
+          end
+          hash[key] = hash[key].first if Array === hash[key] && hash[key].size == 1
+        end
+      end
+
+      hash
+    end
+
+    def extract_bookmark(doc)
+      bookmark = doc.search("[@rel='bookmark']").first rescue nil
+      bookmark.attributes['href'] if bookmark.respond_to? :attributes
+    end
+
+    def parse_element(element, target = nil)
+      if target == :url
+        case element.name
+        when 'img'    then element['src']
+        when 'a'      then element['href']
+        when 'object' then element['value']
+        end
+      elsif Class === target
+        target.find(:first => element)
+      else
+        case element.name
+        when 'abbr' then element['title']
+        when 'img'  then element['alt']
+        else element.innerHTML
+        end.strip.strip_html.coerce
+      end
+    end
+
+    def prepare_value(value)
+      Hash === value ? 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)
+    self.class.class_eval { define_method(method) { instance_variable_get("@#{method}") } }
+    instance_variable_get("@#{method}")
+  end
+
+  extend Base
+end
+
+class InvalidMicroformat  < Exception; end
+class MicroformatNotFound < Exception; end
+
+# type & id are used a lot in uformats and deprecated in ruby.  no loss.
+OpenStruct.class_eval { undef :type, :id }
+Symbol.class_eval { def no_bang() to_s.sub('!','').to_sym end }

data/lib/microformat/simple.rb

@@ -0,0 +1,28 @@
+require 'microformat'
+
+class Microformat::Simple < String
+  extend Microformat::Base
+
+  class << self
+    def find_first(doc)
+      find_every(doc).first
+    end
+
+    def build_class(tags)
+      @from.inject([]) do |array, (key, value)|
+        tags.each_child do |tag|
+          next unless tag.respond_to? :attributes
+          array << new(tag.innerHTML) if tag.attributes[key.to_s] == value.to_s
+        end
+        array
+      end
+    end
+
+    def from(options)
+      @from ||= {}
+      options.each do |tag, value|
+        @from[tag] = value
+      end
+    end
+  end
+end

data/lib/microformat/string.rb

@@ -0,0 +1,40 @@
+require 'generator'
+require 'date'
+require 'time'
+
+# http://project.ioni.st/post/925#post-925
+class String
+  def coerce
+    attempt = nil
+    while coercions.next?
+      attempt = coercions.next
+      break if !attempt.nil?
+    end
+    %w[@coercions @generator].each { |i| remove_instance_variable i }
+    attempt.nil? ? self : attempt
+  end
+
+  def strip_html
+    gsub(/<(?:[^>'"]*|(['"]).*?\1)*>/,'')
+  end
+  
+private
+  def coercions
+    @coercions ||= Generator.new do |@generator|
+      try { self == 'true' }
+      try { [self == 'false', false] }
+      try { [Date.parse(self), Time.parse(self)] }
+      try { Integer(self) }
+      try { Float(self) }
+    end
+  end
+
+  def try
+    attempt, desired = yield
+    if attempt
+      @generator.yield(desired.nil? ? attempt : desired)
+    end
+  rescue ArgumentError
+    @generator.yield nil
+  end
+end

data/lib/mofo.rb

@@ -0,0 +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}" }

data/lib/mofo/hcalendar.rb

@@ -0,0 +1,12 @@
+# => http://microformats.org/wiki/hcalendar
+require 'microformat'
+
+class HCalendar < Microformat
+  container :vevent
+
+  one :class, :description, :dtend, :dtstamp, :dtstart,
+      :duration, :location, :status, :summary, :uid,
+      :last_modified, :url => :url
+
+  many :category
+end

data/lib/mofo/hcard.rb

@@ -0,0 +1,40 @@
+# => http://microformats.org/wiki/hcard
+require 'microformat'
+
+class HCard < Microformat
+  container :vcard
+
+  one :fn, :bday, :tz, :sort_string, :uid, :class
+  many :label, :sound, :title, :role, :key, 
+       :mailer, :rev, :nickname, :category, :note,
+       :logo => :url, :url => :url, :photo => :url
+
+  one :n do
+    one :family_name, :given_name, :additional_name
+    many :honorific_prefix, :honorific_suffix
+  end 
+
+  many :email do 
+    many :type
+    many :value
+  end 
+
+  many :tel do
+    many :type
+    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
+end

data/lib/mofo/hentry.rb

@@ -0,0 +1,11 @@
+# => http://microformats.org/wiki/hatom
+require 'microformat'
+require 'mofo/hcard'
+require 'mofo/rel_tag'
+
+class HEntry < Microformat
+  one :entry_title!, :entry_summary, :updated, :published,
+      :author => HCard
+
+  many :entry_content, :tags => RelTag
+end

data/lib/mofo/hfeed.rb

@@ -0,0 +1,6 @@
+# => http://microformats.org/wiki/hatom
+require 'mofo/hentry'
+
+class HFeed < Microformat
+  many :hentry => HEntry
+end

data/lib/mofo/hreview.rb

@@ -0,0 +1,16 @@
+# => http://microformats.org/wiki/hreview
+require 'microformat'
+require 'mofo/hcard'
+require 'mofo/rel_tag'
+
+class HReview < Microformat
+  one :version, :summary, :type, :dtreviewed, :rating, :description
+
+  one :reviewer => HCard
+
+  one :item! do
+    one :fn
+  end
+
+  many :tags => RelTag
+end

data/lib/mofo/rel_tag.rb

@@ -0,0 +1,7 @@
+# => http://microformats.org/wiki/rel-design-pattern
+require 'microformat/simple'
+
+class RelTag < Microformat::Simple
+  container :tags
+  from :rel => :tag
+end

data/lib/mofo/xoxo.rb

@@ -0,0 +1,56 @@
+$:.unshift 'lib'
+require 'microformat'
+
+class XOXO < Microformat
+  class << self
+    PARENTS = %w[ol ul]
+    CHILDREN = %w[li]
+
+    xpath_build =  proc { |element| element.map { |e| "/#{e}" } * ' | '  }
+    CHILDREN_XPATH = xpath_build.call(CHILDREN)
+    PARENTS_XPATH = xpath_build.call(PARENTS)
+
+    def find_first(doc)
+      find_every(doc).first
+    end
+
+    def find_every(doc)
+      tree = []
+      doc.each do |child|
+        tree << build_tree(child)
+      end
+      tree
+    end
+
+    def find_occurances(doc)
+      @options[:class] ? doc/".xoxo" : doc.search(PARENTS_XPATH)
+    end
+
+    def build_tree(child)
+      tree = []
+      child.search(CHILDREN_XPATH) do |element|
+        label, branch = nil, nil
+        element.children.each do |inner|
+          label  ||= build_label(inner) unless inner.elem? && PARENTS.include?(inner.name)
+          branch ||= build_tree(inner) if inner.elem? && PARENTS.include?(inner.name)
+        end
+        tree << (branch ? { label => branch } : label)
+      end 
+      tree
+    end
+
+    def build_label(node)
+      if node.elem? 
+        label = Label.new(node.innerHTML.strip)
+        label.url = node['href'] if node.name == 'a'
+        label
+      elsif node.text? && !node.to_s.strip.empty?
+        node.to_s.strip 
+      end
+    end
+  end
+
+  class Label < String
+    attr_accessor :url
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: mofo
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2006-11-09 00:00:00 -08:00
+summary: mofo is a ruby microformat parser
+require_paths: 
+- lib
+email: chris[at]ozmm[dot]org
+homepage: http://mofo.rubyforge.org/
+rubyforge_project: 
+description: mofo is a ruby microformat parser
+autorequire: mofo
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Chris Wanstrath
+files: 
+- README
+- CHANGELOG
+- LICENSE
+- lib/microformat
+- lib/microformat.rb
+- lib/mofo
+- lib/mofo.rb
+- lib/microformat/simple.rb
+- lib/microformat/string.rb
+- lib/mofo/hcalendar.rb
+- lib/mofo/hcard.rb
+- lib/mofo/hentry.rb
+- lib/mofo/hfeed.rb
+- lib/mofo/hreview.rb
+- lib/mofo/rel_tag.rb
+- lib/mofo/xoxo.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+