hmachine 0.0.1 → 0.1.0

data/test/microformat/rellicense_test.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class RelLicenseTest < Test::Unit::TestCase
+  setup do
+    @html = get_fixture('rel_license.html')
+    @doc = Nokogiri::HTML.parse(@html)
+  end
+  
+  describe 'Class' do    
+    should 'find itself in a document' do
+      assert_equal 2, HMachine::Microformat::RelLicense.find_in(@doc).count
+    end
+  end
+  
+  describe 'Instance' do
+    setup do
+      @klass = HMachine::Microformat::RelLicense
+      @node = @klass.find_in(@doc).first
+    end
+    
+    should 'have a license' do
+      test = @klass.new(@node)
+      assert_respond_to test, :license
+    end
+    
+    should 'parse the license out of the node' do
+      test = @klass.new(@node)
+      assert_equal 'http://creativecommons.org/licenses/by/2.0/', test.license
+    end
+    
+    should 'be the license when converted to a string' do
+      test = @klass.new(@node)
+      assert_equal test.license, test.to_s
+    end
+  end
+end

data/test/microformat/reltag_test.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class RelTagTest < Test::Unit::TestCase
+  setup do
+    @html = get_fixture('huffduffer.html')
+    @doc = Nokogiri::HTML.parse(@html)
+  end
+  
+  describe 'Class' do    
+    should 'find itself in a document' do
+      first_entry = @doc.css('.hfeed > .hentry').first
+      assert_equal 8, HMachine::Microformat::RelTag.find_in(first_entry).count
+    end
+    
+    should 'parse itself out of a document' do
+      first_entry = @doc.css('.hfeed > .hentry').first
+      assert_equal HMachine::Microformat::RelTag, HMachine::Microformat::RelTag.parse(first_entry).first.class
+    end
+  end
+  
+  describe 'Instance' do
+    setup do
+      @klass = HMachine::Microformat::RelTag
+      first_entry = @doc.css('.hfeed > .hentry').first
+      @node = @klass.find_in(first_entry).first
+    end
+    
+    should 'have a name that is the tag' do
+      test = @klass.new(@node)
+      assert_equal test.tag.keys.first, test.name
+    end
+    
+    should 'convert to a string easily' do
+      test = @klass.new(@node)
+      assert_equal test.name, "#{test}"
+    end
+    
+    should 'store the url for the tag' do
+      test = @klass.new(@node)
+      assert_equal test.tag.values.first, test.url
+    end
+    
+    should 'hash should be a representation of the tag' do
+      test = @klass.new(@node)
+      assert_equal test.tag, test.to_h
+    end
+  end
+  
+  describe 'Parsing' do
+    setup do
+      @klass = HMachine::Microformat::RelTag
+    end
+    
+    should "get a tag" do
+      first_entry = @doc.css('.hfeed > .hentry').first
+      test = @klass.new(@klass.find_in(first_entry).first)
+      assert_equal "event%3Aspeaker%3Dtim+o%27reilly", test.tag.keys.first
+    end
+  end  
+  
+end

data/test/microformat/votelinks_test.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class VoteLinksTest < Test::Unit::TestCase
+  setup do
+    @html = get_fixture('likeorhate.html')
+    @doc = Nokogiri::HTML.parse(@html)
+  end
+  
+  describe 'Class' do    
+    should 'find itself in a document' do
+      assert_equal 3, HMachine::Microformat::VoteLinks.find_in(@doc).count
+    end
+  end
+  
+  describe 'Instance' do
+    setup do
+      @klass = HMachine::Microformat::VoteLinks
+      @node = @klass.find_in(@doc).first
+    end
+    
+    should 'be a specific type of vote' do
+      test = @klass.new(@node)
+      assert_equal 'vote-for', test.type
+    end
+    
+    should 'check vote type' do
+      test = @klass.new(@node)
+      assert test.for?, "VoteLink is type of #{test.type}"
+      assert !test.against?
+      assert !test.abstain?
+    end
+    
+    should 'store the url of the vote' do
+      test = @klass.new(@node)
+      assert_equal 'http://likeorhate.com/rate/?id=1191956&rate=like', test.url
+    end
+    
+    should "Additional human-readable commentary can be added using the existing 'title' attribute" do
+      test = @klass.new(@node)
+      assert_equal 'Do you like it? Click now and vote!', test.title
+    end
+    
+  end
+end

