rango 0.0.4 → 0.0.6

data/lib/rango/exceptions.rb

@@ -58,61 +58,61 @@ module Rango
   # http://en.wikipedia.org/wiki/List_of_HTTP_status_codes
 
   # informational
-  class Informational               < Rango::HttpError; end
-  class Continue                    < Rango::Informational; STATUS ||= 100; end
-  class SwitchingProtocols          < Rango::Informational; STATUS ||= 101; end
+  Informational = Class.new(Rango::HttpError)
+  Error100 = Continue = Class.new(Rango::Informational) { STATUS ||= 100 }
+  Error101 = SwitchingProtocols = Class.new(Rango::Informational) { STATUS ||= 101 }
 
   # successful
-  class Successful                  < Rango::HttpError; end
-  class OK                          < Rango::Successful; STATUS ||= 200; end
-  class Created                     < Rango::Successful; STATUS ||= 201; end
-  class Accepted                    < Rango::Successful; STATUS ||= 202; end
-  class NonAuthoritativeInformation < Rango::Successful; STATUS ||= 203; end
-  class NoContent                   < Rango::Successful; STATUS ||= 204; end
-  class ResetContent                < Rango::Successful; STATUS ||= 205; end
-  class PartialContent              < Rango::Successful; STATUS ||= 206; end
+  Successful = Class.new(Rango::HttpError)
+  Error200 = OK = Class.new(Rango::Successful) { STATUS ||= 200 }
+  Error201 = Created = Class.new(Rango::Successful) { STATUS ||= 201 }
+  Error202 = Accepted = Class.new(Rango::Successful) { STATUS ||= 202 }
+  Error203 = NonAuthoritativeInformation = Class.new(Rango::Successful) { STATUS ||= 203 }
+  Error204 = NoContent = Class.new(Rango::Successful) { STATUS ||= 204 }
+  Error205 = ResetContent = Class.new(Rango::Successful) { STATUS ||= 205 }
+  Error206 = PartialContent = Class.new(Rango::Successful) { STATUS ||= 206 }
 
   # redirection
-  class Redirection                 < Rango::HttpError; end
-  class MultipleChoices             < Rango::Redirection; STATUS ||= 300; end
-  class MovedPermanently            < Rango::Redirection; STATUS ||= 301; end
-  class MovedTemporarily            < Rango::Redirection; STATUS ||= 302; end
-  class SeeOther                    < Rango::Redirection; STATUS ||= 303; end
-  class NotModified                 < Rango::Redirection; STATUS ||= 304; end
-  class UseProxy                    < Rango::Redirection; STATUS ||= 305; end
-  class TemporaryRedirect           < Rango::Redirection; STATUS ||= 307; end
+  Redirection = Class.new(Rango::HttpError)
+  Error300 = MultipleChoices = Class.new(Rango::Redirection) { STATUS ||= 300 }
+  Error301 = MovedPermanently = Class.new(Rango::Redirection) { STATUS ||= 301 }
+  Error302 = MovedTemporarily = Class.new(Rango::Redirection) { STATUS ||= 302 }
+  Error303 = SeeOther = Class.new(Rango::Redirection) { STATUS ||= 303 }
+  Error304 = NotModified = Class.new(Rango::Redirection) { STATUS ||= 304 }
+  Error305 = UseProxy = Class.new(Rango::Redirection) { STATUS ||= 305 }
+  Error307 = TemporaryRedirect = Class.new(Rango::Redirection) { STATUS ||= 307 }
 
   # client error
