markaby 0.4 → 0.5

data/README

@@ -73,44 +73,13 @@ This doesn't effect Rails users, but when used in regular Ruby code, it can
 be a bit disorienting.  You are recommended to put your Markaby code in a
 module where it won't mix with anything.
 
-= A Note About Rails Helpers
-
-When used in Rails templates, the Rails helper object is passed into 
-Markaby::Builder.  When you call helper methods inside Markaby, the output
-from those methods will be output to the stream.  This is incredibly
-handy, since most Rails helpers output HTML tags.
-
-  head do
-    javascript_include_tag 'prototype'
-    autodiscovery_link_tag
-  end
-
-However, some methods are designed to give back a String which you can use
-elsewhere.  Call the <tt>@helpers</tt> object with the method and you'll get
-the String back and nothing will be output.
-
-  p "Total is: #{@helper.number_to_human_size @file_bytes}"
-
-Conversely, you may call instance variables from your controller by using
-a method and its value will be returned, nothing will be output.
-
-  # Inside imaginary ProductController
-  def list
-    @products = Product.find :all
-  end
-
-  # Inside app/views/product/list.mab
-  products.each do |product|
-    p product.title
-  end
-
-= A Quick Tour
+= The Six Steps of Markaby
 
 If you dive right into Markaby, it'll probably make good sense, but you're
-likely to run into a few kinks.  Keep these pointers in mind and everything
-will be fine.
+likely to run into a few kinks.  Why not review these six steps and commit
+them memory so you can really *know* what you're doing?
 
-== Element Classes
+== 1. Element Classes
 
 Element classes may be added by hooking methods onto container elements:
 
@@ -128,15 +97,15 @@ Which results in:
     <div class="entryContent">Okay, once again, the idea here is ...</div>
   </div>
 
-== Element IDs
+== 2. Element IDs
 
 IDs may be added by the use of bang methods:
 
-  div.page!
-    div.content!
+  div.page! {
+    div.content! {
       h1 "A Short Short Saintly Dog"
-    end
-  end
+    }
+  }
 
 Which results in:
 
@@ -146,29 +115,87 @@ Which results in:
     </div>
   </div>
 
-== Markaby assumes XHTML 1.0 Transitional 
+== 3. Validate Your XHTML 1.0 Output 
 
-Output defaults to XHTML 1.0 Transitional. To do XHTML 1.0 Strict,
-try this:
+If you'd like Markaby to help you assemble valid XHTML documents,
+you can use the <tt>xhtml_transitional</tt> or <tt>xhtml_strict</tt>
+methods in place of the normal <tt>html</tt> tag.
 
   xhtml_strict do
-    # innerds
+    head { ... }
+    body { ... }
   end
 
