reform 2.2.3 → 2.3.2

data/lib/reform/form/prepopulate.rb

@@ -1,18 +1,19 @@
 # prepopulate!(options)
 # prepopulator: ->(model, user_options)
 module Reform::Form::Prepopulate
-  def prepopulate!(options={})
+  def prepopulate!(options = {})
     prepopulate_local!(options)  # call #prepopulate! on local properties.
     prepopulate_nested!(options) # THEN call #prepopulate! on nested forms.
 
     self
   end
 
-private
+  private
+
   def prepopulate_local!(options)
     schema.each do |dfn|
       next unless block = dfn[:prepopulator]
-      Uber::Options::Value.new(block).evaluate(self, options)
+      Declarative::Option(block, instance_exec: true).(self, options)
     end
   end
 
@@ -21,4 +22,4 @@ private
       Disposable::Twin::PropertyProcessor.new(dfn, self).() { |form| form.prepopulate!(options) }
     end
   end
-end
+end

data/lib/reform/form/validate.rb

@@ -5,56 +5,71 @@ module Reform::Form::Validate
       include Uber::Callable
 
       def call(form, options)
-        params = options[:input]
         # TODO: Schema should provide property names as plain list.
-        properties = options[:binding][:nested].definitions.collect { |dfn| dfn[:name] }
+        # ensure param keys are strings.
+        params = options[:input].each_with_object({}) { |(k, v), hash|
+          hash[k.to_s] = v
+        }
 
-        properties.each { |name| (!params[name].nil? && params[name] != "") and return false }
-        true # skip
+        # return false if any property inputs are populated.
+        options[:binding][:nested].definitions.each do |definition|
+          value = params[definition.name.to_s]
+          return false if (!value.nil? && value != '')
+        end
+
+        true # skip this property
       end
     end
   end
 
-
   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
+  private
+
   # Meant to return params processable by the representer. This is the hook for munching date fields, etc.
   def deserialize!(params)
     # NOTE: it is completely up to the form user how they want to deserialize (e.g. using an external JSON-API representer).
-      # use the deserializer as an external instance to operate on the Twin API,
-      # e.g. adding new items in collections using #<< etc.
+    # use the deserializer as an external instance to operate on the Twin API,
+    # e.g. adding new items in collections using #<< etc.
     # DISCUSS: using self here will call the form's setters like title= which might be overridden.
     params
   end
 
   # 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.
-    deserializer = Disposable::Rescheme.from(source,
+  def deserializer!(source = self.class, options = {}) # called on top-level, only, for now.
+    deserializer = Disposable::Rescheme.from(
+      source,
       {
         include:          [Representable::Hash::AllowSymbols, Representable::Hash],
         superclass:       Representable::Decorator,
-        definitions_from: lambda { |inline| inline.definitions },
+        definitions_from: ->(inline) { inline.definitions },
         options_from:     :deserializer,
-        exclude_options:  [:default, :populator] # Reform must not copy Disposable/Reform-only options that might confuse representable.
+        exclude_options:  %i[default populator] # Reform must not copy Disposable/Reform-only options that might confuse representable.
       }.merge(options)
     )
 
     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,90 @@
+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
+
+      def add_error(key, error_text)
+        CustomError.new(key, error_text, @results)
+      end
+
+      def to_results
+        @results
+      end
+
+      private
+
+      # this doesn't do nested errors (e.g. )
+      def filter_for(method, *args)
+        @results.collect { |r| r.public_send(method, *args).to_h }
+                .inject({}) { |hah, err| hah.merge(err) { |key, old_v, new_v| (new_v.is_a?(Array) ? (old_v |= new_v) : old_v.merge(new_v)) } }
+                .find_all { |k, v| # filter :nested=>{:something=>["too nested!"]} #DISCUSS: do we want that here?
+                  if v.is_a?(Hash)
+                    nested_errors = v.select { |attr_key, val| attr_key.is_a?(Integer) && val.is_a?(Array) && val.any? }
+                    v = nested_errors.to_a if nested_errors.any?
+                  end
+                  v.is_a?(Array)
+                }.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.
+          traverse = traverse(@result.errors, path)
+          # when returns {} is because no errors are found
+          # when returns a String is because an error has been found on the main key not in the nested one.
+          #   Collection with custom rule will return a String here and does not need to be considered
+          #   as a nested error.
+          # when return an Array without an index is same as String but it's a property with a custom rule.
+          # Check test/validation/dry_validation_test.rb:685
+          return if traverse == {} || traverse.is_a?(String) || (traverse.is_a?(Array) && path.compact.size == 1)
+
+          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,34 @@
 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
+
+      return {name: :default}.merge(options) if name.nil?
 
-    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
 
@@ -33,8 +39,10 @@ module Reform::Validation
   end
 
   def valid?
-    Groups::Result.new(self.class.validation_groups).(to_nested_hash, errors, self)
+    validate({})
   end
+
+  NoValidationLibraryError = Class.new(RuntimeError)
 end
 
 require "reform/validation/groups"

data/lib/reform/validation/groups.rb

@@ -19,11 +19,11 @@ 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
 
-  private
+    private
 
     def index_for(options)
       return find_index { |el| el.first == options[:after] } + 1 if options[:after]
@@ -31,43 +31,28 @@ 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].nil? && 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.3"
+  VERSION = "2.3.2".freeze
 end

data/reform.gemspec

@@ -1,30 +1,30 @@
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'reform/version'
+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.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.authors       = ["Nick Sutterer", "Fran Worley"]
+  spec.email         = ["apotonick@gmail.com", "frances@safetytoolbox.co.uk"]
+  spec.description   = "Form object decoupled from models."
+  spec.summary       = "Form object decoupled from models with validation, population and presentation."
+  spec.homepage      = "https://github.com/trailblazer/reform"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(%r(^bin/)) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency             "disposable",     ">= 0.3.0", "< 0.4.0"
-  spec.add_dependency             "uber",           ">= 0.0.15", "< 0.2.0"
+  spec.add_dependency             "disposable",     ">= 0.4.2", "< 0.5.0"
   spec.add_dependency             "representable",  ">= 2.4.0", "< 3.1.0"
+  spec.add_dependency             "uber",           "< 0.2.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 "minitest-line"
+  spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "multi_json"
-  spec.add_development_dependency "dry-validation", ">= 0.10.0"
+  spec.add_development_dependency "rake"
 end

data/test/benchmarking.rb

@@ -1,15 +1,48 @@
-require 'reform'
-require 'ostruct'
-require 'benchmark'
+require "reform"
+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 +56,4 @@ time = Benchmark.measure do
   end
 end
 
-puts time
+puts time

data/test/call_new_api.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+class CallTest < Minitest::Spec
+  Song = Struct.new(:title)
+
+  class SongForm < TestForm
+    property :title
+
+    validation do
+      params { required(:title).filled }
+    end
+  end
+
+  let(:form) { SongForm.new(Song.new) }
+
+  it { form.(title: "True North").success?.must_equal true }
+  it { form.(title: "True North").failure?.must_equal false }
+  it { form.(title: "").success?.must_equal false }
+  it { form.(title: "").failure?.must_equal true }
+
+  it { form.(title: "True North").errors.messages.must_equal({}) }
+  it { form.(title: "").errors.messages.must_equal(title: ["must be filled"]) }
+end