-  class ClientError                 < Rango::HttpError; end
-  class BadRequest                  < Rango::ClientError; STATUS ||= 400; end
-  class MultiPartParseError         < Rango::BadRequest; end
-  class Unauthorized                < Rango::ClientError; STATUS ||= 401; end
-  class PaymentRequired             < Rango::ClientError; STATUS ||= 402; end
-  class Forbidden                   < Rango::ClientError; STATUS ||= 403; end
-  class NotFound                    < Rango::ClientError; STATUS ||= 404; end
-  class ActionNotFound              < Rango::NotFound; end
-  class TemplateNotFound            < Rango::NotFound; end
-  class LayoutNotFound              < Rango::NotFound; end
-  class MethodNotAllowed            < Rango::ClientError; STATUS ||= 405; end
-  class NotAcceptable               < Rango::ClientError; STATUS ||= 406; end
-  class ProxyAuthenticationRequired < Rango::ClientError; STATUS ||= 407; end
-  class RequestTimeout              < Rango::ClientError; STATUS ||= 408; end
-  class Conflict                    < Rango::ClientError; STATUS ||= 409; end
-  class Gone                        < Rango::ClientError; STATUS ||= 410; end
-  class LengthRequired              < Rango::ClientError; STATUS ||= 411; end
-  class PreconditionFailed          < Rango::ClientError; STATUS ||= 412; end
-  class RequestEntityTooLarge       < Rango::ClientError; STATUS ||= 413; end
-  class RequestURITooLarge          < Rango::ClientError; STATUS ||= 414; end
-  class UnsupportedMediaType        < Rango::ClientError; STATUS ||= 415; end
-  class RequestRangeNotSatisfiable  < Rango::ClientError; STATUS ||= 416; end
-  class ExpectationFailed           < Rango::ClientError; STATUS ||= 417; end
+  ClientError = Class.new(Rango::HttpError)
+  Error400 = BadRequest = Class.new(Rango::ClientError) { STATUS ||= 400 }
+  MultiPartParseError = Class.new(Rango::BadRequest)
+  Error401 = Unauthorized = Class.new(Rango::ClientError) { STATUS ||= 401 }
+  Error402 = PaymentRequired = Class.new(Rango::ClientError) { STATUS ||= 402 }
+  Error403 = Forbidden = Class.new(Rango::ClientError) { STATUS ||= 403 }
+  Error404 = NotFound = Class.new(Rango::ClientError) { STATUS ||= 404 }
+  ActionNotFound = Class.new(Rango::NotFound)
+  TemplateNotFound = Class.new(Rango::NotFound)
+  LayoutNotFound = Class.new(Rango::NotFound)
+  Error405 = MethodNotAllowed = Class.new(Rango::ClientError) { STATUS ||= 405 }
+  Error406 = NotAcceptable = Class.new(Rango::ClientError) { STATUS ||= 406 }
+  Error407 = ProxyAuthenticationRequired = Class.new(Rango::ClientError) { STATUS ||= 407 }
+  Error408 = RequestTimeout = Class.new(Rango::ClientError) { STATUS ||= 408 }
+  Error409 = Conflict = Class.new(Rango::ClientError) { STATUS ||= 409 }
+  Error410 = Gone = Class.new(Rango::ClientError) { STATUS ||= 410 }
+  Error411 = LengthRequired = Class.new(Rango::ClientError) { STATUS ||= 411 }
+  Error412 = PreconditionFailed = Class.new(Rango::ClientError) { STATUS ||= 412 }
+  Error413 = RequestEntityTooLarge = Class.new(Rango::ClientError) { STATUS ||= 413 }
+  Error414 = RequestURITooLarge = Class.new(Rango::ClientError) { STATUS ||= 414 }
+  Error415 = UnsupportedMediaType = Class.new(Rango::ClientError) { STATUS ||= 415 }
+  Error416 = RequestRangeNotSatisfiable = Class.new(Rango::ClientError) { STATUS ||= 416 }
+  Error417 = ExpectationFailed = Class.new(Rango::ClientError) { STATUS ||= 417 }
 
   # server error