data/test/microformat/xfn_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class XFNTest < Test::Unit::TestCase
+  setup do
+    html = get_fixture('xfn.html')
+    @doc = Nokogiri::HTML.parse(html)
+    @klass = HMachine::Microformat::XFN
+  end
+  
+  should 'search the document for relationships' do
+    contact = @klass.parse_first(@doc)
+    assert_respond_to contact, :rel
+    contact.rel.include? 'contact'
+  end
+  
+  should 'define boolean methods' do
+    contact = @klass.parse_first(@doc)
+    assert_respond_to contact, :friendship?
+    assert_respond_to contact, :me?
+    assert contact.friendship?
+  end
+  
+  should 'be able to parse just "me" relationships' do
+    me = @klass.parse_me(@doc)
+    assert me.first.me?
+  end
+  
+end

data/test/microformat/xmdp_test.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class XMDPTest < Test::Unit::TestCase
+  setup do
+    html = get_fixture('xmdp.html')
+    doc = Nokogiri::HTML.parse(html)
+    @klass = HMachine::Microformat::XMDP
+    @node = @klass.find_in(doc).first
+  end
+  
+  should 'be just like a definition list' do
+    xmdp = @klass.new(@node)
+    assert xmdp.to_h.has_key?(:rel)
+  end
+  
+end

data/test/microformat/xoxo_test.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class XOXOTest < Test::Unit::TestCase
+  setup do
+    html = get_fixture('xoxo.html')
+    doc = Nokogiri::HTML.parse(html)
+    @klass = HMachine::Microformat::XOXO
+    @node = @klass.find_in(doc).first
+  end
+    
+  should 'construct an outline' do
+    test = @klass.new(@node)
+    assert_equal 5, test.outline.count
+  end
+  
+  should 'convert to an array easily' do
+    test = @klass.new(@node)
+    assert_equal test.outline, test.to_a
+  end
+  
+  should 'index quickly into the outline' do
+    test = @klass.new(@node)
+    assert_equal test.to_a[0], test[0]
+  end
+  
+  should 'convert list items to an array' do
+    test = @klass.new(@node)
+    assert_instance_of Array, test[0]
+  end
+  
+  should 'convert lists to arrays' do
+    test = @klass.new(@node)
+    assert_instance_of Array, test[0][1]
+  end
+  
+  should 'convert definition lists to hashes' do
+    test = @klass.new(@node)
+    assert test[3].first.has_key?("description"), "Definition List is: #{test[3].first.inspect}"
+  end
+  
+  should 'convert links to hashes' do
+    test = @klass.new(@node)
+    assert test[4].first.has_key?(:url), "Definition List is: #{test[4].first.inspect}"
+  end
+  
+  should 'know if this is a blogroll' do
+    test = @klass.new(@node)
+    assert !test.blogroll?, "Test is a blogroll"
+  end    
+  
+end

data/test/microformat_test.rb

@@ -1,42 +1,20 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class MicroformatTest < Test::Unit::TestCase
-  setup do
-    @html = get_fixture('hcard/commercenet.html')
-    @document = Nokogiri::HTML.parse(@html)
-    @hcard_class = HMachine::Microformat::HCard
-  end
-    
-  test 'creates a microformat for a given node' do
-    hcard = HMachine::Microformat.create_for_node(@hcard_class, @document.css(@hcard_class::ROOT_SELECTOR)[0])
-    assert hcard.is_a?(@hcard_class), "Created a #{hcard.class}"
-  end
-  
-  test "rejects invalid nodes" do
-    hcard = HMachine::Microformat.create_for_node(@hcard_class, @document)
-    assert hcard.nil? 
-  end
-  
-  test 'finds a given microformat in a document' do
-    first_hcard = HMachine::Microformat.find_in_node(@hcard_class, @document)[0]
-    assert first_hcard.is_a?(@hcard_class), "Object is a #{first_hcard.class}"
+class MicroformatTest < Test::Unit::TestCase  
+  should 'map a symbol to a design pattern' do
+    assert HMachine::Microformat::HCard, HMachine::Microformat.map(:hcard)
+    assert HMachine::Microformat::RelTag, HMachine.map(:reltag)
   end
   
-  test 'knows that there are multiple microformats in a document' do
-    hcards = HMachine::Microformat.find_in_node(@hcard_class, @document)
-    assert hcards.respond_to? :length
+  should 'find all microformats in a document' do
+    huffduff = HMachine::Microformat.find_all get_fixture('huffduffer.html')
+    assert_equal 45, huffduff.count
   end
   
-  test 'finds all the microformats in a document' do
-    microformats = HMachine::Microformat.find_all(@document)
-    assert microformats.length == 1, "Number of Microformats in document: #{microformats.length}"
+  should 'find specific microformats in a document' do
+    huffduff = HMachine::Microformat.find get_fixture('huffduffer.html'), :hcard
+    assert_equal 'mawunsch', huffduff.first.fn
+    assert_equal 10, huffduff.count
   end
