reform 2.0.0.rc1 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 981ddfe5d276177430c4441c81e38f8d1bc89166
-  data.tar.gz: 269eeca94c1c7636e4ff8fd73df5e2c6bccc459c
+  metadata.gz: a87860e43b6e321c13ae641903aa1a6b098c2ec1
+  data.tar.gz: 50d863fbf7d3e5ba9ea7eb0ea2d46a073e7cf458
 SHA512:
-  metadata.gz: 165337839adaf02e97f805f05974a2ce9b8b1950f848493a1feabbb5ce708c3877e7bb6f59c7d0f5ab088f36ddfc10c3b4069cbed2ada2ba95909a360c0d705d
-  data.tar.gz: c7cf74f86eebc98c0810299fbaa179715b2bf92ba02d666f8658a116323d8b3b637fb9cf36361612f673abe1e5aa9541d04b1606d674f758fcc264d165d0f23c
+  metadata.gz: 6a3171c4d74d852e77a88d817b886515fbe2c0f469e9f54abb3e53efd7b237013010d4b1c404b382c5e068294bd5747c9bd61061fdc511c18db8507bfff5630c
+  data.tar.gz: 12f688ec7d485fafd29924d91c5dd59862ff3fb6f23c463a3b4e6be2aaddaa6d7381e706f318029841509bfd52571d4b462d6eead389c976a3437085b6053f84

data/.travis.yml

@@ -1,15 +1,17 @@
 language: ruby
 rvm:
   - 2.2.0
-  - 2.1.5
-  - 2.0.0
   - 1.9.3
+services:
+  - mongodb
 gemfile:
+  - gemfiles/Gemfile.rails-4.2
+  - gemfiles/Gemfile.rails-4.1
   - gemfiles/Gemfile.rails-4.0
   - gemfiles/Gemfile.rails-3.2
   - gemfiles/Gemfile.rails-3.1
-  - gemfiles/Gemfile.rails-3.0
+  # - gemfiles/Gemfile.rails-3.0
 matrix:
   fast_finish: true
   allow_failures:
-    - rvm: ruby-head
+    - rvm: 1.9.3

data/CHANGES.md

