uformats 1.2.1

data/lib/uformats/hcalendar.rb

@@ -0,0 +1,23 @@
+require 'uformats/basic'
+
+module Microformats
+  module HCalendar    
+    class Event < BasicNestedFormat
+    
+      identifier :vevent
+    
+      structure( 
+        :version => :string,
+        :url => :url,
+        :summary => :string,
+        :dtstart => :datetime,
+        :dtend => :datetime,
+        :dtstamp => :datetime,
+        :location => :string,
+        :description => :string,
+        :uid => :string 
+      )
+    
+    end
+  end
+end

data/lib/uformats/hcard.rb

@@ -0,0 +1,100 @@
+require 'uformats/basic'
+
+module Microformats
+  class HCard < BasicNestedFormat
+    
+    identifier :vcard
+    
+    structure(
+      :fn => :string,
+      :n => {
+        :family_name      => :string,
+        :given_name       => :string,
+        :additional_names => :string,
+        :honorific_prefix => [:string],
+        :honorific_suffix => [:string],
+      },
+      :nickname => [:string],
+      :sort_string => :string,
+      :url => [:url],
+      :email => [{
+        :type  => [:string],
+        :value  => :email,
+      }],
+      :tel => [{
+        :type  => [:string],
+        :value  => :value,
+      }],
+      :adr => [{
+        :post_office_box  => :string,
+        :extended_address => :string,
+        :street_address   => :string,
+        :locality         => :string,
+        :region           => :string,
+        :postal_code      => :string,
+        :country_name     => :string,
+        :type             => [:string],
+        :value            => :string,
+      }],
+      :label => :string,
+      :geo => {
+        :latitude   => :float,
+        :longitude  => :float,
+      },
+      :tz => :string,
+      :photo => :url, 
+      :logo => :url, 
+      :sound => :string, 
+      :bday => :datetime,
+      :title => :string,
+      :role => :string,
+      :org => {
+        :organization_name => :string,
+        :organization_unit => :string,
+      },
+      :category => [:string],
+      :note => [:string],
+      :class => :string,
+      :key => :string,
+      :mailer => :string,
+      :uid => :string,
+      :rev => :string
+    )
+    
+    def post_process!
+      n_optimize!
+      org_optimize!
+    end
+  
+    #
+    # Perform implied 'N' optimization
+    # http://microformats.org/wiki/hcard#Implied_.22N.22_Optimization
+    #
+    def n_optimize!
+      @tree[:n] ||= MethodHash.new
+      if (!@tree[:n][:family_name] && !@tree[:n][:given_name] && @tree[:fn])
+        @tree[:n][:family_name], @tree[:n][:given_name] = case @tree[:fn]
+        when /^(\w+), (\w+)$/u
+          [$1, $2]
+        when /^(\w+) (\w)\.?$/u
+          [$1, $2]
+        when /^(\w+) (\w+)$/u
+          [$2, $1]
+        end
+      end
+    end
+    
+    #
+    # Perform org optimization (for when organization-name is implicit)
+    #
+    def org_optimize!
+      return if lookup(:org, :organization_name)
+      Microformats.each_element_by_class(source, :org) do |element|
+        @tree[:org] ||= MethodHash.new
+        @tree[:org][:organization_name] = process_as_string(element)
+        return
+      end
+    end
+  
+  end
+end

data/lib/uformats/hreview.rb

