merb_helpers 0.4.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 YOUR NAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY 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.

data/README

@@ -0,0 +1,4 @@
+merb_helpers
+=================
+
+A plugin for the Merb framework that provides ....

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+PLUGIN = "merb_helpers"
+NAME = "merb_helpers"
+VERSION = "0.4.0"
+AUTHOR = "Yehuda Katz"
+EMAIL = "wycats@gmail.com"
+HOMEPAGE = "http://merb.rubyforge.org/"
+SUMMARY = "Helper support for merb (similar to the Rails form helpers)"
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.requirements << 'merb'
+  s.require_path = 'lib'
+  s.autorequire = PLUGIN
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+end
+
+spec.add_dependency("merb", ">=0.4")
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{NAME}-#{VERSION}}
+end

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/merb_helpers.rb
+Add your Merb rake tasks to lib/merb_helpers/merbtasks.rb

data/lib/form_helpers.rb

@@ -0,0 +1,183 @@
+module Merb
+  module Helpers
+    module Form
+    
+      def error_messages_for(obj, error_li = nil, html_class='submittal_failed')
+        return "" unless obj.errors
+        header_message = block_given? ? yield(obj.errors) : "<h2>Form submittal failed because of #{obj.errors.size} problems</h2>"
+        ret = %Q{
+          <div class='#{html_class}'>
+            #{header_message}
+            <ul>
+        }
+        obj.errors.each {|err| ret << (error_li ? error_li.call(err) : "<li>#{err[0]} #{err[1]}</li>") }
+        ret << %Q{
+            </ul>
+          </div>
+        }
+      end
+      
+      def obj_from_ivar_or_sym(obj)
+        obj.is_a?(Symbol) ? instance_variable_get("@#{obj}") : obj
+      end
+      
+      def tag(tag_name, contents, attrs = {})
+        open_tag(tag_name, attrs) + contents + "</#{tag_name}>"
+      end
+      
+      def form_tag(attrs = {}, &block)
+        attrs.merge!( :enctype => "multipart/form-data" ) if attrs.delete(:multipart)
+        fake_form_method = set_form_method(attrs)
+        concat(open_tag("form", attrs), block.binding)
+        concat(generate_fake_form_method(fake_form_method), block.binding) if fake_form_method
+        concat(capture(&block), block.binding)
+        concat("</form>", block.binding)
+      end
+      
+      def form_for(obj, attrs={}, &block)
+        obj = obj_from_ivar_or_sym(obj)
+        fake_form_method = set_form_method(attrs, obj)
+        concat(open_tag("form", attrs), block.binding)
+        concat(generate_fake_form_method(fake_form_method), block.binding) if fake_form_method
+        fields_for(obj, attrs, &block)
+        concat("</form>", block.binding)
+      end
+      
+      def fields_for(obj, attrs=nil, &block)
+        obj = obj_from_ivar_or_sym(obj)
+        old_obj, @_obj = @_obj, obj
+        @_object_name = "#{@_obj.class}".snake_case
+        old_block, @_block = @_block, block
+        
+        concat(capture(&block), block.binding)
+
+        @_obj, @_block = old_obj, old_block        
+      end
+      
+      def control_name(col)
+        "#{@_object_name}[#{col}]"
+      end
+      
+      def control_value(col)
+        @_obj.send(col)
+      end
+      
+      def control_name_value(col, attrs)
+        {:name => control_name(col), :value => control_value(col)}.merge(attrs)
+      end
+      
+      def text_control(col, attrs = {})
+        errorify_field(attrs, col)
+        text_field(control_name_value(col, attrs))
+      end
+      
+      def text_field(attrs = {})
+        attrs.merge!(:type => "text")
+        optional_label(attrs) { self_closing_tag("input", attrs) }
+      end
+      
+      def checkbox_control(col, attrs = {})
+        errorify_field(attrs, col)
+        val = @_obj.send(col)
+        attrs.merge!(:value => val ? "1" : "0")
+        attrs.merge!(:checked => "checked") if val
+        checkbox_field(control_name_value(col, attrs))
+      end
+      
+      def checkbox_field(attrs = {})
+        attrs.merge!(:type => :checkbox)
+        attrs.add_html_class!("checkbox")
+        optional_label(attrs){self_closing_tag("input", attrs)}
+      end
+      
+      def hidden_control(col, attrs = {})
+        attrs.delete(:label)
+        errorify_field(attrs, col)
+        hidden_field(control_name_value(col, attrs))
+      end
+      
+      def hidden_field(attrs = {})
+        attrs.delete(:label)
+        attrs.merge!(:type => :hidden)
+        self_closing_tag("input", attrs)
+      end
+      
+      def radio_group_control(col, options = {}, attrs = {})
+        errorify_field(attrs, col)
+        val = @_obj.send(col)
+        ret = ""
+        options.each do |opt|
+          hash = {:name => "#{@_object_name}[#{col}]", :value => opt, :label => opt}
+          hash.merge!(:selected => "selected") if val.to_s == opt.to_s
+          ret << radio_field(hash)
+        end
+        ret
+      end
+      
+      def radio_field(attrs = {})
+        attrs.merge!(:type => "radio")
+        attrs.add_html_class!("radio")
+        optional_label(attrs){self_closing_tag("input", attrs)}
+      end
+      
+      def text_area_control(col, attrs = {})
+        attrs ||= {}
+        errorify_field(attrs, col)
+        text_area_field(control_value(col), attrs.merge(:name => control_name(col)))
+      end
+      
+      def text_area_field(val, attrs = {})
+        val ||=""
+        optional_label(attrs) do
+          open_tag("textarea", attrs) +
+          val +
+          "</textarea>"
+        end
+      end
+      
+      def submit_button(contents, attrs = {})
+        attrs.merge!(:type => "submit")
+        tag("button", contents, attrs)
+      end
+
+      def label(name, contents = "", attrs = {})
+        tag("label", name.to_s + contents, attrs)
+      end
+      
+      private
+      # Fake out the browser to send back the method for RESTful stuff.
+      # Fall silently back to post if a method is given that is not supported here
+      def set_form_method(options = {}, obj = nil)
+        options[:method] ||= (!obj || obj.new_record? ? :post : :put)
+        if ![:get,:post].include?(options[:method])
+          fake_form_method = options[:method] if [:put, :delete].include?(options[:method])
+          options[:method] = :post
+        end
+        fake_form_method
+      end
+
+      def generate_fake_form_method(fake_form_method)
+        fake_form_method ? hidden_field(:name => "_method", :value => "#{fake_form_method}") : ""
+      end
+      
+      def optional_label(attrs = {})
+        label = attrs.delete(:label) if attrs
+        if label
+          title = label.is_a?(Hash) ? label.delete(:title) : label
+          label(title, yield, label.is_a?(Hash) ? label : {})
+        else
+          yield
+        end
+      end   
+      
+      def errorify_field(attrs, col)
+        attrs.add_html_class!("error") if !@_obj.valid? && @_obj.errors.on(col)
+      end         
+      
+    end
+  end
+end
+
+class Merb::ViewContext
+  include Merb::Helpers::Form
+end

