markaby 0.7.0 → 0.8.0

data/lib/markaby/tags.rb

@@ -1,6 +1,8 @@
 module Markaby
   FORM_TAGS         = [ :form, :input, :select, :textarea ]
-  SELF_CLOSING_TAGS = [ :base, :meta, :link, :hr, :br, :param, :img, :area, :input, :col, :frame ]
+  SELF_CLOSING_TAGS = [:area, :base, :br, :col, :command, :embed, :frame, :hr,
+                       :img, :input, :keygen, :link, :meta, :param, :source,
+                       :track, :wbr]
 
   # Common sets of attributes.
   AttrCore   = [:id, :class, :style, :title]
@@ -20,6 +22,13 @@ module Markaby
   AttrVAlign = [:valign]
   Attrs      = AttrCore + AttrI18n + AttrEvents
 
+  AttrsBoolean = [
+    :checked, :disabled, :multiple, :readonly, :selected, # standard forms
+    :autofocus, :required, :novalidate, :formnovalidate, # HTML5 forms
+    :defer, :ismap, # <script defer>, <img ismap>
+    :compact, :declare, :noresize, :noshade, :nowrap # deprecated or unused
+  ]
+
   # All the tags and attributes from XHTML 1.0 Strict
   class XHTMLStrict
     class << self
@@ -190,4 +199,91 @@ module Markaby
     @forms = @tags & FORM_TAGS
     @self_closing = @tags & SELF_CLOSING_TAGS
   end
+
+  class HTML5
+    class << self
+      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
+    end
+
+    @doctype = ['html']
+    @tagset = XHTMLTransitional.tagset.merge({
+      :abbr => Attrs,
+      :article => Attrs,
+      :aside => Attrs,
+      :audio => Attrs,
+      :bdi => Attrs,
+      :canvas => Attrs,
+      :command => Attrs,
+      :datalist => Attrs,
+      :details => Attrs,
+      :embed => Attrs,
+      :figure => Attrs,
+      :figcaption => Attrs,
+      :footer => Attrs,
+      :header => Attrs,
+      :hgroup => Attrs,
+      :keygen => Attrs,
+      :mark => Attrs,
+      :menu => Attrs,
+      :meter => Attrs,
+      :nav => Attrs,
+      :output => Attrs,
+      :progress => Attrs,
+      :rp => Attrs,
+      :rt => Attrs,
+      :ruby => Attrs,
+      :section => Attrs,
+      :source => Attrs,
+      :time => Attrs,
+      :track => Attrs,
+      :video => Attrs,
+      :wbr => Attrs
+    })
+
+    # Additional attributes found in HTML5
+    additional_tags = {
+      :a => [:media, :download, :ping],
+      :area => [:media, :download, :ping, :hreflang, :rel, :type],
+      :base => [:target],
+      :button => [:autofocus, :form, :formaction, :formenctype, :formmethod,
+                  :formnovalidate, :formtarget],
+      :fieldset => [:form, :disabled, :name],
+      :form => [:novalidate],
+      :label => [:form],
+      :html => [:manifest],
+      :iframe => [:sandbox, :seamless, :srcdoc],
+      :img => [:crossorigin],
+      :input => [:autofocus, :placeholder, :form, :required, :autocomplete,
+                 :min, :max, :multiple, :pattern, :step, :list, :width, :height,
+                 :dirname, :formaction, :formenctype, :formmethod,
+                 :formnovalidate, :formtarget],
+      :link => [:sizes],
+      :meta => [:charset],
+      :menu => [:type, :label],
+      :object => [:form],
+      :ol => [:reversed],
+      :object => [:typemustmatch],
+      :output => [:form],
+      :script => [:async],
+      :select => [:autofocus, :form, :required],
+      :style => [:scoped],
+      :textarea => [:autofocus, :placeholder, :form, :required, :dirname,
+                    :maxlength, :wrap],
+    }
+
+    AttrsHTML5  = [:contenteditable, :contextmentu, :draggable, :dropzone,
+                   :hidden, :role, :spellcheck, :translate]
+
+    additional_tags.each do |k, v|
+      @tagset[k] += v
+    end
+
+    @tagset.each do |k, v|
+      @tagset[k] += AttrsHTML5
+    end
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
 end

