reform 2.3.0.rc1 → 2.5.0

data/lib/reform/form/call.rb

@@ -17,7 +17,7 @@ module Reform::Form::Call
     end
 
     def failure?
-      ! @success
+      !@success
     end
   end
 end

data/lib/reform/form/composition.rb

@@ -16,13 +16,13 @@ module Reform::Form::Composition
     #
     # class CoverSongForm < Reform::Form
     #   model :song, on: :cover_song
-    def model(main_model, options={})
+    def model(main_model, options = {})
       super
 
       composition_model = options[:on] || main_model
 
       # FIXME: this should just delegate to :model as in FB, and the comp would take care of it internally.
-      [:persisted?, :to_key, :to_param].each do |method|
+      %i[persisted? to_key to_param].each do |method|
         define_method method do
           model[composition_model].send(method)
         end

data/lib/reform/form/dry.rb

@@ -1,8 +1,14 @@
+gem 'dry-validation', '~> 1.5'
 require "dry-validation"
-require "dry/validation/schema/form"
 require "reform/validation"
+require "reform/form/dry/input_hash"
+
+::Dry::Validation.load_extensions(:hints)
 
 module Reform::Form::Dry
+  class Contract < Dry::Validation::Contract
+  end
+
   def self.included(includer)
     includer.send :include, Validations
     includer.extend Validations::ClassMethods
@@ -19,76 +25,32 @@ module Reform::Form::Dry
       includer.extend(ClassMethods)
     end
 
-
     class Group
-      def initialize(options = {})
-        options ||= {}
-        schema_class = options[:schema] || Dry::Validation::Schema
-        @validator = Dry::Validation.Schema(schema_class, build: false)
+      include InputHash
 
-        @schema_inject_params = options[:with] || {}
+      def initialize(**options)
+        @validator = options.fetch(:contract, Contract)
+        @schema_inject_params = options.fetch(:with, {})
       end
 
-      def instance_exec(&block)
-        @validator = Dry::Validation.Schema(@validator, build: false, &block)
+      attr_reader :validator, :schema_inject_params, :block
 
-        # inject the keys into the configure block automatically
-        keys = @schema_inject_params.keys
-        @validator.class_eval do
-          configure do
-            keys.each { |k| option k }
-          end
-        end
+      def instance_exec(&block)
+        @block = block
       end
 
       def call(form)
-        dynamic_options = {}
-        dynamic_options[:form] = form if @schema_inject_params[:form]
-        inject_options  = @schema_inject_params.merge(dynamic_options)
-
-        # TODO: only pass submitted values to Schema#call?
-        dry_result      = call_schema(inject_options, input_hash(form))
-        # dry_messages    = dry_result.messages
-
-        return dry_result
-        reform_errors   = Reform::Contract::Errors.new(dry_result) # TODO: dry should be merged here.
-      end
-
-    private
-      def call_schema(inject_options, input)
-        @validator.new(@validator.rules, inject_options).(input)
-      end
-
-      # if dry_error is a hash rather than an array then it contains
-      # the messages for a nested property
-      # these messages need to be added to the correct collection
-      # objects.
-
-      # collections:
-      # {0=>{:name=>["must be filled"]}, 1=>{:name=>["must be filled"]}}
-
-      # Objects:
-      # {:name=>["must be filled"]}
-      # simply load up the object and attach the message to it
+        # when passing options[:schema] the class instance is already created so we just need to call
+        # "call"
+        return validator.call(input_hash(form)) unless validator.is_a?(Class) && @validator <= ::Dry::Validation::Contract
 
-      # we can't use to_nested_hash as it get's messed up by composition.
-      def input_hash(form)
-        hash = form.class.nested_hash_representer.new(form).to_hash
-        symbolize_hash(hash)
+        dynamic_options = { form: form }
+        inject_options = schema_inject_params.merge(dynamic_options)
+        contract.new(inject_options).call(input_hash(form))
       end
 
-      # dry-v needs symbolized keys
-      # TODO: Don't do this here... Representers??
-      def symbolize_hash(old_hash)
-        old_hash.each_with_object({}) { |(k, v), new_hash|
-          new_hash[k.to_sym] = if v.is_a?(Hash)
-                             symbolize_hash(v)
-                           elsif v.is_a?(Array)
-                             v.map{ |h| h.is_a?(Hash) ? symbolize_hash(h) : h }
-                           else
-                             v
-                           end
-        }
+      def contract
+        @contract ||= Class.new(validator, &block)
       end
     end
   end

data/lib/reform/form/dry/input_hash.rb

