reform 2.1.0 → 2.2.0.rc1

data/lib/reform/form/active_record.rb

@@ -1,30 +0,0 @@
-require "reform/form/orm"
-
-module Reform::Form::ActiveRecord
-  def self.included(base)
-    base.class_eval do
-      register_feature Reform::Form::ActiveRecord
-      include Reform::Form::ActiveModel
-      include Reform::Form::ORM
-      extend ClassMethods
-    end
-  end
-
-  module ClassMethods
-    def validates_uniqueness_of(attribute, options={})
-      options = options.merge(:attributes => [attribute])
-      validates_with(UniquenessValidator, options)
-    end
-    def i18n_scope
-      :activerecord
-    end
-  end
-
-  def to_nested_hash(*)
-    super.with_indifferent_access
-  end
-
-  class UniquenessValidator < ::ActiveRecord::Validations::UniquenessValidator
-    include Reform::Form::ORM::UniquenessValidator
-  end
-end

data/lib/reform/form/lotus.rb

@@ -1,59 +0,0 @@
-require "lotus/validations"
-
-# Implements ::validates and friends, and #valid?.
-module Reform::Form::Lotus
-  class Errors < Lotus::Validations::Errors
-    def merge!(errors, prefix)
-      new_errors = {}
-      errors.instance_variable_get(:@errors).each do |name, err|
-        field = (prefix+[name]).join(".")
-        new_errors[field] = err
-      end
-      #   next if messages[field] and messages[field].include?(msg)
-
-      new_errors.each { |field, err| add(field, *err) } # TODO: use namespace feature in Lotus here!
-    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 build_errors
-    Errors.new
-  end
-
-  private
-
-  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
-end

data/lib/reform/form/multi_parameter_attributes.rb

@@ -1,48 +0,0 @@
-module Reform::Form::MultiParameterAttributes
-  # TODO: implement this with parse_filter, so we don't have to manually walk through the hash, etc.
-  class DateTimeParamsFilter
-    def call(params)
-      params = params.dup # DISCUSS: not sure if that slows down form processing?
-      date_attributes = {}
-
-      params.each do |attribute, value|
-        if value.is_a?(Hash)
-          params[attribute] = call(value) # TODO: #validate should only handle local form params.
-        elsif matches = attribute.match(/^(\w+)\(.i\)$/)
-          date_attribute = matches[1]
-          date_attributes[date_attribute] = params_to_date(
-            params.delete("#{date_attribute}(1i)"),
-            params.delete("#{date_attribute}(2i)"),
-            params.delete("#{date_attribute}(3i)"),
-            params.delete("#{date_attribute}(4i)"),
-            params.delete("#{date_attribute}(5i)")
-          )
-        end
-      end
-      params.merge!(date_attributes)
-    end
-
-  private
-    def params_to_date(year, month, day, hour, minute)
-      date_fields = [year, month, day].map!(&:to_i)
-      time_fields = [hour, minute].map!(&:to_i)
-
-      if date_fields.any?(&:zero?) || !Date.valid_date?(*date_fields)
-        return nil
-      end
-
-      if hour.blank? && minute.blank?
-        Date.new(*date_fields)
-      else
-        args = date_fields + time_fields
-        Time.zone ? Time.zone.local(*args) :
-          Time.new(*args)
-      end
-    end
-  end
-
-  # this hooks into the format-specific #deserialize! method.
-  def deserialize!(params)
-    super DateTimeParamsFilter.new.call(params) # if params.is_a?(Hash) # this currently works for hash, only.
-  end
-end

data/lib/reform/form/validation/unique_validator.rb

@@ -1,54 +0,0 @@
-# === Unique Validation
-# Reform's own implementation for uniqueness which does not write to model
-#
-# == Usage
-# Pass a true boolean value to validate a field against all values available in
-# the database:
-# validates :title, unique: true
-#
-# == Options
-# = Scope
-# A scope can be use to filter the records that need to be compare with the
-# current value to validate. A scope array can have one to many fields define.
-#
-# A scope can be define the following ways:
-# validates :title, unique: { scope: :album_id }
-# validates :title, unique: { scope: [:album_id] }
-# validates :title, unique: { scope: [:album_id, ...] }
-#
-# All fields included in a scope must be declared as a property like this:
-# property :album_id
-# validates :title, unique: { scope: :album_id }
-#
-# Just remove write access to the property if the field must not be change:
-# property :album_id, writeable: false
-# validates :title, unique: { scope: :album_id }
-#
-# This use case is useful if album_id is set to a Song this way:
-# song = album.songs.new
-# album_id is automatically set and can't be change by the operation
-
-class Reform::Form::UniqueValidator < ActiveModel::EachValidator
-  def validate_each(form, attribute, value)
-    model = form.model_for_property(attribute)
-
-    # search for models with attribute equals to form field value
-    query = model.class.where(attribute => value)
-
-    # apply scope if options has been declared
-    Array(options[:scope]).each do |field|
-      # add condition to only check unique value with the same scope
-      query = query.where(field => form.send(field))
-    end
-
-    # if model persisted, query may return 0 or 1 rows, else 0
-    allow_count = model.persisted? ? 1 : 0
-    form.errors.add(attribute, :taken) if query.count > allow_count
-  end
-end
-
-# FIXME: ActiveModel loads validators via const_get(#{name}Validator). This magic forces us to
-# make the new :unique validator available here.
-Reform::Form::ActiveModel::Validations::Validator.class_eval do
-  UniqueValidator = Reform::Form::UniqueValidator
-end

