reform 2.0.5 → 2.1.0.rc1

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

@@ -1,4 +1,33 @@
-# Reform's own implementation for uniqueness which does not write to model.
+# === 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)
@@ -6,11 +35,15 @@ class Reform::Form::UniqueValidator < ActiveModel::EachValidator
     # search for models with attribute equals to form field value
     query = model.class.where(attribute => value)
 
-    # if model persisted, excluded own model from query
-    query = query.merge(model.class.where("id <> ?", model.id)) if model.persisted?
+    # 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 any models found, add error on attribute
-    form.errors.add(attribute, "#{attribute} must be unique.") if query.any?
+    # 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
 
@@ -18,4 +51,4 @@ end
 # make the new :unique validator available here.
 Reform::Form::ActiveModel::Validations::Validator.class_eval do
   UniqueValidator = Reform::Form::UniqueValidator
-end
+end

data/lib/reform/validation.rb

@@ -0,0 +1,40 @@
+# Adds ::validates and friends, and #valid? to the object.
+# This is completely form-independent.
+module Reform::Validation
+  module ClassMethods
+    def validation_groups
+      @groups ||= Groups.new(validation_group_class) # TODO: inheritable_attr with Inheritable::Hash
+    end
+
+    # DSL.
+    def validation(name, options={}, &block)
+      heritage.record(:validation, name, options, &block)
+
+      group = validation_groups.add(name, options)
+
+      group.instance_exec(&block)
+    end
+
+    def validates(*args, &block)
+      validation(:default, inherit: true) { validates *args, &block }
+    end
+
+    def validate(*args, &block)
+      validation(:default, inherit: true) { validate *args, &block }
+    end
+
+    def validates_with(*args, &block)
+      validation(:default, inherit: true) { validates_with *args, &block }
+    end
+  end
+
+  def self.included(includer)
+    includer.extend(ClassMethods)
+  end
+
+  def valid?
+    Groups::Result.new(self.class.validation_groups).(@fields, errors, self)
+  end
+end
+
+require "reform/validation/groups"

data/lib/reform/validation/groups.rb

@@ -0,0 +1,73 @@
+module Reform::Validation
+  # A Group is a set of native validations, targeting a validation backend (AM, Lotus, Dry).
+  # Group receives configuration via #validates and #validate and translates that to its
+  # internal backend.
+  #
+  # The #call method will run those validations on the provided objects.
+
+  # Set of Validation::Group objects.
+  # This implements adding, iterating, and finding groups, including "inheritance" and insertions.
+  class Groups < Array
+    def initialize(group_class)
+      @group_class = group_class
+    end
+
+    def add(name, options)
+      if options[:inherit]
+        return self[name] if self[name]
+      end
+
+      i = index_for(options)
+
+      self.insert(i, [name, group = @group_class.new, options]) # Group.new
+      group
+    end
+
+  private
+
+    def index_for(options)
+      return find_index { |el| el.first == options[:after] } + 1 if options[:after]
+      size # default index: append.
+    end
+
+    def [](name)
+      cfg = find { |cfg| cfg.first == name }
+      return unless cfg
+      cfg[1]
+    end
+
+
+    # Runs all validations groups according to their rules and returns result.
+    # Populates errors passed into #call.
+    class Result # DISCUSS: could be in Groups.
+      def initialize(groups)
+        @groups = groups
+      end
+
+      def call(fields, errors, form)
+        result = true
+        results = {}
+
+        @groups.each do |cfg|
+          name, group, options = cfg
+          depends_on = options[:if]
+
+          if evaluate_if(depends_on, results, form)
+            # puts "evaluating #{group.instance_variable_get(:@validator).instance_variable_get(:@checker).inspect}"
+            results[name] = group.(fields, errors, form).empty? # validate.
+          end
+
+          result &= errors.empty?
+        end
+
+        result
+      end
+
+      def evaluate_if(depends_on, results, form)
+        return true if depends_on.nil?
+        return results[depends_on] if depends_on.is_a?(Symbol)
+        form.instance_exec(results, &depends_on)
+      end
+    end
+  end
+end

data/lib/reform/version.rb

@@ -1,3 +1,3 @@
 module Reform
-  VERSION = "2.0.5"
+  VERSION = "2.1.0.rc1"
 end

data/reform.gemspec

@@ -17,8 +17,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency             "disposable",     "~> 0.1.11"
+  spec.add_dependency             "disposable",     ">= 0.2.1", "< 0.3.0"
   spec.add_dependency             "uber",           "~> 0.0.11"