-  
-  describe 'Find hCard' do    
-    test 'document contains an hCard' do
-      first_hcard = HMachine::Microformat.find_hcard(@document)[0]
-      assert first_hcard.is_a?(@hcard_class), "Object is a #{first_hcard.class}"
-    end
-  end
-  
+
 end

data/test/pattern/date_time_test.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__),'..','test_helper')
+
+class DateTimePatternTest < Test::Unit::TestCase
+  setup do
+    @pattern = HMachine::Pattern::DateTime
+  end
+  
+  should 'recognize a simple iso8601 date' do
+    assert @pattern.date?('2010-02-14')
+    assert @pattern.date?('2010-185')
+    assert !@pattern.date?('12:00pm')
+  end
+  
+  should 'recognize a simple iso8601 time' do
+    assert @pattern.time?('12:00')
+    assert @pattern.time?('4:00pm')
+    assert @pattern.time?('12:45:30Z')
+    assert !@pattern.time?('2010-02-14')
+  end
+  
+  should 'build an iso8601 date' do
+    assert '2010-02-14', @pattern.date('February 14, 2010')
+    assert_equal @pattern.date('July 4 2010'), @pattern.date('2010-185')
+    assert_equal '2010-1-1', @pattern.date('January 2010')
+  end
+  
+  should 'build an iso8601 time' do
+    assert_equal 'T12:0:0-18000', @pattern.time('12:00')
+    assert_equal 'T13:0:0-18000', @pattern.time('1:00pm')
+    assert_equal 'T4:45:30Z', @pattern.time('4:45:30Z')
+    assert !@pattern.time('12')
+  end
+  
+  should 'build a iso8601 timestamp' do
+    assert_equal '2010-2-14', @pattern.iso8601('2010-02-14')
+    assert_equal 'T4:45:30Z', @pattern.iso8601('4:45:30Z')
+    assert_equal '2010-2-14T4:45:30Z', @pattern.iso8601('February 14 2010 4:45:30Z')
+    assert @pattern.iso8601('Hello world').empty?
+  end
+  
+  should 'validate a DateTime string' do
+    assert @pattern.valid?('2010-02-14')
+    assert !@pattern.valid?('Hello World!')
+    assert !@pattern.valid?('+441223 123 123')
+  end
+  
+  should 'convert a datetime string to a Time object' do
+    valentines_day = @pattern.extract_from('2010-02-14')
+    afternoon = @pattern.extract_from('16:30')
+    assert_equal Time, valentines_day.class
+    assert_equal 2010, valentines_day.year
+    assert_equal 16, afternoon.hour
+  end
+  
+end

data/test/pattern/value_class_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__),'..','test_helper')
+
+class ValueClassPatternTest < Test::Unit::TestCase
+  setup do
+    @pattern = HMachine::Pattern::ValueClass    
+  end
+  
+  should 'concatenate two html elements to create one datetime value' do
+    html = get_fixture('test-fixture/value-class-date-time/value-dt-test-YYYY-MM-DD--HH-MM.html')
+    doc = Nokogiri.parse(html)
+    doc_dtstart = doc.css('.dtstart').first
+    doc_dtend = doc.css('.dtend').first
+    
+    dtstart = @pattern.extract_from(doc_dtstart)
+    dtend = @pattern.extract_from(doc_dtend)
+    assert_equal Time, dtstart.class
+    assert_equal 2009, dtstart.year
+    assert_equal 6, dtstart.mon
+    assert_equal 26, dtstart.day
+    assert_equal 19, dtstart.hour
+    assert_equal 22, dtend.hour
+  end
+  
+  should 'concatenate abbr title attribute and the text from a span element to create one datetime value' do
+    html = get_fixture('test-fixture/value-class-date-time/value-dt-test-abbr-YYYY-MM-DD--HH-MM.html')
+    doc = Nokogiri.parse(html)
+    
+    dtstart = @pattern.extract_from(doc)
+    assert_equal 2008, dtstart.year
+    assert_equal 2, dtstart.wday
+  end
+  
+end

data/test/pattern_test.rb