data/lib/reform/rails.rb

@@ -1,13 +0,0 @@
-require "reform/form/active_model"
-require "reform/form/active_model/validations"
-
-require "reform/active_record" if defined?(ActiveRecord)
-require "reform/mongoid" if defined?(Mongoid)
-
-Reform::Form.class_eval do # DISCUSS: i'd prefer having a separate Rails module to be mixed into the Form but this is way more convenient for 99% users.
-  include Reform::Form::ActiveModel
-  include Reform::Form::ActiveModel::FormBuilderMethods
-  include Reform::Form::ActiveRecord if defined?(ActiveRecord)
-  include Reform::Form::Mongoid if defined?(Mongoid)
-  include Reform::Form::ActiveModel::Validations
-end

data/test/active_model_custom_validation_translations_test.rb

@@ -1,75 +0,0 @@
-require 'test_helper'
-
-class ActiveModelCustomValidationTranslationsTest < MiniTest::Spec
-  module SongForm
-    class WithBlock < Reform::Form
-      model :song
-      property :title
-
-      validate do
-        errors.add :title, :blank
-        errors.add :title, :custom_error_message
-      end
-    end
-
-    class WithLambda < Reform::Form
-      model :song
-      property :title
-
-      validate ->{ errors.add :title, :blank
-                   errors.add :title, :custom_error_message }
-    end
-
-    class WithMethod < Reform::Form
-      model :song
-      property :title
-
-      validate :custom_validation_method
-      def custom_validation_method
-        errors.add :title, :blank
-        errors.add :title, :custom_error_message
-      end
-    end
-  end
-
-
-  describe 'when using a default translation' do
-    it 'translates the error message when custom validation is used with block' do
-      form = SongForm::WithBlock.new(Song.new)
-      form.validate({})
-      form.errors[:title].must_include "can't be blank"
-    end
-
-    it 'translates the error message when custom validation is used with lambda' do
-      form = SongForm::WithLambda.new(Song.new)
-      form.validate({})
-      form.errors[:title].must_include "can't be blank"
-    end
-
-    it 'translates the error message when custom validation is used with method' do
-      form = SongForm::WithMethod.new(Song.new)
-      form.validate({})
-      form.errors[:title].must_include "can't be blank"
-    end
-  end
-
-  describe 'when using a custom translation' do
-    it 'translates the error message when custom validation is used with block' do
-      form = SongForm::WithBlock.new(Song.new)
-      form.validate({})
-      form.errors[:title].must_include "Custom Error Message"
-    end
-
-    it 'translates the error message when custom validation is used with lambda' do
-      form = SongForm::WithLambda.new(Song.new)
-      form.validate({})
-      form.errors[:title].must_include "Custom Error Message"
-    end
-
-    it 'translates the error message when custom validation is used with method' do
-      form = SongForm::WithMethod.new(Song.new)
-      form.validate({})
-      form.errors[:title].must_include "Custom Error Message"
-    end
-  end
-end

data/test/active_model_test.rb

