reform 2.3.0.rc1 → 2.3.0.rc2

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,95 +1,19 @@
 require "dry-validation"
-require "dry/validation/schema/form"
+require "dry/validation/version"
 require "reform/validation"
+require "reform/form/dry/input_hash"
 
 module Reform::Form::Dry
   def self.included(includer)
-    includer.send :include, Validations
-    includer.extend Validations::ClassMethods
-  end
-
-  module Validations
-    module ClassMethods
-      def validation_group_class
-        Group
-      end
+    if Gem::Version.new(Dry::Validation::VERSION) > Gem::Version.new("0.13.3")
+      require "reform/form/dry/new_api"
+      validations = Reform::Form::Dry::NewApi::Validations
+    else
+      require "reform/form/dry/old_api"
+      validations = Reform::Form::Dry::OldApi::Validations
     end
 
-    def self.included(includer)
-      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)
-
-        @schema_inject_params = options[:with] || {}
-      end
-
-      def instance_exec(&block)
-        @validator = Dry::Validation.Schema(@validator, build: false, &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
-      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
-
-      # 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({}) { |(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
+    includer.send :include, validations
+    includer.extend validations::ClassMethods
   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/dry/new_api.rb

@@ -0,0 +1,58 @@
+module Reform::Form::Dry
+  module NewApi
+    class Contract < Dry::Validation::Contract
+    end
+
+    module Validations
+      module ClassMethods
+        def validation_group_class
+          Group
+        end
+      end
+
+      def self.included(includer)
+        includer.extend(ClassMethods)
+      end
+
+      class Group
+        include InputHash
+
+        def initialize(options = {})
+          options ||= {}
+          @validator = options[:schema] || Reform::Form::Dry::NewApi::Contract
+
+          @schema_inject_params = options[:with] || {}
+        end
+
+        def instance_exec(&block)
+          Dry::Validation.load_extensions(:hints)
+          @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)
+
+          Dry::Schema::DSL.class_eval do
+            inject_options.each do |key, value|
+              define_method(key) { value }
+            end
+          end
+
+          # when passing options[:schema] the class instance is already created so we just need to call
+          # "call"
+          @validator = @validator.build(&@block) if @validator == Reform::Form::Dry::NewApi::Contract
+
+          # TODO: only pass submitted values to Schema#call?
+          dry_result = @validator.call(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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Reform::Form::Dry
+  module OldApi
+    class Schema < Dry::Validation::Schema
+    end
+
+    module Validations
+      module ClassMethods
+        def validation_group_class
+          Group
+        end
+      end
+
+      def self.included(includer)
+        includer.extend(ClassMethods)
+      end
+
+      class Group
+        include InputHash
+
+        def initialize(options = {})
+          options ||= {}
+          schema_class = options[:schema] || Reform::Form::Dry::OldApi::Schema
+          @validator = Dry::Validation.Schema(schema_class, build: false)
+
+          @schema_inject_params = options[:with] || {}
+        end
+
+        def instance_exec(&block)
+          @validator = Dry::Validation.Schema(@validator, build: false, &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
+        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
+      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