RubyGems - erector - Versions diffs - 0.1.0 → 0.1.25 - Mend

erector 0.1.0 → 0.1.25

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

data/README.txt +90 -9
data/lib/erector.rb +6 -0
data/lib/erector/helpers.rb +15 -8
data/lib/erector/html_parts.rb +45 -18
data/lib/erector/widget.rb +96 -25
data/lib/erector/widgets/table.rb +17 -3
data/spec/erector/widget_spec.rb +179 -27
data/spec/erector/widgets/table_spec.rb +72 -68
metadata +4 -4

data/README.txt CHANGED

@@ -6,30 +6,30 @@
 == DESCRIPTION
-With Erector, you define views without templates, in natural Ruby code, with all the power of objects, functions, modular
-decomposition, etc.
+Erector is a Builder-based view framework, inspired by Markaby but overcoming some of its flaws. In Erector all views are
+objects, not template files, which allows the full power of OO (inheritance, modular decomposition, encapsulation) in views.
 == FEATURES/PROBLEMS:
-* FIX (list of features or problems)
+This is a *prerelease work in progress* and this gem is **NOT READY FOR USE** by anyone who's not on the Erector team yet. We'll be rolling out a
+version 0.2.0 soon which should include howto documentation and such.
 == SYNOPSIS
-TODO
+TODO (HOWTO, sample code, etc.)
 == REQUIREMENTS
-* treetop
 == INSTALL
 To install as a gem:
-* sudo gem install hoe
+* sudo gem install erector
 To install as a plugin:
-* ???
+* TODO
 == LICENSE:
@@ -56,9 +56,57 @@ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-== DOCUMENTATION
+== USER DOCUMENTATION
-TODO
+TODO (more on how you get started, and call it from rails)
+The basic way to construct some HTML/XML with erector is to pass a
+block to Erector::Widget.new.  For example:
+  html = Erector::Widget.new do
+    p "Hello, world!"
+  end
+  html.to_s          #=> <p>Hello, world!</p>
+Or, subclass Erector::Widget and implement a render method:
+  class Hello < Erector::Widget
+    def render
+      html do
+        head do
+          title "Hello"
+        end
+        body do
+          text "Hello, "
+          b "world!"
+        end
+      end
+    end
+  end
+  Hello.new.to_s
+  #=> <html><head><title>Hello</title></head><body>Hello, <b>world!</b></body></html>
+Here are the basics:
+  element('foo')           # <foo></foo>
+  empty_element('foo')     # <foo />
+  html                     # <html></html> (likewise for other common html tags)
+  b "foo"                  # <b>foo</b>
+  text 'foo'               # foo
+  text '&<>'               # &amp;&lt;&gt; (what you generally want, especially
+                           # if the text came from the user or a database)
+  text raw('&<>')          # &<> (back door for raw html)
+  rawtext('&<>')           # &<> (alias for text(raw()))
+  html { text foo }        # <html>foo</html>
+  html "foo"               # <html>foo</html>
+  html foo                 # <html>bar</html> (if the method foo returns the string "bar")
+  a(:href => 'foo.html')   # <a href="foo.html"></a>
+  a(:href => 'q?a&b')      # <a href="q?a&amp;b"></a>  (quotes as for text)
+  a(:href => raw('&amp;')) # <a href="&amp;"></a>
+  text nbsp("Save Doc")    # Save&#160;Doc (turns spaces into non-breaking spaces)
+  instruct                 # <?xml version="1.0" encoding="UTF-8"?>
+TODO: document more obscure features like capture, Table, :class => ['one', 'two']
 === Layout Inheritance
@@ -91,3 +139,36 @@ methods in its subclasses. There's one trick you'll need to use this layout for
 Here the abstract layout widget is used in a concrete fashion by the template-based layout. Normally, the `content` method
 would be implemented by subclassing widgets, but the layout template sets it directly and then calls to_s on the layout widget.
 This allows the same layout to be shared in a backward compatible way.