@@ -0,0 +1,37 @@
+module Reform::Form::Dry
+  module InputHash
+    private
+
+    # if dry_error is a hash rather than an array then it contains
+    # the messages for a nested property
+    # these messages need to be added to the correct collection
+    # objects.
+
+    # collections:
+    # {0=>{:name=>["must be filled"]}, 1=>{:name=>["must be filled"]}}
+
+    # Objects:
+    # {:name=>["must be filled"]}
+    # simply load up the object and attach the message to it
+
+    # we can't use to_nested_hash as it get's messed up by composition.
+    def input_hash(form)
+      hash = form.class.nested_hash_representer.new(form).to_hash
+      symbolize_hash(hash)
+    end
+
+    # dry-v needs symbolized keys
+    # TODO: Don't do this here... Representers??
+    def symbolize_hash(old_hash)
+      old_hash.each_with_object({}) do |(k, v), new_hash|
+        new_hash[k.to_sym] = if v.is_a?(Hash)
+                               symbolize_hash(v)
+                             elsif v.is_a?(Array)
+                               v.map { |h| h.is_a?(Hash) ? symbolize_hash(h) : h }
+                             else
+                               v
+                             end
+      end
+    end
+  end
+end

data/lib/reform/form/populator.rb

@@ -26,7 +26,8 @@ class Reform::Form::Populator
     twin
   end
 
-private
+  private
+
   def call!(options)
     form = options[:represented]
     @value.(form, options) # Declarative::Option call.
@@ -37,7 +38,7 @@ private
   end
 
   def get(options)
-     Representable::GetValue.(nil, options)
+    Representable::GetValue.(nil, options)
   end
 
   class IfEmpty < self # Populator
@@ -59,7 +60,8 @@ private
       end
     end
 
-  private
+    private
+
     def run!(form, fragment, options)
       return @user_proc.new if @user_proc.is_a?(Class) # handle populate_if_empty: Class. this excludes using Callables, though.
 
@@ -75,18 +77,14 @@ private
 
       @value.(form, options[:fragment], options[:user_options])
     end
-
   end
 
   # Sync (default) blindly grabs the corresponding form twin and returns it. This might imply that nil is returned,
   # and in turn #validate! is called on nil.
   class Sync < self
     def call!(options)
-      if options[:binding].array?
-        return options[:model][options[:index]]
-      else
-        options[:model]
-      end
+      return options[:model][options[:index]] if options[:binding].array?
+      options[:model]
     end
   end
 
@@ -102,8 +100,8 @@ private
   # (which population is) to the form.
   class External
     def call(input, options)
-      options[:represented].class.definitions.
-        get(options[:binding][:name])[:internal_populator].(input, options)
+      options[:represented].class.definitions
+                           .get(options[:binding][:name])[:internal_populator].(input, options)
     end
   end
 end

data/lib/reform/form/prepopulate.rb

@@ -1,14 +1,15 @@
 # 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]

data/lib/reform/form/validate.rb

@@ -5,17 +5,23 @@ 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
@@ -30,27 +36,28 @@ module Reform::Form::Validate
     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)
     )
 

data/lib/reform/result.rb

@@ -1,28 +1,45 @@
 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?
+      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 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) }
-          .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
+        @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
@@ -39,17 +56,27 @@ module Reform
         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) == {}
+          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
+        private
+
         def traverse(hash, path)
           path.inject(hash) { |errs, segment| errs[segment] || {} } # FIXME. test if all segments present.
         end

data/lib/reform/validation.rb

@@ -7,7 +7,7 @@ module Reform::Validation
     end
 
     # DSL.
-    def validation(name=nil, 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.
 
@@ -20,19 +20,17 @@ module Reform::Validation
     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)
+        return {name: name}.merge(options)
       end
 
-      if name.nil?
-        return { name: :default }.merge(options)
-      end
+      return {name: :default}.merge(options) if name.nil?
 
-      { name: :default }.merge(name)
+      {name: :default}.merge(name)
     end
 
     def validation_group_class
-      raise NoValidationLibraryError, 'no validation library loaded. Please include a ' +
-                            'validation library such as Reform::Form::Dry'
+      raise NoValidationLibraryError, "no validation library loaded. Please include a " +
+                                      "validation library such as Reform::Form::Dry"
     end
   end
 
@@ -40,6 +38,10 @@ module Reform::Validation
     includer.extend(ClassMethods)
   end
 
+  def valid?
+    validate({})
+  end
+
   NoValidationLibraryError = Class.new(RuntimeError)
 end
 

data/lib/reform/validation/groups.rb

@@ -23,7 +23,7 @@ module Reform::Validation
       group
     end
 
-  private
+    private
 
     def index_for(options)
       return find_index { |el| el.first == options[:after] } + 1 if options[:after]
@@ -36,7 +36,6 @@ module Reform::Validation
       cfg[1]
     end
 
-
     # Runs all validations groups according to their rules and returns all Result objects.
     class Validate
       def self.call(groups, form)
@@ -44,14 +43,13 @@ module Reform::Validation
 
         groups.collect do |(name, group, options)|
           next unless evaluate?(options[:if], results, form)
-
           results[name] = group.(form) # run validation for group. store and collect <Result>.
         end
       end
 
       def self.evaluate?(depends_on, results, form)
         return true if depends_on.nil?
-        return results[depends_on].success? 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