+  spec.add_dependency             "representable",  ">= 2.4.0", "< 3.1.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
@@ -31,5 +32,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "multi_json"
 
   spec.add_development_dependency "lotus-validations"
+  spec.add_development_dependency "dry-validation"
   spec.add_development_dependency "actionpack"
 end

data/test/active_record_test.rb

@@ -21,6 +21,8 @@ require 'reform/active_record'
 
 class ActiveRecordTest < MiniTest::Spec
   class SongForm < Reform::Form
+    feature Reform::Form::ActiveModel::Validations
+
     include Reform::Form::ActiveRecord
     model :song
 

data/test/contract_test.rb

@@ -40,7 +40,7 @@ class ContractTest < MiniTest::Spec
   end
 
   describe "#options_for" do
-    it { AlbumForm.options_for(:name).inspect.must_match "#<Representable::Definition ==>name @options" }
-    it { AlbumForm.new(album).options_for(:name).inspect.must_match "#<Representable::Definition ==>name @options" }
+    it { AlbumForm.options_for(:name).extend(Declarative::Inspect).inspect.must_equal "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
+    it { AlbumForm.new(album).options_for(:name).extend(Declarative::Inspect).inspect.must_equal "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
   end
 end

data/test/deprecation_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+
+class DeprecationRemoveMePopulatorTest < MiniTest::Spec
+  Album = Struct.new(:songs)
+  Song  = Struct.new(:title)
+
+
+  class AlbumForm < Reform::Form
+    collection :songs, populator: ->(fragment, collection, index, *) { return Representable::Pipeline::Stop if fragment[:title]=="Good"
+      songs[index]
+              } do
+      property :title
+    end
+  end
+
+  it do
+    form = AlbumForm.new(Album.new([Song.new, Song.new]))
+    hash = {songs: [{title: "Good"}, {title: "Bad"}]}
+
+    form.validate(hash)
+
+    form.songs.size.must_equal 2
+    form.songs[0].title.must_equal nil
+    form.songs[1].title.must_equal "Bad"
+  end
+end

data/test/deserialize_test.rb

@@ -1,26 +1,26 @@
 require 'test_helper'
+require "representable/json"
 
 class DeserializeTest < MiniTest::Spec
   Song  = Struct.new(:title, :album, :composer)
   Album = Struct.new(:title, :artist)
-  Artist = Struct.new(:name)
+  Artist = Struct.new(:name, :callname)
 
   class JsonAlbumForm < Reform::Form
     module Json
       def deserialize(params)
-        # params = deserialize!(params) # DON'T call those hash hooks.
-
         deserializer.new(self).
         # extend(Representable::Debug).
           from_json(params)
       end
 
       def deserializer
-        deserializer = Disposable::Twin::Schema.from(self.class,
+        Disposable::Rescheme.from(self.class,
           include:          [Representable::JSON],
           superclass:       Representable::Decorator,
-          representer_from: lambda { |inline| inline.representer_class },
-          options_from:     :deserializer
+          definitions_from: lambda { |inline| inline.definitions },
+          options_from:     :deserializer,
+          exclude_options:  [:populator]
         )
       end
     end
@@ -33,6 +33,7 @@ class DeserializeTest < MiniTest::Spec
     end
   end
 
+
   let (:artist) { Artist.new("A-ha") }
   it do
     artist_id = artist.object_id
@@ -46,6 +47,26 @@ class DeserializeTest < MiniTest::Spec
     form.artist.name.must_equal "Mute"
     form.artist.model.object_id.must_equal artist_id
   end
+
+  describe "infering the deserializer from another form should NOT copy its populators" do
+    class CompilationForm < Reform::Form
+      property :artist, populator: ->(options) { self.artist = Artist.new(nil, options[:fragment].to_s) } do
+        property :name
+      end
+
+      def deserializer
+        super(JsonAlbumForm, include: [Representable::Hash])
+      end
+    end
+
+    # also tests the Form#deserializer API. # FIXME.
+    it "uses deserializer inferred from JsonAlbumForm but deserializes/populates to CompilationForm" do
+      form = CompilationForm.new(Album.new)
+      form.validate("artist"=> {"name" => "Horowitz"}) # the deserializer doesn't know symbols.
+      form.sync
+      form.artist.model.must_equal Artist.new("Horowitz", %{{"name"=>"Horowitz"}})
+    end
+  end
 end
 
 
@@ -66,10 +87,10 @@ class ValidateWithBlockTest < MiniTest::Spec
     form  = AlbumForm.new(album)
     json  = {title: "Apocalypse Soon", artist: {name: "Mute"}}.to_json
 
-    deserializer = Disposable::Twin::Schema.from(AlbumForm,
+    deserializer = Disposable::Rescheme.from(AlbumForm,
       include:          [Representable::JSON],
       superclass:       Representable::Decorator,
-      representer_from: lambda { |inline| inline.representer_class },
+      definitions_from: lambda { |inline| inline.definitions },
       options_from:     :deserializer
     )
 

data/test/dummy/config/locales/en.yml

@@ -1,7 +1,9 @@
 ---
 en:
   # custom validation error messages
-
+  errors:
+    messages:
+      taken: has already been taken
   activemodel:
     errors:
       models:
@@ -9,3 +11,4 @@ en:
           attributes:
             title:
               custom_error_message: Custom Error Message
+              taken: has already been taken

data/test/errors_test.rb

@@ -83,10 +83,10 @@ class ErrorsTest < MiniTest::Spec
 
 
   describe "#validate with main form invalid" do
-    before { @result = form.validate("title"=>"", "band"=>{"label"=>{:name => "Fat Wreck"}}) }
-
-    it { @result.must_equal false }
-    it { form.errors.messages.must_equal({:title=>["can't be blank"]}) }
+    it do
+      form.validate("title"=>"", "band"=>{"label"=>{:name => "Fat Wreck"}}).must_equal false
+      form.errors.messages.must_equal({:title=>["can't be blank"]})
+    end
   end
 
 

data/test/feature_test.rb

@@ -10,8 +10,8 @@ class FeatureInheritanceTest < BaseTest
       "May 16"
     end
 
-    def self.included(base)
-      base.representer_class.representable_attrs.features << self # TODO: register_feature
+    def self.included(includer)
+      includer.send :register_feature, self
     end
   end
 

data/test/fixtures/dry_error_messages.yml

@@ -0,0 +1,43 @@
+array?: "%{name} must be an array"
+
+empty?: "%{name} cannot be empty"
+
+exclusion?: "%{name} must not be one of: %{list}"
+
+eql?: "%{name} must be equal to %{eql_value}"
+
+filled?: "%{name} must be filled"
+
+format?: "%{name} is in invalid format"
+
+gt?: "%{name} must be greater than %{num} (%{value} was given)"
+
+gteq?: "%{name} must be greater than or equal to %{num}"
+
+hash?: "%{name} must be a hash"
+
+inclusion?: "%{name} must be one of: %{list}"
+
+int?: "%{name} must be an integer"
+
+key?: "%{name} is missing"
+
+lt?: "%{name} must be less than %{num} (%{value} was given)"
+
+lteq?: "%{name} must be less than or equal to %{num}"
+
+max_size?: "%{name} size cannot be greater than %{num}"
+
+min_size?: "%{name} size cannot be less than %{num}"
+
+nil?: "%{name} cannot be nil"
+
+size?:
+  range: "%{name} size must be within %{left} - %{right}"
+  default: "%{name} size must be %{num}"
+
+str?: "%{name} must be a string"
+
+good_musical_taste?: "you're a bad person"
+
+form_access_validation?: "this doesn't look like a Reform form dude!!"

data/test/form_builder_test.rb

@@ -12,7 +12,7 @@ class FormBuilderCompatTest < BaseTest
     end
 
     collection :songs do
-      feature Reform::Form::ActiveModel::FormBuilderMethods
+      # feature Reform::Form::ActiveModel::FormBuilderMethods
       property :title
       property :release_date, :multi_params => true
       validates :title, :presence => true
@@ -37,15 +37,17 @@ class FormBuilderCompatTest < BaseTest
 
 
   let (:song) { OpenStruct.new }
-  let (:form) { AlbumForm.new(OpenStruct.new(
-    :artist => Artist.new(:name => "Propagandhi"),
-    :songs  => [song],
-    :label  => Label.new,
+  let (:form) {
+    AlbumForm.new(OpenStruct.new(
+      :artist => Artist.new(:name => "Propagandhi"),
+      :songs  => [song],
+      :label  => Label.new,
 
-    :band => Band.new(OpenStruct.new(location: OpenStruct.new))
-    )) }
+      :band => Band.new(OpenStruct.new(location: OpenStruct.new))
+    ))
+  }
 
-  it "xxxrespects _attributes params hash" do
+  it "respects _attributes params hash" do
     form.validate(
       "artist_attributes" => {"name" => "Blink 182"},
       "songs_attributes"  => {"0" => {"title" => "Damnit"}},