+== DEVELOPER NOTES
+* Check out project from rubyforge:
+  svn co svn+ssh://developername@rubyforge.org/var/svn/erector/trunk erector
+* Install gems:
+  sudo gem install rake rails rspec rubyforge hpricot
+* Run specs:
+  rake
+* Check out the available rake tasks:
+  rake -T
+=== VERSIONING POLICY
+* Versions are of the form major.minor.tiny
+* Tiny revisions fix bugs or documentation
+* Minor revisions add API calls, or change behavior
+* Minor revisions may also remove API calls, but these must be clearly announced in History.txt, with instructions on how to migrate
+* Major revisions are about marketing more than technical needs. We will stay in major version 0 until we're happy taking the "alpha" label off it. And if we ever do a major overhaul of the API, especially one that breaks backwards compatibility, we will probably want to increment the major version.
+* We will not be shy about incrementing version numbers -- if we end up going to version 0.943.67 then so be it.
+* Developers should attempt to add lines in History.txt to reflect their checkins. These should reflect feature-level changes, not just one line per checkin. The top section of History.txt is used as the Release Notes by the "rake publish" task and will appear on the RubyForge file page.
+* Someone making a release must fill in the version number in History.txt as well as in Rakefile. Note that "rake publish" requires a "VERSION=1.2.3" parameter to confirm you're releasing the version you intend.
+* As soon as a release is made and published, the publisher should go into History.txt and make a new section. Since we won't yet know what the next version will be called, the new section will be noted by a single "==" at the top of the file.

data/lib/erector.rb CHANGED

@@ -1,3 +1,4 @@
+require "rubygems"
 require "action_controller"
 require "erector/extensions/action_controller"
 require "erector/extensions/object"
@@ -5,3 +6,8 @@ require "erector/helpers"
 require "erector/html_parts"
 require "erector/widget"
 require "erector/widgets"
+##
+# Erector view framework
+module Erector
+end

data/lib/erector/helpers.rb CHANGED

@@ -1,18 +1,25 @@
 module Erector
   module Helpers
     [
-        :link_to,
         :image_tag,
         :javascript_include_tag,
         :stylesheet_link_tag,
-        :link_to_function,
-        :link_to_remote,
         :sortable_element,
-        :sortable_element_js,
-        :mail_to
+        :sortable_element_js
     ].each do |helper_name|
       define_method helper_name do |*args|
-        text helpers.send(helper_name, *args)
+        text raw(helpers.send(helper_name, *args))
+      end
+    end
+    [
+        :link_to_function,
+        :link_to,
+        :link_to_remote,
+        :mail_to
+    ].each do |link_helper|
+      define_method link_helper do |link_text, *args|
+        text raw(helpers.send(link_helper, h(link_text), *args))
       end
     end
@@ -36,8 +43,8 @@ module Erector
       helpers.cycle(*args)
     end
-    def simple_format(*args)
-      helpers.simple_format(*args)
+    def simple_format(string)
+      p raw(string.to_s.html_escape.gsub(/\r\n?/, "\n").gsub(/\n/, "<br/>\n"))
     end
     def time_ago_in_words(*args)

data/lib/erector/html_parts.rb CHANGED

@@ -2,21 +2,21 @@ module Erector
   class HtmlParts < Array
     def to_s
       map do |part|
-        case part['type']
-        when 'open'
-          part['attributes'] ?
-            "<#{part['tagName']}#{format_attributes(part['attributes'])}>" :
-            "<#{part['tagName']}>"
-        when 'close'
-          "</#{part['tagName']}>"
-        when 'standalone'
-          part['attributes'] ?
-            "<#{part['tagName']}#{format_attributes(part['attributes'])} />" :
-            "<#{part['tagName']}  />"
-        when 'text'
-          part['value'].to_s
-        when 'instruct'
-          "<?xml#{format_attributes(part['attributes'])}?>"
+        case part[:type].to_sym
+        when :open
+          part[:attributes] ?
+            "<#{part[:tagName]}#{format_attributes(part[:attributes])}>" :
+            "<#{part[:tagName]}>"
+        when :close
+          "</#{part[:tagName]}>"
+        when :empty
+          part[:attributes] ?
+            "<#{part[:tagName]}#{format_attributes(part[:attributes])} />" :
+            "<#{part[:tagName]}  />"
+        when :text
+          part[:value].html_escape
+        when :instruct
+          "<?xml#{format_sorted(sort_for_xml_declaration(part[:attributes]))}?>"
         end
       end.join
     end
