erector 0.5.1 → 0.6.3

data/lib/erector/widgets/table.rb

@@ -1,24 +1,49 @@
 module Erector
   module Widgets #:nodoc:
+    # The Table widget provides the ability to render a table from a 
+    # list of objects (one for each row).
+    #
+    # Because the default for the column titles utilizes the ActiveSupport
+    # Inflector#titleize method, this widget requires active_support to be loaded.
+    #
+    #   class UsersTable < Erector::Widgets::Table
+    #     column :first_name
+    #     column :last_name
+    #     column :email
+    #     row_classes :even, :odd
+    #   end
+    #
+    #   widget UsersTable, :row_objects => [user_1, user_2, user_3]
     class Table < Erector::Widget
       ColumnDefinition = Struct.new(:id, :name, :cell_proc)
       class << self
-        def column(id, name=id.to_s.humanize.titleize, &cell_proc)
+        # Define a column, optionally specifying the name (the heading
+        # that the user sees) and a block which renders the cell given
+        # a row object.  If the block is not specified, the cell contains
+        # the result of calling a method whose name is id.
+        # 
+        # The name can be a string or a proc.
+        def column(id, name=id.to_s.titleize, &cell_proc)
           cell_proc ||= proc {|object| text object.__send__(id)}
           column_definitions << ColumnDefinition.new(id, name, cell_proc)
         end
 
-        def column_definitions
+        def column_definitions #:nodoc:
           @column_definitions ||= []
         end
 
+        # A list of HTML classes to apply to the rows in turn.  After the
+        # list is exhausted, start again at the start.  The most
+        # common use for this is to specify one class for odd rows
+        # and a different class for even rows.
         def row_classes(*row_classes)
           @row_class_list = row_classes
         end
         attr_reader :row_class_list
       end
 
-      def render
+      # The standard erector content method.
+      def content
         table do
           thead do
             tr do
@@ -42,7 +67,7 @@ module Erector
       end
 
       protected
-      def row(object, index)
+      def row(object, index) #:nodoc:
         tr(:class => row_css_class(object, index)) do
           column_definitions.each do |column_def|
             td do
@@ -52,19 +77,20 @@ module Erector
         end
       end
 
-      # Im overridable
+      # You can override this method to provide a class for a row
+      # (as an alternative to calling row_classes).
       def row_css_class(object, index)
         cycle(index)
       end
 
-      def column_definitions
+      def column_definitions #:nodoc:
         self.class.column_definitions
       end
 
-      def cycle(index)
+      def cycle(index) #:nodoc:
         list = self.class.row_class_list
         list ? list[index % list.length] : ''
       end
     end
   end
-end
+end

data/spec/erector/indentation_spec.rb

@@ -4,8 +4,9 @@ describe "indentation" do
 
   it "can detect newliney tags" do
     widget = ::Erector::Widget.new
-    string = widget.output
-    widget.enable_prettyprint = true
+    widget.instance_eval do 
+      @prettyprint = true
+    end
     widget.newliney("i").should == false
     widget.newliney("table").should == true
   end
@@ -14,21 +15,21 @@ describe "indentation" do
     Erector::Widget.new() do
       text "Hello, "
       b "World"
-    end.enable_prettyprint(true).to_s.should == "Hello, <b>World</b>"
+    end.to_pretty.should == "Hello, <b>World</b>"
   end
   
   it "should add newlines before open newliney tags" do
     Erector::Widget.new() do
       p "foo"
       p "bar"
-    end.enable_prettyprint(true).to_s.should == "<p>foo</p>\n<p>bar</p>\n"
+    end.to_pretty.should == "<p>foo</p>\n<p>bar</p>\n"
   end
   
   it "should add newlines between text and open newliney tag" do
     Erector::Widget.new() do
       text "One"
       p "Two"
-    end.enable_prettyprint(true).to_s.should == "One\n<p>Two</p>\n"
+    end.to_pretty.should == "One\n<p>Two</p>\n"
   end
   
   it "should add newlines after end newliney tags" do
@@ -36,7 +37,7 @@ describe "indentation" do
       tr do
         td "cell"
       end
-    end.enable_prettyprint(true).to_s.should == "<tr>\n  <td>cell</td>\n</tr>\n"
+    end.to_pretty.should == "<tr>\n  <td>cell</td>\n</tr>\n"
   end
   
   it "should treat empty elements as start and end" do
@@ -44,7 +45,7 @@ describe "indentation" do
       p "before"
       br
       p "after"
-    end.enable_prettyprint(true).to_s.should == "<p>before</p>\n<br />\n<p>after</p>\n"
+    end.to_pretty.should == "<p>before</p>\n<br />\n<p>after</p>\n"
   end
   
   it "empty elements sets at_start_of_line" do
@@ -52,7 +53,7 @@ describe "indentation" do
       text "before"
       br
       p "after"
-    end.enable_prettyprint(true).to_s.should == "before\n<br />\n<p>after</p>\n"
+    end.to_pretty.should == "before\n<br />\n<p>after</p>\n"
   end
 
   it "will not insert extra space before/after input element" do
@@ -62,7 +63,7 @@ describe "indentation" do
       text 'Name'
       input :type => 'text'
       text 'after'
-    end.enable_prettyprint(true).to_s.should == 'Name<input type="text" />after'
+    end.to_pretty.should == 'Name<input type="text" />after'
   end
   
   it "will indent" do
@@ -77,7 +78,7 @@ describe "indentation" do
           end
         end
       end
-    end.enable_prettyprint(true).to_s.should == <<END
+    end.to_pretty.should == <<END
 <html>
   <head>
     <title>hi</title>
@@ -91,22 +92,43 @@ describe "indentation" do
 END
   end
   
+  it "preserves indentation for sub-rendered widgets" do
+    tea = Erector::Widget.new do
+      div do
+        p "oolong"
+      end
+    end
+    cup = Erector::Widget.new do
+      div do
+        p "fine china"
+        tea.write_via(self)
+      end
+    end
+    
+    cup.to_pretty.should == <<END
+<div>
+  <p>fine china</p>
+  <div>
+    <p>oolong</p>
+  </div>
+</div>
+END
+  end
+  
   it "can turn off newlines" do
     Erector::Widget.new() do
       text "One"
       p "Two"
-    end.enable_prettyprint(false).to_s.should == "One<p>Two</p>"
+    end.to_s.should == "One<p>Two</p>"
   end
   
-  it "cannot turn newlines on and off, because the output is cached" do
+  it "can turn newlines on and off" do
     widget = Erector::Widget.new() do
       text "One"
       p "Two"
-    end.enable_prettyprint(false)
-    widget.to_s.should == "One<p>Two</p>"
-    widget.enable_prettyprint(true)
+    end
     widget.to_s.should == "One<p>Two</p>"
-    widget.enable_prettyprint(false)
+    widget.to_pretty.should == "One\n<p>Two</p>\n"
     widget.to_s.should == "One<p>Two</p>"
   end
   
@@ -114,14 +136,7 @@ END
     widget = Erector::Widget.new() do
       text "One"
       p "Two"
-    end.enable_prettyprint(false).to_pretty.should == "One\n<p>Two</p>\n"
-  end
-  
-  it "to_pretty will leave newlines on if they already were" do
-    widget = Erector::Widget.new() do
-      text "One"
-      p "Two"
-    end.enable_prettyprint(true).to_pretty.should == "One\n<p>Two</p>\n"
+    end.to_pretty.should == "One\n<p>Two</p>\n"
   end
   
   it "can turn newlines on/off via global variable" do

data/spec/erector/widget_spec.rb

@@ -11,42 +11,42 @@ module WidgetSpec
 
     describe "#to_s" do
       class << self
-        define_method("invokes #render and returns the string representation of the rendered widget") do
-          it "invokes #render and returns the string representation of the rendered widget" do
+        define_method("invokes #content and returns the string representation of the rendered widget") do
+          it "invokes #content and returns the string representation of the rendered widget" do
             widget = Erector::Widget.new do
               div "Hello"
             end
-            mock.proxy(widget).render
+            mock.proxy(widget).content
             widget.to_s.should == "<div>Hello</div>"
           end
         end
       end
 
       context "when passed no arguments" do
-        send "invokes #render and returns the string representation of the rendered widget"
+        send "invokes #content and returns the string representation of the rendered widget"
       end
 
