merb-helpers 0.9.8

data/lib/merb-helpers/date_time_formatting.rb

@@ -0,0 +1,127 @@
+module DateAndTimeFormatting
+  
+  def self.included(base)
+    base.class_eval do
+      include DateAndTimeFormatting::InstanceMethods
+      include OrdinalizedFormatting
+      extend DateAndTimeFormatting::ClassMethods
+    end
+  end
+  
+  module InstanceMethods
+    
+    
+    # Format a date/time instance using a defined format
+    #
+    # ==== Parameters
+    # format<Symbol>:: of the format key from Date.date_formats
+    #
+    # ==== Returns
+    # String:: formattred string
+    # 
+    #--
+    # @public
+    def formatted(format = :default)
+      self.strftime(Date.formats[format])
+    end
+  
+  end
+  
+  module ClassMethods
+    
+    @@formats = {
+      :db             => "%Y-%m-%d %H:%M:%S", 
+      :time           => "%H:%M", # 21:12
+      :date           => "%Y-%m-%d", # 2008-12-04
+      :short          => "%d %b %H:%M", # 01 Sep 21:12
+      :long           => "%B %d, %Y %H:%M",
+      :rfc822         => "%a, %d %b %Y %H:%M:%S %z"
+    }
+    
+    # Lists the date and time formats
+    #
+    # ==== Returns
+    # Hash:: a hash with all formats available
+    # --
+    # @public
+    def formats
+      @@formats
+    end
+    
+    # Adds a date and time format
+    #
+    # ==== Parameters
+    # key<Symbol>:: name of the format
+    # format<Hash>:: time format to use
+    #
+    # ==== Returns
+    # Hash:: a hash with all formats available
+    # --
+    # @public
+    def add_format(key, format)
+      formats.merge!({key => format})
+    end
+    
+    
+    # Resets the date and time formats
+    # --
+    # @private
+    def reset_formats
+      original_formats = [:db, :time, :short, :date, :long, :long_ordinal, :rfc822]
+      formats = @@formats.delete_if{|format, v| !original_formats.include?(format)}
+    end
+
+  end
+  
+end
+
+module Ordinalize
+  # Ordinalize turns a number into an ordinal string used to denote the
+  # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  # Examples
+  #   1.ordinalize     # => "1st"
+  #   2.ordinalize     # => "2nd"
+  #   1002.ordinalize  # => "1002nd"
+  #   1003.ordinalize  # => "1003rd"
+  def ordinalize
+    if (11..13).include?(self % 100)
+      "#{self}th"
+    else
+      case self % 10
+        when 1; "#{self}st"
+        when 2; "#{self}nd"
+        when 3; "#{self}rd"
+        else    "#{self}th"
+      end
+    end
+  end
+end
+
+Integer.send :include, Ordinalize
+
+# Time.now.to_ordinalized_s :long
+# => "February 28th, 2006 21:10"
+module OrdinalizedFormatting
+  
+  def to_ordinalized_s(format = :default)
+    format = Date.formats[format] 
+    return self.to_s if format.nil?
+    strftime_ordinalized(format)
+  end
+
+  # Gives you a relative date in an attractive format
+  #
+  # ==== Parameters
+  # format<String>:: strftime string used to formatt a time/date object
+  # locale<String, Symbol>:: An optional value which can be used by localization plugins
+  #
+  # ==== Returns
+  # String:: Ordinalized time/date object
+  #
+  # ==== Examples
+  #    5.days.ago.strftime_ordinalized('%b %d, %Y')     # => 
+  def strftime_ordinalized(fmt, format=nil)
+    strftime(fmt.gsub(/(^|[^-])%d/, '\1_%d_')).gsub(/_(\d+)_/) { |s| s.to_i.ordinalize }
+  end
+end

data/lib/merb-helpers/date_time_helpers.rb