-== The <tt>capture</tt> Method
+This will add the XML instruction and the doctype tag to your document.
+Also, a character set meta tag will be placed inside your <tt>head</tt>
+tag.
+
+Now, since Markaby knows which doctype you're using, it checks a big
+list of valid tags and attributes before printing anything.
+
+  >> div :styl => "padding: 10px" do
+  >>   img :src => "samorost.jpg"
+  >> end
+  InvalidHtmlError: no such attribute `styl'
+
+Markaby will also make sure you don't use the same element ID twice!
+
+== 4. Escape or No Escape?
+
+Markaby uses a simple convention for escaping stuff: if a string
+is an argument, it gets escaped.  If the string is in a block, it
+doesn't.
+
+This is handy if you're using something like RedCloth or
+RDoc inside an element.  Pass the string back through the block
+and it'll skip out of escaping.
+
+  div.comment { RedCloth.new(str).to_html }
+
+But, if we have some raw text that needs escaping, pass it in
+as an argument:
+
+  div.comment raw_str
+
+One caveat: if you have other tags inside a block, the string
+passed back will be ignored.
 
-Want to catch a block of HTML as a string and play with it a bit?
-Use the <tt>capture</tt> method.
+  div.comment {
+    div.author "_why"
+    div.says "Torpedoooooes!"
+    "<div>Silence.</div>"
+  }
 
-Commonly used to join HTML blocks together:
+The final div above won't appear in the output.  You can't mix
+tag modes like that, friend.
+
+== 5. Auto-stringification
+
+If you end up using any of your Markaby "tags" as a string, the
+tag won't be output.  It'll be up to you to add the new string
+back into the HTML output.
+
+This means if you call <tt>to_s</tt>, you'll get a string back.
+
+  div.title { "Rock Bottom" + span(" by Robert Wyatt").to_s }
+
+But, when you're adding strings in Ruby, <tt>to_s</tt> happens automatically.
+
+  div.title { "Rock Bottom" + span(" by Robert Wyatt") }
+
+Interpolation works fine.
+
+  div.title { "Rock Bottom #{span(" by Robert Wyatt")}" }
+
+And any other operation you might perform on a string.
 
   div.menu! \
     ['5.gets', 'bits', 'cult', 'inspect', '-h'].map do |category|
-      capture { link_to category }
+      link_to category
     end.
     join( " | " )
 
-== The <tt>tag!</tt> Method
+== 6. The <tt>tag!</tt> Method
 
 If you need to force a tag at any time, call <tt>tag!</tt> with the
 tag name followed by the possible arguments and block.  The CssProxy
@@ -180,6 +207,45 @@ won't work with this technique.
     end
   end
 
+= A Note About Rails Helpers
+
+When used in Rails templates, the Rails helper object is passed into 
+Markaby::Builder.  When you call helper methods inside Markaby, the output
+from those methods will be output to the stream.  This is incredibly
+handy, since most Rails helpers output HTML tags.
+
+  head do
+    javascript_include_tag 'prototype'
+    autodiscovery_link_tag
+  end
+
+However, some methods are designed to give back a String which you can use
+elsewhere.  That's okay!  Every method returns a Fragment object, which can
+be used as a string.
+
+  p { "Total is: #{number_to_human_size @file_bytes}" }
+
+Also see the Quick Tour above, specifically the stuff about auto-stringification.
+
+If for any reason you have trouble with fragments, you can just
+call the <tt>@helpers</tt> object with the method and you'll get
+the String back and nothing will be output.
+
+  p { "Total is: #{@helper.number_to_human_size @file_bytes}" }
+
+Conversely, you may call instance variables from your controller by using
+a method and its value will be returned, nothing will be output.
+
+  # Inside imaginary ProductController
+  def list
+    @products = Product.find :all
+  end
+
+  # Inside app/views/product/list.mab
+  products.each do |product|
+    p product.title
+  end
+
 = Credits
 
 Markaby is a work of immense hope by Tim Fletcher and why the lucky stiff.

data/Rakefile

@@ -7,9 +7,14 @@ require 'tools/rakehelp'
 require 'fileutils'
 include FileUtils
 
+REV = File.read(".svn/entries")[/committed-rev="(\d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || "0.5" + (REV ? ".#{REV}" : "")
+
+task :default => [:package]
+
 setup_tests
 setup_rdoc ['README', 'CHANGELOG', 'lib/**/*.rb']
 
 summary = "Markup as Ruby, write HTML in your native Ruby tongue"
 test_file = "test/test_markaby.rb"
-setup_gem("markaby", "0.4",  "Tim Fletcher and _why", summary, ['builder'], test_file)
+setup_gem("markaby", VERS,  "Tim Fletcher and _why", summary, [['builder', '>=2.0.0']], test_file)

data/lib/markaby.rb

@@ -19,7 +19,9 @@ $:.unshift File.expand_path(File.dirname(__FILE__))
 # * Markaby::Template: a class for hooking Markaby into Rails as a
 #   proper templating language.
 module Markaby
-  VERSION = '0.4'
+  VERSION = '0.5'
+
+  class InvalidXhtmlError < Exception; end
 end
 
 unless defined?(Builder)
@@ -30,5 +32,4 @@ end
 require 'markaby/builder'
 require 'markaby/cssproxy'
 require 'markaby/metaid'
-require 'markaby/tags'
 require 'markaby/template'

data/lib/markaby/builder.rb

@@ -1,3 +1,5 @@
+require 'markaby/tags'
+
 module Markaby
   # The Markaby::Builder class is the central gear in the system.  When using
   # from Ruby code, this is the only class you need to instantiate directly.
@@ -19,22 +21,27 @@ module Markaby
   class Builder
 
     @@default = {
-      :indent => 2,
+      :indent => 0,
       :output_helpers => true,
       :output_xml_instruction => true,
       :output_meta_tag => true,
-      :image_tag_options => { :border => '0', :alt => '' }
+      :auto_validation => true,
+      :tagset => Markaby::XHTMLTransitional
     }
 
     def self.set(option, value)
       @@default[option] = value
     end
 
-    XHTMLTransitional = ["-//W3C//DTD XHTML 1.0 Transitional//EN", "DTD/xhtml1-transitional.dtd"]
-    
-    XHTMLStrict = ["-//W3C//DTD XHTML 1.0 Strict//EN", "DTD/xhtml1-strict.dtd"]
+    def self.ignored_helpers 
+      @@ignored_helpers ||= [] 
+    end 
+ 
+    def self.ignore_helpers(*helpers) 
+      ignored_helpers.concat helpers 
+    end 
 
-    attr_accessor :output_helpers
+    attr_accessor :output_helpers, :tagset
 
     # Create a Markaby builder object.  Pass in a hash of variable assignments to
     # +assigns+ which will be available as instance variables inside tag construction
@@ -52,14 +59,13 @@ module Markaby
     #   }
     #
     def initialize(assigns = {}, helpers = nil, &block)
-      @stream = []
+      @streams = [[]]
       @assigns = assigns
-      @margin = -1
+      @elements = {}
 
-      @indent = @@default[:indent]
-      @output_helpers = @@default[:output_helpers]
-      @output_meta_tag = @@default[:output_meta_tag]
-      @output_xml_instruction = @@default[:output_xml_instruction]
+      @@default.each do |k, v|
+        instance_variable_set("@#{k}", @assigns[k] || v)
+      end
 
       if helpers.nil?
         @helpers = nil
@@ -79,18 +85,19 @@ module Markaby
         end
       end
 
-      @margin += 1
-      @builder = ::Builder::XmlMarkup.new(:indent => @indent, :margin => @margin, :target => @stream)
+      @builder = ::Builder::XmlMarkup.new(:indent => @indent, :target => @streams.last)
+      class << @builder
+          attr_accessor :target, :level
+      end
 
       if block
-        r = instance_eval &block
-        text(r) if to_s.empty?
+        text(capture(&block))
       end
     end
 
     # Returns a string containing the HTML stream.  Internally, the stream is stored as an Array.
     def to_s
-      @stream.join
+      @streams.last.to_s
     end
 
     # Write a +string+ to the HTML stream without escaping it.
@@ -111,89 +118,111 @@ module Markaby
     #   => "<h1>TITLE</h1>\n<h2>CAPTURE ME</h2>\n"
     #
     def capture(&block)
-      old_stream = @stream.dup
-      @stream.replace []
-      str = instance_eval(&block).to_s
-      str = @stream.join unless @stream.empty?
-      @stream.replace old_stream
+      @streams.push(builder.target = [])
+      @builder.level += 1
+      str = instance_eval(&block)
+      str = @streams.last.join if @streams.last.any?
+      @streams.pop
+      @builder.level -= 1
+      builder.target = @streams.last
       str
     end
 
-    # Content_for will store the given block in an instance variable for later use 
-    # in another template or in the layout.
-    #
-    # The name of the instance variable is content_for_<name> to stay consistent 
-    # with @content_for_layout which is used by ActionView's layouts.
-    #
-    # Example:
-    #
-    #   content_for("header") do
-    #     h1 "Half Shark and Half Lion"
-    #   end
-    #
-    # If used several times, the variable will contain all the parts concatenated.
-    def content_for(name, &block)
-      eval "@content_for_#{name} = (@content_for_#{name} || '') + capture(&block)"
-    end
-
     # Create a tag named +tag+. Other than the first argument which is the tag name,
     # the arguments are the same as the tags implemented via method_missing.
     def tag!(tag, *args, &block)
+      ele_id = nil
+      if @auto_validation and @tagset
+          if !@tagset.tagset.has_key?(tag)
+              raise InvalidXhtmlError, "no element `#{tag}' for #{tagset.doctype}"
+          elsif args.last.respond_to?(:to_hash)
+              attrs = args.last.to_hash
+              attrs.each do |k, v|
+                  atname = k.to_s.downcase.intern
+                  unless k =~ /:/ or @tagset.tagset[tag].include? atname
+                      raise InvalidXhtmlError, "no attribute `#{k}' on #{tag} elements"
+                  end
+                  if atname == :id
+                      ele_id = v.to_s
+                      if @elements.has_key? ele_id
+                          raise InvalidXhtmlError, "id `#{ele_id}' already used (id's must be unique)."
+                      end
+                  end
+              end
+          end
+      end
       if block
         str = capture &block
         block = proc { text(str) }
       end