-      context "when passed an argument that is #render" do
-        send "invokes #render and returns the string representation of the rendered widget"
+      context "when passed an argument that is #content" do
+        send "invokes #content and returns the string representation of the rendered widget"
       end
 
-      context "when passed an argument that is not #render" do
+      context "when passed an argument that is not #content" do
         attr_reader :widget
         before do
           @widget = Erector::Widget.new
-          def widget.alternate_render
-            div "Hello from Alternate Render"
+          def widget.alternate_content
+            div "Hello from Alternate Write"
           end
-          mock.proxy(widget).alternate_render
+          mock.proxy(widget).alternate_content
         end
 
         it "invokes the passed in method name and returns the string representation of the rendered widget" do
-          widget.to_s(:alternate_render).should == "<div>Hello from Alternate Render</div>"
+          widget.to_s(:content_method_name => :alternate_content).should == "<div>Hello from Alternate Write</div>"
         end
 
-        it "does not invoke #render" do
-          dont_allow(widget).render
-          widget.to_s(:alternate_render)
+        it "does not invoke #content" do
+          dont_allow(widget).content
+          widget.to_s(:content_method_name => :alternate_content)
         end
       end
     end
@@ -60,18 +60,76 @@ module WidgetSpec
       end
     end
 
+    describe '#widget' do
+      context "basic nesting" do
+        before do
+          class Parent < Erector::Widget
+            def content
+              text 1
+              widget Child do
+                text 2
+                third
+              end
+            end
+
+            def third
+              text 3
+            end
+          end
+
+          class Child < Erector::Widget
+            def content
+              super
+            end
+          end
+        end
+
+        it "renders nested widgets in the correct order" do
+          Parent.new.to_s.should == '123'
+        end
+      end
+      
+    end
+
     describe "#widget" do
+      class Orphan < Erector::Widget
+        def content
+          p @name
+        end
+      end
+      
+      context "when passed a class" do
+        it "renders it" do
+          Erector::Widget.new do
+            div do
+              widget Orphan, :name => "Annie"
+            end
+          end.to_s.should == "<div><p>Annie</p></div>"
+        end
+      end
+      
+      context "when passed an instance" do
+        it "renders it" do
+          Erector::Widget.new do
+            div do
+              widget Orphan.new(:name => "Oliver")
+            end
+          end.to_s.should == "<div><p>Oliver</p></div>"
+        end
+      end
+
       context "when nested" do
         it "renders the tag around the rest of the block" do
           parent_widget = Class.new(Erector::Widget) do
-            def render
+            def content
               div :id => "parent_widget" do
                 super
               end
             end
           end
+          
           child_widget = Class.new(Erector::Widget) do
-            def render
+            def content
               div :id => "child_widget" do
                 super
               end
@@ -79,7 +137,8 @@ module WidgetSpec
           end
 
           widget = Class.new(Erector::Widget) do
-            def render
+            needs :parent_widget, :child_widget
+            def content
               widget(parent_widget) do
                 widget(child_widget) do
                   super
@@ -88,7 +147,7 @@ module WidgetSpec
             end
           end
 
-          widget.new(nil, :parent_widget => parent_widget, :child_widget => child_widget) do
+          widget.new(:parent_widget => parent_widget, :child_widget => child_widget) do
             div :id => "widget"
           end.to_s.should == '<div id="parent_widget"><div id="child_widget"><div id="widget"></div></div></div>'
         end
@@ -583,65 +642,23 @@ module WidgetSpec
       end
     end
 
-    describe '#widget' do
-      before do
-        class Parent < Erector::Widget
-          def render
-            text 1
-            widget Child do
-              text 2
-              third
-            end
-          end
-
-          def third
-            text 3
-          end
-        end
-
-        class Child < Erector::Widget
-          def render
-            super
-          end
-        end
-      end
-
-      it "renders nested widgets in the correct order" do
-        Parent.new.to_s.should == '123'
-      end
-    end
-
-    describe '#render_to' do
+    describe '#write_via' do
       class A < Erector::Widget
-        def render
+        def content
           p "A"
         end
       end
 
-      it "renders to a doc" do
-        class B < Erector::Widget
-          def render
-            text "B"
-            A.new.render_to(@output)
-            text "B"
-          end
-        end
-        b = B.new
-        b.to_s.should == "B<p>A</p>B"
-        b.output.size.should == 10  # B, <p>, A, </p>, B
-      end
-
       it "renders to a widget's doc" do
         class B < Erector::Widget