@@ -0,0 +1,182 @@
+require 'uformats/basic'
+require 'uformats/hcard'
+
+module Microformats
+  class HReview < BasicNestedFormat
+    
+    structure(
+      :version => :string,
+      :summary => :string,
+      :type => :string,
+      :item => {
+        :fn => :string,
+        :url => [:url],
+        :photo => [:url],
+        :vcard => :hcard,
+        :vevent => :event, 
+      },
+      :reviewer => {
+        :fn => :string,
+        :url => :url,
+        :email => :email,
+        :vcard => :hcard,
+      },
+      :dtreviewed => :datetime,
+      :rating => [:rating],
+      :worst => [:worst],
+      :best => [:best],
+      :description => :xhtml,
+      :permalink => :url
+    )
+    
+    VALID_TYPES = %w[product business event person place website url]
+    
+    def post_process!
+      fix_anonymous_reviewer!
+      fix_ratings!
+    end
+  
+    #
+    # Returns true if this is a valid hReview
+    #
+    def valid?
+      unless (
+        lookup(:item, :fn) || lookup(:item, :url) ||
+        lookup(:item, :photo) || lookup(:item, :vcard)
+      )
+        @validation_message = 'missing item details'
+        return false
+      end
+      if (
+        lookup(:type) &&
+        !VALID_TYPES.include?(lookup(:type))
+      )
+        @validation_message = 'invalid review type'
+        return false
+      end
+      if (
+        (lookup(:version) || 999).to_f > 0.2 &&
+        %w[person business].include?(lookup(:type)) &&
+        !lookup(:item, :vcard)
+      )
+        @validation_message = 'item must be vcard for person or business'
+        return false
+      end
+      return true
+    end
+    attr_accessor :validation_message
+    
+    def license
+      return (licenses || []).first
+    end
+    
+    def licenses
+      return @licenses ||= Microformats.rel_licenses(@source)
+    end
+    
+    def process_as_hcard(element)
+      return HCard.new(element)
+    end
+    
+    def process_as_event(element)
+      return HCalendar::Event.new(element)
+    end
+    
+    def process_as_rating(element)
+      value = process_as_float(element)
+      tags = Microformats.rel_tags_above_element(element)
+      if !value && value_element = Microformats.first_element_by_class(element, :value)
+        value = process_as_float(value_element)
+        tags = Microformats.rel_tags_above_element(value_element)
+      end
+      return set_score(:score=, value, tags)
+    end
+    
+    def process_as_best(element)
+      value = process_as_float(element)
+      tags = Microformats.rel_tags_above_element(element)
+      return set_score(:best=, value, tags)
+    end
+    
+    def process_as_worst(element)
+      value = process_as_float(element)
+      tags = Microformats.rel_tags_above_element(element)
+      return set_score(:worst=, value, tags)
+    end
+        
+    def set_score(sym, value, tags)
+      @ratings ||= {}
+      if tags
+        tags.each do |tag|
+          @ratings[tag] ||= Rating.new
+          @ratings[tag].__send__(sym, value)
+        end
+      else
+        @rating ||= Rating.new
+        @rating.__send__(sym, value)
+      end
+      return nil
+    end
+    
+    def fix_anonymous_reviewer!
+      return if lookup(:reviewer, :fn)
+      Microformats.each_element_by_class(@source, :reviewer) do |e|
+        if 'anonymous' == process_as_string(e).downcase
+          @tree[:reviewer][:fn] = 'anonymous'
+          return
+        end
+      end
+    end
+    
+    #
+    # Assign default values for ratings, and insert them into 
+    # the tree
+    #
+    def fix_ratings!
+      if (@rating)
+        @rating.best ||= Rating::BEST
+        @rating.worst ||= Rating::WORST
+        default_best = @rating.best
+        default_worst = @rating.worst 
+      end
+      default_best ||= Rating::BEST
+      default_worst ||= Rating::WORST
+      @ratings ||= {}
+      @ratings.each do |tag, rating|
+        rating.best  ||= default_best
+        rating.worst ||= default_worst
+      end
+      @tree[:rating] = @rating
+      @tree[:ratings] = @ratings
+    end
+
+    class Rating
+      WORST = 1
+      BEST = 5
+      
+      def initialize(score=nil)
+        @score = score
+      end
+      
+      attr_reader :best, :worst, :score
+      
+      def best=(b)
+        @best = b.to_i
+      end
+      
+      def worst=(w)
+        @worst = w.to_i
+      end
+      
+      def score=(s)
+        @score = s.to_f
+      end
+          
+      def to_f
+        return (@score - (@worst || WORST)).to_f / ((@best || BEST) - (@worst || WORST))
+      end
+    end # Rating
+    
+  end # HReview
+
+end