-      @builder.method_missing(tag, *args, &block)
+
+      f = fragment { @builder.method_missing(tag, *args, &block) }
+      @elements[ele_id] = f if ele_id
+      f
     end
 
-    # Create XML markup based on the name of the method +sym+. This method is never 
-    # invoked directly, but is called for each markup method in the markup block.
-    #
-    # This method is also used to intercept calls to helper methods and instance
+    # This method is used to intercept calls to helper methods and instance
     # variables.  Here is the order of interception:
     #
-    # * If +sym+ is a recognized HTML tag, the tag is output
-    #   or a CssProxy is returned if no arguments are given.
-    # * If +sym+ appears to be a self-closing tag, its block
-    #   is ignored, thus outputting a valid self-closing tag.
-    # * If +sym+ is also the name of an instance variable, the
-    #   value of the instance variable is returned.
     # * If +sym+ is a helper method, the helper method is called
     #   and output to the stream.
-    # * Otherwise, +sym+ and its arguments are passed to tag!
+    # * If +sym+ is a Builder::XmlMarkup method, it is passed on to the builder object.
+    # * If +sym+ is also the name of an instance variable, the
+    #   value of the instance variable is returned.
+    # * If +sym+ has come this far and no +tagset+ is found, +sym+ and its arguments are passed to tag!
+    # * If a tagset is found, though, +NoMethodError+ is raised.
+    #
+    # method_missing used to be the lynchpin in Markaby, but it's no longer used to handle
+    # HTML tags.  See html_tag for that.
     def method_missing(sym, *args, &block)