@@ -14,6 +14,9 @@ you don't need to know about forms anymore, the twin handles that using #insert.
 * With `Composition` included, `Form#model` would give you a composition object. You can grab that using `Form#mapper` now.
 * `Form#update!` is deprecated. It still works but will remind you to override `#present!` or use pre-populators as [described here](http://trailblazerb.org/gems/reform/prepopulator.html) and in the Trailblazer book, chapter "Nested Forms".
 
+* Forms do not `include ActiveModel::Validations` anymore. This has polluted the entire gem and is not encapsulated in `Validator`. Consider using Lotus Validations instead.
+* Validation inheritance with `ActiveModel::Validations` is broken with Rails 3.2 and 4.0. Update Rails or use the `Lotus` validations.
+
 ## 1.2.6
 
 * Added `:prepopulate` to fill out form properties for presentation. Note that you need to call `Form#prepopulate!` to trigger the prepopulation.

data/Gemfile

@@ -3,5 +3,5 @@ source 'https://rubygems.org'
 gemspec
 
 #gem 'representable', path: "../representable"
- # gem "disposable", path: "../disposable"
+# gem "disposable", path: "../disposable"
 # gem "disposable", github: "apotonick/disposable"

data/README.md

@@ -40,7 +40,7 @@ Forms have a ridiculously simple API with only a handful of public methods.
 3. `#errors` returns validation messages in a classic ActiveModel style.
 4. `#sync` writes form data back to the model. This will only use setter methods on the model(s).
 5. `#save` (optional) will call `#save` on the model and nested models. Note that this implies a `#sync` call.
-6. `#present!` (optional) will run pre-population hooks to "fill out" your form before rendering.
+6. `#prepopulate!` (optional) will run pre-population hooks to "fill out" your form before rendering.
 
 In addition to the main API, forms expose accessors to the defined properties. This is used for rendering or manual operations.
 
@@ -77,7 +77,7 @@ Your `@form` is now ready to be rendered, either do it yourself or use something
 
 Nested forms and collections can be easily rendered with `fields_for`, etc. Note that you no longer pass the model to the form builder, but the Reform instance.
 
-Optionally, you might want to use the [#present!](#present) method to pre-populate fields and prepare the form for rendering.
+Optionally, you might want to use the `#prepopulate!` method to pre-populate fields and prepare the form for rendering.
 
 
 ## Validation
@@ -283,6 +283,30 @@ Add this line to your Gemfile:
 gem 'reform'
 ```
 
+Reform works fine with Rails 3.1-4.2. However, inheritance of validations with `ActiveModel::Validations` is broken in Rails 3.2 and 4.0.
+
+Since Reform 2.0 you need to specify which **validation backend** you want to use (unless you're in a Rails environment where ActiveModel will be used).
+
+To use ActiveModel (not recommended as it doesn't support removing validations).
+
+```ruby
+require "reform/form/active_model/validations"
+Reform::Form.class_eval do
+  include Reform::Form::ActiveModel::Validations
+end
+```
+
+To use Lotus validations (recommended).
+
+```ruby
+require "reform/form/lotus"
+Reform::Form.class_eval do
+  include Reform::Form::Lotus
+end
+```
+
+Put this in an initializer or on top of your script.
+
 
 ## Compositions
 
@@ -723,8 +747,10 @@ Rails and Reform work together out-of-the-box.
 
 However, you should know about two things.
 
-1. In case you explicitely _don't_ want to have automatic support for `ActiveRecord` and form builder: `require reform/form`, only.
+1. In case you explicitely _don't_ want to have automatic support for `ActiveRecord` or `Mongoid` and form builder: `require reform/form`, only.
 2. In some setups around Rails 4 the `Form::ActiveRecord` module is not loaded properly, usually triggering a `NoMethodError` saying `undefined method 'model'`. If that happened to you, `require 'reform/rails'` manually at the bottom of your `config/application.rb`.
+3. Mongoid form gets loaded with the gem if `Mongoid` constant is defined.
+
 
 ## ActiveRecord Compatibility
 
@@ -741,6 +767,24 @@ class SongForm < Reform::Form
   include Reform::Form::ActiveRecord
 ```
 
+## Mongoid Compatibility
+
+Reform provides the following `Mongoid` specific features. They're mixed in automatically in a Rails/Mongoid setup.
+
+ * Uniqueness validations. Use `validates_uniqueness_of` in your form.
+
+You may want to include the module manually then.
+
+```ruby
+class SongForm < Reform::Form
+  include Reform::Form::Mongoid
+```
+
+## Uniqueness Validation
+
+Both ActiveRecord and Mongoid modules will support "native" uniqueness support from the model class when you use `validates_uniqueness_of`. They will provide options like `:scope`, etc.
+
+You're encouraged to use Reform's non-writing `unique: true` validation, though. [Learn more](http://trailblazerb.org/gems/reform/validation.html)
 
 ## ActiveModel Compliance
 

data/gemfiles/Gemfile.rails-4.1

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in reform.gemspec
+gemspec :path => '../'
+
+gem 'railties', '~> 4.1.0'
+gem 'activerecord', '~> 4.1.0'
+gem 'minitest'

data/gemfiles/Gemfile.rails-4.2

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in reform.gemspec
+gemspec :path => '../'
+
+gem 'railties', '~> 4.2.0'
+gem 'activerecord', '~> 4.2.0'
+gem 'minitest'

data/lib/reform/active_record.rb

@@ -1,3 +1,4 @@
 require 'reform/form/active_model'
+require 'reform/form/orm'
 require 'reform/form/active_record'
 require 'reform/form/model_reflections' # only load this in AR context as simple_form currently is bound to AR.

data/lib/reform/contract.rb

@@ -27,7 +27,7 @@ module Reform
       end
 
       if validates_options = options[:validates]
-        validates name, validates_options.dup # .dup for RAils 3.x because it's retarded.
+        validates name, validates_options.dup # .dup for RAils 3.x.
       end
 
       super
@@ -39,20 +39,18 @@ module Reform
       args.each { |name| property(name, options) }
     end
 
-    # FIXME: make AM optional.
-    require 'active_model'
-    include ActiveModel::Validations
-
     require 'reform/contract/validate'
     include Reform::Contract::Validate
 
-    def errors # FIXME: this is needed for Rails 3.0 compatibility.
-      @errors ||= Errors.new(self)
+
+    module ValidatesWarning
+      def validates(*)
+        raise "[Reform] Please include either Reform::Form::ActiveModel::Validations or Reform::Form::Lotus in your form class."
+      end
     end
+    extend ValidatesWarning
 
   private
-    attr_writer :errors # only used in top form. (is that true?)
-
     # DISCUSS: can we achieve that somehow via features in build_inline?
     # TODO: check out if that is needed with Lotus::Validations and make it a AM feature.
     def self.process_inline!(mod, definition)
@@ -92,5 +90,3 @@ module Reform
     extend Reform::Schema
   end
 end
-
-require 'reform/contract/errors'

data/lib/reform/contract/errors.rb

@@ -1,25 +1,11 @@
 # The Errors class is planned to replace AM::Errors. It provides proper nested error messages.
 class Reform::Contract::Errors < ActiveModel::Errors
-  def messages
-    return super unless Reform.rails3_0?
-    self
-  end
-
-  # def each
-  #   messages.each_key do |attribute|
-  #     self[attribute].each { |error| yield attribute, Array.wrap(error) }
-  #   end
-  # end
-
   def merge!(errors, prefix)
-    # TODO: merge into AM.
     errors.messages.each do |field, msgs|
       unless field.to_sym == :base
         field = (prefix+[field]).join(".").to_sym # TODO: why is that a symbol in Rails?
       end
 
-      msgs = [msgs] if Reform.rails3_0? # DISCUSS: fix in #each?
-
       msgs.each do |msg|
         next if messages[field] and messages[field].include?(msg)
         add(field, msg)
@@ -28,7 +14,7 @@ class Reform::Contract::Errors < ActiveModel::Errors
   end
 
   def valid? # TODO: test me in unit test.
-    blank?
+    empty?
   end
 
   def to_s

data/lib/reform/contract/validate.rb

@@ -1,36 +1,31 @@
 module Reform::Contract::Validate
   def validate
-    options = {:errors => errs = Reform::Contract::Errors.new(self), :prefix => []}
+    validate!(errs=build_errors, [])
 
-    validate!(options)
-
-    self.errors = errs # if the AM valid? API wouldn't use a "global" variable this would be better.
-
-    errors.valid?
+    @errors = errs
+    errors.empty?
   end
 
-  def validate!(options)
-    prefix = options[:prefix]
+  def validate!(errors, prefix)
+    validate_nested!(nested_errors = build_errors, prefix) # call valid? recursively and collect nested errors.
 
-    validate_nested!(options) # call valid? recursively and collect nested errors.
+    valid?  # calls AM/Lotus validators and invokes self.errors=.
 
-    valid?  # this validates on <Fields> using AM::Validations, currently.
+    errors.merge!(self.errors, prefix) # local errors.
+    errors.merge!(nested_errors, []) #
+  end
 
-    options[:errors].merge!(self.errors, prefix)
+  def errors
+    @errors ||= build_errors
   end
 
 private
 
   # runs form.validate! on all nested forms
-  def validate_nested!(options)
+  def validate_nested!(errors, prefixes)
     schema.each(twin: true) do |dfn|
-      property_options = options.dup
-
-      property_options[:prefix] = options[:prefix].dup # TODO: implement Options#dup.
-      property_options[:prefix] << dfn.name
-
       # recursively call valid? on nested form.
-      Disposable::Twin::PropertyProcessor.new(dfn, self).() { |form| form.validate!(property_options) }
+      Disposable::Twin::PropertyProcessor.new(dfn, self).() { |form| form.validate!(errors, prefixes+[dfn.name]) }
     end
   end
 end

data/lib/reform/form/active_model.rb

@@ -99,5 +99,10 @@ module Reform::Form::ActiveModel
       return ::ActiveModel::Name.new(OpenStruct.new(:name => string)) if Reform.rails3_0?
       ::ActiveModel::Name.new(self, namespace, string)
     end
+  end # ClassMethods
+
+
+  def model_name(*args)
+    self.class.model_name(*args)
   end
 end

data/lib/reform/form/active_model/validations.rb

@@ -0,0 +1,66 @@
+require "active_model"
+require "reform/contract/errors"
+
+module Reform::Form::ActiveModel
+  # AM::Validations for your form.
+  #
+  # Note: The preferred way for validations should be Lotus::Validations, as ActiveModel::Validation's implementation is
+  # old, very complex given that it needs to do a simple thing, and it's using globals like @errors.
+  #
+  # Implements ::validates and friends, and #valid?.
+  module Validations
+    def self.included(includer)
+      includer.instance_eval do
+        extend Uber::InheritableAttr
+        inheritable_attr :validator
+        self.validator = Class.new(Validator)
+
+        class << self
+          extend Uber::Delegates
+          delegates :validator, :validates, :validate, :validates_with, :validate_with
+        end
+      end
+    end
+
+    def build_errors
+      Reform::Contract::Errors.new(self)
+    end
+
+
+    # Validators is the validatable object. On the class level, we define validations,
+    # on instance, it exposes #valid?.
+    class Validator
+      include ActiveModel::Validations
+
+      def initialize(form)
+        @form = form
+      end
+
+      def method_missing(method_name, *args, &block)
+        @form.send(method_name, *args, &block)
+      end
+
+      def self.name # FIXME: this is only needed for i18n, it seems.
+        "ba"
+      end
+
+      def self.clone
+        Class.new(self)
+      end
+    end
+
+
+    def valid?
+      validator = self.class.validator.new(self)
+      validator.valid? # run the Validations object's validator with the form as context. this won't pollute anything in the form.
+
+
+      #errors.merge!(validator.errors, "")
+      validator.errors.each do |name, error| # TODO: handle with proper merge, or something. validator.errors is ALWAYS AM::Errors.
+        errors.add(name, error)
+      end
+
+      errors.empty?
+    end
+  end
+end

data/lib/reform/form/active_record.rb

@@ -3,6 +3,7 @@ module Reform::Form::ActiveRecord
     base.class_eval do
       register_feature Reform::Form::ActiveRecord
       include Reform::Form::ActiveModel
+      include Reform::Form::ORM
       extend ClassMethods
     end
   end
@@ -18,28 +19,6 @@ module Reform::Form::ActiveRecord
   end
 
   class UniquenessValidator < ::ActiveRecord::Validations::UniquenessValidator
-    # when calling validates it should create the Vali instance already and set @klass there! # TODO: fix this in AM.
-    def validate(form)
-      property = attributes.first
-
-      # here is the thing: why does AM::UniquenessValidator require a filled-out record to work properly? also, why do we need to set
-      # the class? it would be way easier to pass #validate a hash of attributes and get back an errors hash.
-      # the class for the finder could either be infered from the record or set in the validator instance itself in the call to ::validates.
-      record = form.model_for_property(property)
-      record.send("#{property}=", form.send(property))
-
-      @klass = record.class # this is usually done in the super-sucky #setup method.
-      super(record).tap do |res|
-        form.errors.add(property, record.errors.first.last) if record.errors.present?
-      end
-    end
-  end
-
-  # TODO: this is no AR thing.
-  def model_for_property(name)
-    return model unless is_a?(Reform::Form::Composition) # i am too lazy for proper inheritance. there should be a ActiveRecord::Composition that handles this.
-
-    model_name = schema.representable_attrs.get(name)[:on]
-    model[model_name]
+    include Reform::Form::ORM::UniquenessValidator
   end
 end

data/lib/reform/form/lotus.rb

@@ -0,0 +1,55 @@
+require "lotus/validations"
+
+# Implements ::validates and friends, and #valid?.
+module Reform::Form::Lotus
+  class Errors < Lotus::Validations::Errors
+    def merge!(errors, prefix)
+      errors.instance_variable_get(:@errors).each do |name, err|
+        field = (prefix+[name]).join(".")
+        add(field, *err) # TODO: use namespace feature in Lotus here!
+      end
+      #   next if messages[field] and messages[field].include?(msg)
+    end
+
+    def inspect
+      @errors.to_s
+    end
+
+    def messages
+      self
+    end
+  end
+
+
+  def self.included(base)
+    # base.send(:include, Lotus::Validations)
+    base.extend(ClassMethods)
+  end
+
+
+  module ClassMethods
+    def validates(name, options)
+      validations.add(name, options)
+    end
+
+    def validate(name, *)
+      # DISCUSS: lotus does not support that?
+      # validations.add(name, options)
+    end
+
+    def validations
+      @validations ||= Lotus::Validations::ValidationSet.new
+    end
+  end
+
+
+  def valid?
+    # DISCUSS: by using @fields here, we avoid setters being called. win!
+    validator = Lotus::Validations::Validator.new(self.class.validations, @fields, errors)
+    validator.validate
+  end
+
+  def build_errors
+    Errors.new
+  end
+end