data/lib/uformats/pluralizer.rb

@@ -0,0 +1,32 @@
+module Microformats
+  class Pluralizer
+    @@plurals = {}
+  
+    PLURALS = [
+      [/([^aeo])y$/, '\1ies'],
+      [/(s+|ch|x)$/, '\1es'],
+    ]
+  
+    def self.pluralize(sym)
+      return @@plurals[sym] if @@plurals[sym]
+      string = sym.to_s
+      PLURALS.each do |match, replacement|
+        if string.match(match)
+          plural = string.sub(match, replacement).to_sym
+          @@plurals[sym] = plural
+          return plural
+        end
+      end
+      plural = (string + 's').to_sym
+      @@plurals[sym] = plural
+      return plural
+    end
+  
+    def self.singularized_lookup(hash, sym)
+      return hash[sym] if hash[sym]
+      plural = hash[Pluralizer.pluralize(sym)]
+      return plural[0] if plural.respond_to?(:[])
+      return nil
+    end
+  end # Pluralizer
+end

data/test/all.rb

@@ -0,0 +1,4 @@
+$: << File.dirname(__FILE__)
+Dir[File.dirname(__FILE__)+'/*_test.rb'].each do |test|
+  require test
+end

data/test/basic_test.rb

@@ -0,0 +1,441 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'uformats/hcard'
+
+class TestFormat < Microformats::BasicNestedFormat
+  structure(
+    :tv => {
+      :type => [:string],
+      :value => :value,
+    },
+    :te => {
+      :type => [:string],
+      :value => :email,
+    },
+    :string => :string,
+    :nested => {
+      :inner => :string,
+    },
+    :integer => :integer,
+    :float => :float,
+    :datetime => :datetime,
+    :url => :url,
+    :email => :email,
+    :xhtml => :xhtml
+  )
+end
+
+class TestFormatWithPostProcess < Microformats::BasicNestedFormat
+
+  structure(:string => :string)
+
+  def post_process!
+    @post = true
+  end
+  attr_reader :post
+end
+
+class BasicNestedFormatTest < Test::Unit::TestCase
+
+  def test_should_accept_rexml_document_as_source
+    assert_nothing_raised{
+      t = TestFormat.new(REXML::Document.new(%{
+        <x class="testformat">
+        </x>
+      }))
+    }
+  end
+
+  def test_should_accept_text_as_source
+    assert_nothing_raised{
+      t = TestFormat.new(%{
+        <x class="testformat">
+        </x>
+      })
+    }
+  end
+  
+  def test_should_call_post_process
+    t = TestFormatWithPostProcess.new('<x></x>')
+    assert(t.post)
+  end
+  
+  def test_should_not_cause_error_if_post_process_not_defined
+    assert_nothing_raised{ TestFormat.new('<x></x>') }
+  end
+  
+  def test_should_expand_include_patterns_before_processing
+    before = %{
+      <div>
+        <span class="testformat">
+          <span class="string" id="master">Foo</span>
+        </span>        
+        <span class="testformat">
+          <object data="#master" class="include" type="text/html"></object>
+        </span>
+      </div>
+    }
+    tfs = []
+    TestFormat.each(before) do |tf|
+      tfs << tf
+    end
+    assert_equal('Foo', tfs[0].string)
+    assert_equal('Foo', tfs[1].string)
+  end
+  
+  def test_should_expand_relative_urls
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="url" href="/link">link</a>
+      </x>
+    }, 'http://www.example.com/')
+    assert_equal('http://www.example.com/link', t.url)
+  end
+  
+  def test_should_return_nested_item_or_nil_via_lookup_method
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <x class="tv">
+          <x class="type">a</x>
+          <x class="type">b</x>
+          <x class="value">c</x>
+        </x>
+      </x>
+    }, 'http://www.example.com/')
+    assert_equal('a', t.lookup(:tv, :type))
+    assert_equal('a', t.lookup(:tv, :types, 0))
+    assert_equal('b', t.lookup(:tv, :types, 1))
+    assert_equal('c', t.lookup(:tv, :value))
+    assert_nil(t.lookup(:foo, :bar))
+  end
+
+  def test_should_return_email_when_href
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="email" href="mailto:bob@example.com">email</a>
+      </x>
+    })
+    assert_equal('bob@example.com', t.email)
+  end
+
+  def test_should_return_email_when_text
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="email">bob@example.com</a>
+      </x>
+    })
+    assert_equal('bob@example.com', t.email)
+  end
+
+  
+  def test_should_interpret_nested_values_when_xml_is_nested
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a><b class="nested"><c class="inner">foo</c>bar</b></a>
+      </x>
+    })
+    assert_equal('foo', t.nested.inner)
+  end
+  
+  def test_should_interpret_nested_values_when_xml_is_not_nested
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a><b class="nested inner">foo</b>bar</a>
+      </x>
+    })
+    assert_equal('foo', t.nested.inner)
+  end
+  
+  def test_should_return_nil_for_missing_href_in_url
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="url">
+          quux
+        </a>
+      </x>
+    })
+    assert_nil(t.url)
+  end
+  
+  def test_should_process_type_and_value_when_value_is_explicit
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="tv">
+          <b class="type">foo</b>
+          <b class="type">bar</b>
+          <b class="value">baz</b>
+          quux
+        </a>
+      </x>
+    })
+    assert_equal('foo', t.tv.type)
+    assert_equal(['foo', 'bar'], t.tv.types)
+    assert_equal('baz', t.tv.value)
+  end
+  
+  def test_should_process_type_and_value_when_value_is_implicit
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="tv">
+          <b class="type">foo</b>
+          <b class="type">bar</b>
+          baz
+        </a>
+      </x>
+    })
+    assert_equal('foo', t.tv.type)
+    assert_equal(['foo', 'bar'], t.tv.types)
+    assert_equal('baz', t.tv.value)
+  end
+  
+  def test_should_process_type_and_email_when_value_is_explicit
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="te">
+          <b class="type">foo</b>
+          <b class="type">bar</b>
+          <b class="value" href="mailto:user@example.com">user@example.com</b>
+          quux
+        </a>
+      </x>
+    })
+    assert_equal('foo', t.te.type)
+    assert_equal(['foo', 'bar'], t.te.types)
+    assert_equal('user@example.com', t.te.value)
+  end
+  
+  def test_should_process_type_and_email_when_value_is_implicit_href
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="te" href="mailto:user@example.com">
+          user@example.com
+          <b class="type">foo</b>
+          <b class="type">bar</b>
+        </a>
+      </x>
+    })
+    assert_equal('foo', t.te.type)
+    assert_equal(['foo', 'bar'], t.te.types)
+    assert_equal('user@example.com', t.te.value)
+  end
+  
+  def test_should_process_type_and_email_when_value_is_implicit_text
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="te">
+          user@example.com
+        </a>
+      </x>
+    })
+    assert_equal('user@example.com', t.te.value)
+  end
+  
+  def test_should_reassemble_marked_up_strings
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="string">
+          <h1>About</h1>
+          <p>This is <a href="/">some text</a>.</p>
+          <h2>Final</h2>
+          <p>This is the last paragraph.</p>
+        </a>
+      </x>
+    })
+    assert_equal('About This is some text. Final This is the last paragraph.', t.string)
+  end
+
+  def test_should_regurgitate_xhtml_verbatim
+    xhtml = %{
+      <h1>About</h1>
+      <p>This is <a href='/'>some text</a>.</p>
+      <h2>Final</h2>
+      <p>This is the last paragraph.</p>
+    }
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="xhtml">
+          #{xhtml}
+        </a>
+      </x>
+    })
+    assert_equal(xhtml.strip.gsub(/\s+/, ' '), t.xhtml.strip.gsub(/\s+/, ' '))
+  end
+  
+  def test_should_use_title_attribute_when_string_is_abbr
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <abbr class="string" title="foo">bar</abbr>
+      </x>
+    })
+    assert_equal('foo', t.string)
+  end
+
+  def test_should_use_alt_attribute_when_string_is_img
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <img class="string" alt="foo" />
+      </x>
+    })
+    assert_equal('foo', t.string)
+  end
+  
+  def test_should_use_href_for_url_when_available
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="url" href="http://example.com/foo">bar</a>
+      </x>
+    })
+    assert_equal('http://example.com/foo', t.url)
+  end
+
+  def test_should_use_src_for_url_when_available
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <img class="url" src="http://example.com/foo" />
+      </x>
+    })
+    assert_equal('http://example.com/foo', t.url)
+  end
+  
+  def test_should_find_all_matching_microformats_via_each_with_text
+    src = %{
+      <z>
+        <x class="testformat">
+          <a class="integer">1</a>
+        </x>
+        <x class="testformat">
+          <a class="integer">2</a>
+        </x>
+      </z>
+    }
+    ary = []
+    TestFormat.each(src) do |tf|
+      ary << tf
+    end
+    assert_equal(1, ary[0].integer)
+    assert_equal(2, ary[1].integer)    
+  end
+
+  def test_should_find_all_matching_microformats_via_each_with_rexml
+    src = REXML::Document.new(%{
+      <z>
+        <x class="testformat">
+          <a class="integer">1</a>
+        </x>
+        <x class="testformat">
+          <a class="integer">2</a>
+        </x>
+      </z>
+    })
+    ary = []
+    TestFormat.each(src) do |tf|
+      ary << tf
+    end
+    assert_equal(1, ary[0].integer)
+    assert_equal(2, ary[1].integer)    
+  end
+
+
+  def test_should_find_first_matching_microformats_via_first
+    src = %{
+      <z>
+        <x class="testformat">
+          <a class="integer">1</a>
+        </x>
+        <x class="testformat">
+          <a class="integer">2</a>
+        </x>
+      </z>
+    }
+    tf = TestFormat.first(src)
+    assert_equal(1, tf.integer)    
+  end
+
+  
+  def test_should_parse_integers
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="integer">09</a>
+      </x>
+    })
+    assert_equal(9, t.integer)
+  end
+  
+  def test_should_parse_floats
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="float">3.14159</a>
+      </x>
+    })
+    assert_in_delta(3.14159, t.float, 0.01)
+  end
+  
+  def test_should_parse_zulu_dates
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="datetime">20050102T030405Z</a>
+      </x>
+    })
+    assert_equal(2005, t.datetime.utc.year)
+    assert_equal(1, t.datetime.utc.month)
+    assert_equal(2, t.datetime.utc.day)
+    assert_equal(3, t.datetime.utc.hour)
+    assert_equal(4, t.datetime.utc.min)
+    assert_equal(5, t.datetime.utc.sec)
+  end
+  
+  def test_should_parse_partial_dates
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="datetime">200501</a>
+      </x>
+    })
+    assert_equal(2005, t.datetime.utc.year)
+    assert_equal(1, t.datetime.utc.month)
+  end
+  
+  def test_should_return_nil_for_invalid_date
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="datetime">Hello!</a>
+      </x>
+    })
+    assert_nil(t.datetime)
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="datetime">9999-88-88</a>
+      </x>
+    })
+    assert_nil(t.datetime)
+  end
+  
+  def test_should_parse_time_zones_with_multiple_pluses
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="datetime">20010101T120000++0200</a>
+      </x>
+    })
+    assert_equal(10, t.datetime.utc.hour)
+  end
+
+  def test_should_parse_time_zones_with_multiple_minuses
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <a class="datetime">20010101T120000--0200</a>
+      </x>
+    })
+    assert_equal(14, t.datetime.utc.hour)
+  end
+
+  
+  def test_should_handle_email_when_encapsulated_by_unknown_element
+    t = TestFormat.new(%{
+      <x class="testformat">
+        <div class="te">
+          <a class="internet" href="mailto:info@example.com">info@example.com</a>
+        </div>
+      </x>
+    })
+    assert_equal('info@example.com', t.te.value)
+  end
+  
+end