-  class ServerError                 < Rango::HttpError; end
-  class InternalServerError         < Rango::ServerError; STATUS ||= 500; end
-  class NotImplemented              < Rango::ServerError; STATUS ||= 501; end
-  class BadGateway                  < Rango::ServerError; STATUS ||= 502; end
-  class ServiceUnavailable          < Rango::ServerError; STATUS ||= 503; end
-  class GatewayTimeout              < Rango::ServerError; STATUS ||= 504; end
-  class HTTPVersionNotSupported     < Rango::ServerError; STATUS ||= 505; end
+  ServerError = Class.new(Rango::HttpError)
+  Error500 = InternalServerError = Class.new(Rango::ServerError) { STATUS ||= 500 }
+  Error501 = NotImplemented = Class.new(Rango::ServerError) { STATUS ||= 501 }
+  Error502 = BadGateway = Class.new(Rango::ServerError) { STATUS ||= 502 }
+  Error503 = ServiceUnavailable = Class.new(Rango::ServerError) { STATUS ||= 503 }
+  Error504 = GatewayTimeout = Class.new(Rango::ServerError) { STATUS ||= 504 }
+  Error505 = HTTPVersionNotSupported = Class.new(Rango::ServerError) { STATUS ||= 505 }
 end

data/lib/rango/gv.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+# GV = generic views
+require "rango/mixins/render"
+
+# what about filters?
+#   - include to controller or use directly (include Rango::GV, but what if I want to include just for example static gv?)
+#   - or Rango::GV.extend FiltersMixin
+
+module Rango
+  module GV
+    class View
+      include Rango::Helpers
+      include Rango::RenderMixin
+      attr_reader :name, :definition
+      attr_accessor :args, :custom_block # we can't use just block because of block(:head)
+      attr_accessor :env, :request, :response
+      def initialize(name, &definition)
+        @name, @definition = name, definition
+      end
+      
+      def setup(*args, &custom_block)
+        self.args = args
+        self.custom_block = custom_block
+      end
+      
+      def call(env)
+        Rango::Router.new.set_rack_env(env) # so env["usher.params"] => env["rango.router.params"]
+        self.request = Rango::Request.new(env)
+        self.response = Rack::Response.new
+        self.env = env
+
+        # Welcome to Ruby 1.9 world! instance_exec is the same as instance_eval,
+        # but it can takes arguments for the custom_block
+        args = [*self.args, self.custom_block]
+        Rango.logger.debug("Calling generic view #{self.name} with #{args.inspect}")
+        body = self.instance_exec(*args, &self.definition)
+
+        # TODO: check how rack test if object is stringable, probably not this way
+        raise ArgumentError unless body.respond_to?(:each) || body.is_a?(String)
+        response.write(body)
+        response.finish
+      end
+    end
+
+    def self.define(action, &definition)
+      # instance method for including
+      define_method(action, &definition)
+
+      # class method for direct usage
+      # TODO: clean this mess before someone start vomit
+      @@view = View.new(action, &definition)
+      module_eval <<-RUBY, __FILE__, __LINE__
+      def self.#{action}(*args, &block)
+        view = @@view.dup
+        view.setup(*args, &block)
+        view # has #call
+      end
+      RUBY
+    end
+  end
+end
+
+# require params[:path]
+# @example
+#   Usher::Interface.for(:rack) do
+#     get("/").to(Rango::GV.static("index"))
+#     get("/:template").to(::Static.dispatcher(:show)).name(:static)
+#     get("/:template").to(Rango::GenericViews.dispatcher(:static)).name(:static)
+#     get("/:template").to do |env|
+#       env["rango.params"][:template] # transform
+#       Rango::GV.static
+#     end
+#   end
+
+# THE MAIN PROBLEM IS THIS CAN'T WORK WITH BLOCKS
+# BECAUSE OF instance_exec(*args, &block, &definition) will cause syntax error in Ruby
+
+###############
+# This might be the best solution:
+#Rango::GV.define(:static) do |view, template = nil, &block|
+#end
+
+# implementation: just definition.call(self, *self.args, &self.block)
+###############
+  
+Rango::GV.define(:static) do |hook = nil|
+  require "rango/helpers" # for javascripts etc helpers
+  path = env["rango.router.params"][:template]
+  path = hook.call(path) unless hook.nil?
+  Rango.logger.debug("Rendering '#{path}'")
+  render path
+end

data/lib/rango/helpers.rb

@@ -18,7 +18,7 @@ module Rango
   end
 end
 
-Rango.import("helpers/assets")
-Rango.import("helpers/syntax")
-Rango.import("helpers/general")
-Rango.import("helpers/merb-helpers")
+require "rango/helpers/assets"
+require "rango/helpers/syntax"
+require "rango/helpers/general"
+require "rango/helpers/merb-helpers"