-      if TAGS.include?(sym) or (FORM_TAGS.include?(sym) and args.empty?)
-        if args.empty? and block.nil?
-          return CssProxy.new do |args, block|
-            if FORM_TAGS.include?(sym) and args.last.respond_to?(:to_hash) and args.last[:id]
-              args.last[:name] ||= args.last[:id]
-            end
-            tag!(sym, *args, &block)
-          end
-        end
-        if args.first.respond_to? :to_hash
-          block ||= proc{}
-        end
-        tag!(sym, *args, &block)
-      elsif SELF_CLOSING_TAGS.include?(sym)
-        tag!(sym, *args)
-      elsif @helpers.respond_to?(sym)
+      if @helpers.respond_to?(sym, true) && !self.class.ignored_helpers.include?(sym)
         r = @helpers.send(sym, *args, &block)
-        @builder << r if @output_helpers
-        r
-      elsif instance_variable_get("@#{sym}")
+        if @output_helpers and r.respond_to? :to_str
+          fragment { @builder << r }
+        else
+          r
+        end
+      elsif ::Builder::XmlMarkup.instance_methods.include?(sym.to_s) 
+        @builder.__send__(sym, *args, &block)
+      elsif instance_variables.include?("@#{sym}")
         instance_variable_get("@#{sym}")