@@ -0,0 +1,190 @@
+module Merb
+  module Helpers
+    # Provides a number of methods for displaying and dealing with dates and times
+    #
+    # Parts were strongly based on http://ar-code.svn.engineyard.com/plugins/relative_time_helpers/, and
+    # active_support
+    #
+    # The key methods are `relative_date`, `relative_date_span`, and `relative_time_span`.  This also gives
+    # you the Rails style Time DSL for working with numbers eg. 3.months.ago or 5.days.until(1.year.from_now)
+    module DateAndTime
+      @@time_class = Time
+      @@time_output = {
+        :today          => 'today',
+        :yesterday      => 'yesterday',
+        :tomorrow       => 'tomorrow',
+        :initial_format => '%b %d',
+        :year_format    => ', %Y'
+      }
+      
+      def self.time_class
+        @@time_class
+      end
+      
+      # ==== Parameters
+      # format<Symbol>:: time format to use
+      # locale<String, Symbol>:: An optional value which can be used by localization plugins
+      #
+      # ==== Returns
+      # String:: a string used to format time using #strftime
+      def self.time_output(format, locale=nil)
+        @@time_output[format]
+      end
+      
+      # Gives you a relative date in an attractive format
+      #
+      # ==== Parameters
+      # time<~to_date>:: The Date or Time to test
+      # locale<String, Symbol>:: An optional value which can be used by localization plugins
+      #
+      # ==== Returns
+      # String:: Relative date
+      #
+      # ==== Examples
+      #   relative_date(Time.now.utc) => "today"
+      #   relative_date(5.days.ago) => "March 5th"
+      #   relative_date(1.year.ago) => "March 10th, 2007"
+      def relative_date(time, locale=nil)
+        date  = time.to_date
+        today = DateAndTime.time_class.now.to_date
+        if date == today
+          DateAndTime.time_output(:today, locale)
+        elsif date == (today - 1)
+          DateAndTime.time_output(:yesterday, locale)
+        elsif date == (today + 1)
+          DateAndTime.time_output(:tomorrow, locale)
+        else
+          fmt  = DateAndTime.time_output(:initial_format, locale).dup
+          fmt << DateAndTime.time_output(:year_format, locale) unless date.year == today.year
+          time.strftime_ordinalized(fmt, locale)
+        end
+      end
+      
+      # Gives you a relative date span in an attractive format
+      #
+      # ==== Parameters
+      # times<~first,~last>:: The Dates or Times to test
+      #
+      # ==== Returns
+      # String:: The sexy relative date span
+      #
+      # ==== Examples
+      #   relative_date([1.second.ago, 10.seconds.ago]) => "March 10th"
+      #   relative_date([1.year.ago, 1.year.ago) => "March 10th, 2007"
+      #   relative_date([Time.now, 1.day.from_now]) => "March 10th - 11th"
+      #   relative_date([Time.now, 1.year.ago]) => "March 10th, 2007 - March 10th, 2008"
+      def relative_date_span(times)
+        times = [times.first, times.last].collect! { |t| t.to_date }
+        times.sort!
+        if times.first == times.last
+          relative_date(times.first)
+        else
+          first = times.first; last = times.last; now = DateAndTime.time_class.now
+          arr = [first.strftime_ordinalized('%b %d')]
+          arr << ", #{first.year}" unless first.year == last.year
+          arr << ' - '
+          arr << last.strftime('%b') << ' ' unless first.year == last.year && first.month == last.month
+          arr << last.day.ordinalize
+          arr << ", #{last.year}" unless first.year == last.year && last.year == now.year
+          arr.to_s
+        end
+      end
+      
+      # Gives you a relative date span in an attractive format
+      #
+      # ==== Parameters
+      # times<~first,~last>:: The Dates or Times to test
+      #
+      # ==== Returns
+      # String:: The sexy relative time span
+      #
+      # ==== Examples
+      #   relative_time_span([1.second.ago, 10.seconds.ago]) => "12:00 - 12:09 AM March 10th"
+      #   relative_time_span([1.year.ago, 1.year.ago) => "12:09 AM March 10th, 2007"
+      #   relative_time_span([Time.now, 13.hours.from_now]) => "12:09 AM - 1:09 PM March 10th"
+      #   relative_time_span([Time.now, 1.year.ago]) => "12:09 AM March 10th, 2007 - 12:09 AM March 10th, 2008"
+      def relative_time_span(times)
+        times = [times.first, times.last].collect! { |t| t.to_time }
+        times.sort!
+        if times.first == times.last
+          "#{prettier_time(times.first)} #{relative_date(times.first)}"
+        elsif times.first.to_date == times.last.to_date
+            same_half = (times.first.hour/12 == times.last.hour/12)
+            "#{prettier_time(times.first, !same_half)} - #{prettier_time(times.last)} #{relative_date(times.first)}"
+      
+        else
+          first = times.first; last = times.last; now = DateAndTime.time_class.now        
+          arr = [prettier_time(first)]
+          arr << ' '
+          arr << first.strftime_ordinalized('%b %d')
+          arr << ", #{first.year}" unless first.year == last.year
+          arr << ' - '
+          arr << prettier_time(last)
+          arr << ' '
+          arr << last.strftime('%b') << ' ' unless first.year == last.year && first.month == last.month
+          arr << last.day.ordinalize
+          arr << ", #{last.year}" unless first.year == last.year && last.year == now.year
+          arr.to_s
+        end
+      end
+      
+      # Condenses time... very similar to time_ago_in_words in ActionPack
+      #
+      # ==== Parameters
+      # from_time<~to_time>:: The Date or Time to start from
+      # to_time<~to_time>:: The Date or Time to go to, Defaults to Time.now.utc
+      # include_seconds<Boolean>:: Count the seconds initially, Defaults to false
+      # locale<String, Symbol>:: An optional value which can be used by localization plugins
+      #
+      # ==== Returns
+      # String:: The time distance
+      #
+      # ==== Examples
+      # time_lost_in_words(3.minutes.from_now)           # => 3 minutes
+      # time_lost_in_words(Time.now - 15.hours)          # => 15 hours
+      # time_lost_in_words(Time.now, 3.minutes.from_now) # => 3 minutes
+      # time_lost_in_words(Time.now)                     # => less than a minute
+      # time_lost_in_words(Time.now, Time.now, true)     # => less than 5 seconds
+      #
+      def time_lost_in_words(from_time, to_time = Time.now.utc, include_seconds = false, locale=nil)
+        from_time = from_time.to_time if from_time.respond_to?(:to_time)
+        to_time = to_time.to_time if to_time.respond_to?(:to_time)
+        distance_in_minutes = (((to_time - from_time).abs)/60).round
+        distance_in_seconds = ((to_time - from_time).abs).round
+      
+        case distance_in_minutes
+          when 0..1
+            return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
+            case distance_in_seconds
+              when 0..4   then 'less than 5 seconds'
+              when 5..9   then 'less than 10 seconds'
+              when 10..19 then 'less than 20 seconds'
+              when 20..39 then 'half a minute'
+              when 40..59 then 'less than a minute'
+              else             '1 minute'
+            end
+      
+          when 2..44           then "#{distance_in_minutes} minutes"
+          when 45..89          then 'about 1 hour'
+          when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
+          when 1440..2879      then '1 day'
+          when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
+          when 43200..86399    then 'about 1 month'
+          when 86400..525599   then "#{(distance_in_minutes / 43200).round} months"
+          when 525600..1051199 then 'about 1 year'
+          else                      "over #{(distance_in_minutes / 525600).round} years"
+        end
+      end
+      alias :time_ago_in_words :time_lost_in_words
+      
+      def prettier_time(time, ampm=true, locale=nil)
+        time.strftime("%I:%M#{" %p" if ampm}").sub(/^0/, '')
+      end
+    end
+  end
+end
+
+class Merb::Controller 
+  include Merb::Helpers::DateAndTime
+end
+

