reform 2.2.4 → 2.3.0.rc1

data/lib/reform/form/populator.rb

@@ -7,7 +7,7 @@
 class Reform::Form::Populator
   def initialize(user_proc)
     @user_proc = user_proc # the actual `populator: ->{}` block from the user, via ::property.
-    @value     = Declarative::Option(user_proc, instance_exec: true) # we can now process Callable, procs, :symbol.
+    @value     = Declarative::Option(user_proc, instance_exec: true, callable: Object) # we can now process Callable, procs, :symbol.
   end
 
   def call(input, options)
@@ -29,10 +29,7 @@ class Reform::Form::Populator
 private
   def call!(options)
     form = options[:represented]
-
-    deprecate_positional_args(form, @user_proc, options) do
-      @value.(form, options)
-    end
+    @value.(form, options) # Declarative::Option call.
   end
 
   def handle_fail(twin, options)
@@ -43,17 +40,6 @@ private
      Representable::GetValue.(nil, options)
   end
 
-  def deprecate_positional_args(form, proc, options) # TODO: remove in 2.2.
-    arity = proc.is_a?(Symbol) ? form.method(proc).arity : proc.arity
-    return yield if arity == 1
-    warn "[Reform] Positional arguments for :populator and friends are deprecated. Please use ->(options) and enjoy the rest of your day. Learn more at http://trailblazerb.org/gems/reform/upgrading-guide.html#to-21"
-    args = []
-    args <<  options[:index] if  options[:index]
-    args << options[:representable_options]
-    form.instance_exec(options[:fragment], options[:model], *args, &proc)
-  end
-
-
   class IfEmpty < self # Populator
     def call!(options)
       binding, twin, index, fragment = options[:binding], options[:model], options[:index], options[:fragment] # TODO: remove once we drop 2.0.

data/lib/reform/form/prepopulate.rb

@@ -21,4 +21,4 @@ private
       Disposable::Twin::PropertyProcessor.new(dfn, self).() { |form| form.prepopulate!(options) }
     end
   end
-end
+end

data/lib/reform/form/validate.rb

@@ -18,16 +18,19 @@ module Reform::Form::Validate
 
   def validate(params)
     # allow an external deserializer.
+    @input_params = params # we want to store these for access via dry later
     block_given? ? yield(params) : deserialize(params)
 
     super() # run the actual validation on self.
   end
+  attr_reader :input_params # make the raw input params public
 
   def deserialize(params)
     params = deserialize!(params)
     deserializer.new(self).from_hash(params)
   end
 
+
 private
   # Meant to return params processable by the representer. This is the hook for munching date fields, etc.
   def deserialize!(params)
@@ -40,7 +43,7 @@ private
 
   # Default deserializer for hash.
   # This is input-specific, e.g. Hash, JSON, or XML.