-      else
+      elsif @tagset.nil?
         tag!(sym, *args, &block)
+      else
+        raise NoMethodError, "no such method `#{sym}'"
       end
     end
 
-    undef_method :p
-    undef_method :select
+    # Every HTML tag method goes through an html_tag call.  So, calling <tt>div</tt> is equivalent
+    # to calling <tt>html_tag(:div)</tt>.  All HTML tags in Markaby's list are given generated wrappers
+    # for this method.
+    #
+    # If the @auto_validation setting is on, this method will check for many common mistakes which
+    # could lead to invalid XHTML.
+    def html_tag(sym, *args, &block)
+      if @auto_validation and @tagset.self_closing.include?(sym) and block
+        raise InvalidXhtmlError, "the `\#{sym}' element is self-closing, please remove the block"
+      end
+      if args.empty? and block.nil? and not NO_PROXY.include?(sym)
+        return CssProxy.new do |args, block|
+          if @tagset.forms.include?(sym) and args.last.respond_to?(:to_hash) and args.last[:id]
+            args.last[:name] ||= args.last[:id]
+          end
+          tag!(sym, *args, &block)
+        end
+      end
+      if not @tagset.self_closing.include?(sym) and args.first.respond_to?(:to_hash)
+        block ||= proc{}
+      end
+      tag!(sym, *args, &block)
+    end
 
-    # Builds a image tag.  Assumes <tt>:border => '0', :alt => ''</tt>.
-    def img(opts = {})
-      tag!(:img, @@default[:image_tag_options].merge(opts))
+    XHTMLTransitional.tags.each do |k|
+      class_eval %{
+        def #{k}(*args, &block)
+          html_tag(#{k.inspect}, *args, &block)
+        end
+      }
     end
 
     # Builds a head tag.  Adds a <tt>meta</tt> tag inside with Content-Type
@@ -201,25 +230,59 @@ module Markaby
     def head(*args, &block)
       tag!(:head, *args) do
         tag!(:meta, "http-equiv" => "Content-Type", "content" => "text/html; charset=utf-8") if @output_meta_tag
-        instance_eval &block
+        instance_eval(&block)
       end
     end
 
     # Builds an html tag.  An XML 1.0 instruction and an XHTML 1.0 Transitional doctype
     # are prepended.  Also assumes <tt>:xmlns => "http://www.w3.org/1999/xhtml",
-    # "xml:lang" => "en", :lang => "en"</tt>.
-    def html(*doctype, &block)
-      doctype = XHTMLTransitional if doctype.empty?
-      @builder.instruct! if @output_xml_instruction
-      @builder.declare!(:DOCTYPE, :html, :PUBLIC, *doctype)
-      tag!(:html, :xmlns => "http://www.w3.org/1999/xhtml", "xml:lang" => "en", :lang => "en", &block)
+    # :lang => "en"</tt>.
+    def xhtml_transitional(&block)
+      self.tagset = Markaby::XHTMLTransitional
+      xhtml_html &block
     end
-    alias_method :xhtml_transitional, :html
 
     # Builds an html tag with XHTML 1.0 Strict doctype instead.
     def xhtml_strict(&block)
-      html XHTMLStrict, &block
+      self.tagset = Markaby::XHTMLStrict
+      xhtml_html &block
+    end
+
+    private
+
+    def xhtml_html(&block)
+      instruct! if @output_xml_instruction
+      declare!(:DOCTYPE, :html, :PUBLIC, *tagset.doctype)
+      tag!(:html, :xmlns => "http://www.w3.org/1999/xhtml", "xml:lang" => "en", :lang => "en", &block)
+    end
+
+    def fragment
+      stream = @streams.last
+      f1 = stream.length
+      yield
+      f2 = stream.length - f1
+      Fragment.new(stream, f1, f2)
     end
 
   end
+
+  # Every tag method in Markaby returns a Fragment.  If any method gets called on the Fragment,
+  # the tag is removed from the Markaby stream and given back as a string.  Usually the fragment
+  # is never used, though, and the stream stays intact.
+  #
+  # For a more practical explanation, check out the README.
+  class Fragment < ::Builder::BlankSlate
+    def initialize(s, a, b)
+      @s, @f1, @f2 = s, a, b 
+    end
+    def method_missing(*a)
+      unless @str
+        @str = @s[@f1, @f2].to_s  
+        @s[@f1, @f2] = [nil] * @f2
+        @str
+      end
+      @str.send(*a)
+    end
+  end
+
 end

data/lib/markaby/cssproxy.rb

@@ -12,12 +12,22 @@ module Markaby
       @blk = blk
     end
   
+    # Adds attributes to an element, for internal use only.  For example, if you
+    # want to write a wrapper which sets a bunch of default attributes for a certain
+    # tag.  Like the default `img' method included with Markaby automatically sets an
+    # empty alt attribute.
+    def merge!(opts)
+      @opts.merge! opts
+      self
+    end
+
     # Adds attributes to an element.  Bang methods set the :id attribute.
     # Other methods add to the :class attribute.  If a block is supplied,
     # it is executed with a merged hash (@opts + args).
     def method_missing(id_or_class, *args, &blk)
       idc = id_or_class.to_s
       case idc
+      when "pass"
       when /!$/
         @opts[:id] = $`
       else 
@@ -33,5 +43,11 @@ module Markaby
         @blk.call(args, blk)
       end
     end
+
+    def to_str
+      @blk.call([[@opts]]).to_s
+    end
+    alias_method :to_s, :to_str
+
   end
 end

data/lib/markaby/rails.rb

@@ -0,0 +1,46 @@
+module Markaby
+
+  # Markaby helpers for Rails.
+  module ActionControllerHelpers
+    # Returns a string of HTML built from the attached +block+.  Any +options+ are
+    # passed into the render method.
+    #
+    # Use this method in your controllers to output Markaby directly from inside.
+    def render_markaby(options = {}, &block)
+      render options.merge({ :text => Builder.new({}, self, &block).to_s })
+    end
+  end
+
+  class ActionViewTemplateHandler
+    def initialize(action_view)
+      @action_view = action_view
+    end
+    def render(template, local_assigns = {})
+      Template.new(template).render(@action_view.assigns.merge(local_assigns), @action_view)
+    end
+  end
+
+  class Builder
+    # Emulate ERB to satisfy helpers like <tt>form_for</tt>.
+    def _erbout; self end
+
+    # Content_for will store the given block in an instance variable for later use 
+    # in another template or in the layout.
+    #
+    # The name of the instance variable is content_for_<name> to stay consistent 
+    # with @content_for_layout which is used by ActionView's layouts.
+    #
+    # Example:
+    #
+    #   content_for("header") do
+    #     h1 "Half Shark and Half Lion"
+    #   end
+    #
+    # If used several times, the variable will contain all the parts concatenated.
+    def content_for(name, &block)
+      @helpers.assigns["content_for_#{name}"] =
+        eval("@content_for_#{name} = (@content_for_#{name} || '') + capture(&block)")
+    end
+  end
+
+end

data/lib/markaby/tags.rb

@@ -1,15 +1,165 @@
 module Markaby
 
-  TAGS = [
-    :a, :abbr, :acronym, :span, :b, :caption, :del, :cite, :code, :col,
-    :colgroup, :dd, :dfn, :dt, :em, :fieldset, :i, :img, :ins, :kbd, :p,
-    :label, :legend, :li, :optgroup, :option, :select, :small, :span, :strong,
-    :sub, :sup,  :tbody, :td, :textarea, :thead, :title, :th, :tr, :tfoot,
-    :tt, :address, :blockquote, :body, :div, :dl, :form, :h1, :h2, :h3, :head,
-    :noscript, :object, :ol, :pre, :q, :samp, :script, :style, :table, :ul
-  ]
-
   FORM_TAGS = [ :form, :input, :select, :textarea ]
-  SELF_CLOSING_TAGS = [ :hr, :br, :link, :meta, :input ]
+  SELF_CLOSING_TAGS = [ :base, :meta, :link, :hr, :br, :param, :img, :area, :input, :col ]
+  NO_PROXY = [ :hr, :br ]
+
+  # 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
+
+  # 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", "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", "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
+    { :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]
+    }.each do |k, v|
+        @tagset[k] += v
+    end
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
 
 end

data/test/test_markaby.rb

@@ -5,54 +5,105 @@ module MarkabyTestHelpers
   def link_to(obj)
     %{<a href="">#{obj}</a>}
   end
-  def pluralize(n, string)
-    n == 1 ? string : string + "s"
+  def pluralize(string)
+    string + "s"
   end
   module_function :link_to, :pluralize
 end
 
 class MarkabyTest < Test::Unit::TestCase
-  
-  def mab(string, assigns = {}, helpers = nil)
-    Markaby::Template.new(string.to_s).render(assigns, helpers)
+
+  def mab(*args, &block)
+    Markaby::Builder.new(*args, &block).to_s
+  end
+
+  def assert_exception(exclass, exmsg, *mab_args, &block)
+    begin
+      mab(*mab_args, &block)
+    rescue Exception => e
+      assert_equal exclass, e.class
+      assert_equal exmsg, e.message
+    end
   end
   
   def test_simple
-    assert_equal "<hr/>\n", mab("hr")
-    assert_equal "<p>foo</p>\n", mab("p 'foo'")
-    assert_equal "<p>\nfoo</p>\n", mab("p { 'foo' }")
+    assert_equal "<hr/>", mab { hr }
+    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>\n}, mab("div.one ''")
-    assert_equal %{<div class="one two"></div>\n}, mab("div.one.two ''")
-    assert_equal %{<div id="three"></div>\n}, mab("div.three! ''")
+    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! '' }
   end
   
   def test_escaping
-    assert_equal "<h1>Apples &amp; Oranges</h1>\n", mab("h1 'Apples & Oranges'")
-    assert_equal "<h1>\nApples & Oranges</h1>\n", mab("h1 { 'Apples & Oranges' }")
-    assert_equal "<h1 class=\"fruits&amp;floots\">Apples</h1>\n", mab("h1 'Apples', :class => 'fruits&floots'")
+    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
-    html = "<div>\n<h1>hello world</h1>\n</div>\n"
-    assert_equal html, mab("div { h1 'hello world' }")
-    assert_equal html, mab("div { capture { h1 'hello world' } }")
-    assert mab("capture { h1 'hello world' }").empty?
+    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>\n<h1>Steve</h1>\n<div>\n<h2>Gerald</h2>\n</div>\n<h3>Gerald</h3>\n</div>\n"
-    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("div { h1 @name; self << capture { div { @name = 'Gerald'; h2 @name } }; h3 @name }",
-                           :name => 'Steve')
+    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 test_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, "no such method `pluralize'", {}, MarkabyTestHelpers) { pluralize('squirrel') }
+  end
+
+  def test_builder_bang_methods
+    assert_equal "<?xml version=\"1.0\" encoding=\"UTF-8\"?>", mab { instruct! }
+  end
+
+  def test_fragments
+    assert_equal %{<div><h1>Monkeys</h1><h2>Giraffes <small>Miniature</small> and <strong>Large</strong></h2><h3>Donkeys</h3><h4>Parakeet <b><i>Innocent IV</i></b> in Classic Chartreuse</h4></div>}, 
+        mab { div { h1 "Monkeys"; h2 { "Giraffes #{small 'Miniature' } and #{strong 'Large'}" }; h3 "Donkeys"; h4 { "Parakeet #{b { i 'Innocent IV' }} in Classic Chartreuse" } } }
+    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, "no such 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 { instruct!; xhtml_transitional { head { title 'OKay' } } }    
+    assert doc =~ /^<\?xml version="1.0" encoding="UTF-8"\?>/
+    assert doc.include?(%{"-//W3C//DTD XHTML 1.0 Transitional//EN" "DTD/xhtml1-transitional.dtd">})
+    assert doc.include?(%{<title>OKay</title>})
   end
 
-  def test_output_helpers
-    assert_equal %{<a href="">edit</a>}, mab("link_to('edit')", {}, MarkabyTestHelpers)
-    assert mab("@output_helpers = false; link_to('edit')", {}, MarkabyTestHelpers).empty?
+  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" "DTD/xhtml1-strict.dtd">})
+    assert doc.include?(%{<title>OKay</title>})
   end
 
 end

data/tools/rakehelp.rb

@@ -79,7 +79,7 @@ def setup_gem(pkg_name, pkg_version, author, summary, dependencies, test_file)
         s.has_rdoc = true
         s.extra_rdoc_files = [ "README" ]
         dependencies.each do |dep|
-            s.add_dependency(dep)
+            s.add_dependency(*dep)
         end
         s.files = %w(README Rakefile setup.rb) +
         Dir.glob("{bin,doc,test,lib}/**/*") + 
@@ -97,4 +97,10 @@ def setup_gem(pkg_name, pkg_version, author, summary, dependencies, test_file)
         p.gem_spec = spec
         p.need_tar = true
     end
+
+    task :install do
+        sh %{rake package}
+        sh %{gem install pkg/#{pkg_name}-#{pkg_version}}
+    end
+
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.0.1
 specification_version: 1
 name: markaby
 version: !ruby/object:Gem::Version 
-  version: "0.4"
-date: 2006-04-11 00:00:00 -06:00
+  version: "0.5"
+date: 2006-10-03 00:00:00 -06:00
 summary: Markup as Ruby, write HTML in your native Ruby tongue
 require_paths: 
 - lib
@@ -25,6 +25,7 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Tim Fletcher and _why
 files: 
@@ -34,12 +35,11 @@ files:
 - test/test_markaby.rb
 - lib/markaby
 - lib/markaby.rb
-- lib/markaby/helper.rb
-- lib/markaby/tags.rb
 - lib/markaby/metaid.rb
+- lib/markaby/tags.rb
 - lib/markaby/builder.rb
 - lib/markaby/cssproxy.rb
-- lib/markaby/view.rb
+- lib/markaby/rails.rb
 - lib/markaby/template.rb
 - tools/rakehelp.rb
 test_files: 
@@ -60,7 +60,7 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.0
+        version: 2.0.0
     version: 

data/lib/markaby/helper.rb

@@ -1,14 +0,0 @@
-module Markaby
-  # Markaby helpers for Rails.
-  module ActionControllerHelper
-    # Returns a string of HTML built from the attached +block+.  Any +options+ are
-    # passed into the render method.
-    #
-    # Use this method in your controllers to output Markaby directly from inside.
-    def render_markaby(options = {}, &block)
-      render options.merge({
-        :text => Builder.new(nil, self, &block).to_s
-      })
-    end
-  end
-end

data/lib/markaby/view.rb

@@ -1,10 +0,0 @@
-module Markaby
-  class View
-    def initialize(action_view)
-      @action_view = action_view
-    end
-    def render(template, local_assigns = {})
-      Template.new(template).render(@action_view.assigns.merge(local_assigns), @action_view)
-    end
-  end
-end