mab 0.0.1 → 0.0.2

data/markaby/lib/markaby/sinatra.rb

@@ -0,0 +1,18 @@
+require 'markaby/tilt'
+require 'sinatra'
+
+module Sinatra
+  class Base
+    # sinatra's #render looks for options in Sinatra::Application
+    # by asking if it responds_to?(:mab)
+    # Unfortunately, if the the mab kernel method is included,
+    # Sinatra::Application will respond_to? it.
+    set :mab, {}
+  end
+
+  module Templates
+    def mab(template, options={}, locals={})
+      render :mab, template, options, locals
+    end
+  end
+end

data/markaby/lib/markaby/tags.rb

@@ -0,0 +1,200 @@
+module Markaby
+  FORM_TAGS         = [ :form, :input, :select, :textarea ]
+  SELF_CLOSING_TAGS = [ :base, :meta, :link, :hr, :br, :param, :img, :area, :input, :col, :frame ]
+
+  # Common sets of attributes.
+  AttrCore   = [:id, :class, :style, :title]
+  AttrI18n   = [:lang, 'xml:lang'.intern, :dir]
+  AttrEvents = [:onclick,
+                :ondblclick,
+                :onmousedown,
+                :onmouseup,
+                :onmouseover,
+                :onmousemove,
+                :onmouseout,
+                :onkeypress,
+                :onkeydown,
+                :onkeyup]
+  AttrFocus  = [:accesskey, :tabindex, :onfocus, :onblur]
+  AttrHAlign = [:align, :char, :charoff]
+  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
+      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
+    end
+
+    @doctype = ['-//W3C//DTD XHTML 1.0 Strict//EN', 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd']
+    @tagset  = {
+      :html       => AttrI18n + [:id, :xmlns],
+      :head       => AttrI18n + [:id, :profile],
+      :title      => AttrI18n + [:id],
+      :base       => [:href, :id],
+      :meta       => AttrI18n + [:id, :http, :name, :content, :scheme, 'http-equiv'.intern],
+      :link       => Attrs    + [:charset, :href, :hreflang, :type, :rel, :rev, :media],
+      :style      => AttrI18n + [:id, :type, :media, :title, 'xml:space'.intern],
+      :script     => [:id, :charset, :type, :src, :defer, 'xml:space'.intern],
+      :noscript   => Attrs,
+      :body       => Attrs + [:onload, :onunload],
+      :div        => Attrs,
+      :p          => Attrs,
+      :ul         => Attrs,
+      :ol         => Attrs,
+      :li         => Attrs,
+      :dl         => Attrs,
+      :dt         => Attrs,
+      :dd         => Attrs,
+      :address    => Attrs,
+      :hr         => Attrs,
+      :pre        => Attrs + ['xml:space'.intern],
+      :blockquote => Attrs + [:cite],
+      :ins        => Attrs + [:cite, :datetime],
+      :del        => Attrs + [:cite, :datetime],
+      :a          => Attrs + AttrFocus + [:charset, :type, :name, :href, :hreflang, :rel, :rev, :shape, :coords],
+      :span       => Attrs,
+      :bdo        => AttrCore + AttrEvents + [:lang, 'xml:lang'.intern, :dir],
+      :br         => AttrCore,
+      :em         => Attrs,
+      :strong     => Attrs,
+      :dfn        => Attrs,
+      :code       => Attrs,
+      :samp       => Attrs,
+      :kbd        => Attrs,
+      :var        => Attrs,
+      :cite       => Attrs,
+      :abbr       => Attrs,
+      :acronym    => Attrs,
+      :q          => Attrs + [:cite],
+      :sub        => Attrs,
+      :sup        => Attrs,
+      :tt         => Attrs,
+      :i          => Attrs,
+      :b          => Attrs,
+      :big        => Attrs,
+      :small      => Attrs,
+      :object     => Attrs + [:declare, :classid, :codebase, :data, :type, :codetype, :archive, :standby, :height, :width, :usemap, :name, :tabindex],
+      :param      => [:id, :name, :value, :valuetype, :type],
+      :img        => Attrs + [:src, :alt, :longdesc, :height, :width, :usemap, :ismap],
+      :map        => AttrI18n + AttrEvents + [:id, :class, :style, :title, :name],
+      :area       => Attrs + AttrFocus + [:shape, :coords, :href, :nohref, :alt],
+      :form       => Attrs + [:action, :method, :enctype, :onsubmit, :onreset, :accept, :accept],
+      :label      => Attrs + [:for, :accesskey, :onfocus, :onblur],
+      :input      => Attrs + AttrFocus + [:type, :name, :value, :checked, :disabled, :readonly, :size, :maxlength, :src, :alt, :usemap, :onselect, :onchange, :accept],
+      :select     => Attrs + [:name, :size, :multiple, :disabled, :tabindex, :onfocus, :onblur, :onchange],
+      :optgroup   => Attrs + [:disabled, :label],
+      :option     => Attrs + [:selected, :disabled, :label, :value],
+      :textarea   => Attrs + AttrFocus + [:name, :rows, :cols, :disabled, :readonly, :onselect, :onchange],
+      :fieldset   => Attrs,
+      :legend     => Attrs + [:accesskey],
+      :button     => Attrs + AttrFocus + [:name, :value, :type, :disabled],
+      :table      => Attrs + [:summary, :width, :border, :frame, :rules, :cellspacing, :cellpadding],
+      :caption    => Attrs,
+      :colgroup   => Attrs + AttrHAlign + AttrVAlign + [:span, :width],
+      :col        => Attrs + AttrHAlign + AttrVAlign + [:span, :width],
+      :thead      => Attrs + AttrHAlign + AttrVAlign,
+      :tfoot      => Attrs + AttrHAlign + AttrVAlign,
+      :tbody      => Attrs + AttrHAlign + AttrVAlign,
+      :tr         => Attrs + AttrHAlign + AttrVAlign,
+      :th         => Attrs + AttrHAlign + AttrVAlign + [:abbr, :axis, :headers, :scope, :rowspan, :colspan],
+      :td         => Attrs + AttrHAlign + AttrVAlign + [:abbr, :axis, :headers, :scope, :rowspan, :colspan],
+      :h1         => Attrs,
+      :h2         => Attrs,
+      :h3         => Attrs,
+      :h4         => Attrs,
+      :h5         => Attrs,
+      :h6         => Attrs
+    }
+
+    @tags         = @tagset.keys
+    @forms        = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+
+  # Additional tags found in XHTML 1.0 Transitional
+  class XHTMLTransitional
+    class << self
+      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
+    end
+
+    @doctype = ['-//W3C//DTD XHTML 1.0 Transitional//EN', 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd']
+    @tagset = XHTMLStrict.tagset.merge({
+      :strike   => Attrs,
+      :center   => Attrs,
+      :dir      => Attrs + [:compact],
+      :noframes => Attrs,
+      :basefont => [:id, :size, :color, :face],
+      :u        => Attrs,
+      :menu     => Attrs + [:compact],
+      :iframe   => AttrCore + [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :scrolling, :align, :height, :width],
+      :font     => AttrCore + AttrI18n + [:size, :color, :face],
+      :s        => Attrs,
+      :applet   => AttrCore + [:codebase, :archive, :code, :object, :alt, :name, :width, :height, :align, :hspace, :vspace],
+      :isindex  => AttrCore + AttrI18n + [:prompt]
+    })
+
+    # Additional attributes found in XHTML 1.0 Transitional
+    additional_tags = {
+      :script => [:language],
+      :a      => [:target],
+      :td     => [:bgcolor, :nowrap, :width, :height],
+      :p      => [:align],
+      :h5     => [:align],
+      :h3     => [:align],
+      :li     => [:type, :value],
+      :div    => [:align],
+      :pre    => [:width],
+      :body   => [:background, :bgcolor, :text, :link, :vlink, :alink],
+      :ol     => [:type, :compact, :start],
+      :h4     => [:align],
+      :h2     => [:align],
+      :object => [:align, :border, :hspace, :vspace],
+      :img    => [:name, :align, :border, :hspace, :vspace],
+      :link   => [:target],
+      :legend => [:align],
+      :dl     => [:compact],
+      :input  => [:align],
+      :h6     => [:align],
+      :hr     => [:align, :noshade, :size, :width],
+      :base   => [:target],
+      :ul     => [:type, :compact],
+      :br     => [:clear],
+      :form   => [:name, :target],
+      :area   => [:target],
+      :h1     => [:align]
+    }
+
+    additional_tags.each do |k, v|
+      @tagset[k] += v
+    end
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+
+  # Additional tags found in XHTML 1.0 Frameset
+  class XHTMLFrameset
+    class << self
+      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
+    end
+
+    @doctype = ['-//W3C//DTD XHTML 1.0 Frameset//EN', 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd']
+    @tagset = XHTMLTransitional.tagset.merge({
+      :frameset => AttrCore + [:rows, :cols, :onload, :onunload],
+      :frame    => AttrCore + [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :noresize, :scrolling]
+    })
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+end

data/markaby/lib/markaby/tilt.rb

@@ -0,0 +1,8 @@
+require 'markaby'
+require 'tilt'
+
+module Markaby
+  module Tilt
+    Template = ::Tilt::MarkabyTemplate
+  end
+end

data/markaby/spec/markaby/builder_spec.rb

@@ -0,0 +1,118 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Markaby
+  describe Builder do
+    before do
+      Markaby::Builder.restore_defaults!
+    end
+
+    after do
+      Markaby::Builder.restore_defaults!
+    end
+
+    it "should have method missing as a private method" do
+      private_methods = Markaby::Builder.private_instance_methods.dup
+      private_methods.map! { |m| m.to_sym }
+      private_methods.should include(:method_missing)
+    end
+
+    describe "setting options" do
+      it "should be able to restore defaults after setting" do
+        Markaby::Builder.set :indent, 2
+        Markaby::Builder.restore_defaults!
+
+        Markaby::Builder.get(:indent).should == 0
+      end
+
+      it "should be able to set global options" do
+        Markaby::Builder.set :indent, 2
+        Markaby::Builder.get(:indent).should == 2
+      end
+    end
+
+    describe "hidden internal variables" do
+      # internal clobbering by passed in assigns
+      it "should not overwrite internal helpers ivar when assigning a :helpers key" do
+        helper = Class.new do
+          def some_method
+            "a value"
+          end
+        end.new
+
+        builder = Markaby::Builder.new({:helpers => nil}, helper)
+        builder.some_method.should == "a value"
+      end
+    end
+
+    describe "evaluating blocks" do
+      it "should evaluate a pure-string block (without requiring a call to the text method)" do
+        b = Builder.new do
+          "foo"
+        end
+
+        b.to_s.should == "foo"
+      end
+
+      it "should only evaluate the last argument in a pure-string block" do
+        b = Builder.new do
+          "foo"
+          "bar"
+        end
+
+        b.to_s.should == "bar"
+      end
+
+      it "should evaluate pure-strings inside an tag" do
+        b = Builder.new do
+          h1 do
+            "foo"
+          end
+        end
+
+        b.to_s.should == "<h1>foo</h1>"
+      end
+
+      it "should ignore a pure string in the block, even if comes last, if there has been any markup whatsoever" do
+        b = Builder.new do
+          h1
+          "foo"
+        end
+
+        b.to_s.should == "<h1/>"
+      end
+    end
+
+    describe "capture" do
+      before do
+        @builder = Builder.new
+      end
+
+      it "should return the string captured" do
+        out = @builder.capture do
+          h1 "TEST"
+          h2 "CAPTURE ME"
+        end
+
+        out.should == "<h1>TEST</h1><h2>CAPTURE ME</h2>"
+      end
+
+      it "should not change the output buffer" do
+        lambda {
+          @builder.capture do
+            h1 "FOO!"
+          end
+        }.should_not change { @builder.to_s }
+      end
+
+      it "should be able to capture inside a capture" do
+        out = @builder.capture do
+          capture do
+            h1 "foo"
+          end
+        end
+
+        out.should == "<h1>foo</h1>"
+      end
+    end
+  end
+end

data/markaby/spec/markaby/css_proxy_test.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+class CssProxyTest < Test::Unit::TestCase
+  it "should have method_missing as private" do
+    methods = Markaby::CssProxy.private_instance_methods.dup
+    methods.map! { |m| m.to_sym }
+
+    methods.should include(:method_missing)
+  end
+
+  def mock_builder
+    mock_builder = Class.new do
+      def tag!(*args); end
+    end.new
+  end
+
+  def test_responds_to_everything
+    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
+
+    assert proxy.respond_to?(:any_method)
+    assert proxy.respond_to?(:foobarbazasdfasdfadfs)
+  end
+
+  def test_does_not_respond_to_method_missing
+    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
+
+    assert !proxy.respond_to?(:method_missing)
+  end
+
+  def test_does_respond_to_private_instance_methods_with_private_flag_set_to_true
+    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
+
+    assert proxy.respond_to?(:method_missing, true)
+  end
+
+  def test_does_not_respond_to_private_instance_methods_with_private_flag_set_to_false
+    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
+
+    assert !proxy.respond_to?(:method_missing, false)
+  end
+
+  def test_respond_to_should_always_return_boolean
+    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
+
+    assert_equal proxy.respond_to?(:method_missing, :a_value), true
+  end
+end

data/markaby/spec/markaby/fragment_test.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+class FragmentTest < Test::Unit::TestCase
+  it "should have method_missing as a private instance method" do
+    private_methods = Markaby::Fragment.private_instance_methods.dup
+    private_methods.map! { |m| m.to_sym }
+
+    private_methods.should include(:method_missing)
+  end
+end

data/markaby/spec/markaby/markaby_other_static.mab

@@ -0,0 +1 @@
+text "_why?"

data/markaby/spec/markaby/markaby_spec.rb

@@ -0,0 +1,184 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Markaby do
+  it "can assign helpers after instantiation" do
+    helper = mock '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
+