@@ -24,11 +24,38 @@ module Erector
     protected
     def format_attributes(attributes)
       return "" if !attributes || attributes.empty?
+      return format_sorted(sorted(attributes))
+    end
+    def format_sorted(sorted)
       results = ['']
+      sorted.each do |key, value|
+        if value
+          if value.is_a?(Array)
+            value = [value].flatten.join(' ')
+          end
+          results << "#{key}=\"#{value.html_escape}\""
+        end
+      end
+      return results.join(' ')
+    end
+    def sorted(attributes)
+      stringized = []
+      attributes.each do |key, value|
+        stringized << [key.to_s, value]
+      end
+      return stringized.sort
+    end
+    def sort_for_xml_declaration(attributes)
+      # correct order is "version, encoding, standalone" (XML 1.0 section 2.8).
+      # But we only try to put version before encoding for now.
+      stringized = []
       attributes.each do |key, value|
-        results << "#{key}=#{value.to_s.inspect}" if value
+        stringized << [key.to_s, value]
       end
-      results.join ' '
+      return stringized.sort{|a, b| b <=> a}
     end
   end
-end
+end

data/lib/erector/widget.rb CHANGED

@@ -2,10 +2,10 @@ module Erector
   class Widget
     class << self
       def all_tags
-        Erector::Widget.full_tags + Erector::Widget.standalone_tags
+        Erector::Widget.full_tags + Erector::Widget.empty_tags
       end
-      def standalone_tags
+      def empty_tags
         ['area', 'base', 'br', 'hr', 'img', 'input', 'link', 'meta']
       end
@@ -50,6 +50,17 @@ module Erector
         instance_eval(&@block)
       end
     end
+    def render_to(doc)
+      @doc = doc
+      render
+    end
+    def render_for(parent)
+      @parent = parent
+      @doc = parent.doc
+      render
+    end
     def widget(widget_class, assigns={}, &block)
       child = widget_class.new(helpers, assigns, doc, &block)
@@ -57,35 +68,79 @@ module Erector
     end
     def h(content)
-      text CGI.escapeHTML(content)
+      content.html_escape
     end
     def open_tag(tag_name, attributes={})
-      @doc << {'type' => 'open', 'tagName' => tag_name, 'attributes' => attributes}
+      @doc << {:type => :open, :tagName => tag_name, :attributes => attributes}
     end
     def text(value)
-      @doc << {'type' => 'text', 'value' => value}
+      @doc << {:type => :text, :value => value}
       nil
     end
+    def raw(value)
+      RawString.new(value.to_s)
+    end
+    def rawtext(value)
+      text raw(value)
+    end
+    def nbsp(value)
+      raw(value.html_escape.gsub(/ /,'&#160;'))
+    end
     def close_tag(tag_name)
-      @doc << {'type' => 'close', 'tagName' => tag_name}
+      @doc << {:type => :close, :tagName => tag_name}
+    end
+    def instruct(attributes={:version => "1.0", :encoding => "UTF-8"})
+      @doc << {:type => :instruct, :attributes => attributes}
     end
+    # Deprecated synonym of instruct
     def instruct!(attributes={:version => "1.0", :encoding => "UTF-8"})
-      @doc << {'type' => 'instruct', 'attributes' => attributes}
+      @doc << {:type => :instruct, :attributes => attributes}
     end