data/lib/markaby/version.rb

@@ -0,0 +1,3 @@
+module Markaby
+  VERSION = '0.8.0'
+end

data/lib/markaby.rb

@@ -16,15 +16,11 @@ $:.unshift File.expand_path(File.dirname(__FILE__))
 # * Markaby::MetAid: metaprogramming helper methods.
 # * Markaby::Tags: lists the roles of various XHTML tags to help Builder
 #   use these tags as they are intended.
-# * Markaby::Template: a class for hooking Markaby into Rails as a
-#   proper templating language.
 module Markaby
-  version_file = File.expand_path(File.dirname(__FILE__) + "/../VERSION")
-  VERSION      = File.read(version_file).strip
-
-  class InvalidXhtmlError < Exception; end
+  class InvalidXhtmlError < StandardError; end
 end
 
+require "markaby/version"
 require 'builder' unless defined?(Builder)
 require 'markaby/builder'
 require 'markaby/cssproxy'

data/spec/markaby/css_proxy_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
-class CssProxyTest < Test::Unit::TestCase
+describe Markaby::CssProxy do
   it "should have method_missing as private" do
     methods = Markaby::CssProxy.private_instance_methods.dup
     methods.map! { |m| m.to_sym }
@@ -14,34 +14,29 @@ class CssProxyTest < Test::Unit::TestCase
     end.new
   end
 
-  def test_responds_to_everything
+  it "responds_to_everything" do
     proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-
-    assert proxy.respond_to?(:any_method)
-    assert proxy.respond_to?(:foobarbazasdfasdfadfs)
+    proxy.respond_to?(:any_method).should be_true
+    proxy.respond_to?(:foobarbazasdfasdfadfs).should be_true
   end
 
-  def test_does_not_respond_to_method_missing
+  it "does_not_respond_to_method_missing" do
     proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-
-    assert !proxy.respond_to?(:method_missing)
+    proxy.should_not respond_to(:method_missing)
   end
 
-  def test_does_respond_to_private_instance_methods_with_private_flag_set_to_true
+  it "does_respond_to_private_instance_methods_with_private_flag_set_to_true" do
     proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-
-    assert proxy.respond_to?(:method_missing, true)
+    proxy.respond_to?(:method_missing, true).should be_true
   end
 
-  def test_does_not_respond_to_private_instance_methods_with_private_flag_set_to_false
+  it "does_not_respond_to_private_instance_methods_with_private_flag_set_to_false" do
     proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-
-    assert !proxy.respond_to?(:method_missing, false)
+    proxy.respond_to?(:method_missing, false).should be_false
   end
 
-  def test_respond_to_should_always_return_boolean
+  it "respond_to_should_always_return_boolean" do
     proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-
-    assert_equal proxy.respond_to?(:method_missing, :a_value), true
+    proxy.respond_to?(:method_missing, :a_value).should be_true
   end
 end

