rango 0.1.0 → 0.1.1

data/lib/rango/helpers/merb-helpers/date_time_formatting.rb

@@ -1,146 +0,0 @@
-# encoding: utf-8
-
-require "date"
-
-module DateAndTimeFormatting
-  def self.included(base)
-    base.class_eval do
-      include DateAndTimeFormatting::InstanceMethods
-      include OrdinalizedFormatting
-      extend DateAndTimeFormatting::ClassMethods
-    end
-  end
-
-  module InstanceMethods
-    # Formats a date/time instance using a defined format
-    #
-    # ==== Parameters
-    # format<Symbol>:: of the format key from Date.date_formats
-    #
-    # ==== Returns
-    # String:: formatted string
-    #
-    # ==== Example
-    #   Time.now.formatted(:rfc822) # => "Sun, 16 Nov 2007 00:21:16 -0800"
-    #   Time.now.formatted(:db) # => "2008-11-16 00:22:09"
-    #
-    # You can also add your own formats using +Date.add_format+ when your app loads.
-    #
-    # # Add the following to your init.rb
-    #   Rango::BootLoader.before_app_loads do
-    #     Date.add_format(:matt, "%H:%M:%S %Y-%m-%d")
-    #   end
-    #
-    # # Format a Time instance with the format you just specified
-    #   Time.now.formatted(:matt) # => "00:00:00 2007-11-02"
-    #
-    #--
-    # @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
-    #
-    # Because this operation is not thread safe, you should define
-    # custom formats when you load you application. The recommended way
-    # to do that, is to use the before_app_loads bootloader.
-    #
-    # If you want to add a format at runtime, you will need to use a mutex
-    # and synchronize it yourself.
-    #
-    # ==== Parameters
-    # key<Symbol>:: name of the format
-    # format<Hash>:: time format to use
-    #
-    # ==== Returns
-    # Hash:: a hash with all formats available
-    #
-    # ==== Example
-    #
-    #   Rango::BootLoader.before_app_loads do
-    #     Date.add_format(:matt, "%H:%M:%S %Y-%m-%d")
-    #   end
-    #
-    #
-    # --
-    # @public
-    def add_format(key, format)
-      formats.merge!({key => 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 format 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[1..-2].to_i.ordinalize }
-  end
-end
-
-Time.send(:include, DateAndTimeFormatting)
-Date.send(:include, DateAndTimeFormatting)

data/lib/rango/helpers/merb-helpers/date_time_helpers.rb

@@ -1,191 +0,0 @@
-# encoding: utf-8
-
-module Rango
-  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 Rango::Controller
-  include Rango::Helpers::DateAndTime
-end

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

@@ -1,450 +0,0 @@
-# encoding: utf-8
-
-require_relative "../tag_helpers"
-
-module Rango
-  module Helpers
-    module Form
-      module Builder
-        class Base
-          include Rango::Helpers::Tag
-          include Rango::Templates::TemplateHelpers
-
-          def initialize(obj, name, origin)
-            @obj, @origin = obj, origin
-            @name = name || @obj.class.name.snake_case.split("/").last
-          end
-
-          def form(attrs = {}, &block)
-            captured = @origin.capture(&block)
-            fake_method_tag = process_form_attrs(attrs)
-            tag(:form, fake_method_tag + captured, attrs)
-          end
-
-          def fieldset(attrs, &block)
-            legend = (l_attr = attrs.delete(:legend)) ? tag(:legend, l_attr) : ""
-            tag(:fieldset, legend + @origin.capture(&block), attrs)
-            # @origin.concat(contents, block.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 => control_value(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 => control_value(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 = control_value(method)
-            arr.map do |attrs|
-              attrs = {:value => attrs} unless attrs.is_a?(Hash)
-              attrs[:checked] = true if (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(control_value(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[: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 = control_value(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] ||= control_value(attrs[:value_method])
-          end
-
-          def update_unbound_controls(attrs, type)
-            case type
-            when "checkbox"
-              update_unbound_check_box(attrs)
-            when "radio"
-              update_unbound_radio_button(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
-
-          def update_unbound_radio_button(attrs)
-            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)
-
-              # unless Rango.disabled?(:merb_helper_escaping)
-              #   text  = Rango::Parse.escape_xml(text)
-              #   value = Rango::Parse.escape_xml(value)
-              # end
-
-              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 != "false" && value != "0" && value != 0
-          end
-
-          def control_name(method)
-            @obj ? "#{@name}[#{method}]" : method
-          end
-
-          def control_value(method)
-            value = @obj ? @obj.send(method) : @origin.params[method]
-            # if Rango.disabled?(:merb_helper_escaping)
-              value.to_s
-            # else
-            #   Rango::Parse.escape_xml(value.to_s)
-            # end
-          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
-              if contents.is_a?(Hash)
-                label_attrs = contents
-                contents = label_attrs.delete(:title)
-              else
-                label_attrs = attrs
-              end
-              tag(:label, contents, label_attrs)
-            else
-              ""
-            end
-          end
-
-          %w(text password file).each do |kind|
-            self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def unbound_#{kind}_field(attrs = {})
-                unbound_label(attrs) + super
-              end
-            RUBY
-          end
-
-          def unbound_label(attrs = {})
-            if attrs[:id]
-              label_attrs = {:for => attrs[:id]}
-            elsif attrs[:name]
-              label_attrs = {:for => attrs[:name]}
-            else
-              label_attrs = {}
-            end
-
-            label_option = attrs.delete(:label)
-            if label_option.is_a? Hash
-              label(label_attrs.merge(label_option))
-            else
-              label(label_option, label_attrs)
-            end
-          end
-
-          def unbound_check_box(attrs = {})
-            label_text = unbound_label(attrs)
-            super + label_text
-          end
-
-          def unbound_hidden_field(attrs = {})
-            attrs.delete(:label)
-            super
-          end
-
-          def unbound_radio_button(attrs = {})
-            label_text = unbound_label(attrs)
-            super + label_text
-          end
-
-          def unbound_select(attrs = {})
-            unbound_label(attrs) + super
-          end
-
-          def unbound_text_area(contents, attrs = {})
-            unbound_label(attrs) + super
-          end
-
-          def button(contents, attrs = {})
-            unbound_label(attrs) + super
-          end
-
-          def submit(value, attrs = {})
-            unbound_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)
-            attrs.merge!(:id => attrs[:name]) if attrs[:name] && !attrs[:id]
-
-            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 && !@obj.errors.on(method.to_sym).blank?
-              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
-    end
-  end
-end