-    def javascript(*args, &blk)
-      params = args[0] if args[0].is_a?(Hash)
-      params ||= args[1] if args[1].is_a?(Hash)
-      unless params
-        params = {}
-        args << params
+    def javascript(*args, &block)
+      if args.length > 2
+        raise ArgumentError, "Cannot accept more than two arguments"
+      end
+      attributes, value = nil, nil
+      arg0 = args[0]
+      if arg0.is_a?(Hash)
+        attributes = arg0
+      else
+        value = arg0
+        arg1 = args[1]
+        if arg1.is_a?(Hash)
+          attributes = arg1
+        end
+      end
+      attributes ||= {}
+      attributes[:type] = "text/javascript"
+      open_tag 'script', attributes
+      # Shouldn't this be a "cdata" HtmlPart?
+      # (maybe, but the syntax is specific to javascript; it isn't
+      # really a generic XML CDATA section.  Specifically,
+      # ]]> within value is not treated as ending the
+      # CDATA section by Firefox2 when parsing text/html,
+      # although I guess we could refuse to generate ]]>
+      # there, for the benefit of XML/XHTML parsers).
+      rawtext "\n// <![CDATA[\n"
+      if block
+        instance_eval(&block)
+      else
+        rawtext value
       end
-      params[:type] = "text/javascript"
-      script(*args, &blk)
+      rawtext "\n// ]]>\n"
+      close_tag 'script'
+      text "\n"
     end
     def __element__(tag_name, *args, &block)
@@ -97,7 +152,7 @@ module Erector
       if arg0.is_a?(Hash)
         attributes = arg0
       else
-        value = arg0.to_s
+        value = arg0
         arg1 = args[1]
         if arg1.is_a?(Hash)
           attributes = arg1
@@ -113,18 +168,18 @@ module Erector
       close_tag tag_name
     end
     alias_method :element, :__element__
-    def __standalone_element__(tag_name, attributes={})
-      @doc << {'type' => 'standalone', 'tagName' => tag_name, 'attributes' => attributes}
+    def __empty_element__(tag_name, attributes={})
+      @doc << {:type => :empty, :tagName => tag_name, :attributes => attributes}
     end
-    alias_method :standalone_element, :__standalone_element__
+    alias_method :empty_element, :__empty_element__
     def capture(&block)
       begin
         original_doc = @doc
         @doc = HtmlParts.new
         yield
-        @doc.to_s
+        raw(@doc.to_s)
       ensure
         @doc = original_doc
       end
@@ -136,6 +191,10 @@ module Erector
       @__to_s = @doc.to_s
     end
+    def html_escape()
+      return to_s()
+    end
     alias_method :inspect, :to_s
     full_tags.each do |tag_name|
@@ -148,10 +207,10 @@ module Erector
       )
     end