@@ -0,0 +1,132 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class PatternTest < Test::Unit::TestCase
+  describe 'Mapper' do
+    should 'map a symbol to a design pattern' do
+      assert HMachine::Pattern::ValueClass, HMachine::Pattern.map(:value_class)
+    end
+  end
+  
+  describe 'URI Design Pattern' do
+    should 'have an extraction method' do
+      assert_respond_to HMachine::Pattern::URL, :extract
+    end
+    
+    should 'normalize URLs' do
+      assert_respond_to HMachine::Pattern::URL, :normalize
+      assert_equal 'http://foobar.com/', HMachine::Pattern::URL.normalize('http://foobar.com')
+    end
+    
+    should 'extract the href out of an a element' do
+      doc = Nokogiri.parse('<a href="http://foobar.com">Hello</a>')
+      a = doc.css('a').first
+      assert_equal 'http://foobar.com/', HMachine::Pattern::URL.extract_from(a)
+    end
+    
+    should 'extract the src out of an img element' do
+      doc = Nokogiri.parse('<img src="http://foobar.com" alt="Foobar" />')
+      img = doc.css('img').first
+      assert_equal 'http://foobar.com/', HMachine::Pattern::URL.extract_from(img)
+    end
+  end
+  
+  describe 'Type/Value Pattern' do
+    setup do
+      @html = get_fixture('test-fixture/hcard/hcard6.html')
+      @doc = Nokogiri::HTML.parse(@html).css('#uf').first
+    end
+    
+    should 'extract the type and value of an element' do
+      html = Nokogiri.parse(%Q{<span class="email">
+	      <span class="type">internet</span> 
+	      <a href="mailto:notthis@example.com">john@example.com</a>
+      </span>})
+      doc = html.css('.email').first
+      type_value = HMachine::Pattern::TypeValue.extract_from(doc)
+      assert type_value.has_key?(:type)
+      assert_equal :internet, type_value[:type]
+      assert_equal 'john@example.com', type_value[:value]
+    end
+  end
+  
+  describe 'Abbr Design Pattern' do
+    should 'have an extraction method' do
+      assert_respond_to HMachine::Pattern::Abbr, :extract
+    end
+    
+    should 'extract the title out of an abbreviation element' do
+      doc = Nokogiri.parse('<abbr title="Hello machine">Hello Human</abbr>')
+      node = doc.css('abbr').first
+      assert_equal 'Hello machine', HMachine::Pattern::Abbr.extract_from(node)
+    end
+    
+    should 'continue as usual if no title is found' do
+      doc = Nokogiri.parse('<abbr>Hello human</abbr>')
+      node = doc.css('abbr').first
+      assert_equal 'Hello human', HMachine::Pattern::Abbr.extract_from(node)
+    end
+  end
+  
+  describe 'Value Class Pattern' do
+    # http://microformats.org/wiki/value-class-pattern-tests
+    should 'find value class in a document' do
+      doc = Nokogiri.parse(%q{
+        <span class="tel">
+          <span class="type">Home</span>:
+          <span class="value">+44</span> (0) <span class="value">1223 123 123</span>
+        </span>
+      })
+      assert HMachine::Pattern::ValueClass.found_in?(doc)
+    end
+    
+    should 'ignore nested value classes' do
+      doc = Nokogiri.parse(%q{
+        <p class="description">
+          <span class="value">
+            <em class="value">Puppies Rule!</em>
+            <strong>But kittens are better!</strong>
+         </span>
+        </p>
+      })
+      assert_equal 1, HMachine::Pattern::ValueClass.find_in(doc).size
+      assert_not_equal 'Puppies Rule!', HMachine::Pattern::ValueClass.extract_from(doc)
+      assert HMachine::Pattern::ValueClass.valid?(HMachine::Pattern::ValueClass.find_in(doc).first)
+    end
+    
+    should 'extract the value' do
+      doc = Nokogiri.parse(%q{<p class="description"><span class="value">Value Class Pattern</span></p>})
+      assert_equal 'Value Class Pattern', HMachine::Pattern::ValueClass.extract_from(doc)
+    end
+    
+    should 'concatenate values' do
+      doc = Nokogiri.parse(%q{
+        <span class="tel">
+          <span class="type">Home</span>:
+          <span class="value">+44</span> (0) <span class="value">1223 123 123</span>
+        </span>
+      })
+      assert_equal '+441223 123 123', HMachine::Pattern::ValueClass.extract_from(doc)
+    end
+    
+    should 'extract the value intelligently from an abbr element' do
+      doc = Nokogiri.parse(%q{<span class="dtstart"><abbr class="value" title="hello">this Tuesday</abbr></span>})
+      assert_not_equal 'this Tuesday', HMachine::Pattern::ValueClass.extract_from(doc)
+      assert_equal 'hello', HMachine::Pattern::ValueClass.extract_from(doc)
+    end
+    
+    should 'use the alt attribute for images or areas' do
+      doc = Nokogiri.parse(%q{<div class="photo">Here's me: <img src="photo.jpg" class="value" alt="Whatever" /></div>})
+      assert_equal "Whatever", HMachine::Pattern::ValueClass.extract_from(doc)
+    end
+    
+    should 'understand the value-title pattern' do
+      doc = Nokogiri.parse(%q{
+      <span class="dtstart">
+        <span class="value-title" title="hi"> </span>
+        Friday, June 5th at 8pm
+      </span>})
+      assert_equal 'hi', HMachine::Pattern::ValueClass.extract_from(doc)
+    end
+    
+  end
+end