-          def render
+          def content
             text "B"
-            A.new.render_to(self)
+            A.new.write_via(self)
             text "B"
           end
         end
         b = B.new
         b.to_s.should == "B<p>A</p>B"
-        b.output.size.should == 10  # B, <p>, A, </p>, B
       end
 
       it "passing a widget to text method renders it" do
@@ -653,5 +670,121 @@ module WidgetSpec
       end
 
     end
+    
+    describe "when declaring parameters with the 'needs' macro" do
+      it "doesn't complain if there aren't any needs declared" do
+        class Thing1 < Erector::Widget
+        end
+        Thing1.new
+      end
+      
+      it "allows you to say that you don't want any parameters" do
+        class Thing2 < Erector::Widget
+          needs nil
+        end
+        lambda { Thing2.new }.should_not raise_error
+        lambda { Thing2.new(:foo => 1) }.should raise_error
+      end
+            
+      it "doesn't complain if you pass it a declared parameter" do
+        class Thing2b < Erector::Widget
+          needs :foo
+        end
+        lambda { Thing2b.new(:foo => 1) }.should_not raise_error
+      end
+      
+      it "complains if you pass it an undeclared parameter" do
+        class Thing3 < Erector::Widget
+          needs :foo
+        end
+        lambda { Thing3.new(:bar => 1) }.should raise_error
+      end
+      
+      it "allows multiple declared parameters" do
+        class Thing4 < Erector::Widget
+          needs :foo, :bar
+        end
+        lambda { Thing4.new(:foo => 1, :bar => 2) }.should_not raise_error
+      end
+      
+      it "complains when passing in an extra parameter after declaring many parameters" do
+        class Thing5 < Erector::Widget
+          needs :foo, :bar
+        end
+        lambda { Thing5.new(:foo => 1, :bar => 2, :baz => 3) }.should raise_error
+      end
+      
+      it "complains when you forget to pass in a needed parameter" do
+        class Thing6 < Erector::Widget
+          needs :foo, :bar
+        end
+        lambda { Thing6.new(:foo => 1) }.should raise_error
+      end
+      
+      it "doesn't complain if you omit a parameter with a default value" do
+        class Thing7 < Erector::Widget
+          needs :foo
+          needs :bar => 7
+          needs :baz => 8
+        end
+        lambda { 
+          thing = Thing7.new(:foo => 1, :baz => 3) 
+          thing.bar.should equal(7)
+          thing.baz.should equal(3)
+        }.should_not raise_error
+      end
+      
+      it "allows multiple values on a line, including default values at the end of the line" do
+        class Thing8 < Erector::Widget
+          needs :foo, :bar => 7, :baz => 8
+        end
+        lambda { 
+          thing = Thing8.new(:foo => 1, :baz => 2)
+          thing.foo.should equal(1)
+          thing.bar.should equal(7)
+          thing.baz.should equal(2)
+        }.should_not raise_error
+      end
+      
+      it "allows nil to be a default value" do
+        class Thing9 < Erector::Widget
+          needs :foo => nil
+        end
+        lambda {
+          thing = Thing9.new
+          thing.foo.should be_nil
+        }.should_not raise_error
+      end
+      
+      it "accumulates needs across the inheritance chain" do
+        class Vehicle < Erector::Widget
+          needs :wheels
+        end
+        
+        class Car < Vehicle
+          needs :engine
+        end
+        
+        lambda { Car.new(:engine => 'V-8', :wheels => 4) }.should_not raise_error
+        lambda { Car.new(:engine => 'V-8') }.should raise_error
+        lambda { Car.new(:wheels => 4) }.should raise_error
+      end
+      
+      it "defines accessors for each of the needed variables" do
+        class NeedfulThing < Erector::Widget
+          needs :love
+        end
+        thing = NeedfulThing.new(:love => "all we need")
+        thing.love.should == "all we need"
+      end
+      
+      it "doesnt define accessors for non-needed variables" do
+        class NeedlessThing < Erector::Widget
+        end
+        thing = NeedlessThing.new(:love => "all we need")
+        lambda {thing.love}.should raise_error
+      end
+      
+    end
   end
 end