hmachine 0.1.0 → 0.1.1

data/test/microformat/rellicense_test.rb

@@ -1,36 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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,20 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-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
-  
-  should 'find all microformats in a document' do
-    huffduff = HMachine::Microformat.find_all get_fixture('huffduffer.html')
-    assert_equal 45, huffduff.count
-  end
-  
-  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
-
-end

data/test/pattern/date_time_test.rb

@@ -1,55 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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