data/lib/merb-helpers/form/builder.rb

@@ -0,0 +1,410 @@
+load File.dirname(__FILE__) / ".." / "tag_helpers.rb"
+
+module Merb::Helpers::Form::Builder
+
+  class Base
+    include Merb::Helpers::Tag
+
+    def initialize(obj, name, origin)
+      @obj, @origin = obj, origin
+      @name = name || @obj.class.name.snake_case.split("/").last
+    end
+
+    def concat(attrs, &blk)
+      @origin.concat(@origin.capture(&blk), blk.binding)
+    end
+
+    def form(attrs = {}, &blk)
+      captured = @origin.capture(&blk)
+      fake_method_tag = process_form_attrs(attrs)
+      tag(:form, fake_method_tag + captured, attrs)
+    end
+
+    def fieldset(attrs, &blk)
+      legend = (l_attr = attrs.delete(:legend)) ? tag(:legend, l_attr) : ""
+      tag(:fieldset, legend + @origin.capture(&blk), attrs)
+      # @origin.concat(contents, blk.binding)
+    end
+
+    %w(text password hidden file).each do |kind|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def bound_#{kind}_field(method, attrs = {})
+          name = control_name(method)
+          update_bound_controls(method, attrs, "#{kind}")
+          unbound_#{kind}_field({:name => name, :value => @obj.send(method)}.merge(attrs))
+        end
+
+        def unbound_#{kind}_field(attrs)
+          update_unbound_controls(attrs, "#{kind}")
+          self_closing_tag(:input, {:type => "#{kind}"}.merge(attrs))
+        end
+      RUBY
+    end
+
+    def bound_check_box(method, attrs = {})
+      name = control_name(method)
+      update_bound_controls(method, attrs, "checkbox")
+      unbound_check_box({:name => name}.merge(attrs))
+    end
+
+    def unbound_check_box(attrs)
+      update_unbound_controls(attrs, "checkbox")
+      if attrs.delete(:boolean)
+        on, off = attrs.delete(:on), attrs.delete(:off)
+        unbound_hidden_field(:name => attrs[:name], :value => off) <<
+          self_closing_tag(:input, {:type => "checkbox", :value => on}.merge(attrs))
+      else
+        self_closing_tag(:input, {:type => "checkbox"}.merge(attrs))
+      end
+    end
+
+    def bound_radio_button(method, attrs = {})
+      name = control_name(method)
+      update_bound_controls(method, attrs, "radio")
+      unbound_radio_button({:name => name, :value => @obj.send(method)}.merge(attrs))
+    end
+
+    def unbound_radio_button(attrs)
+      update_unbound_controls(attrs, "radio")
+      self_closing_tag(:input, {:type => "radio"}.merge(attrs))
+    end
+
+    def bound_radio_group(method, arr)
+      val = @obj.send(method)
+      arr.map do |attrs|
+        attrs = {:value => attrs} unless attrs.is_a?(Hash)
+        attrs[:checked] ||= (val == attrs[:value])
+        radio_group_item(method, attrs)
+      end.join
+    end
+
+    def unbound_radio_group(arr, attrs = {})
+      arr.map do |ind_attrs|
+        ind_attrs = {:value => ind_attrs} unless ind_attrs.is_a?(Hash)
+        joined = attrs.merge(ind_attrs)
+        joined.merge!(:label => joined[:label] || joined[:value])
+        unbound_radio_button(joined)
+      end.join
+    end
+
+    def bound_select(method, attrs = {})
+      name = control_name(method)
+      update_bound_controls(method, attrs, "select")
+      unbound_select({:name => name}.merge(attrs))
+    end
+
+    def unbound_select(attrs = {})
+      update_unbound_controls(attrs, "select")
+      attrs[:name] << "[]" if attrs[:multiple] && !(attrs[:name] =~ /\[\]$/)
+      tag(:select, options_for(attrs), attrs)
+    end
+
+    def bound_text_area(method, attrs = {})
+      name = "#{@name}[#{method}]"
+      update_bound_controls(method, attrs, "text_area")
+      unbound_text_area(@obj.send(method), {:name => name}.merge(attrs))
+    end
+
+    def unbound_text_area(contents, attrs)
+      update_unbound_controls(attrs, "text_area")
+      tag(:textarea, contents, attrs)
+    end
+
+    def button(contents, attrs)
+      update_unbound_controls(attrs, "button")
+      tag(:button, contents, attrs)
+    end
+
+    def submit(value, attrs)
+      attrs[:type]  ||= "submit"
+      attrs[:name]  ||= "submit"
+      attrs[:value] ||= value
+      update_unbound_controls(attrs, "submit")
+      self_closing_tag(:input, attrs)
+    end
+
+    private
+
+    def process_form_attrs(attrs)
+      method = attrs[:method]
+
+      # Unless the method is :get, fake out the method using :post
+      attrs[:method] = :post unless attrs[:method] == :get
+      # Use a fake PUT if the object is not new, otherwise use the method
+      # passed in. Defaults to :post if no method is set.
+      method ||= (@obj.respond_to?(:new_record?) && !@obj.new_record?) || (@obj.respond_to?(:new?) && !@obj.new?) ? :put : :post
+
+      attrs[:enctype] = "multipart/form-data" if attrs.delete(:multipart) || @multipart
+
+      method == :post || method == :get ? "" : fake_out_method(attrs, method)
+    end
+
+    # This can be overridden to use another method to fake out methods
+    def fake_out_method(attrs, method)
+      self_closing_tag(:input, :type => "hidden", :name => "_method", :value => method)
+    end
+
+    def update_bound_controls(method, attrs, type)
+      case type
+      when "checkbox"
+        update_bound_check_box(method, attrs)
+      when "select"
+        update_bound_select(method, attrs)
+      end
+    end
+
+    def update_bound_check_box(method, attrs)
+      raise ArgumentError, ":value can't be used with a bound_check_box" if attrs.has_key?(:value)
+
+      attrs[:boolean] = attrs.fetch(:boolean, true)
+
+      val = @obj.send(method)
+      attrs[:checked] = attrs.key?(:on) ? val == attrs[:on] : considered_true?(val)
+    end
+
+    def update_bound_select(method, attrs)
+      attrs[:value_method] ||= method
+      attrs[:text_method] ||= attrs[:value_method] || :to_s
+      attrs[:selected] ||= @obj.send(attrs[:value_method])
+    end
+
+    def update_unbound_controls(attrs, type)
+      case type
+      when "checkbox"
+        update_unbound_check_box(attrs)
+      when "file"
+        @multipart = true
+      end
+
+      attrs[:disabled] ? attrs[:disabled] = "disabled" : attrs.delete(:disabled)
+    end
+
+    def update_unbound_check_box(attrs)
+      boolean = attrs[:boolean] || (attrs[:on] && attrs[:off]) ? true : false
+
+      case
+      when attrs.key?(:on) ^ attrs.key?(:off)
+        raise ArgumentError, ":on and :off must be specified together"
+      when (attrs[:boolean] == false) && (attrs.key?(:on))
+        raise ArgumentError, ":boolean => false cannot be used with :on and :off"
+      when boolean && attrs.key?(:value)
+        raise ArgumentError, ":value can't be used with a boolean checkbox"
+      end
+
+      if attrs[:boolean] = boolean
+        attrs[:on] ||= "1"; attrs[:off] ||= "0"
+      end
+
+      attrs[:checked] = "checked" if attrs.delete(:checked)
+    end
+
+    # Accepts a collection (hash, array, enumerable, your type) and returns a string of option tags. 
+    # Given a collection where the elements respond to first and last (such as a two-element array), 
+    # the "lasts" serve as option values and the "firsts" as option text. Hashes are turned into
+    # this form automatically, so the keys become "firsts" and values become lasts. If selected is
+    # specified, the matching "last" or element will get the selected option-tag. Selected may also
+    # be an array of values to be selected when using a multiple select.
+    #
+    # ==== Parameters
+    # attrs<Hash>:: HTML attributes and options
+    #
+    # ==== Options
+    # +selected+:: The value of a selected object, which may be either a string or an array.
+    # +prompt+:: Adds an addtional option tag with the provided string with no value.
+    # +include_blank+:: Adds an additional blank option tag with no value.
+    #
+    # ==== Returns
+    # String:: HTML
+    #
+    # ==== Examples
+    #   <%= options_for [["apple", "Apple Pie"], ["orange", "Orange Juice"]], :selected => "orange"
+    #   => <option value="apple">Apple Pie</option><option value="orange" selected="selected">Orange Juice</option>
+    #
+    #   <%= options_for [["apple", "Apple Pie"], ["orange", "Orange Juice"]], :selected => ["orange", "apple"], :prompt => "Select One"
+    #   => <option value="">Select One</option><option value="apple" selected="selected">Apple Pie</option><option value="orange" selected="selected">Orange Juice</option>
+    def options_for(attrs)
+      blank, prompt = attrs.delete(:include_blank), attrs.delete(:prompt)
+      b = blank || prompt ? tag(:option, prompt || "", :value => "") : ""
+
+      # yank out the options attrs
+      collection, selected, text_method, value_method = 
+        attrs.extract!(:collection, :selected, :text_method, :value_method)
+
+      # if the collection is a Hash, optgroups are a-coming
+      if collection.is_a?(Hash)
+        ([b] + collection.map do |g,col|
+          tag(:optgroup, options(col, text_method, value_method, selected), :label => g)
+        end).join
+      else
+        options(collection || [], text_method, value_method, selected, b)
+      end
+    end
+
+    def options(col, text_meth, value_meth, sel, b = nil)
+      ([b] + col.map do |item|
+        text_meth = text_meth && item.respond_to?(text_meth) ? text_meth : :last
+        value_meth = value_meth && item.respond_to?(value_meth) ? value_meth : :first
+        
+        text = item.is_a?(String) ? item : item.send(text_meth)
+        value = item.is_a?(String) ? item : item.send(value_meth)
+
+        option_attrs = {:value => value}
+        if sel.is_a?(Array)
+          option_attrs.merge!(:selected => "selected") if value.in? sel
+        else
+          option_attrs.merge!(:selected => "selected") if value == sel
+        end
+        tag(:option, text, option_attrs)
+      end).join
+    end
+
+    def radio_group_item(method, attrs)
+      attrs.merge!(:checked => "checked") if attrs[:checked]
+      bound_radio_button(method, attrs)
+    end
+
+    def considered_true?(value)
+      value && value != "0" && value != 0
+    end
+
+    def control_name(method)
+      "#{@name}[#{method}]"
+    end
+
+    def add_css_class(attrs, new_class)
+      attrs[:class] = attrs[:class] ? "#{attrs[:class]} #{new_class}" : new_class
+    end
+  end
+
+  class Form < Base
+    def label(contents, attrs = {})
+      if contents.is_a?(Hash)
+        attrs    = contents
+        contents = attrs.delete(:label)
+      end
+      if contents
+        for_attr = attrs[:id] ? {:for => attrs[:id]} : {}
+        if contents.is_a?(Hash)
+          attrs = contents
+          contents = attrs.delete(:title)
+          for_attr = for_attr.merge(attrs)
+        end
+        tag(:label, contents, for_attr)
+      else
+        ""
+      end
+    end
+
+    %w(text password file).each do |kind|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def unbound_#{kind}_field(attrs = {})
+          label(attrs) + super
+        end
+      RUBY
+    end
+
+    def unbound_check_box(attrs = {})
+      label_text = label(attrs)
+      super + label_text
+    end
+
+    def unbound_hidden_field(attrs = {})
+      attrs.delete(:label)
+      super
+    end
+
+    def unbound_radio_button(attrs = {})
+      label_text = label(attrs)
+      super + label_text
+    end
+
+    def unbound_select(attrs = {})
+      label(attrs) + super
+    end
+
+    def unbound_text_area(contents, attrs = {})
+      label(attrs) + super
+    end
+
+    def button(contents, attrs = {})
+      label(attrs) + super
+    end
+
+    def submit(value, attrs = {})
+      label(attrs) + super
+    end
+
+    private
+
+    def update_bound_controls(method, attrs, type)
+      attrs.merge!(:id => "#{@name}_#{method}") unless attrs[:id]
+      super
+    end
+
+    def update_unbound_controls(attrs, type)
+      case type
+      when "text", "radio", "password", "hidden", "checkbox", "file"
+        add_css_class(attrs, type)
+      end
+      super
+    end
+
+    def radio_group_item(method, attrs)
+      unless attrs[:id]
+        attrs.merge!(:id => "#{@name}_#{method}_#{attrs[:value]}")
+      end
+
+      attrs.merge!(:label => attrs[:label] || attrs[:value])
+      super
+    end
+  end
+
+  module Errorifier
+    def error_messages_for(obj, error_class, build_li, header, before)
+      obj ||= @obj
+      return "" unless obj.respond_to?(:errors)
+
+      sequel = !obj.errors.respond_to?(:each)
+      errors = sequel ? obj.errors.full_messages : obj.errors
+
+      return "" if errors.empty?
+
+      header_message = header % [errors.size, errors.size == 1 ? "" : "s"]
+      markup = %Q{<div class='#{error_class}'>#{header_message}<ul>}
+      errors.each {|err| markup << (build_li % (sequel ? err : err.join(" ")))}
+      markup << %Q{</ul></div>}
+    end
+
+    private
+
+    def update_bound_controls(method, attrs, type)
+      if @obj.errors.on(method.to_sym)
+        add_css_class(attrs, "error")
+      end
+      super
+    end
+  end
+
+  class FormWithErrors < Form
+    include Errorifier
+  end
+
+  module Resourceful
+    private
+
+    def process_form_attrs(attrs)
+      attrs[:action] ||= @origin.url(@name, @obj) if @origin
+      super
+    end
+  end
+
+  class ResourcefulForm < Form
+    include Resourceful
+  end
+
+  class ResourcefulFormWithErrors < FormWithErrors
+    include Errorifier
+    include Resourceful
+  end
+
+end