data/lib/form_model.rb

@@ -0,0 +1,5 @@
+module Merb
+  class FormModel
+  
+  end  
+end

data/lib/merb_helpers.rb

@@ -0,0 +1,12 @@
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+
+  # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
+  Merb::Plugins.config[:merb_helpers] = {
+    :chickens => false
+  }
+  
+  require 'form_model'
+  require 'form_helpers'
+  Merb::Plugins.add_rakefiles "merb_helpers/merbtasks"
+end

data/lib/merb_helpers/merbtasks.rb

@@ -0,0 +1,6 @@
+namespace :merb_helpers do
+  desc "Do something for merb_helpers"
+  task :default do
+    puts "merb_helpers doesn't do anything"
+  end
+end

data/specs/merb_helpers_spec.rb

@@ -0,0 +1,412 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'merb_helpers'
+
+include Merb::ViewContextMixin
+include Merb::ErubisCaptureMixin
+include Merb::Helpers::Form
+
+describe "error_messages_for" do
+  before :each do
+    @obj = Object.new
+    def @obj.errors() [["foo", "bar"], ["baz", "bat"]] end
+  end
+  
+  it "should build default error messages" do
+    errs = error_messages_for(@obj)
+    errs.should include("<h2>Form submittal failed because of 2 problems</h2>")
+    errs.should include("<li>foo bar</li>")
+    errs.should include("<li>baz bat</li>")
+  end
+  
+  it "should accept a custom HTML class" do
+    errs = error_messages_for(@obj, nil, "foo")
+    errs.should include("<div class='foo'>")
+  end
+  
+  it "should accept a custom header block" do
+    errs = error_messages_for(@obj) {|errs| "<h3>Failure: #{errs.size} issues</h3>"}
+    errs.should include("<h3>Failure: 2 issues</h3>")
+  end
+  
+  it "should accept a custom error list item block" do
+    errs = error_messages_for(@obj, proc {|err| "<li>#{err[0]} column: #{err[1]}</li>"})
+    errs.should include("<li>foo column: bar</li>")
+  end
+  
+end
+
+describe "form_tag" do
+  it_should_behave_like "FakeBufferConsumer"
+  
+  it "should use the post method by default" do
+    form_tag do
+      _buffer << "CONTENT"
+    end
+    _buffer.should match_tag(:form, :method => "post")
+    _buffer.should include("CONTENT")
+  end
+  
+  it "should use the get method if set" do
+    form_tag :method => :get do
+      _buffer << "CONTENT"
+    end
+    _buffer.should match_tag(:form, :method => "get")
+    _buffer.should include("CONTENT")        
+  end
+  
+  it "should fake out the put method if set" do
+    form_tag :method => :put do
+      _buffer << "CONTENT"
+    end
+    _buffer.should match_tag(:form, :method => "post")
+    _buffer.should match_tag(:input, :type => "hidden", :name => "_method", :value => "put")    
+  end
+  
+  it "should fake out the delete method if set" do
+    form_tag :method => :delete do
+      _buffer << "CONTENT"
+    end
+    _buffer.should match_tag(:form, :method => "post")
+    _buffer.should match_tag(:input, :type => "hidden", :name => "_method", :value => "delete")
+  end
+  
+  it "should silently set method to post if an unsupported method is used" do
+      form_tag :method => :dodgy do
+        _buffer << "CONTENT"
+      end
+      _buffer.should match_tag(:form, :method => "post")
+      _buffer.should_not match_tag(:input, :type => "hidden", :name => "_method", :value => "dodgy")
+  end
+  
+  it "should take create a form" do
+    form_tag(:action => "foo", :method => :post) do
+      _buffer << "Hello"
+    end
+    _buffer.should match_tag(:form, :action => "foo", :method => "post")
+    _buffer.should include("Hello")
+  end
+  
+  it "should set a form to be mutlipart" do
+    form_tag( :action => "foo", :method => :post, :multipart => true ) do
+      _buffer << "CONTENT"
+    end
+    _buffer.should match_tag( :form, :action => "foo", :method => "post", :enctype => "multipart/form-data")
+    _buffer.should include("CONTENT")  
+  end
+end
+
+describe "form_for" do
+  it_should_behave_like "FakeBufferConsumer"  
+  
+  it "should wrap the contents in a form tag" do
+    form_for(:obj) do
+      _buffer << "Hello"
+    end
+    _buffer.should match_tag(:form, :method => "post")
+    _buffer.should match_tag(:input, :type => "hidden", :value => "put", :name => "_method")    
+  end
+  
+  it "should set the method to post be default" do
+    @obj2 = FakeModel2.new
+    form_for(:obj2) do
+    end
+    _buffer.should match_tag(:form, :method => "post")
+    _buffer.should_not match_tag(:input, :type => "hidden", :name => "_method")
+  end
+  
+  it "should support PUT if the object passed in is not a new_record? via a hidden field" do
+    form_for(:obj) do
+    end
+    _buffer.should match_tag(:form, :method => "post")
+    _buffer.should match_tag(:input, :type => "hidden", :value => "put", :name => "_method")    
+  end
+  
+end
+
+describe "fields_for" do
+  it_should_behave_like "FakeBufferConsumer"
+  
+  it "should dump the contents in the context of the object" do
+    fields_for(:obj) do
+      text_control(:foo).should match_tag(:input, :type => "text", :value => "foowee")
+      _buffer << "Hello"
+    end
+    _buffer.should == "Hello"
+  end  
+
+  it "should be able to modify the context midstream" do
+    @obj2 = FakeModel2.new    
+    form_for(:obj) do
+      text_control(:foo).should match_tag(:input, :type => "text", :value => "foowee")      
+      fields_for(:obj2) do
+        text_control(:foo).should match_tag(:input, :name => "fake_model2[foo]", :type => "text", :value => "foowee2")
+      end
+      text_control(:foo).should match_tag(:input, :type => "text", :value => "foowee")      
+    end
+  end
+  
+  it "should handle an explicit nil attribute" do
+    fields_for(:obj, nil) do
+      _buffer << text_control(:foo)
+    end
+    _buffer.should match_tag(:input, :name => "fake_model[foo]", :value => "foowee", :type => "text")
+  end
+  
+end
+
+describe "text_field (basic)" do
+  it_should_behave_like "FakeBufferConsumer"
+  
+  it "should return a basic text field based on the values passed in" do
+    text_field(:name => "foo", :value => "bar").should match_tag( :input, :type => "text", :name => "foo", :value => "bar")
+  end
+  
+  it "should wrap the field in a label if the :label option is passed to the text_field" do
+    result = text_field(:label => "LABEL" )
+    result.should match(/<label>LABEL<input type="text"\s*\/><\/label>/)
+  end
+end
+
+describe "text_control (data bound)" do
+  it_should_behave_like "FakeBufferConsumer"
+  
+  it "should take a string object and return a useful text control" do
+    f = form_for :obj do
+      text_control(:foo).should match_tag(:input, :type => "text", :name => "fake_model[foo]", :value => "foowee")
+    end
+  end
+
+  it "should take additional attributes and use them" do
+    form_for :obj do
+      text_control(:foo, :bar => "7").should match_tag(:input, :type => "text", :name => "fake_model[foo]", :value => "foowee", :bar => "7")
+    end
+  end
+  
+  it "should wrap the text_control in a label if the :label option is passed in" do
+    form_for :obj do
+      _buffer << text_control(:foo, :label => "LABEL")
+    end
+    _buffer.should match(/<label>LABEL<input/)
+    res = _buffer.scan(/<[^>]*>/)
+    res[2].should_not match_tag(:input, :label => "LABEL")
+  end
+end
+
+describe "checkbox_field (basic)" do
+  it "should return a basic checkbox based on the values passed in" do
+    checkbox_field(:name => "foo", :checked => "checked").should match_tag(:input, :class => "checkbox", :name => "foo", :checked => "checked")
+  end
+  
+  it "should wrap the checkbox_field in a label if the :label option is passed in" do
+    result = checkbox_field(:label => "LABEL" )
+    result.should match(/<label>LABEL<input/)
+    res = result.scan(/<[^>]*>/)
+    res[2].should_not match_tag(:input, :label => "LABEL")
+  end
+end
+
+describe "checkbox_control (data bound)" do
+  it_should_behave_like "FakeBufferConsumer"  
+    
+  it "should take a string and return a useful checkbox control" do
+    form_for :obj do
+      checkbox_control(:baz).should match_tag(:input, :type =>"checkbox", :name => "fake_model[baz]", :class => "checkbox", :value => "1", :checked => "checked")
+      checkbox_control(:bat).should match_tag(:input, :type =>"checkbox", :name => "fake_model[bat]", :class => "checkbox", :value => "0")
+    end
+  end
+  
+  it "should render controls with errors if their attribute contains an error" do
+    form_for :obj do
+      checkbox_control(:bazbad).should match_tag(:input, :type =>"checkbox", :name => "fake_model[bazbad]", 
+        :class => "error checkbox", :value => "1", :checked => "checked")
+      checkbox_control(:batbad).should match_tag(:input, :type =>"checkbox", :name => "fake_model[batbad]", 
+        :class => "error checkbox", :value => "0")        
+    end
+  end  
+  
+  it "should wrap the checkbox_control in a label if the label option is passed in" do
+    form_for :obj do
+      _buffer << checkbox_control(:foo, :label => "LABEL")
+    end
+    _buffer.should match( /<label>LABEL<input/ )
+    res = _buffer.scan(/<[^>]*>/)
+    res[2].should_not match_tag(:input, :label => "LABEL")
+    end
+end
+
+describe "hidden_field (basic)" do
+  
+  it "should return a basic checkbox based on the values passed in" do
+    hidden_field(:name => "foo", :value => "bar").should match_tag(:input, :type => "hidden", :name => "foo", :value => "bar")
+  end
+  
+  it "should not render a label if the :label option is passed in" do
+    res = hidden_field(:label => "LABEL")
+    res.should_not match(/<label>LABEL/)
+    res.should_not match_tag(:input, :label=> "LABEL")  
+  end
+end
+
+describe "hidden_control (data bound)" do
+  it_should_behave_like "FakeBufferConsumer"
+    
+  it "should take a string and return a useful checkbox control" do
+    form_for :obj do 
+      hidden_control(:foo).should match_tag(:input, :type =>"hidden", :name => "fake_model[foo]", :value => "foowee")
+    end
+  end
+  
+  it "should render controls with errors if their attribute contains an error" do
+    form_for :obj do
+      hidden_control(:foobad).should match_tag(:input, :type =>"hidden", :name => "fake_model[foobad]", :value => "foowee", :class => "error")
+    end
+  end
+  
+  it "should not render a label if the :label option is passed in" do
+    form_for :obj do
+      res = hidden_control(:foo, :label => "LABEL")
+      res.should_not match(/<label>LABEL/)
+      res.should_not match_tag(:input, :label=> "LABEL")  
+    end
+  end
+    
+end
+
+describe "radio button (basic)" do
+  it "should should return a basic radio button based on the values passed in" do
+    radio_field(:name => "foo", :value => "bar").should match_tag(:input, :type => "radio", :name => "foo", :value => "bar")
+  end
+  
+  it "should render a label when the label is passed in" do
+    result = radio_field(:name => "foo", :value => "bar", :label => "LABEL")
+    result.should match(/<label>LABEL<input/)
+    res = result.scan(/<[^>]*>/)
+    res[2].should_not match_tag(:input, :label => "LABEL")
+  end
+  
+end
+
+describe "radio button groups (data bound)" do
+  it_should_behave_like "FakeBufferConsumer"
+  
+  it "should return a group of radio buttons" do
+    form_for :obj do
+      radio = radio_group_control(:foo, [:foowee, :baree]).scan(/<[^>]*>/)
+      radio[1].should match_tag(:input, :type => "radio", :name => "fake_model[foo]", :value => "foowee", :selected => "selected")
+      radio[4].should match_tag(:input, :type => "radio", :name => "fake_model[foo]", :value => "baree")
+      radio[2].should not_match_tag(:selected => "selected")
+    end
+  end
+  
+  it "should wrap the each radio button in the group in a label corresponding to the options" do
+    form_for :obj do
+      radio = radio_group_control(:foo, [:foowee, :baree])
+      radio.scan( /<label>(foowee|baree)<input/ ).size.should == 2
+      radio = radio.scan(/<[^>]*>/)
+      radio[1].should_not match_tag(:input, :label => "LABEL")
+      radio[4].should_not match_tag(:input, :label => "LABEL")
+    end
+  end
+end
+
+describe "text area (basic)" do
+  it "should should return a basic text area based on the values passed in" do
+    text_area_field("foo", :name => "foo").should match_tag(:textarea, :name => "foo")
+  end
+  
+  it "should handle a nil content" do
+    text_area_field(nil, :name => "foo").should == "<textarea name=\"foo\"></textarea>"
+  end
+  
+  it "should handle a nil attributes hash" do
+    text_area_field("CONTENT", nil).should == "<textarea>CONTENT</textarea>"
+  end
+  
+  it "should render a label when the label is passed in" do
+    result = text_area_field( "CONTENT", :name => "foo", :value => "bar", :label => "LABEL")
+    result.should match(/<label>LABEL<textarea/)
+    res = result.scan(/<[^>]*>/)
+    res[1].should_not match_tag(:textarea, :label => "LABEL")
+  end
+end
+
+describe "text area (data bound)" do
+  it_should_behave_like "FakeBufferConsumer"
+  
+  it "should return a bound text area" do
+    form_for :obj do
+      ta = text_area_control(:foo)
+      tab = text_area_control(:foobad)
+      ta.should match_tag(:textarea, :name => "fake_model[foo]")
+      tab.should match_tag(:textarea, :name => "fake_model[foobad]", :class => "error")
+      ta.should include("foowee")
+    end
+  end
+  
+  it "should handle a nil content value" do
+    @obj.nothing.should be_nil
+    form_for :obj do
+      text_area_control(:nothing).should match_tag(:textarea, :name => "fake_model[nothing]")
+    end
+  end
+  
+  it "should handle a nil attribute hash" do
+    form_for :obj do
+      text_area_control(:nothing, nil).should match_tag(:textarea, :name => "fake_model[nothing]")
+    end
+  end
+
+  it "should render a label when the label is passed in" do
+    form_for :obj do
+      result = text_area_control( :foo, :label => "LABEL")
+      result.should match(/<label>LABEL<textarea/)
+      res = result.scan(/<[^>]*>/)
+      res[1].should_not match_tag(:textarea, :label => "LABEL")
+    end
+  end
+
+end
+
+describe "form helper supporting methods for controls" do
+  it_should_behave_like "FakeBufferConsumer"
+  
+  it "should give class_name[colname] for control_name" do
+    form_for :obj do
+      text_control( :foo ).should match_tag( :input, :type => "text", :name => "fake_model[foo]")
+    end
+  end
+  
+  it "should provide value=method_value for the control_value method" do
+    form_for :obj do
+      text_control( :foo ).should match_tag( :input, :type => "text", :value => "foowee")
+    end
+  end
+  
+  it "should give name and value for a call to control_name_value" do
+    form_for :obj do
+      control_name_value(:foo, :attribute => "ATTRIBUTE" ).should == {  :name => "fake_model[foo]",
+                                                                        :value => "foowee",
+                                                                        :attribute => "ATTRIBUTE"}
+    end    
+  end
+end
+
+describe "submit_button" do
+  it_should_behave_like "FakeBufferConsumer"
+    
+  it "should produce a simple submit button" do
+    submit_button("Foo").should == "<button type=\"submit\">Foo</button>"
+  end
+end
+
+describe "label helpers" do
+  it_should_behave_like "FakeBufferConsumer"
+  
+  it "should add a label to arbitrary markup in a template" do
+    result = label("Name:", text_field(:name => "name_value"))
+    result.should == "<label>Name:<input type=\"text\" name=\"name_value\"/></label>"
+    
+  end
+    
+end
+