data/lib/rango/helpers/assets.rb

@@ -1,21 +1,30 @@
 # encoding: utf-8
 
+# TODO: javascript "application" => media/javascripts/application.js
+# ... but what if I need full path? It should be tested if file exist, of course
+# javascript Path.new("design/whatever.js")
 module Rango
   module Helpers
     # stolen from pupu (but it's OK, it's my code)
     # @since 0.0.2
     def javascript(basename)
-      path = Path.new(File.join(Project.settings.media_root, "javascripts", "#{basename}.js"))
+      path = MediaPath.new(File.join(Project.settings.media_root, "javascripts", "#{basename}.js"))
       tag :script, src: path.url, type: "text/javascript"
     end
 
     # @since 0.0.2
     def stylesheet(basename, attrs = Hash.new)
-      path = Path.new(File.join(Project.settings.media_root, basename))
+      path = MediaPath.new(File.join(Project.settings.media_root, "stylesheets", basename))
       default = {href: path.url, media: 'screen', rel: 'stylesheet', type: 'text/css'}
       single_tag :link, default.merge(attrs)
     end
 
+    def image(basename, attrs = Hash.new)
+      path = MediaPath.new(File.join(Project.settings.media_root, "images", basename))
+      default = {src: path.url, alt: path.basename}
+      single_tag :img, default.merge(attrs)
+    end
+
     # @since 0.0.2
     def javascripts(*names)
       names.map { |name| self.javascript(name) }.join("\n")

data/lib/rango/helpers/merb-helpers/core_ext/numeric.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
+# TODO: rewrite default_format-related functionality, it should simply write to Hash#default
 class Numeric
   module Transformer
 

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

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 module DateAndTimeFormatting
-
   def self.included(base)
     base.class_eval do
       include DateAndTimeFormatting::InstanceMethods
@@ -11,8 +10,6 @@ module DateAndTimeFormatting
   end
 
   module InstanceMethods
-
-
     # Formats a date/time instance using a defined format
     #
     # ==== Parameters
@@ -40,11 +37,9 @@ module DateAndTimeFormatting
     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
@@ -92,18 +87,7 @@ module DateAndTimeFormatting
     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
@@ -134,7 +118,6 @@ 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?
@@ -152,7 +135,10 @@ module OrdinalizedFormatting
   #
   # ==== 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 }
+  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/form/builder.rb

@@ -1,447 +1,450 @@
 # encoding: utf-8
 
-load File.dirname(__FILE__) / ".." / "tag_helpers.rb"
-Rango.import("templates/template")
-
-module Rango::Helpers::Form::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))
+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
 
-        def unbound_#{kind}_field(attrs)
-          update_unbound_controls(attrs, "#{kind}")
-          self_closing_tag(:input, {:type => "#{kind}"}.merge(attrs))
+        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
-      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
+        module Errorifier
+          def error_messages_for(obj, error_class, build_li, header, before)
+            obj ||= @obj
+            return "" unless obj.respond_to?(:errors)
 
-    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
+            sequel = !obj.errors.respond_to?(:each)
+            errors = sequel ? obj.errors.full_messages : obj.errors
 
-    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
+            return "" if errors.empty?
 
-    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
+            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
 
-        text  = item.is_a?(String) ? item : item.send(text_meth)
-        value = item.is_a?(String) ? item : item.send(value_meth)
+          private
 
-        # 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
+          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
-        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
+        class FormWithErrors < Form
+          include Errorifier
+        end
 
-    def add_css_class(attrs, new_class)
-      attrs[:class] = attrs[:class] ? "#{attrs[:class]} #{new_class}" : new_class
-    end
-  end
+        module Resourceful
+          private
 
-  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
+          def process_form_attrs(attrs)
+            attrs[:action] ||= @origin.url(@name, @obj) if @origin
+            super
+          end
         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
+        class ResourcefulForm < Form
+          include Resourceful
         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")
+        class ResourcefulFormWithErrors < FormWithErrors
+          include Errorifier
+          include Resourceful
+        end
       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