-  def deserializer(source=self.class, options={}) # called on top-level, only, for now.
+  def deserializer!(source=self.class, options={}) # called on top-level, only, for now.
     deserializer = Disposable::Rescheme.from(source,
       {
         include:          [Representable::Hash::AllowSymbols, Representable::Hash],
@@ -54,7 +57,12 @@ private
     deserializer
   end
 
+  def deserializer(*args)
+    # DISCUSS: should we simply delegate to class and sort out memoizing there?
+    self.class.deserializer_class || self.class.deserializer_class = deserializer!(*args)
+  end
 
-  class DeserializeError < RuntimeError
+  def self.included(includer)
+    includer.singleton_class.send :attr_accessor, :deserializer_class
   end
 end

data/lib/reform/result.rb

@@ -0,0 +1,63 @@
+module Reform
+  class Contract < Disposable::Twin
+
+    # Collects all native results of a form of all groups and provides
+    # a unified API: #success?, #errors, #messages, #hints.
+    # #success? returns validity of the branch.
+    class Result
+      def initialize(results, nested_results=[]) # DISCUSS: do we like this?
+        @results = results # native Result objects, e.g. `#<Dry::Validation::Result output={:title=>"Fallout", :composer=>nil} errors={}>`
+        @failure = (results + nested_results).find(&:failure?) # TODO: test nested.
+      end
+
+      def failure?; @failure  end
+      def success?; !failure? end
+
+      def errors(*args);   filter_for(:errors, *args) end
+      def messages(*args); filter_for(:messages, *args) end
+      def hints(*args);    filter_for(:hints, *args) end
+
+    private
+      def filter_for(method, *args)
+        @results.collect { |r| r.public_send(method, *args) }
+          .inject({}) { |hsh, errs| hsh.merge(errs) }
+          .find_all { |k, v| v.is_a?(Array) } # filter :nested=>{:something=>["too nested!"]} #DISCUSS: do we want that here?
+          .to_h
+      end
+
+      # Note: this class will be redundant in Reform 3, where the public API
+      # allows/enforces to pass options to #errors (e.g. errors(locale: "br"))
+      # which means we don't have to "lazy-handle" that with "pointers".
+      # :private:
+      class Pointer
+        extend Forwardable
+
+        def initialize(result, path)
+          @result, @path = result, path
+        end
+
+        def_delegators :@result, :success?, :failure?
+
+        def errors(*args);   traverse_for(:errors, *args) end
+        def messages(*args); traverse_for(:messages, *args) end
+        def hints(*args);    traverse_for(:hints, *args) end
+
+        def advance(*path)
+          path = @path + path.compact # remove index if nil.
+          return if traverse(@result.errors, path) == {}
+
+          Pointer.new(@result, path)
+        end
+
+      private
+        def traverse(hash, path)
+          path.inject(hash) { |errs, segment| errs[segment] || {} } # FIXME. test if all segments present.
+        end
+
+        def traverse_for(method, *args)
+          traverse(@result.public_send(method, *args), @path) # TODO: return [] if nil
+        end
+      end
+    end
+  end
+end

data/lib/reform/validation.rb

@@ -3,28 +3,36 @@
 module Reform::Validation
   module ClassMethods
     def validation_groups
-      @groups ||= Groups.new(validation_group_class) # TODO: inheritable_attr with Inheritable::Hash
+      @groups ||= Groups.new(validation_group_class)
     end
 
     # DSL.
-    def validation(name=:default, options={}, &block)
-      heritage.record(:validation, name, options, &block)
+    def validation(name=nil, options={}, &block)
+      options = deprecate_validation_positional_args(name, options)
+      name    = options[:name] # TODO: remove in favor of kw args in 3.0.
 
+      heritage.record(:validation, 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 deprecate_validation_positional_args(name, options)
+      if name.is_a?(Symbol)
+        warn "[Reform] Form::validation API is now: validation(name: :default, if:nil, schema:Schema). Please use keyword arguments instead of positional arguments."
+        return { name: name }.merge(options)
+      end
+
+      if name.nil?
+        return { name: :default }.merge(options)
+      end
 
-    def validate(*args, &block)
-      validation(:default, inherit: true) { validate *args, &block }
+      { name: :default }.merge(name)
     end
 
-    def validates_with(*args, &block)
-      validation(:default, inherit: true) { validates_with *args, &block }
+    def validation_group_class
+      raise NoValidationLibraryError, 'no validation library loaded. Please include a ' +
+                            'validation library such as Reform::Form::Dry'
     end
   end
 
@@ -32,9 +40,7 @@ module Reform::Validation
     includer.extend(ClassMethods)
   end
 
-  def valid?
-    Groups::Result.new(self.class.validation_groups).(to_nested_hash, errors, self)
-  end
+  NoValidationLibraryError = Class.new(RuntimeError)
 end
 
 require "reform/validation/groups"

data/lib/reform/validation/groups.rb

@@ -19,7 +19,7 @@ module Reform::Validation
 
       i = index_for(options)
 
-      self.insert(i, [name, group = @group_class.new, options]) # Group.new
+      self.insert(i, [name, group = @group_class.new(options), options]) # Group.new
       group
     end
 
@@ -31,43 +31,29 @@ module Reform::Validation
     end
 
     def [](name)
-      cfg = find { |cfg| cfg.first == name }
+      cfg = find { |c| c.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
+    # Runs all validations groups according to their rules and returns all Result objects.
+    class Validate
+      def self.call(groups, form)
         results = {}
 
-        @groups.each do |cfg|
-          name, group, options = cfg
-          depends_on = options[:if]
+        groups.collect do |(name, group, options)|
+          next unless evaluate?(options[:if], results, form)
 
-          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?
+          results[name] = group.(form) # run validation for group. store and collect <Result>.
         end
-
-        result
       end
 
-      def evaluate_if(depends_on, results, form)
+      def self.evaluate?(depends_on, results, form)
         return true if depends_on.nil?
-        return results[depends_on] if depends_on.is_a?(Symbol)
+        return results[depends_on].success? if depends_on.is_a?(Symbol)
         form.instance_exec(results, &depends_on)
       end
     end
   end
-end
+end

data/lib/reform/version.rb

@@ -1,3 +1,3 @@
 module Reform
-  VERSION = "2.2.4"
+  VERSION = "2.3.0.rc1"
 end

data/reform.gemspec

@@ -5,11 +5,11 @@ require 'reform/version'
 Gem::Specification.new do |spec|
   spec.name          = "reform"
   spec.version       = Reform::VERSION
-  spec.authors       = ["Nick Sutterer", "Garrett Heinlen"]
-  spec.email         = ["apotonick@gmail.com", "heinleng@gmail.com"]
+  spec.authors       = ["Nick Sutterer", "Fran Worley"]
+  spec.email         = ["apotonick@gmail.com", "frances@safetytoolbox.co.uk"]
   spec.description   = %q{Form object decoupled from models.}
   spec.summary       = %q{Form object decoupled from models with validation, population and presentation.}
-  spec.homepage      = "https://github.com/apotonick/reform"
+  spec.homepage      = "https://github.com/trailblazer/reform"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -17,13 +17,14 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency             "disposable",    ">= 0.4.1"
-  spec.add_dependency             "representable", ">= 2.4.0", "< 3.1.0"
+  spec.add_dependency             "disposable",     ">= 0.4.2", "< 0.5.0"
+  spec.add_dependency             "uber",           "< 0.2.0"
+  spec.add_dependency             "representable",  ">= 2.4.0", "< 3.1.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "dry-types"
   spec.add_development_dependency "multi_json"
-  spec.add_development_dependency "dry-validation", ">= 0.10.0"
+  spec.add_development_dependency "dry-validation", ">= 0.10.1"
 end

data/test/benchmarking.rb

@@ -1,15 +1,49 @@
 require 'reform'
-require 'ostruct'
-require 'benchmark'
+require 'benchmark/ips'
+require "reform/form/dry"
 
 class BandForm < Reform::Form
-  property :name, validates: {presence: true}
+  feature Reform::Form::Dry
+  property :name#, validates: {presence: true}
+  collection :songs do
+    property :title#, validates: {presence: true}
+  end
+end
 
+class OptimizedBandForm < Reform::Form
+  feature Reform::Form::Dry
+  property :name#, validates: {presence: true}
   collection :songs do
-    property :title, validates: {presence: true}
+    property :title#, validates: {presence: true}
+  
+  	def deserializer(*args)
+      # DISCUSS: should we simply delegate to class and sort out memoizing there? 
+      self.class.deserializer_class || self.class.deserializer_class = deserializer!(*args)
+ 	end
+  end
+
+  def deserializer(*args)
+    # DISCUSS: should we simply delegate to class and sort out memoizing there? 
+    self.class.deserializer_class || self.class.deserializer_class = deserializer!(*args)
   end
 end
 
+songs = 10.times.collect { OpenStruct.new(title: "Be Stag") }
+band = OpenStruct.new(name: "Teenage Bottlerock", songs: songs)
+
+unoptimized_form = BandForm.new(band)
+optimized_form   = OptimizedBandForm.new(band)
+
+songs_params = songs_params = 10.times.collect { {title: "Commando"} }
+
+Benchmark.ips do |x|
+   x.report("2.2") { BandForm.new(band).validate("name" => "Ramones", "songs" => songs_params) }
+   x.report("2.3") { OptimizedBandForm.new(band).validate("name" => "Ramones", "songs" => songs_params)  }
+end
+
+exit
+
+
 songs = 50.times.collect { OpenStruct.new(title: "Be Stag") }
 band = OpenStruct.new(name: "Teenage Bottlerock", songs: songs)
 
@@ -23,4 +57,4 @@ time = Benchmark.measure do
   end
 end
 
-puts time
+puts time

data/test/call_test.rb

@@ -3,7 +3,7 @@ require "test_helper"
 class CallTest < Minitest::Spec
   Song = Struct.new(:title)
 
-  class SongForm < Reform::Form
+  class SongForm < TestForm
     property :title
 
     validation do

data/test/changed_test.rb

@@ -6,7 +6,7 @@ class ChangedTest < MiniTest::Spec
   Album = Struct.new(:name, :songs, :artist)
   Artist = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :name
 
     collection :songs do

data/test/coercion_test.rb

@@ -8,7 +8,7 @@ class CoercionTest < BaseTest
     end
   end
 
-  class Form < Reform::Form
+  class Form < TestForm
     feature Coercion
 
     property :released_at, type: Types::Form::DateTime
@@ -58,7 +58,7 @@ class CoercionTest < BaseTest
 
     it { subject.released_at.must_equal DateTime.parse("30/03/1981") }
     it { subject.hit.length.must_equal 312 }
-    it { subject.hit.good.must_equal nil }
+    it { assert_nil subject.hit.good }
     it { subject.band.label.value.must_equal "9999.999999.99" } # coercion happened once.
   end
 

data/test/composition_test.rb

@@ -1,11 +1,49 @@
 require 'test_helper'
 
+class FormCompositionInheritanceTest < MiniTest::Spec
+  module SizePrice
+    include Reform::Form::Module
+
+    property :price
+    property :size
+
+    module InstanceMethods
+      def price(for_size: size)
+        case for_size.to_sym
+          when :s then super() * 1
+          when :m then super() * 2
+          when :l then super() * 3
+        end
+      end
+    end
+  end
+
+  class OutfitForm < TestForm
+    include Reform::Form::Composition
+    include SizePrice
+
+    property :price,  inherit: true, on: :tshirt
+    property :size,   inherit: true, on: :measurement
+  end
+
+
+  let (:measurement) { Measurement.new(:l) }
+  let (:tshirt)      { Tshirt.new(2, :m) }
+  let (:form)        { OutfitForm.new(tshirt: tshirt, measurement: measurement) }
+
+  Tshirt = Struct.new(:price, :size)
+  Measurement = Struct.new(:size)
+
+  it { form.price.must_equal 6 }
+  it { form.price(for_size: :s).must_equal 2 }
+end
+
 class FormCompositionTest < MiniTest::Spec
   Song      = Struct.new(:id, :title, :band)
   Requester = Struct.new(:id, :name, :requester)
   Band      = Struct.new(:title)
 
-  class RequestForm < Reform::Form
+  class RequestForm < TestForm
     include Composition
 
     property  :name,          :on =>  :requester
@@ -17,9 +55,8 @@ class FormCompositionTest < MiniTest::Spec
     property :captcha,        :on => :song, :virtual => true
 
     validation do
-      key(:name).required
-      key(:name).required
-      key(:title).required
+      required(:name).filled
+      required(:title).filled
     end
 
     property :band,           :on => :song do
@@ -37,20 +74,21 @@ class FormCompositionTest < MiniTest::Spec
   it { form.title.must_equal "Rio" }
   it { form.name.must_equal "Duran Duran" }
   it { form.requester_id.must_equal 2 }
-  it { form.channel.must_equal nil }
+  it { assert_nil form.channel }
   it { form.requester.must_equal "MCP" } # same name as composed model.
-  it { form.captcha.must_equal nil }
+  it { assert_nil form.captcha }
 
   # #model just returns <Composition>.
   it { form.mapper.must_be_kind_of Disposable::Composition }
 
   # #model[] -> composed models
   it { form.model[:requester].must_equal requester }
-  it { form.model[:song].must_equal      song }
+  it { form.model[:song].must_equal song }
 
 
   it "creates Composition for you" do
-    form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb").must_equal false
+    form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb").must_equal true
+    form.validate("title" => "", "name" => "Frenzal Rhomb").must_equal false
   end
 
   describe "#save" do
@@ -133,7 +171,7 @@ class FormCompositionCollectionTest < MiniTest::Spec
     end
   end
 
-  class LibraryForm < Reform::Form
+  class LibraryForm < TestForm
     include Reform::Form::Composition
 
     collection :books, on: :library do