data/specs/spec_helper.rb

@@ -0,0 +1,99 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+require 'rubygems'
+require 'merb'
+# require 'merb/test/rspec'
+
+class FakeModel
+  def self.columns
+    [FakeColumn.new(:foo, :string), 
+     FakeColumn.new(:foobad, :string),       
+     FakeColumn.new(:bar, :integer), 
+     FakeColumn.new(:barbad, :integer),      
+     FakeColumn.new(:baz, :boolean),
+     FakeColumn.new(:bazbad, :boolean),
+     FakeColumn.new(:bat, :boolean),
+     FakeColumn.new(:batbad, :boolean)
+     ]     
+  end
+  
+  def valid?
+    false
+  end
+  
+  def new_record?
+    false
+  end
+  
+  def errors
+    FakeErrors.new(self)
+  end
+  
+  def foo
+    "foowee"
+  end
+  
+  alias_method :foobad, :foo
+  
+  def bar
+    7
+  end
+  alias_method :barbad, :bar
+  
+  def baz
+    true
+  end
+  alias_method :bazbad, :baz
+  
+  def bat
+    false
+  end
+  alias_method :batbad, :bat
+  
+  def nothing
+    nil
+  end
+end
+
+class FakeModel2 < FakeModel
+
+  def foo
+    "foowee2"
+  end
+  alias_method :foobad, :foo
+  
+  def new_record?
+    true
+  end
+  
+end
+
+class FakeErrors
+  
+  def initialize(model)
+    @model = model
+  end
+  
+  def on(name)
+    name.to_s.include?("bad")
+  end
+  
+end
+
+class FakeColumn
+  attr_accessor :name, :type
+  def initialize(name, type)
+    @name, @type = name, type
+  end
+end
+
+
+  
+
+describe "FakeBufferConsumer", :shared => true do
+  
+  before :each do
+    @obj = FakeModel.new
+    def _buffer(buf = "") @buffer ||= "" end    
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: merb_helpers
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+date: 2007-11-05 00:00:00 -08:00
+summary: Helper support for merb (similar to the Rails form helpers)
+require_paths: 
+- lib
+email: wycats@gmail.com
+homepage: http://merb.rubyforge.org/
+rubyforge_project: 
+description: Helper support for merb (similar to the Rails form helpers)
+autorequire: merb_helpers
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Yehuda Katz
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/form_helpers.rb
+- lib/form_model.rb
+- lib/merb_helpers
+- lib/merb_helpers/merbtasks.rb
+- lib/merb_helpers.rb
+- specs/merb_helpers_spec.rb
+- specs/spec_helper.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+executables: []
+
+extensions: []
+
+requirements: 
+- merb
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+    version: