merb_helpers 0.4.0 → 0.5

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
+rubygems_version: 0.9.0
 specification_version: 1
 name: merb_helpers
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
-date: 2007-11-05 00:00:00 -08:00
+  version: "0.5"
+date: 2008-01-09 00:00:00 -08:00
 summary: Helper support for merb (similar to the Rails form helpers)
 require_paths: 
 - lib
@@ -33,13 +33,13 @@ files:
 - 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
+- lib/tasks
+- lib/merb_helpers/date_time_helpers.rb
+- lib/merb_helpers/form_helpers.rb
+- lib/merb_helpers/form_model.rb
+- lib/tasks/merb_tasks.rb
 test_files: []
 
 rdoc_options: []
@@ -52,8 +52,8 @@ executables: []
 
 extensions: []
 
-requirements: 
-- merb
+requirements: []
+
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: merb
@@ -62,5 +62,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0.4"
+        version: "0.5"
     version: 

data/lib/form_helpers.rb

@@ -1,183 +0,0 @@
-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/specs/merb_helpers_spec.rb

@@ -1,412 +0,0 @@
-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
-