markaby 0.8.1 → 0.9.1

data/lib/markaby/xhtml_transitional.rb

@@ -0,0 +1,61 @@
+require "markaby/xml_tagset"
+require "markaby/xhtml_strict"
+module Markaby
+  # Additional tags found in XHTML 1.0 Transitional
+  class XHTMLTransitional < XmlTagset
+    @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
+end

data/lib/markaby/xml_tagset.rb

@@ -0,0 +1,19 @@
+require "markaby/tagset"
+module Markaby
+  # Additional tags found in XHTML 1.0 Frameset
+  class XmlTagset < Tagset
+    class << self
+      def default_options
+        super.merge({
+          output_xml_instruction: true,
+          output_meta_tag: "xhtml",
+          root_attributes: {
+            xmlns: "http://www.w3.org/1999/xhtml",
+            "xml:lang": "en",
+            lang: "en"
+          }
+        })
+      end
+    end
+  end
+end

data/lib/markaby.rb

@@ -4,7 +4,7 @@
 # as well as the full set of Markaby classes.
 #
 # For a full list of features and instructions, see the README.
-$:.unshift File.expand_path(File.dirname(__FILE__))
+$:.unshift __dir__
 
 # Markaby is a module containing all of the great Markaby classes that
 # do such an excellent job.
@@ -21,6 +21,7 @@ module Markaby
 end
 
 require "markaby/version"
-require 'builder' unless defined?(Builder)
-require 'markaby/builder'
-require 'markaby/cssproxy'
+require "builder" unless defined?(Builder)
+require "markaby/tagset"
+require "markaby/builder"
+require "markaby/cssproxy"

data/spec/markaby/builder_spec.rb

@@ -39,7 +39,7 @@ module Markaby
           end
         end.new
 
-        builder = Markaby::Builder.new({:helpers => nil}, helper)
+        builder = Markaby::Builder.new({helpers: nil}, helper)
         builder.some_method.should == "a value"
       end
     end

data/spec/markaby/css_proxy_spec.rb

@@ -9,34 +9,35 @@ describe Markaby::CssProxy do
   end
 
   def mock_builder
-    mock_builder = Class.new do
-      def tag!(*args); end
+    Class.new do
+      def tag!(*args)
+      end
     end.new
   end
 
   it "responds_to_everything" do
-    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-    proxy.respond_to?(:any_method).should be_true
-    proxy.respond_to?(:foobarbazasdfasdfadfs).should be_true
+    proxy = Markaby::CssProxy.new(mock_builder, "stream", :sym)
+    proxy.respond_to?(:any_method).should be true
+    proxy.respond_to?(:foobarbazasdfasdfadfs).should be true
   end
 
   it "does_not_respond_to_method_missing" do
-    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
+    proxy = Markaby::CssProxy.new(mock_builder, "stream", :sym)
     proxy.should_not respond_to(:method_missing)
   end
 
   it "does_respond_to_private_instance_methods_with_private_flag_set_to_true" do
-    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-    proxy.respond_to?(:method_missing, true).should be_true
+    proxy = Markaby::CssProxy.new(mock_builder, "stream", :sym)
+    proxy.respond_to?(:method_missing, true).should be true
   end
 
   it "does_not_respond_to_private_instance_methods_with_private_flag_set_to_false" do
-    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-    proxy.respond_to?(:method_missing, false).should be_false
+    proxy = Markaby::CssProxy.new(mock_builder, "stream", :sym)
+    proxy.respond_to?(:method_missing, false).should be false
   end
 
   it "respond_to_should_always_return_boolean" do
-    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-    proxy.respond_to?(:method_missing, :a_value).should be_true
+    proxy = Markaby::CssProxy.new(mock_builder, "stream", :sym)
+    proxy.respond_to?(:method_missing, :a_value).should be true
   end
 end

data/spec/markaby/fragment_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
-class FragmentTest < Test::Unit::TestCase
+describe "Fragments" do
   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 }

data/spec/markaby/html5_spec.rb

@@ -2,12 +2,12 @@ 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 = 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 = mab { html5 { head { title "OKay" } } }
     document.should_not include("xmlns")
   end
 
@@ -27,12 +27,14 @@ describe Markaby do
   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"/>')
+    document = mab { xhtml_strict { head { title "OKay" } } }
+    document.should include("<meta")
+    document.should include('http-equiv="Content-Type"')
+    document.should include('content="text/html; charset=utf-8"')
   end
 
   it "should put correct html5 charset meta" do
-    document = mab { html5 { head { title 'OKay' } } }
+    document = mab { html5 { head { title "OKay" } } }
     document.should include('<meta charset="utf-8"/>')
   end
 
@@ -48,38 +50,42 @@ describe Markaby do
 
   it "should add a closing slash to self-closing tags in xhtml" do
     document = mab { br }
-    document.should include('<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 not add a closing slash to self-closing tags in html5" do
+  #   pending
 
-  it "should close empty non-self-closing tags in html5" do
-    pending do
-      document = mab { html5 { header } }
-      document.should include("<header></header>")
-    end
+  #   document = mab { html5 { br } }
+  #   document.should include("<br>")
+  # end
+
+  # it "should close empty non-self-closing tags in html5" do
+  #   pending
+  #   document = mab { html5 { header } }
+  #   document.should include("<header></header>")
+  # end
+
+  it "should allow custom elements" do
+    document = mab { html5 { my_custom_element(id: "mce-123") { "Hello" } } }
+    document.should include("<my-custom-element id=\"mce-123\">Hello</my-custom-element>")
   end
 
   it "should not allow fake attributes" do
     expect {
       mab do
         html5 do
-          input "something", :fake => "fake", :foo => "bar"
+          input "something", fake: "fake", foo: "bar"
         end
       end
-    }.to raise_error
+    }.to raise_error(Markaby::InvalidXhtmlError)
   end
 
   it "should allow new attributes" do
     expect {
       mab do
         html5 do
-          input "something", :placeholder => "placeholder"
+          input "something", placeholder: "placeholder"
         end
       end
     }.not_to raise_error
@@ -88,13 +94,56 @@ describe Markaby do
   it "should allow a placeholder on an input" do
     doc = mab do
       html5 do
-        input :type => "text",
-              :name => "foo",
-              :value => "bar",
-              :placeholder => "something"
+        input type: "text",
+          name: "foo",
+          value: "bar",
+          placeholder: "something"
+      end
+    end
+
+    doc.should include('<input type="text" ')
+    doc.should include('name="foo"')
+    doc.should include('value="bar"')
+    doc.should include('placeholder="something"')
+  end
+
+  it "should allow data attributes anywhere" do
+    doc = mab do
+      html5 do
+        div("data-foo" => "bar")
+      end
+    end
+
+    doc.should include('<div data-foo="bar"/>')
+  end
+
+  it "expands data attributes provided as a hash" do
+    doc = mab do
+      html5 do
+        div(data: {foo: "bar"})
+      end
+    end
+
+    doc.should include('<div data-foo="bar"/>')
+  end
+
+  it "dasherises data attributes provided as a hash" do
+    doc = mab do
+      html5 do
+        div(data: {some_attribute: "value"})
+      end
+    end
+
+    doc.should include('<div data-some-attribute="value"/>')
+  end
+
+  it "should allow aria attributes everywhere" do
+    doc = mab do
+      html5 do
+        div("aria-foo" => "bar")
       end
     end
 
-    doc.should == "<!DOCTYPE html><html><input type=\"text\" name=\"foo\" value=\"bar\" placeholder=\"something\"/></html>"
+    doc.should include('<div aria-foo="bar"/>')
   end
 end

data/spec/markaby/markaby_spec.rb

@@ -1,8 +1,19 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Markaby do
+  it "should work with classes and ids" do
+    mab { div.one "" }.should == %(<div class="one"></div>)
+    mab { div.one.two "" }.should == %(<div class="one two"></div>)
+    mab { div.three! "" }.should == %(<div id="three"></div>)
+    mab { hr.hidden }.should == %(<hr class="hidden"/>)
+
+    out = mab { input.foo id: "bar" }
+    out.should match("<input.*class=\"foo\".*/>")
+    out.should match("<input.*name=\"bar\".*/>")
+  end
+
   it "can assign helpers after instantiation" do
-    helper = double 'helper', :foo => :bar
+    helper = double "helper", foo: :bar
 
     builder = Markaby::Builder.new
     builder.helper = helper
@@ -11,35 +22,31 @@ describe Markaby do
 
   it "should be able to set a local" do
     builder = Markaby::Builder.new
-    builder.locals = { :foo => "bar" }
+    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.locals = {foo: "baz"}
     builder.foo.should == "baz"
   end
 
   it "should assign the correct key" do
     builder = Markaby::Builder.new
-    builder.locals = { :key => :value }
+    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.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>"
@@ -53,115 +60,89 @@ describe Markaby do
       div {
         h1 "Monkeys"
         h2 {
-          "Giraffes #{small('Miniature')} and #{strong 'Large'}"
+          "Giraffes #{small("Miniature")} and #{strong "Large"}"
         }
         h3 "Donkeys"
-        h4 { "Parakeet #{b { i 'Innocent IV' }} in Classic Chartreuse" }
+        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
+  it "should copy instance variables from a helper object" do
+    klass = Class.new do
+      def initialize
+        @hello = "hello there"
+      end
+    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>})
+    builder = Markaby::Builder.new({}, klass.new)
+    builder.capture { @hello }.should == "hello there"
   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"})
+  describe Markaby::InvalidXhtmlError do
+    it "should inherit from StandardError" do
+      Markaby::InvalidXhtmlError.superclass.should == StandardError
+    end
   end
 
-  def version_file
-    File.expand_path(File.dirname(__FILE__) + "/../../VERSION")
-  end
+  it "can assign helpers after instantiation" do
+    helper = double "helper", foo: :bar
 
-  def test_markaby_should_have_correct_version
-    assert_equal Markaby::VERSION, File.read(version_file).strip
+    builder = Markaby::Builder.new
+    builder.helper = helper
+    builder.foo.should == :bar
   end
 
-  def test_duplicate_usage_of_same_id
-    assert_raises Markaby::InvalidXhtmlError do
-      mab do
-        p.one!
-        p.one!
-      end
-    end
+  it "should be able to set a local" do
+    builder = Markaby::Builder.new
+    builder.locals = {foo: "bar"}
+    builder.foo.should == "bar"
   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
+  it "should be able to set a different local value" do
+    builder = Markaby::Builder.new
+    builder.locals = {foo: "baz"}
+    builder.foo.should == "baz"
   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
+  it "should assign the correct key" do
+    builder = Markaby::Builder.new
+    builder.locals = {key: :value}
+    builder.key.should == :value
   end
 
-  def test_local_assigning
-    builder = Markaby::Builder.new(:variable => :a_value)
+  it "should be able to assign multiple locals" do
+    builder = Markaby::Builder.new
 
-    assert_equal :a_value, builder.variable
-  end
+    builder.locals = {one: "two", three: "four"}
 
-  def test_local_assignment_with_strings
-    builder = Markaby::Builder.new("variable" => :a_value)
-    assert_equal :a_value, builder.variable
+    builder.one.should == "two"
+    builder.three.should == "four"
   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
+  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>"
 
-  def test_method_missing_should_call_tag_if_no_tagset_present
-    Markaby::Builder.set(:tagset, nil)
+    generated = mab {
+      div {
+        h1 "Monkeys"
+        h2 {
+          "Giraffes #{small("Miniature")} and #{strong "Large"}"
+        }
+        h3 "Donkeys"
+        h4 { "Parakeet #{b { i "Innocent IV" }} in Classic Chartreuse" }
+      }
+    }
 
-    builder = Markaby::Builder.new
-    builder.something.should == "<something/>"
+    generated.should == str
   end
 
   it "should copy instance variables from a helper object" do
@@ -181,4 +162,3 @@ describe Markaby do
     end
   end
 end
-