data/spec/markaby/html5_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Markaby do
+  it "should insert an html5 doctype" do
+    document = mab { html5 { head { title 'OKay' } } }
+    document.should include("<!DOCTYPE html>")
+  end
+
+  it "should not have xmlns in html5 html tag" do
+    document = mab { html5 { head { title 'OKay' } } }
+    document.should_not include("xmlns")
+  end
+
+  it "should make html5-specific tags" do
+    document = mab { html5 { tag! :header } }
+    document.should include("header")
+  end
+
+  it "should accept html5-specific tag as a block" do
+    document = mab { html5 { header { h1 "Wow" } } }
+    document.should include("<header><h1>Wow</h1></header>")
+  end
+
+  it "should make html5-specific tags in partials" do
+    document = mab { html5 { header { h1 "Wow" } } }
+    document.should include("<header><h1>Wow</h1></header>")
+  end
+
+  it "should put correct xhtml charset meta" do
+    document = mab { xhtml_strict { head { title 'OKay' } } }
+    document.should include('<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>')
+  end
+
+  it "should put correct html5 charset meta" do
+    document = mab { html5 { head { title 'OKay' } } }
+    document.should include('<meta charset="utf-8"/>')
+  end
+
+  it "should add a class to a html5 tag" do
+    document = mab { html5 { canvas.big "yo look" } }
+    document.should include('<canvas class="big">yo look</canvas>')
+  end
+
+  it "should add an id to a html5 tag" do
+    document = mab { html5 { canvas.only! "yo look" } }
+    document.should include('<canvas id="only">yo look</canvas>')
+  end
+
+  it "should add a closing slash to self-closing tags in xhtml" do
+    document = mab { br }
+    document.should include('<br/>')
+  end
+
+  it "should not add a closing slash to self-closing tags in html5" do
+    pending do
+      document = mab { html5 { br } }
+      document.should include('<br>')
+    end
+  end
+
+  it "should close empty non-self-closing tags in html5" do
+    pending do
+      document = mab { html5 { header } }
+      document.should include("<header></header>")
+    end
+  end
+
+  it "should not allow fake attributes" do
+    expect {
+      mab do
+        html5 do
+          input "something", :fake => "fake", :foo => "bar"
+        end
+      end
+    }.to raise_error
+  end
+
+  it "should allow new attributes" do
+    expect {
+      mab do
+        html5 do
+          input "something", :placeholder => "placeholder"
+        end
+      end
+    }.not_to raise_error
+  end
+
+  it "should allow a placeholder on an input" do
+    doc = mab do
+      html5 do
+        input :type => "text",
+              :name => "foo",
+              :value => "bar",
+              :placeholder => "something"
+      end
+    end
+
+    doc.should == "<!DOCTYPE html><html><input type=\"text\" name=\"foo\" value=\"bar\" placeholder=\"something\"/></html>"
+  end
+end

data/spec/markaby/markaby_spec.rb

@@ -1,78 +1,12 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
-class MarkabyTest < Test::Unit::TestCase
-  def teardown
-    Markaby::Builder.restore_defaults!
-  end
-
-  def test_simple
-    assert_equal "<hr/>", mab { hr }
-    assert_equal "<hr/><br/>", mab { hr; br }
-    assert_equal "<p>foo</p>", mab { p 'foo' }
-    assert_equal "<p>foo</p>", mab { p { 'foo' } }
-  end
-
-  def test_classes_and_ids
-    assert_equal %{<div class="one"></div>},     mab { div.one '' }
-    assert_equal %{<div class="one two"></div>}, mab { div.one.two '' }
-    assert_equal %{<div id="three"></div>},      mab { div.three! '' }
-    assert_equal %{<hr class="hidden"/>},        mab { hr.hidden }
-
-    out = mab { input.foo :id => 'bar' }
-    out.should match("<input.*class=\"foo\".*/>")
-    out.should match("<input.*name=\"bar\".*/>")
-  end
-
-  def test_escaping
-    assert_equal "<h1>Apples &amp; Oranges</h1>", mab { h1 'Apples & Oranges' }
-    assert_equal "<h1>Apples & Oranges</h1>", mab { h1 { 'Apples & Oranges' } }
-    assert_equal "<h1 class=\"fruits&amp;floots\">Apples</h1>", mab { h1 'Apples', :class => 'fruits&floots' }
-  end
-
-  def test_capture
-    builder = Markaby::Builder.new
-    assert builder.to_s.empty?
-    assert_equal "<h1>TEST</h1>", builder.capture { h1 'TEST' }
-    assert builder.to_s.empty?
-    assert mab { capture { h1 'hello world' }; nil }.empty?
-    assert_equal mab { div { h1 'TEST' } }, mab { div { capture { h1 'TEST' } } }
-  end
-
-  def test_ivars
-    html = "<div><h1>Steve</h1><div><h2>Gerald</h2></div><h3>Gerald</h3></div>"
-    assert_equal html, mab { div { @name = 'Steve'; h1 @name; div { @name = 'Gerald'; h2 @name }; h3 @name } }
-    assert_equal html, mab { div { @name = 'Steve'; h1 @name; self << capture { div { @name = 'Gerald'; h2 @name } }; h3 @name } }
-    assert_equal html, mab(:name => 'Steve') { div { h1 @name; self << capture { div { @name = 'Gerald'; h2 @name } }; h3 @name } }
-  end
-
-  def test_ivars_without_at_symbol
-    assert_equal "<h1>Hello World</h1>", mab { @message = 'Hello World'; h1 message }
-  end
-
-  def spec_helpers
-    Markaby::Builder.ignored_helpers.clear
-    assert_equal %{squirrels}, mab({}, MarkabyTestHelpers) { pluralize('squirrel') }
-    assert_equal %{<a href="">edit</a>}, mab({}, MarkabyTestHelpers) { link_to('edit') }
-    assert mab({}, MarkabyTestHelpers) { @output_helpers = false; link_to('edit'); nil }.empty?
-    Markaby::Builder.ignore_helpers :pluralize
-    assert_exception(NoMethodError, "undefined method `pluralize'", {}, MarkabyTestHelpers) { pluralize('squirrel') }
-  end
-
-  def test_uses_helper_instance_variable
-    helper = Module.new do
-      @some_ivar = :ivar_value
-    end
-
-    builder = Markaby::Builder.new({}, helper)
-    assert_equal :ivar_value, builder.some_ivar
-  end
-
+describe Markaby do
   it "can assign helpers after instantiation" do