-    standalone_tags.each do |tag_name|
+    empty_tags.each do |tag_name|
       self.class_eval(
         "def #{tag_name}(*args, &block)\n" <<
-        "  __standalone_element__('#{tag_name}', *args, &block)\n" <<
+        "  __empty_element__('#{tag_name}', *args, &block)\n" <<
         "end",
         __FILE__,
         __LINE__ - 4
@@ -172,9 +231,21 @@ module Erector
       widget = self
       @helpers.metaclass.class_eval do
         define_method :concat do |some_text, binding|
-          widget.text some_text
+          widget.text widget.raw(some_text)
         end
       end
     end
   end
-end
+end
+class RawString < String
+  def html_escape
+    self
+  end
+end
+class Object
+  def html_escape
+    return CGI.escapeHTML(to_s())
+  end
+end

data/lib/erector/widgets/table.rb CHANGED

@@ -11,6 +11,11 @@ module Erector
         def column_definitions
           @column_definitions ||= []
         end
+        def row_classes(*row_classes)
+          @row_class_list = row_classes
+        end
+        attr_reader :row_class_list
       end
       def render
@@ -18,13 +23,17 @@ module Erector
           tr do
             column_definitions.each do |column_def|
               th do
-                h column_def.name
+                if column_def.name.is_a?(Proc)
+                  self.instance_exec(column_def.id, &column_def.name)
+                else
+                  text column_def.name
                 end
+              end
             end
           end
           tbody do
-            @row_objects.each do |object|
-              tr do
+            @row_objects.each_with_index do |object, index|
+              tr(:class => cycle(index)) do
                 column_definitions.each do |column_def|
                   td do
                     self.instance_exec(object, &column_def.cell_proc)
@@ -40,6 +49,11 @@ module Erector
       def column_definitions
         self.class.column_definitions
       end
+      def cycle(index)
+        list = self.class.row_class_list
+        list ? list[index % list.length] : ''
+      end
     end
   end
 end

data/spec/erector/widget_spec.rb CHANGED

@@ -3,21 +3,18 @@ require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 module WidgetSpec
   describe Erector::Widget do
     describe ".all_tags" do
-      it "returns set of full and standalone tags" do
+      it "returns set of full and empty tags" do
         Erector::Widget.all_tags.class.should == Array
-        Erector::Widget.all_tags.should == Erector::Widget.full_tags + Erector::Widget.standalone_tags
+        Erector::Widget.all_tags.should == Erector::Widget.full_tags + Erector::Widget.empty_tags
       end
     end
-    describe "#instruct!" do
-      it "when passed no arguments; returns an instruct element with version 1 and utf-8" do
+    describe "#instruct" do
+      it "when passed no arguments; returns an XML declaration with version 1 and utf-8" do
         html = Erector::Widget.new do
-          instruct!
-        end.to_s
-        html.should include("<?xml")
-        html.should include('encoding="UTF-8"')
-        html.should include('version="1.0')
-        html.should include("?>")
+          instruct
+          # version must precede encoding, per XML 1.0 4th edition (section 2.8)
+        end.to_s.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
       end
     end
@@ -44,6 +41,32 @@ module WidgetSpec
         div[:nil_attribute].should be_nil
       end
+      it "with an array of CSS classes, returns a tag with the classes separated" do
+        Erector::Widget.new do
+          element('div', :class => [:foo, :bar])
+        end.to_s.should == "<div class=\"foo bar\"></div>";
+      end
+      it "with an array of CSS classes as strings, returns a tag with the classes separated" do
+        Erector::Widget.new do
+          element('div', :class => ['foo', 'bar'])
+        end.to_s.should == "<div class=\"foo bar\"></div>";
+      end
+      it "with a CSS class which is a string, just use that as the attribute value" do
+        Erector::Widget.new do
+          element('div', :class => "foo bar")
+        end.to_s.should == "<div class=\"foo bar\"></div>";
+      end
+      it "with many attributes, alphabetize them" do
+        Erector::Widget.new do
+          empty_element('foo', :alpha => "", :betty => "5", :aardvark => "tough",
+            :carol => "", :demon => "", :erector => "", :pi => "3.14", :omicron => "", :zebra => "", :brain => "")
+        end.to_s.should == "<foo aardvark=\"tough\" alpha=\"\" betty=\"5\" brain=\"\" carol=\"\" demon=\"\" " \
+           "erector=\"\" omicron=\"\" pi=\"3.14\" zebra=\"\" />";
+      end
       it "with inner tags; returns nested tags" do
         widget = Erector::Widget.new do
           element 'div' do
@@ -102,22 +125,83 @@ module WidgetSpec
           end
         end
       end
+      it "when outputting text; quotes it" do
+        Erector::Widget.new do
+          element 'div', 'test &<>text'
+        end.to_s.should == "<div>test &amp;&lt;&gt;text</div>"
+      end
+      it "when outputting text via text; quotes it" do
+        Erector::Widget.new do
+          element 'div' do
+            text "test &<>text"
+          end
+        end.to_s.should == "<div>test &amp;&lt;&gt;text</div>"
+      end
+      it "when outputting attribute value; quotes it" do
+        Erector::Widget.new do
+          element 'a', :href => "foo.cgi?a&b"
+        end.to_s.should == "<a href=\"foo.cgi?a&amp;b\"></a>"
+      end
+      it "with raw text, does not quote it" do
+        Erector::Widget.new do
+          element 'div' do
+            text raw("<b>bold</b>")
+          end
+        end.to_s.should == "<div><b>bold</b></div>"
+      end
+      it "with raw text and no block, does not quote it" do
+        Erector::Widget.new do
+          element 'div', raw("<b>bold</b>")
+        end.to_s.should == "<div><b>bold</b></div>"
+      end
+      it "with raw attribute, does not quote it" do
+        Erector::Widget.new do
+          element 'a', :href => raw("foo?x=&nbsp;")
+        end.to_s.should == "<a href=\"foo?x=&nbsp;\"></a>"
+      end
+      it "with quote in attribute, quotes it" do
+        Erector::Widget.new do
+          element 'a', :onload => "alert(\"foo\")"
+        end.to_s.should == "<a onload=\"alert(&quot;foo&quot;)\"></a>"
+      end
+      it "with a non-string, non-raw, calls to_s and quotes" do
+        Erector::Widget.new do
+          element 'a' do
+            text [7, "foo&bar"]
+          end
+        end.to_s.should == "<a>7foo&amp;bar</a>"
+      end
+      it "calls to_s" do
+        Erector::Widget.new do
+          img :width=>50
+        end.to_s.should == "<img width=\"50\" />"
+      end
     end
-    describe "#standalone_element" do
-      it "when receiving attributes, renders a standalone_element with the attributes" do
+    describe "#empty_element" do
+      it "when receiving attributes, renders an empty element with the attributes" do
         Erector::Widget.new do
-          standalone_element 'input', :name => 'foo[bar]'
+          empty_element 'input', :name => 'foo[bar]'
         end.to_s.should == '<input name="foo[bar]" />'
       end
-      it "when not receiving attributes, renders a standalone_element without attributes" do
+      it "when not receiving attributes, renders an empty element without attributes" do
         Erector::Widget.new do
-          standalone_element 'br'
+          empty_element 'br'
         end.to_s.should == '<br />'
       end
-      it "renders the proper standalone tags" do
+      it "renders the proper empty-element tags" do
         ['area', 'base', 'br', 'hr', 'img', 'input', 'link', 'meta'].each do |tag_name|
           expected = "<#{tag_name} />"
           actual = Erector::Widget.new do
@@ -126,24 +210,63 @@ module WidgetSpec
           begin
             actual.should == expected
           rescue Spec::Expectations::ExpectationNotMetError => e
-            puts "Expected #{tag_name} to be a standalone element. Expected #{expected}, got #{actual}"
+            puts "Expected #{tag_name} to be an empty-element tag. Expected #{expected}, got #{actual}"
             raise e
           end
         end
       end
     end
+    describe "nbsp" do
+      it "turns consecutive spaces into consecutive non-breaking spaces" do
+        Erector::Widget.new do
+          text nbsp("a  b")
+        end.to_s.should == "a&#160;&#160;b"
+      end
+      it "works in text context" do
+        Erector::Widget.new do
+          element 'a' do
+            text nbsp("&<> foo")
+          end
+        end.to_s.should == "<a>&amp;&lt;&gt;&#160;foo</a>"
+      end
+      it "works in attribute value context" do
+        Erector::Widget.new do
+          element 'a', :href => nbsp("&<> foo")
+        end.to_s.should == "<a href=\"&amp;&lt;&gt;&#160;foo\"></a>"
+      end
+    end
+    describe '#h' do
+      before do
+        @widget = Erector::Widget.new
+      end
+      it "escapes regular strings" do
+        @widget.h("&").should == "&amp;"
+      end
+      it "does not escape raw strings" do
+        @widget.h(@widget.raw("&")).should == "&"
+      end
+    end
     describe "#javascript" do
-      it "when receiving a block; renders the content inside of a script text/javascript element" do
-        body = Erector::Widget.new do
+      it "when receiving a block; renders the content inside of script text/javascript tags" do
+        Erector::Widget.new do
           javascript do
-            text 'alert("hello");'
+            rawtext 'if (x < y && x > z) alert("don\'t stop");'
           end
-        end.to_s
-        doc = Hpricot(body)
-        script_tag = doc.at("script")
-        script_tag[:type].should == "text/javascript"
-        script_tag.inner_html.should include('alert("hello");')
+        end.to_s.should == <<EXPECTED
+<script type="text/javascript">
+// <![CDATA[
+if (x < y && x > z) alert("don't stop");
+// ]]>
+</script>
+EXPECTED
       end
       it "when receiving a params hash; renders a source file" do
@@ -156,13 +279,30 @@ module WidgetSpec
       it "when receiving text and a params hash; renders a source file" do
         html = Erector::Widget.new do
-          javascript('alert("hello");', :src => "/my/js/file.js")
+          javascript('alert("&<>\'hello");', :src => "/my/js/file.js")
         end.to_s
         doc = Hpricot(html)
         script_tag = doc.at('script')
         script_tag[:src].should == "/my/js/file.js"
-        script_tag.inner_html.should include('alert("hello");')
+        script_tag.inner_html.should include('alert("&<>\'hello");')
+      end
+      it "with too many arguments; raises ArgumentError" do
+        proc do
+          Erector::Widget.new do
+            javascript 'foobar', {}, 'fourth'
+          end.to_s
+        end.should raise_error(ArgumentError)
       end
+      it "script method doesn't do any magic" do
+        Erector::Widget.new do
+          script(:type => "text/javascript") do
+            rawtext "if (x < y || x > z) onEnterGetTo('/search?a=b&c=d')"
+          end
+        end.to_s.should == "<script type=\"text/javascript\">if (x < y || x > z) onEnterGetTo('/search?a=b&c=d')</script>"
+      end
     end
     describe '#capture' do
@@ -195,6 +335,18 @@ module WidgetSpec
       end
     end
+    describe 'nested' do
+      it "can insert another widget without raw" do
+        inner = Erector::Widget.new do
+          p "foo"
+        end
+        outer = Erector::Widget.new do
+          div inner
+        end.to_s.should == '<div><p>foo</p></div>'
+      end
+    end
     describe '#widget' do
       before do
         class Parent < Erector::Widget

data/spec/erector/widgets/table_spec.rb CHANGED

@@ -5,10 +5,12 @@ module TableSpec
     column :column_a
     column :column_b
     column :column_c
+    row_classes :even, :odd
   end
   class CustomHeadingTable < Erector::Widgets::Table
     column :a, "Column - A"
+    column :b, lambda {|id| span id}
   end
   class CustomCellTable < Erector::Widgets::Table
@@ -17,88 +19,90 @@ module TableSpec
     end
   end
-  describe Erector::Widgets::Table do
-    before do
-      view_cache do
-        widget = CustomHeadingTable.new(
-          nil,
-          :row_objects => []
-        )
-        widget.to_s
+  describe ::Erector::Widgets::Table do
+    describe "with custom heading" do
+      before do
+        view_cache do
+          widget = CustomHeadingTable.new(
+            nil,
+              :row_objects => []
+          )
+          widget.to_s
+        end
       end
-    end
-    it "renders a tbody to be compatible with IE6" do
-      doc.at("tbody").should_not be_nil
-    end
-  end
-  describe Erector::Widgets::Table, "with custom heading" do
-    before do
-      view_cache do
-        widget = CustomHeadingTable.new(
-          nil,
-          :row_objects => []
-        )
-        widget.to_s
+      it "renders a custom heading text and procs" do
+        table = doc.at("table")
+        table.search("th").map {|c| c.inner_html}.should == [
+          "Column - A",
+          "<span>b</span>"
+        ]
       end
-    end
-    it "renders a custom heading" do
-      table = doc.at("table")
-      table.at("th").inner_html.should == "Column - A"
-    end
-  end
-  describe Erector::Widgets::Table, "with custom cell content" do
-    before do
-      @object1 = Struct.new(:a).new("Hello")
-      view_cache do
-        widget = CustomCellTable.new(
-          nil,
-          :row_objects => [@object1]
-        )
-        widget.to_s
+      it "renders a tbody to be compatible with IE6" do
+        doc.at("tbody").should_not be_nil
       end
     end
-    it "renders custom cell html" do
-      table = doc.at("table")
-      row = table.search("tr")[1]
-      row.at("td").inner_html.should == "<span>Hello</span>"
-    end
-  end
+    describe "with custom cell content" do
+      before do
+        @object1 = Struct.new(:a).new("Hello")
+        view_cache do
+          widget = CustomCellTable.new(
+            nil,
+              :row_objects => [@object1]
+          )
+          widget.to_s
+        end
+      end
-  describe Erector::Widgets::Table, "with default heading and cell definitions" do
-    before do
-      @object1 = Struct.new(:column_a, :column_b, :column_c).new(1, 2, 3)
-      @object2 = Struct.new(:column_a, :column_b, :column_c).new(4, 5, 6)
-      view_cache do
-        widget = DefaultsTestTable.new(
-          nil,
-          :row_objects => [@object1, @object2]
-        )
-        widget.to_s
+      it "renders custom cell html" do
+        table = doc.at("table")
+        row = table.search("tr")[1]
+        row.at("td").inner_html.should == "<span>Hello</span>"
       end
-      @table = doc.at("table")
     end
-    it "renders column titles" do
-      title_row = @table.at("tr")
-      titles = title_row.search("th").collect {|heading| heading.inner_html}
-      titles.should == [ "Column A", "Column B", "Column C" ]
-    end
+    describe "with default heading and cell definitions" do
+      before do
+        @object1 = Struct.new(:column_a, :column_b, :column_c).new(1, 2, 3)
+        @object2 = Struct.new(:column_a, :column_b, :column_c).new(4, 5, 6)
+        @object3 = Struct.new(:column_a, :column_b, :column_c).new(7, 8, 9)
+        view_cache do
+          widget = DefaultsTestTable.new(
+            nil,
+              :row_objects => [@object1, @object2, @object3]
+          )
+          widget.to_s
+        end
+        @table = doc.at("table")
+      end
-    it "renders data" do
-      data_rows = @table.search("tr")[1..-1]
-      cell_values = data_rows.collect do |row|
-        row.search("td").collect {|col| col.inner_html}
+      it "renders column titles" do
+        title_row = @table.at("tr")
+        titles = title_row.search("th").collect {|heading| heading.inner_html}
+        titles.should == [ "Column A", "Column B", "Column C" ]
       end
-      cell_values.should == [
-        ['1', '2', '3'],
-        ['4', '5', '6']
-      ]
+      it "renders data" do
+        data_rows = @table.search("tr")[1..-1]
+        cell_values = data_rows.collect do |row|
+          row.search("td").collect {|col| col.inner_html}
+        end
+        cell_values.should == [
+          ['1', '2', '3'],
+          ['4', '5', '6'],
+          ['7', '8', '9'],
+        ]
+      end
+      it "renders the row classes" do
+        data_rows = @table.search("tr")[1..-1]
+        data_rows[0]['class'].should == 'even'
+        data_rows[1]['class'].should == 'odd'
+        data_rows[2]['class'].should == 'even'
+      end
     end
   end
 end

metadata CHANGED

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: erector
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.25
 platform: ruby
 authors:
 - Pivotal Labs
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2008-02-13 00:00:00 -08:00
+date: 2008-02-26 00:00:00 -08:00
 default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency
@@ -21,7 +21,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.5.0
     version:
-description: With Erector, you define views without templates, in natural Ruby code, with all the power of objects, functions, modular decomposition, etc.
+description: Erector is a Builder-based view framework, inspired by Markaby but overcoming some of its flaws. In Erector all views are objects, not template files, which allows the full power of OO (inheritance, modular decomposition, encapsulation) in views.
 email:
 - alex@pivotallabs.com
 executables: []
@@ -78,6 +78,6 @@ rubyforge_project: erector
 rubygems_version: 1.0.1
 signing_key:
 specification_version: 2
-summary: With Erector, you define views without templates, in natural Ruby code, with all the power of objects, functions, modular decomposition, etc.
+summary: Erector is a Builder-based view framework, inspired by Markaby but overcoming some of its flaws
 test_files: []