bureaucrat 0.0.3 → 0.10.0

data/README.md

@@ -1,124 +1,139 @@
 Bureaucrat
 ==========
 
-Form handling for Ruby inspired by Django forms.
+Form handling for Ruby inspired by [Django forms](https://docs.djangoproject.com/en/dev/#forms).
 
-Structure
----------
+Description
+-----------
 
-                     Form ----> as_<render_mode>, valid?, errors/cleaned_data
+Bureaucrat is a library for handling the processing, validation and rendering of HTML forms.
+
+Structure of a Form
+-------------------
+
+                     Form ----> valid?, errors/cleaned_data
                 ______|________
               /       |         \
           Field     Field      Field  ----> clean
             |         |          |
           Widget    Widget     Widget ----> render
 
-- A Form has a list of Fields.
-- A Field has a Widget.
-- A Widget knows how to render itself.
-- A Field knows how to validate an input value and convert it from a string to the required type.
-- A Form knows how to render all its fields along with all the required error messages.
-- After validation, a valid Form responds to 'cleaned_data' by returning a hash of validated values.
-- After validation an invalid Form responds to 'errors' by returning a hash of field_name => error_messages
+**Form**:
+Collection of named Fields, handles global validation and the last pass of
+data conversion.
+After validation, a valid Form responds to `cleaned_data` by returning a
+hash of validated values and an invalid Form responds to `errors` by
+returning a hash of field_name => error_messages.
+
+**Field**:
+Handles the validation and data conversion of each field belonging to the Form. Each Field is associated to a name on the parent Form.
+
+**Widget**:
+Handles the rendering of a Form field. Each Field has two widgets associated, one for normal rendering, and another for hidden inputs rendering. Every type of Field has default Widgets defined, but they can be overriden on a per-Form basis.
 
 Usage examples
 --------------
 
-    require 'bureaucrat'
-    require 'bureaucrat/quickfields'
-
-    class MyForm < Bureaucrat::Forms::Form
-      extend Bureaucrat::Quickfields
-
-      string  :nickname, :max_length => 50
-      string  :realname, :require => false
-      email   :email
-      integer :age, :min_value => 0
-      boolean :newsletter, :required => false
-
-      def save
-        user = User.create!(cleaned_data)
-        Mailer.deliver_confirmation_mail(user)
-        user
-      end
-    end
-
-    # A Form initialized without parameters is an unbound Form.
-    unbound_form = MyForm.new
-    unbound_form.valid? # => false
-    unbound_form.errors # => {}
-    unbound_form.cleaned_data # => nil
-    puts unbound_form.as_p
-    # Prints:
-    # <p><label for="id_nickname">Nickname:</label> <input type="text" name="nickname" id="id_nickname" maxlength="50" /></p>
-    # <p><label for="id_realname">Realname:</label> <input type="text" name="realname" id="id_realname" /></p>
-    # <p><label for="id_email">Email:</label> <input type="text" name="email" id="id_email" /></p>
-    # <p><label for="id_age">Age:</label> <input type="text" name="age" id="id_age" /></p>
-    # <p><label for="id_newsletter">Newsletter:</label> <input type="checkbox" name="newsletter" id="id_newsletter" /></p>
-
-    invalid_bound_form = MyForm.new(:nickname => 'bureaucrat', :email => 'badformat', :age => '30')
-    invalid_bound_form.valid? # => false
-    invalid_bound_form.errors # {:email => ["Enter a valid e-mail address."]}
-    invalid_bound_form.cleaned_data # => nil
-    puts invalid_bound_form.as_table
-    # Prints:
-    # <tr><th><label for="id_nickname">Nickname:</label></th><td><input type="text" value="bureaucrat" name="nickname" id="id_nickname" maxlength="50" /></td></tr>
-    # <tr><th><label for="id_realname">Realname:</label></th><td><ul class="errorlist"><li>This field is required</li></ul><input type="text" name="realname" id="id_realname" /></td></tr>
-    # <tr><th><label for="id_email">Email:</label></th><td><ul class="errorlist"><li>Enter a valid e-mail address.</li></ul><input type="text" value="badformat" name="email" id="id_email" /></td></tr>
-    # <tr><th><label for="id_age">Age:</label></th><td><input type="text" value="30" name="age" id="id_age" /></td></tr>
-    # <tr><th><label for="id_newsletter">Newsletter:</label></th><td><input type="checkbox" name="newsletter" id="id_newsletter" /></td></tr>
-
-    valid_bound_form = MyForm.new(:nickname => 'bureaucrat', :email => 'valid@email.com', :age => '30')
-    valid_bound_form.valid? # => true
-    valid_bound_form.errors # {}
-    valid_bound_form.cleaned_data # => {:age => 30, :newsletter => false, :nickname => "bureaucrat", :realname => "", :email = >"valid@email.com"}
-    puts valid_bound_form.as_ul
-    # Prints:
-    # <li><label for="id_nickname">Nickname:</label> <input type="text" value="bureaucrat" name="nickname" id="id_nickname" maxlength="50" /></li>
-    # <li><ul class="errorlist"><li>This field is required</li></ul><label for="id_realname">Realname:</label> <input type="text" name="realname" id="id_realname" /></li>
-    # <li><label for="id_email">Email:</label> <input type="text" value="valid@email.com" name="email" id="id_email" /></li>
-    # <li><label for="id_age">Age:</label> <input type="text" value="30" name="age" id="id_age" /></li>
-    # <li><label for="id_newsletter">Newsletter:</label> <input type="checkbox" name="newsletter" id="id_newsletter" /></li>
-
-    valid_bound_form.save # A new User is created and a confirmation mail is delivered
+```ruby
+require 'bureaucrat'
+require 'bureaucrat/quickfields'
+
+class MyForm < Bureaucrat::Forms::Form
+  extend Bureaucrat::Quickfields
+
+  string  :nickname, max_length: 50
+  string  :realname, required: false
+  email   :email
+  integer :age, min_value: 0
+  boolean :newsletter, required: false
+
+  # Note: Bureaucrat doesn't define save
+  def save
+    user = User.create!(cleaned_data)
+    Mailer.deliver_confirmation_mail(user)
+    user
+  end
+end
+
+# A Form initialized without parameters is an unbound Form.
+unbound_form = MyForm.new
+unbound_form.valid? # => false
+unbound_form.errors # => {}
+unbound_form.cleaned_data # => nil
+puts unbound_form.as_p
+# Prints:
+# <p><label for="id_nickname">Nickname:</label> <input type="text" name="nickname" id="id_nickname" maxlength="50" /></p>
+# <p><label for="id_realname">Realname:</label> <input type="text" name="realname" id="id_realname" /></p>
+# <p><label for="id_email">Email:</label> <input type="text" name="email" id="id_email" /></p>
+# <p><label for="id_age">Age:</label> <input type="text" name="age" id="id_age" /></p>
+# <p><label for="id_newsletter">Newsletter:</label> <input type="checkbox" name="newsletter" id="id_newsletter" /></p>
+
+invalid_bound_form = MyForm.new(nickname: 'bureaucrat', email: 'badformat', age: '30')
+invalid_bound_form.valid? # => false
+invalid_bound_form.errors # {email: ["Enter a valid e-mail address."]}
+invalid_bound_form.cleaned_data # => nil
+puts invalid_bound_form.as_table
+# Prints:
+# <tr><th><label for="id_nickname">Nickname:</label></th><td><input type="text" value="bureaucrat" name="nickname" id="id_nickname" maxlength="50" /></td></tr>
+# <tr><th><label for="id_realname">Realname:</label></th><td><ul class="errorlist"><li>This field is required</li></ul><input type="text" name="realname" id="id_realname" /></td></tr>
+# <tr><th><label for="id_email">Email:</label></th><td><ul class="errorlist"><li>Enter a valid e-mail address.</li></ul><input type="text" value="badformat" name="email" id="id_email" /></td></tr>
+# <tr><th><label for="id_age">Age:</label></th><td><input type="text" value="30" name="age" id="id_age" /></td></tr>
+# <tr><th><label for="id_newsletter">Newsletter:</label></th><td><input type="checkbox" name="newsletter" id="id_newsletter" /></td></tr>
+
+valid_bound_form = MyForm.new(nickname: 'bureaucrat', email: 'valid@email.com', age: '30')
+valid_bound_form.valid? # => true
+valid_bound_form.errors # {}
+valid_bound_form.cleaned_data # => {age: 30, newsletter: false, nickname: "bureaucrat", realname: "", :email = >"valid@email.com"}
+puts valid_bound_form.as_ul
+# Prints:
+# <li><label for="id_nickname">Nickname:</label> <input type="text" value="bureaucrat" name="nickname" id="id_nickname" maxlength="50" /></li>
+# <li><ul class="errorlist"><li>This field is required</li></ul><label for="id_realname">Realname:</label> <input type="text" name="realname" id="id_realname" /></li>
+# <li><label for="id_email">Email:</label> <input type="text" value="valid@email.com" name="email" id="id_email" /></li>
+# <li><label for="id_age">Age:</label> <input type="text" value="30" name="age" id="id_age" /></li>
+# <li><label for="id_newsletter">Newsletter:</label> <input type="checkbox" name="newsletter" id="id_newsletter" /></li>
+
+valid_bound_form.save # A new User is created and a confirmation mail is delivered
+```
 
 Examples of different ways of defining forms
 --------------
 
-    require 'bureaucrat'
-    require 'bureaucrat/quickfields'
-
-    class MyForm < Bureaucrat::Forms::Form
-      include Bureaucrat::Fields
-
-      field :nickname, CharField.new(:max_length => 50)
-      field :realname, CharField.new(:required => false)
-      field :email, EmailField.new
-      field :age, IntegerField.new(:min_value => 0)
-      field :newsletter, BooleanField.new(:required => false) 
-    end
-
-    class MyFormQuick < Bureaucrat::Forms::Form
-      extend Bureaucrat::Quickfields
-
-      string  :nickname, :max_length => 50
-      string  :realname, :required => false
-      email   :email
-      integer :age, :min_value => 0
-      boolean :newsletter, :required => false
-    end
-
-    def quicker_form
-      f = Class.new(Bureaucrat::Forms::Form)
-      f.extend(Bureaucrat::Quickfields)
-      yield f
-      f
-    end
-
-    MyFormQuicker = quicker_form do |f|
-      f.string  :nickname, :max_length => 50
-      f.string  :realname, :required => false
-      f.email   :email
-      f.integer :age, :min_value => 0
-      f.boolean :newsletter, :required => false
-    end
+```ruby
+require 'bureaucrat'
+require 'bureaucrat/quickfields'
+
+class MyForm < Bureaucrat::Forms::Form
+  include Bureaucrat::Fields
+
+  field :nickname, CharField.new(max_length: 50)
+  field :realname, CharField.new(required: false)
+  field :email, EmailField.new
+  field :age, IntegerField.new(min_value: 0)
+  field :newsletter, BooleanField.new(required: false) 
+end
+
+class MyFormQuick < Bureaucrat::Forms::Form
+  extend Bureaucrat::Quickfields
+
+  string  :nickname, max_length: 50
+  string  :realname, required: false
+  email   :email
+  integer :age, min_value: 0
+  boolean :newsletter, required: false
+end
+
+def inline_form
+  f = Class.new(Bureaucrat::Forms::Form)
+  f.extend(Bureaucrat::Quickfields)
+  yield f
+  f
+end
+
+form_maker = inline_form do |f|
+  f.string  :nickname, max_length: 50
+  f.string  :realname, required: false
+  f.email   :email
+  f.integer :age, min_value: 0
+  f.boolean :newsletter, required: false
+end
+```

data/Rakefile

@@ -0,0 +1,9 @@
+require "rake/testtask"
+
+task :default => :test
+
+desc 'Run all tests'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = './test/**/*_test.rb'
+  t.verbose = false
+end

data/bureaucrat.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+  s.name = 'bureaucrat'
+  s.version = '0.10.0'
+  s.summary = "Form handling for Ruby inspired by Django forms."
+  s.description = "Bureaucrat is a form handling library for Ruby."
+  s.author = "Bruno Deferrari"
+  s.email = "utizoc@gmail.com"
+  s.homepage = "http://github.com/tizoc/bureaucrat"
+
+  s.files = [
+    "lib/bureaucrat/fields.rb",
+    "lib/bureaucrat/forms.rb",
+    "lib/bureaucrat/formsets.rb",
+    "lib/bureaucrat/quickfields.rb",
+    "lib/bureaucrat/temporary_uploaded_file.rb",
+    "lib/bureaucrat/utils.rb",
+    "lib/bureaucrat/validators.rb",
+    "lib/bureaucrat/widgets.rb",
+    "lib/bureaucrat.rb",
+    "README.md",
+    "LICENSE",
+    "test/fields_test.rb",
+    "test/forms_test.rb",
+    "test/formsets_test.rb",
+    "test/test_helper.rb",
+    "test/widgets_test.rb",
+    "Rakefile",
+    "bureaucrat.gemspec"
+  ]
+
+  s.require_paths = ['lib']
+end

data/lib/bureaucrat.rb

@@ -1,10 +1,28 @@
-libdir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
-
 module Bureaucrat
-  VERSION = '0.0.1'
-end
+  VERSION = '0.10.0'
+
+  class ValidationError < Exception
+    attr_reader :code, :params, :messages
 
-require 'bureaucrat/widgets'
-require 'bureaucrat/fields'
-require 'bureaucrat/forms'
+    def initialize(message, code = nil, params = nil)
+      if message.is_a? Array
+        @messages = message
+      else
+        @code = code
+        @params = params
+        @messages = [message]
+      end
+    end
+
+    def to_s
+      "ValidationError(#{@messages.inspect})"
+    end
+  end
+
+  require_relative 'bureaucrat/utils'
+  require_relative 'bureaucrat/validators'
+  require_relative 'bureaucrat/widgets'
+  require_relative 'bureaucrat/fields'
+  require_relative 'bureaucrat/forms'
+  require_relative 'bureaucrat/temporary_uploaded_file'
+end

data/lib/bureaucrat/fields.rb

@@ -1,461 +1,697 @@
-require 'bureaucrat/utils'
-require 'bureaucrat/validation'
-require 'bureaucrat/widgets'
+require 'set'
 
 module Bureaucrat
-module Fields
+  module Fields
 
-  class ErrorList < Array
-    include Utils
+    class ErrorList < Array
+      include Utils
 
-    def to_s
-      as_ul
-    end
+      def to_s
+        as_ul
+      end
 
-    def as_ul
-      ul = '<ul class="errorlist">%s</ul>'
-      li = '<li>%s</li>'
-      empty? ? '' : mark_safe(ul % map {|e| li % conditional_escape(e)}.join("\n"))
-    end
+      def as_ul
+        if empty?
+          ''
+        else
+          ul = '<ul class="errorlist">%s</ul>'
+          li = '<li>%s</li>'
 
-    def as_text
-      empty? ? '' : map{|e| '* %s' % e}.join("\n")
+          result = ul % map{|e| li % conditional_escape(e)}.join("\n")
+          mark_safe(result)
+        end
+      end
+
+      def as_text
+        empty? ? '' : map{|e| '* %s' % e}.join("\n")
+      end
     end
-  end
 
-  class ErrorHash < Hash
-    include Utils
+    class ErrorHash < Hash
+      include Utils
 
-    def to_s
-      as_ul
-    end
+      def to_s
+        as_ul
+      end
 
-    def as_ul
-      ul = '<ul class="errorlist">%s</ul>'
-      li = '<li>%s%s</li>'
-      empty? ? '' : mark_safe(ul % map {|k, v| li % [k, v]}.join)
-    end
+      def as_ul
+        ul = '<ul class="errorlist">%s</ul>'
+        li = '<li>%s%s</li>'
+        empty? ? '' : mark_safe(ul % map {|k, v| li % [k, v]}.join)
+      end
 
-    def as_text
-      map do |k, v|
-        '* %s\n%s' % [k, v.map{|i| '  * %s'}.join("\n")]
-      end.join("\n")
+      def as_text
+        map do |k, v|
+          "* %s\n%s" % [k, v.map{|i| '  * %s'}.join("\n")]
+        end.join("\n")
+      end
     end
-  end
 
-  class FieldValidationError < Exception
-    attr_reader :messages
+    class Field
+      attr_accessor :required, :label, :initial, :error_messages, :widget, :hidden_widget, :show_hidden_initial, :help_text, :validators
 
-    def initialize(message)
-      message = [message] unless message.is_a?(Array)
-      @messages = ErrorList.new(message)
-    end
+      def initialize(options={})
+        @required = options.fetch(:required, true)
+        @show_hidden_initial = options.fetch(:show_hidden_initial, false)
+        @label = options[:label]
+        @initial = options[:initial]
+        @help_text = options.fetch(:help_text, '')
+        @widget = options.fetch(:widget, default_widget)
 
-    def to_s
-      @messages.inspect
-    end
-  end
+        @widget = @widget.new if @widget.is_a?(Class)
+        @widget.attrs.update(widget_attrs(@widget))
+        @widget.is_required = @required
 
-  class Field
-    include Validation::Validators
-    include Validation::Converters
+        @hidden_widget = options.fetch(:hidden_widget, default_hidden_widget)
+        @hidden_widget = @hidden_widget.new if @hidden_widget.is_a?(Class)
 
-    class << self
-      attr_reader :default_error_messages
+        @error_messages = default_error_messages.
+          merge(options.fetch(:error_messages, {}))
 
-      def set_error(key, template)
-        @default_error_messages ||= {}
-        @default_error_messages[key] = template
+        @validators = default_validators + options.fetch(:validators, [])
       end
 
-      def widget(widget=nil)
-        @widget = widget unless widget.nil?
-        @widget
+      # Default error messages for this kind of field. Override on subclasses to add or replace messages
+      def default_error_messages
+        {
+          required: 'This field is required',
+          invalid: 'Enter a valid value'
+        }
       end
 
-      def hidden_widget(hidden_widget=nil)
-        @hidden_widget = hidden_widget unless hidden_widget.nil?
-        @hidden_widget
+      # Default validators for this kind of field.
+      def default_validators
+        []
       end
 
-      # Copy field properties to the child class
-      def inherited(c)
-        c.widget        widget
-        c.hidden_widget hidden_widget
-        default_error_messages.each {|k, v| c.set_error k, v}
+      # Default widget for this kind of field. Override on subclasses to customize.
+      def default_widget
+        Widgets::TextInput
       end
-    end
 
-    # Field properties
-    widget        Widgets::TextInput
-    hidden_widget Widgets::HiddenInput
-    set_error     :required, 'This field is required'
-    set_error     :invalid, 'Enter a valid value'
+      # Default hidden widget for this kind of field. Override on subclasses to customize.
+      def default_hidden_widget
+        Widgets::HiddenInput
+      end
 
-    attr_accessor :required, :label, :initial, :error_messages, :widget, :hidden_widget, :show_hidden_initial, :help_text
+      def prepare_value(value)
+        value
+      end
 
-    def initialize(options={})
-      @required = options.fetch(:required, true)
-      @show_hidden_initial = options.fetch(:show_hidden_initial, false)
-      @label = options[:label]
-      @initial = options[:initial]
-      @help_text = options.fetch(:help_text, '')
-      @widget = options.fetch(:widget, self.class.widget)
+      def to_object(value)
+        value
+      end
 
-      @widget = @widget.new if @widget.is_a?(Class)
-      extra_attrs = widget_attrs(@widget)
-      @widget.attrs.update(extra_attrs) if extra_attrs
+      def validate(value)
+        if required && Validators.empty_value?(value)
+          raise ValidationError.new(error_messages[:required])
+        end
+      end
 
-      @error_messages = self.class.default_error_messages.
-        merge(options.fetch(:error_messages, {}))
-    end
+      def run_validators(value)
+        if Validators.empty_value?(value)
+          return
+        end
 
-    def validating
-      yield
-    rescue Validation::ValidationError => error
-      tpl = error_messages.fetch(error.error_code, error.error_code.to_s)
-      msg = Utils.format_string(tpl, error.parameters)
-      raise FieldValidationError.new(msg)
-    end
+        errors = []
 
-    def clean(value)
-      validating { is_present(value) if @required }
-      value
-    end
+        validators.each do |v|
+          begin
+            v.call(value)
+          rescue ValidationError => e
+            if e.code && error_messages.has_key?(e.code)
+              message = error_messages[e.code]
+
+              if e.params
+                message = Utils.format_string(message, e.params)
+              end
+
+              errors << message
+            else
+              errors += e.messages
+            end
+          end
+        end
 
-    def widget_attrs(widget)
-      # Override to add field specific attributes
-    end
+        unless errors.empty?
+          raise ValidationError.new(errors)
+        end
+      end
 
-    def initialize_copy(original)
-      super(original)
-      @initial = original.initial ? original.initial.dup : original.initial
-      @label = original.label ? original.label.dup : original.label
-      @error_messages = original.error_messages.dup
-    end
+      def clean(value)
+        value = to_object(value)
+        validate(value)
+        run_validators(value)
+        value
+      end
 
-  end
+      # The data to be displayed when rendering for a bound form
+      def bound_data(data, initial)
+        data
+      end
 
-  class CharField < Field
-    set_error :max_length, 'Ensure this value has at most %(max)s characters (it has %(length)s).'
-    set_error :min_length, 'Ensure this value has at least %(min)s characters (it has %(length)s).'
+      # List of attributes to add on the widget. Override to add field specific attributes
+      def widget_attrs(widget)
+        {}
+      end
 
-    attr_accessor :max_length, :min_length
+      # Populates object.name if posible
+      def populate_object(object, name, value)
+        setter = :"#{name}="
 
-    def initialize(options={})
-      @max_length = options.delete(:max_length)
-      @min_length = options.delete(:min_length)
-      super(options)
-    end
+        if object.respond_to?(setter)
+          object.send(setter, value)
+        end
+      end
+
+      def initialize_copy(original)
+        super(original)
+        @initial = original.initial
+        begin
+          @initial = @initial.dup
+        rescue TypeError
+          # non-clonable
+        end
+        @label = original.label && original.label.dup
+        @widget = original.widget && original.widget.dup
+        @validators = original.validators.dup
+        @error_messages = original.error_messages.dup
+      end
 
-    def widget_attrs(widget)
-      return if @max_length.nil?
-      return {:maxlength => @max_length.to_s} if
-        widget.kind_of?(Widgets::TextInput) || widget.kind_of?(Widgets::PasswordInput)
     end
 
-    def clean(value)
-      super(value)
-      return '' if empty_value?(value)
+    class CharField < Field
+      attr_accessor :max_length, :min_length
+
+      def initialize(options = {})
+        @max_length = options.delete(:max_length)
+        @min_length = options.delete(:min_length)
+        super(options)
 
-      validating do
-          has_max_length(value, @max_length) if @max_length
-          has_min_length(value, @min_length) if @min_length
+        if @min_length
+          validators << Validators::MinLengthValidator.new(@min_length)
         end
 
-      value
-    end
-  end
+        if @max_length
+          validators << Validators::MaxLengthValidator.new(@max_length)
+        end
+      end
 
-  class IntegerField < Field
-    set_error :invalid, 'Enter a whole number.'
-    set_error :max_value, 'Ensure this value is less than or equal to %(max)s.'
-    set_error :min_value, 'Ensure this value is greater than or equal to %(min)s.'
+      def to_object(value)
+        if Validators.empty_value?(value)
+          ''
+        else
+          value
+        end
+      end
 
-    def initialize(options={})
-      @max_value = options.delete(:max_value)
-      @min_value = options.delete(:min_value)
-      super(options)
+      def widget_attrs(widget)
+        super(widget).tap do |attrs|
+          if @max_length && (widget.kind_of?(Widgets::TextInput) ||
+                             widget.kind_of?(Widgets::PasswordInput))
+            attrs.merge(maxlength: @max_length.to_s)
+          end
+        end
+      end
     end
 
-    def clean(value)
-      super(value)
-      return nil if empty_value?(value)
+    class IntegerField < Field
+      def initialize(options={})
+        @max_value = options.delete(:max_value)
+        @min_value = options.delete(:min_value)
+        super(options)
 
-      validating do
-          value = to_integer(value)
-          is_not_greater_than(value, @max_value) if @max_value
-          is_not_lesser_than(value, @min_value) if @min_value
+        if @min_value
+          validators << Validators::MinValueValidator.new(@min_value)
         end
 
-      value
-    end
-  end
+        if @max_value
+          validators << Validators::MaxValueValidator.new(@max_value)
+        end
+      end
+
+      def default_error_messages
+        super.merge(invalid: 'Enter a whole number.',
+                    max_value: 'Ensure this value is less than or equal to %(max)s.',
+                    min_value: 'Ensure this value is greater than or equal to %(min)s.')
+      end
+
+      def to_object(value)
+        value = super(value)
 
-  class FloatField < Field
-    set_error :invalid, 'Enter a number.'
-    set_error :max_value, 'Ensure this value is less than or equal to %(max)s.'
-    set_error :min_value, 'Ensure this value is greater than or equal to %(min)s.'
+        if Validators.empty_value?(value)
+          return nil
+        end
 
-    def initialize(options={})
-      @max_value = options.delete(:max_value)
-      @min_value = options.delete(:min_value)
-      super(options)
+        begin
+          Integer(value.to_s)
+        rescue ArgumentError
+          raise ValidationError.new(error_messages[:invalid])
+        end
+      end
     end
 
-    def clean(value)
-      super(value)
-      return nil if empty_value?(value)
+    class FloatField < IntegerField
+      def default_error_messages
+        super.merge(invalid: 'Enter a number.')
+      end
 
-      validating do
-          value = to_float(value)
-          is_not_greater_than(value, @max_value) if @max_value
-          is_not_lesser_than(value, @min_value) if @min_value
+      def to_object(value)
+        if Validators.empty_value?(value)
+          return nil
         end
 
-      value
+        begin
+          Utils.make_float(value.to_s)
+        rescue ArgumentError
+          raise ValidationError.new(error_messages[:invalid])
+        end
+      end
     end
-  end
 
-  class BigDecimalField < Field
-    set_error :invalid, 'Enter a number.'
-    set_error :max_value, 'Ensure this value is less than or equal to %(max)s.'
-    set_error :min_value, 'Ensure this value is greater than or equal to %(min)s.'
-    set_error :max_digits, 'Ensure that there are no more than %(max)s digits in total.'
-    set_error :max_decimal_places, 'Ensure that there are no more than %(max)s decimal places.'
-    set_error :max_whole_digits, 'Ensure that there are no more than %(max)s digits before the decimal point.'
-
-    def initialize(options={})
-      @max_value = options.delete(:max_value)
-      @min_value = options.delete(:min_value)
-      @max_digits = options.delete(:max_digits)
-      @max_decimal_places = options.delete(:max_decimal_places)
-      @whole_digits = @max_digits - @decimal_places if @max_digits && @decimal_places
-      super(options)
-    end
+    class BigDecimalField < Field
+      def initialize(options={})
+        @max_value = options.delete(:max_value)
+        @min_value = options.delete(:min_value)
+        @max_digits = options.delete(:max_digits)
+        @max_decimal_places = options.delete(:max_decimal_places)
+
+        if @max_digits && @max_decimal_places
+          @max_whole_digits = @max_digits - @decimal_places
+        end
 
-    def clean(value)
-      super(value)
-      return nil if !@required && empty_value?(value)
+        super(options)
 
-      validating do
-          value = to_big_decimal(value.to_s.strip)
-          is_not_greater_than(value, @max_value) if @max_value
-          is_not_lesser_than(value, @min_value) if @min_value
-          has_max_digits(value, @max_digits) if @max_digits
-          has_max_decimal_places(value, @max_decimal_places) if @max_decimal_places
-          has_max_whole_digits(value, @max_whole_digits) if @max_whole_digits
+        if @min_value
+          validators << Validators::MinValueValidator.new(@min_value)
         end
 
-      value
-    end
-  end
+        if @max_value
+          validators << Validators::MaxValueValidator.new(@max_value)
+        end
+      end
+
+      def default_error_messages
+        super.merge(invalid: 'Enter a number.',
+                    max_value: 'Ensure this value is less than or equal to %(max)s.',
+                    min_value: 'Ensure this value is greater than or equal to %(min)s.',
+                    max_digits: 'Ensure that there are no more than %(max)s digits in total.',
+                    max_decimal_places: 'Ensure that there are no more than %(max)s decimal places.',
+                    max_whole_digits: 'Ensure that there are no more than %(max)s digits before the decimal point.')
+      end
 
-  # DateField
-  # TimeField
-  # DateTimeField
+      def to_object(value)
+        if Validators.empty_value?(value)
+          return nil
+        end
 
-  class RegexField < CharField
-    def initialize(regex, options={})
-      error_message = options.delete(:error_message)
-      if error_message
-        options[:error_messages] ||= {}
-        options[:error_messages][:invalid] = error_messages
+        begin
+          Utils.make_float(value)
+          BigDecimal.new(value)
+        rescue ArgumentError
+          raise ValidationError.new(error_messages[:invalid])
+        end
       end
-      super(options)
-      @regex = regex
-    end
 
-    def clean(value)
-      value = super(value)
-      return value if value.empty?
-      validating { matches_regex(value, @regex) }
-      value
+      def validate(value)
+        super(value)
+
+        if Validators.empty_value?(value)
+          return nil
+        end
+
+        if value.nan? || value.infinite?
+          raise ValidationError.new(error_messages[:invalid])
+        end
+
+        sign, alldigits, _, whole_digits = value.split
+
+        if @max_digits && alldigits.length > @max_digits
+          msg = Utils.format_string(error_messages[:max_digits],
+                                    max: @max_digits)
+          raise ValidationError.new(msg)
+        end
+
+        decimals = alldigits.length - whole_digits
+
+        if @max_decimal_places && decimals > @max_decimal_places
+          msg = Utils.format_string(error_messages[:max_decimal_places],
+                                    max: @max_decimal_places)
+          raise ValidationError.new(msg)
+        end
+
+        if @max_whole_digits && whole_digits > @max_whole_digits
+          msg = Utils.format_string(error_messages[:max_whole_digits],
+                                    max: @max_whole_digits)
+          raise ValidationError.new(msg)
+        end
+
+        value
+      end
     end
-  end
 
-  class EmailField < RegexField
-    # Original from Django's EmailField:
-    # email_re = re.compile(
-    #    r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*"  # dot-atom
-    #    r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-011\013\014\016-\177])*"' # quoted-string
-    #    r')@(?:[A-Z0-9]+(?:-*[A-Z0-9]+)*\.)+[A-Z]{2,6}$', re.IGNORECASE)  # domain
-    EMAIL_RE = /(^[-!#\$%&'*+\/=?^_`{}|~0-9A-Z]+(\.[-!#\$%&'*+\/=?^_`{}|~0-9A-Z]+)*|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-011\013\014\016-\177])*")@(?:[A-Z0-9]+(?:-*[A-Z0-9]+)*\.)+[A-Z]{2,6}$/i
+    # DateField
+    # TimeField
+    # DateTimeField
+
+    class RegexField < CharField
+      def initialize(regex, options={})
+        error_message = options.delete(:error_message)
+
+        if error_message
+          options[:error_messages] ||= {}
+          options[:error_messages][:invalid] = error_message
+        end
+
+        super(options)
 
-    set_error :invalid, 'Enter a valid e-mail address.'
+        @regex = regex
 
-    def initialize(options={})
-      super(EMAIL_RE, options)
+        validators << Validators::RegexValidator.new(regex: regex)
+      end
     end
-  end
 
-  # TODO: add tests
-  class FileField < Field
-    widget    Widgets::FileInput
-    set_error :invalid, 'No file was submitted. Check the encoding type on the form.'
-    set_error :missing, 'No file was submitted.'
-    set_error :empty, 'The submitted file is empty.'
-    set_error :max_length, 'Ensure this filename has at most %(max)d characters (it has %(length)d).'
-
-    def initialize(options)
-      @max_length = options.delete(:max_length)
-      super(options)
+    class EmailField < CharField
+      def default_error_messages
+        super.merge(invalid: 'Enter a valid e-mail address.')
+      end
+
+      def default_validators
+        [Validators::ValidateEmail]
+      end
+
+      def clean(value)
+        value = to_object(value).strip
+        super(value)
+      end
     end
 
-    def clean(data, initial=nil)
-      super(initial || data)
+    # TODO: rewrite
+    class FileField < Field
+      def initialize(options)
+        @max_length = options.delete(:max_length)
+        @allow_empty_file = options.delete(:allow_empty_file)
+        super(options)
+      end
 
-      if !required && empty_value?(data)
-        return nil
-      elsif !data && initial
-        return initial
+      def default_error_messages
+        super.merge(invalid: 'No file was submitted. Check the encoding type on the form.',
+                    missing: 'No file was submitted.',
+                    empty: 'The submitted file is empty.',
+                    max_length: 'Ensure this filename has at most %(max)d characters (it has %(length)d).',
+                    contradiction: 'Please either submit a file or check the clear checkbox, not both.')
       end
 
-      # TODO: file validators?
-      validating do
-          # UploadedFile objects should have name and size attributes.
-          begin
-            file_name = data.name
-            file_size = data.size
-          rescue NoMethodError
-            fail_with(:invalid)
+      def default_widget
+        Widgets::ClearableFileInput
+      end
+
+      def to_object(data)
+        if Validators.empty_value?(data)
+          return nil
+        end
+
+        # UploadedFile objects should have name and size attributes.
+        begin
+          file_name = data.name
+          file_size = data.size
+        rescue NoMethodError
+          raise ValidationError.new(error_messages[:invalid])
+        end
+
+        if @max_length && file_name.length > @max_length
+          msg = Utils.format_string(error_messages[:max_length],
+                                    max: @max_length,
+                                    length: file_name.length)
+          raise ValidationError.new(msg)
+        end
+
+        if Utils.blank_value?(file_name)
+          raise ValidationError.new(error_messages[:invalid])
+        end
+
+        if !@allow_empty_file && !file_size
+          raise ValidationError.new(error_messages[:empty])
+        end
+
+        data
+      end
+
+      def clean(data, initial = nil)
+        # If the widget got contradictory inputs, we raise a validation error
+        if data.object_id ==  Widgets::ClearableFileInput::FILE_INPUT_CONTRADICTION.object_id
+          raise ValidationError.new(error_messages[:contradiction])
+        end
+
+        # False means the field value should be cleared; further validation is
+        # not needed.
+        if data == false
+          unless @required
+            return false
           end
 
-          fail_with(:max_length, :max => @max_length, :length => file_name.length) if
-            @max_length && file_name.length > @max_length
+          # If the field is required, clearing is not possible (the widget
+          # shouldn't return false data in that case anyway). false is not
+          # an 'empty_value'; if a false value makes it this far
+          # it should be validated from here on out as nil (so it will be
+          # caught by the required check).
+          data = nil
+        end
 
-          fail_with(:invalid) unless file_name
-          fail_with(:empty) unless file_size || file_size == 0
+        if !data && initial
+          initial
+        else
+          super(data)
         end
+      end
 
-      data
+      def bound_data(data, initial)
+        if data.nil? || data.object_id == Widgets::ClearableFileInput::FILE_INPUT_CONTRADICTION.object_id
+          initial
+        else
+          data
+        end
+      end
     end
-  end
 
-  #class ImageField < FileField
-  #end
+    #class ImageField < FileField
+    #end
 
-  # URLField
+    # URLField
 
-  class BooleanField < Field
-    widget Widgets::CheckboxInput
+    class BooleanField < Field
+      def default_widget
+        Widgets::CheckboxInput
+      end
 
-    def clean(value)
-      value = to_bool(value)
-      super(value)
-      validating { is_true(value) if @required }
-      value
-    end
-  end
+      def to_object(value)
+        if value.kind_of?(String) && ['false', '0'].include?(value.downcase)
+          value = false
+        else
+          value = Utils.make_bool(value)
+        end
 
-  class NullBooleanField < BooleanField
-    widget Widgets::NullBooleanSelect
+        value = super(value)
 
-    def clean(value)
-      case value
-      when true, 'true', '1', 'on' then true
-      when false, 'false', '0' then false
-      else nil
+        if !value && required
+          raise ValidationError.new(error_messages[:required])
+        end
+
+        value
       end
     end
-  end
 
-  class ChoiceField < Field
-    widget    Widgets::Select
-    set_error :invalid_choice, 'Select a valid choice. %(value)s is not one of the available choices.'
+    class NullBooleanField < BooleanField
+      def default_widget
+        Widgets::NullBooleanSelect
+      end
 
-    def initialize(choices=[], options={})
-      options[:required] = options.fetch(:required, true)
-      super(options)
-      self.choices = choices
-    end
+      def to_object(value)
+        case value
+        when true, 'true', '1', 'on' then true
+        when false, 'false', '0' then false
+        else nil
+        end
+      end
 
-    def choices
-      @choices
+      def validate(value)
+      end
     end
 
-    def choices=(value)
-      @choices = @widget.choices = value.to_a
-    end
+    class ChoiceField < Field
+      def initialize(choices=[], options={})
+        options[:required] = options.fetch(:required, true)
+        super(options)
+        self.choices = choices
+      end
+
+      def initialize_copy(original)
+        super(original)
+        self.choices = original.choices.dup
+      end
 
-    def clean(value)
-      value = super(value)
-      value = '' if empty_value?(value)
-      value = value.to_s
+      def default_error_messages
+        super.merge(invalid_choice: 'Select a valid choice. %(value)s is not one of the available choices.')
+      end
 
-      return value if value.empty?
+      def default_widget
+        Widgets::Select
+      end
 
-      validating do
-          fail_with(:invalid_choice, :value => value) unless valid_value?(value)
+      def choices
+        @choices
+      end
+
+      def choices=(value)
+        @choices = @widget.choices = value
+      end
+
+      def to_object(value)
+        if Validators.empty_value?(value)
+          ''
+        else
+          value.to_s
         end
+      end
 
-      value
-    end
+      def validate(value)
+        super(value)
 
-    def valid_value?(value)
-      @choices.each do |k, v|
+        unless !value || Validators.empty_value?(value) || valid_value?(value)
+          msg = Utils.format_string(error_messages[:invalid_choice],
+                                    value: value)
+          raise ValidationError.new(msg)
+        end
+      end
+
+      def valid_value?(value)
+        @choices.each do |k, v|
           if v.is_a?(Array)
             # This is an optgroup, so look inside the group for options
             v.each do |k2, v2|
               return true if value == k2.to_s
             end
+          elsif k.is_a?(Hash)
+            # this is a hash valued choice list
+            return true if value == k[:value].to_s
           else
             return true if value == k.to_s
           end
         end
-      false
-    end
-  end
 
-  # TODO: tests
-  class TypedChoiceField < ChoiceField
-    def initialize(choices=[], options={})
-      @coerce = options.delete(:coerce) || lambda{|val| val}
-      @empty_value = options.fetch(:empty_value, '')
-      options.delete(:empty_value)
-      super(choices, options)
+        false
+      end
     end
 
-    def clean(value)
-      value = super(value)
-      return @empty_value if value == @empty_value || empty_value?(value)
+    class TypedChoiceField < ChoiceField
+      def initialize(choices=[], options={})
+        @coerce = options.delete(:coerce) || lambda{|val| val}
+        @empty_value = options.fetch(:empty_value, '')
+        options.delete(:empty_value)
+        super(choices, options)
+      end
+
+      def to_object(value)
+        value = super(value)
+        original_validate(value)
 
-      begin
-        @coerce.call(value)
-      rescue
-        validating { fail_with(:invalid_choice, :value => value) }
+        if value == @empty_value || Validators.empty_value?(value)
+          return @empty_value
+        end
+
+        begin
+          @coerce.call(value)
+        rescue TypeError, ValidationError
+          msg = Utils.format_string(error_messages[:invalid_choice],
+                                    value: value)
+          raise ValidationError.new(msg)
+        end
+      end
+
+      alias_method :original_validate, :validate
+
+      def validate(value)
       end
     end
-  end
 
-  # TODO: tests
-  class MultipleChoiceField < ChoiceField
-    widget        Widgets::SelectMultiple
-    hidden_widget Widgets::MultipleHiddenInput
-    set_error     :invalid_choice, 'Select a valid choice. %(value)s is not one of the available choices.'
-    set_error     :invalid_list, 'Enter a list of values.'
-
-    def clean(value)
-      validating do
-          is_present(value) if @required
-          return [] if ! @required && ! value || value.empty?
-          is_array(value)
-          not_empty(value) if @required
-
-          new_value = value.map(&:to_s)
-          new_value.each do |val|
-            fail_with(:invalid_choice, :value => val) unless valid_value?(val)
+    class MultipleChoiceField < ChoiceField
+      def default_error_messages
+        super.merge(invalid_choice: 'Select a valid choice. %(value)s is not one of the available choices.',
+                    invalid_list: 'Enter a list of values.')
+      end
+
+      def default_widget
+        Widgets::SelectMultiple
+      end
+
+      def default_hidden_widget
+        Widgets::MultipleHiddenInput
+      end
+
+      def to_object(value)
+        if !value || Validators.empty_value?(value)
+          []
+        elsif !value.is_a?(Array)
+          raise ValidationError.new(error_messages[:invalid_list])
+        else
+          value.map(&:to_s)
+        end
+      end
+
+      def validate(value)
+        if required && (!value || Validators.empty_value?(value))
+          raise ValidationError.new(error_messages[:required])
+        end
+
+        value.each do |val|
+          unless valid_value?(val)
+            msg = Utils.format_string(error_messages[:invalid_choice],
+                                      value: val)
+            raise ValidationError.new(msg)
           end
         end
+      end
+    end
+
+    # TypedMultipleChoiceField < MultipleChoiceField
+
+    # TODO: tests
+    class ComboField < Field
+      def initialize(fields=[], *args)
+        super(*args)
+        fields.each {|f| f.required = false}
+        @fields = fields
+      end
+
+      def clean(value)
+        super(value)
+        @fields.each {|f| value = f.clean(value)}
+        value
+      end
+    end
+
+    # MultiValueField
+    # FilePathField
+    # SplitDateTimeField
+
+    class IPAddressField < CharField
+      def default_error_messages
+        super.merge(invalid: 'Enter a valid IPv4 address.')
+      end
+
+      def default_validators
+        [Validators::ValidateIPV4Address]
+      end
+    end
+
+    class SlugField < CharField
+      def default_error_messages
+        super.merge(invalid: "Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens.")
+      end
 
-      new_value
+      def default_validators
+        [Validators::ValidateSlug]
+      end
     end
   end
-
-  # ComboField
-  # MultiValueField
-  # FilePathField
-  # SplitDateTimeField
-  # IPAddressField
-  # SlugField
-end; end
+end