-    helper = mock 'helper', :foo => :bar
+    helper = double 'helper', :foo => :bar
 
     builder = Markaby::Builder.new
     builder.helper = helper
-    assert_equal :bar, builder.foo
+    builder.foo.should == :bar
   end
 
   it "should be able to set a local" do
@@ -240,4 +174,11 @@ class MarkabyTest < Test::Unit::TestCase
     builder = Markaby::Builder.new({}, klass.new)
     builder.capture { @hello }.should == "hello there"
   end
+
+  describe Markaby::InvalidXhtmlError do
+    it "should inherit from StandardError" do
+      Markaby::InvalidXhtmlError.superclass.should == StandardError
+    end
+  end
 end
+

data/spec/markaby/markaby_test_unit_spec.rb

@@ -0,0 +1,251 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+class MarkabyTest < Test::Unit::TestCase
+  def teardown
+    Markaby::Builder.restore_defaults!
+  end
+
+  def test_simple
+    assert_equal "<hr/>", mab { hr }
+    assert_equal "<hr/><br/>", mab { hr; br }
+    assert_equal "<p>foo</p>", mab { p 'foo' }
+    assert_equal "<p>foo</p>", mab { p { 'foo' } }
+  end
+
+  def test_classes_and_ids
+    assert_equal %{<div class="one"></div>},     mab { div.one '' }
+    assert_equal %{<div class="one two"></div>}, mab { div.one.two '' }
+    assert_equal %{<div id="three"></div>},      mab { div.three! '' }
+    assert_equal %{<hr class="hidden"/>},        mab { hr.hidden }
+
+    out = mab { input.foo :id => 'bar' }
+    out.should match("<input.*class=\"foo\".*/>")
+    out.should match("<input.*name=\"bar\".*/>")
+  end
+
+  def test_escaping
+    assert_equal "<h1>Apples &amp; Oranges</h1>", mab { h1 'Apples & Oranges' }
+    assert_equal "<h1>Apples & Oranges</h1>", mab { h1 { 'Apples & Oranges' } }
+    assert_equal "<h1 class=\"fruits&amp;floots\">Apples</h1>", mab { h1 'Apples', :class => 'fruits&floots' }
+  end
+
+  def test_capture
+    builder = Markaby::Builder.new
+    assert builder.to_s.empty?
+    assert_equal "<h1>TEST</h1>", builder.capture { h1 'TEST' }
+    assert builder.to_s.empty?
+    assert mab { capture { h1 'hello world' }; nil }.empty?
+    assert_equal mab { div { h1 'TEST' } }, mab { div { capture { h1 'TEST' } } }
+  end
+
+  def test_ivars
+    html = "<div><h1>Steve</h1><div><h2>Gerald</h2></div><h3>Gerald</h3></div>"
+    assert_equal html, mab { div { @name = 'Steve'; h1 @name; div { @name = 'Gerald'; h2 @name }; h3 @name } }
+    assert_equal html, mab { div { @name = 'Steve'; h1 @name; self << capture { div { @name = 'Gerald'; h2 @name } }; h3 @name } }
+    assert_equal html, mab(:name => 'Steve') { div { h1 @name; self << capture { div { @name = 'Gerald'; h2 @name } }; h3 @name } }
+  end
+
+  def test_ivars_without_at_symbol
+    assert_equal "<h1>Hello World</h1>", mab { @message = 'Hello World'; h1 message }
+  end
+
+  def spec_helpers
+    Markaby::Builder.ignored_helpers.clear
+    assert_equal %{squirrels}, mab({}, MarkabyTestHelpers) { pluralize('squirrel') }
+    assert_equal %{<a href="">edit</a>}, mab({}, MarkabyTestHelpers) { link_to('edit') }
+    assert mab({}, MarkabyTestHelpers) { @output_helpers = false; link_to('edit'); nil }.empty?
+    Markaby::Builder.ignore_helpers :pluralize
+    assert_exception(NoMethodError, "undefined method `pluralize'", {}, MarkabyTestHelpers) { pluralize('squirrel') }
+  end
+
+  def test_uses_helper_instance_variable
+    helper = Module.new do
+      @some_ivar = :ivar_value
+    end
+
+    builder = Markaby::Builder.new({}, helper)
+    assert_equal :ivar_value, builder.some_ivar
+  end
+end
+
+describe Markaby do
+  it "can assign helpers after instantiation" do
+    helper = double 'helper', :foo => :bar
+
+    builder = Markaby::Builder.new
+    builder.helper = helper
+    builder.foo.should == :bar
+  end
+
+  it "should be able to set a local" do
+    builder = Markaby::Builder.new
+    builder.locals = { :foo => "bar" }
+    builder.foo.should == "bar"
+  end
+
+  it "should be able to set a different local value" do
+    builder = Markaby::Builder.new
+    builder.locals = { :foo => "baz" }
+    builder.foo.should == "baz"
+  end
+
+  it "should assign the correct key" do
+    builder = Markaby::Builder.new
+    builder.locals = { :key => :value }
+    builder.key.should == :value
+  end
+
+  it "should be able to assign multiple locals" do
+    builder = Markaby::Builder.new
+
+    builder.locals = { :one => "two", :three => "four" }
+
+    builder.one.should == "two"
+    builder.three.should == "four"
+  end
+
+  def test_builder_bang_methods
+    assert_equal "<?xml version=\"1.0\" encoding=\"UTF-8\"?>", mab { instruct! }
+  end
+
+  it "should be able to produce the correct html from a fragment" do
+    str = ""
+    str += "<div>"
+    str += "<h1>Monkeys</h1>"
+    str += "<h2>Giraffes <small>Miniature</small> and <strong>Large</strong></h2>"
+    str += "<h3>Donkeys</h3>"
+    str += "<h4>Parakeet <b><i>Innocent IV</i></b> in Classic Chartreuse</h4>"
+    str += "</div>"
+
+    generated = mab {
+      div {
+        h1 "Monkeys"
+        h2 {
+          "Giraffes #{small('Miniature')} and #{strong 'Large'}"
+        }
+        h3 "Donkeys"
+        h4 { "Parakeet #{b { i 'Innocent IV' }} in Classic Chartreuse" }
+      }
+    }
+
+    generated.should == str
+  end
+
+  def test_fragments
+    assert_equal %{<div><h1>Monkeys</h1><h2>Giraffes <strong>Miniature</strong></h2><h3>Donkeys</h3></div>},
+        mab { div { h1 "Monkeys"; h2 { "Giraffes #{strong 'Miniature' }" }; h3 "Donkeys" } }
+
+    assert_equal %{<div><h1>Monkeys</h1><h2>Giraffes <small>Miniature</small> and <strong>Large</strong></h2><h3>Donkeys</h3><h4>Parakeet <strong>Large</strong> as well...</h4></div>},
+        mab { div { @a = small 'Miniature'; @b = strong 'Large'; h1 "Monkeys"; h2 { "Giraffes #{@a} and #{@b}" }; h3 "Donkeys"; h4 { "Parakeet #{@b} as well..." } } }
+  end
+
+  def test_invalid_xhtml
+    assert_exception(NoMethodError, "undefined method `dav'") { dav {} }
+    assert_exception(Markaby::InvalidXhtmlError, "no attribute `styl' on div elements") { div(:styl => 'ok') {} }
+    assert_exception(Markaby::InvalidXhtmlError, "no attribute `class' on tbody elements") { tbody.okay {} }
+  end
+
+  def test_full_doc_transitional
+    doc = mab { xhtml_transitional { head { title 'OKay' } } }
+    assert doc =~ /^<\?xml version="1.0" encoding="UTF-8"\?>/
+    assert doc.include?(%{"-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">})
+    assert doc.include?(%{<title>OKay</title>})
+  end
+
+  def test_full_doc_strict
+    doc = mab { xhtml_strict { head { title 'OKay' } } }
+    assert doc =~ /^<\?xml version="1.0" encoding="UTF-8"\?>/
+    assert doc.include?(%{"-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">})
+    assert doc.include?(%{<title>OKay</title>})
+  end
+
+  def test_full_doc_frameset
+    doc = mab { xhtml_frameset { head { title 'OKay' } } }
+    assert doc =~ /^<\?xml version="1.0" encoding="UTF-8"\?>/
+    assert doc.include?(%{"-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">})
+    assert doc.include?(%{<title>OKay</title>})
+  end
+
+  def test_root_attributes_can_be_changed
+    doc = mab { xhtml_strict(:lang => 'fr') { head { title { 'Salut!' } } } }
+    assert doc.include?(%{"-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">})
+    assert doc.include?(%{<title>Salut!</title>})
+    assert doc.include?(%{ lang="fr"})
+  end
+
+  def version_file
+    File.expand_path(File.dirname(__FILE__) + "/../../VERSION")
+  end
+
+  def test_markaby_should_have_correct_version
+    assert_equal Markaby::VERSION, File.read(version_file).strip
+  end
+
+  def test_duplicate_usage_of_same_id
+    assert_raises Markaby::InvalidXhtmlError do
+      mab do
+        p.one!
+        p.one!
+      end
+    end
+  end
+
+  # auto validation
+
+  def test_tagging_with_invalid_tag_should_raise_error
+    assert_raises Markaby::InvalidXhtmlError do
+      mab do
+        tag! :an_invalid_tag
+      end
+    end
+  end
+
+  def test_self_closing_html_tag_with_block_throws_errors
+    assert_raises Markaby::InvalidXhtmlError do
+      mab do
+        html_tag :img do
+        end
+      end
+    end
+  end
+
+  def test_local_assigning
+    builder = Markaby::Builder.new(:variable => :a_value)
+
+    assert_equal :a_value, builder.variable
+  end
+
+  def test_local_assignment_with_strings
+    builder = Markaby::Builder.new("variable" => :a_value)
+    assert_equal :a_value, builder.variable
+  end
+
+  def test_local_assignment_prefers_symbols_to_strings
+    builder = Markaby::Builder.new("variable" => "string_value", :variable => :symbol_value)
+    assert_equal :symbol_value, builder.variable
+  end
+
+  def test_method_missing_should_call_tag_if_no_tagset_present
+    Markaby::Builder.set(:tagset, nil)
+
+    builder = Markaby::Builder.new
+    builder.something.should == "<something/>"
+  end
+
+  it "should copy instance variables from a helper object" do
+    klass = Class.new do
+      def initialize
+        @hello = "hello there"
+      end
+    end
+
+    builder = Markaby::Builder.new({}, klass.new)
+    builder.capture { @hello }.should == "hello there"
+  end
+
+  describe Markaby::InvalidXhtmlError do
+    it "should inherit from StandardError" do
+      Markaby::InvalidXhtmlError.superclass.should == StandardError
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,15 +1,10 @@
 require 'test/unit'
-require 'spec'
-require 'spec/interop/test'
+require 'rspec'
 
 $:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'markaby'
 require 'markaby/kernel_method'
-require 'markaby/rails'
-
-require 'markaby/sinatra'
-require 'erb'
 
 module MarkabyTestHelpers
   def link_to(obj)
@@ -36,6 +31,9 @@ module Test
   module Unit
     class TestCase
       include TestHelpers
+      def self.it(name, &blk)
+        define_method("test_#{name}", &blk)
+      end
     end
   end
 end