@@ -1,207 +0,0 @@
-require 'test_helper'
-
-module IsolatedRailsEngine
-  def self.use_relative_model_naming?
-    true
-  end
-
-  class Lyric < ActiveRecord::Base
-  end
-end
-
-module NormalRailsEngine
-  class Lyric < ActiveRecord::Base
-  end
-end
-
-
-class NewActiveModelTest < MiniTest::Spec # TODO: move to test/rails/
-  class SongForm < Reform::Form
-    include Reform::Form::ActiveModel
-
-    property :name
-  end
-
-  let (:artist) { Artist.create(:name => "Frank Zappa") }
-  let (:form) { SongForm.new(artist) }
-
-  it do
-    form.persisted?.must_equal true
-    form.to_key.must_equal [artist.id]
-    form.to_param.must_equal "#{artist.id}"
-    form.to_model.must_equal form
-    form.id.must_equal artist.id
-    form.model_name.must_equal form.class.model_name
-  end
-
-  describe "::model_name" do
-    it { form.class.model_name.must_be_kind_of ActiveModel::Name }
-    it { form.class.model_name.to_s.must_equal "NewActiveModelTest::Song" }
-
-    let (:class_with_model) {
-      Class.new(Reform::Form) do
-        include Reform::Form::ActiveModel
-
-        model :album
-      end
-    }
-
-    it { class_with_model.model_name.must_be_kind_of ActiveModel::Name }
-    it { class_with_model.model_name.to_s.must_equal "Album" }
-
-    let (:class_with_isolated_model) {
-      Class.new(Reform::Form) do
-        include Reform::Form::ActiveModel
-
-        model "isolated_rails_engine/lyric", namespace: "isolated_rails_engine"
-      end
-    }
-
-    it { class_with_isolated_model.model_name.must_be_kind_of ActiveModel::Name }
-    it { class_with_isolated_model.model_name.to_s.must_equal "IsolatedRailsEngine::Lyric" }
-
-    let (:class_with_namespace_model) {
-      Class.new(Reform::Form) do
-        include Reform::Form::ActiveModel
-
-        model "normal_rails_engine/lyric"
-      end
-    }
-
-    it { class_with_namespace_model.model_name.must_be_kind_of ActiveModel::Name }
-    it { class_with_namespace_model.model_name.to_s.must_equal "NormalRailsEngine::Lyric" }
-
-    let (:subclass_of_class_with_model) {
-      Class.new(class_with_model)
-    }
-
-    it { subclass_of_class_with_model.model_name.must_be_kind_of ActiveModel::Name }
-    it { subclass_of_class_with_model.model_name.to_s.must_equal 'Album' }
-
-    it { form.class.model_name.route_key.must_equal "new_active_model_test_songs" }
-    it { class_with_model.model_name.route_key.must_equal "albums" }
-    it { class_with_isolated_model.model_name.route_key.must_equal "lyrics" }
-    it { class_with_namespace_model.model_name.route_key.must_equal "normal_rails_engine_lyrics" }
-    it { subclass_of_class_with_model.model_name.route_key.must_equal 'albums' }
-
-    describe "class named Song::Form" do
-      it do
-        class Form < Reform::Form
-          include Reform::Form::ActiveModel
-          self
-        end.model_name.to_s.must_equal "NewActiveModelTest"
-      end
-    end
-
-
-    describe "inline with model" do
-      let (:form_class) {
-        Class.new(Reform::Form) do
-          include Reform::Form::ActiveModel
-
-          property :song do
-            include Reform::Form::ActiveModel
-            model :hit
-          end
-        end
-      }
-
-      let (:inline) { form_class.new(OpenStruct.new(:song => Object.new)).song }
-
-      it { inline.class.model_name.must_be_kind_of ActiveModel::Name }
-      it { inline.class.model_name.to_s.must_equal "Hit" }
-    end
-
-    describe "inline without model" do
-      let (:form_class) {
-        Class.new(Reform::Form) do
-          include Reform::Form::ActiveModel
-
-          property :song do
-            include Reform::Form::ActiveModel
-          end
-
-          collection :hits do
-            include Reform::Form::ActiveModel
-          end
-        end
-      }
-
-      let (:form) { form_class.new(OpenStruct.new(:hits=>[OpenStruct.new], :song => OpenStruct.new)) }
-
-      it { form.song.class.model_name.must_be_kind_of ActiveModel::Name }
-      it { form.song.class.model_name.to_s.must_equal "Song" }
-      it "singularizes collection name" do
-        form.hits.first.class.model_name.to_s.must_equal "Hit"
-      end
-    end
-  end
-end
-
-
-class ActiveModelWithCompositionTest < MiniTest::Spec
-   class HitForm < Reform::Form
-    include Composition
-    include Reform::Form::ActiveModel
-
-    property  :title,         :on => :song
-    properties :name, :genre, :on => :artist # we need to check both ::property and ::properties here!
-
-    model :hit, :on => :song
-  end
-
-  let (:rio) { OpenStruct.new(:title => "Rio") }
-  let (:duran) { OpenStruct.new }
-  let (:form) { HitForm.new(:song => rio, :artist => duran) }
-
-  describe "model accessors a la model#[:hit]" do
-    it { form.model[:song].must_equal rio }
-    it { form.model[:artist].must_equal duran }
-
-    it "doesn't delegate when :on missing" do
-      class SongOnlyForm < Reform::Form
-        include Composition
-        include Reform::Form::ActiveModel
-
-        property :title,  :on => :song
-
-        model :song
-      end.new(:song => rio, :artist => duran).model[:song].must_equal rio
-    end
-  end
-
-
-  it "provides ::model_name" do
-    form.class.model_name.must_equal "Hit"
-  end
-
-  it "provides #persisted?" do
-    HitForm.new(:song => OpenStruct.new.instance_eval { def persisted?; "yo!"; end; self }, :artist => OpenStruct.new).persisted?.must_equal "yo!"
-  end
-
-  it "provides #to_key" do
-    HitForm.new(:song => OpenStruct.new.instance_eval { def to_key; "yo!"; end; self }, :artist => OpenStruct.new).to_key.must_equal "yo!"
-  end
-
-  it "provides #to_param" do
-    HitForm.new(:song => OpenStruct.new.instance_eval { def to_param; "yo!"; end; self }, :artist => OpenStruct.new).to_param.must_equal "yo!"
-  end
-
-  it "provides #to_model" do
-    form = HitForm.new(:song => OpenStruct.new, :artist => OpenStruct.new)
-    form.to_model.must_equal form
-  end
-
-  it "works with any order of ::model and ::property" do
-    class AnotherForm < Reform::Form
-      include Composition
-      include Reform::Form::ActiveModel
-
-      model :song, :on => :song
-      property  :title,  :on => :song
-    end
-
-
-    AnotherForm.new(:song => rio).model[:song].must_equal rio
-  end
-end