mab 0.0.2 → 0.0.3

data/markaby/lib/markaby/sinatra.rb

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

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

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

data/markaby/spec/markaby/builder_spec.rb

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

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

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

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

data/markaby/spec/markaby/markaby_spec.rb

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