reform 2.2.4 → 2.6.2

data/lib/reform/form/dry.rb

@@ -1,18 +1,20 @@
+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
   end
 
   module Validations
-    def build_errors
-      Reform::Contract::Errors.new(self)
-    end
-
     module ClassMethods
       def validation_group_class
         Group
@@ -24,43 +26,31 @@ module Reform::Form::Dry
     end
 
     class Group
-      def initialize
-        @schemas = []
-      end
+      include InputHash
 
-      def instance_exec(&block)
-        @schemas << block
-        @validator = Builder.new(@schemas.dup).validation_graph
-      end
-
-      def call(fields, reform_errors, form)
-        # a message item looks like: {:confirm_password=>["confirm_password size cannot be less than 2"]}
-        @validator.with(form: form).call(fields).messages.each do |field, dry_error|
-          dry_error.each do |attr_error|
-            reform_errors.add(field, attr_error)
-          end
-        end
+      def initialize(options)
+        @validator = options.fetch(:contract, Contract)
+        @schema_inject_params = options.fetch(:with, {})
       end
 
-      class Builder < Array
-        def initialize(array)
-          super(array)
-          @validator = Dry::Validation.Form({}, &shift)
-        end
+      attr_reader :validator, :schema_inject_params, :block
 
-        def validation_graph
-          build_graph(@validator)
-        end
+      def instance_exec(&block)
+        @block = block
+      end
 
+      def call(form)
+        # 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
 
-        private
+        dynamic_options = { form: form }
+        inject_options = schema_inject_params.merge(dynamic_options)
+        contract.new(**inject_options).call(input_hash(form))
+      end
 
-        def build_graph(validator)
-          if empty?
-            return validator
-          end
-          build_graph(Dry::Validation.Schema(validator, {}, &shift))
-        end
+      def contract
+        @contract ||= Class.new(validator, &block)
       end
     end
   end

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     = ::Representable::Option(user_proc) # we can now process Callable, procs, :symbol.
   end
 
   def call(input, options)
@@ -26,13 +26,21 @@ class Reform::Form::Populator
     twin
   end
 
-private
+  private
+
   def call!(options)
     form = options[:represented]
+    evaluate_option(form, options)
+  end
+
+  def evaluate_option(form, options)
+    if @user_proc.is_a?(Uber::Callable) && @user_proc.method(:call).arity == 2 # def call(form, options)
+      warn %{[Reform] Accepting `form` as a positional argument in `:populator` will be deprecated. Please use `def call(form:, **options)` signature instead.}
 
-    deprecate_positional_args(form, @user_proc, options) do
-      @value.(form, options)
+      return @value.(form, exec_context: form, keyword_arguments: options)
     end
+
+    @value.(exec_context: form, keyword_arguments: options.merge(form: form)) # Representable::Option call
   end
 
   def handle_fail(twin, options)
@@ -40,20 +48,9 @@ private
   end
 
   def get(options)
-     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)
+    Representable::GetValue.(nil, options)
   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.
@@ -73,12 +70,13 @@ 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.
 
       deprecate_positional_args(form, @user_proc, options) do
-        @value.(form, options)
+        evaluate_option(form, options)
       end
     end
 
@@ -89,18 +87,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
 
@@ -116,8 +110,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,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]
-      Declarative::Option(block, instance_exec: true).(self, options)
+      ::Representable::Option(block).(exec_context: self, keyword_arguments: 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

@@ -4,57 +4,72 @@ module Reform::Form::Validate
     class AllBlank
       include Uber::Callable
 
-      def call(form, options)
-        params = options[:input]
+      def call(input:, binding:, **)
         # TODO: Schema should provide property names as plain list.
-        properties = options[:binding][:nested].definitions.collect { |dfn| dfn[:name] }
+        # ensure param keys are strings.
+        params = 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.
+        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/form.rb

@@ -1,5 +1,7 @@
 module Reform
   class Form < Contract
+    class InvalidOptionsCombinationError < StandardError; end
+
     def self.default_nested_class
       Form
     end
@@ -15,8 +17,32 @@ module Reform
 
     module Property
       # Add macro logic, e.g. for :populator.
-      def property(name, options={}, &block)
-        definition = super # let representable sort out inheriting of properties, and so on.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def property(name, options = {}, &block)
+        if (options.keys & %i[skip_if populator]).size == 2
+          raise InvalidOptionsCombinationError.new(
+            "[Reform] #{self}:property:#{name} Do not use skip_if and populator together, use populator with skip! instead"
+          )
+        end
+
+        # if composition and inherited we also need this setting
+        # to correctly inherit modules
+        options[:_inherited] = options[:inherit] if options.key?(:on) && options.key?(:inherit)
+
+        if options.key?(:parse)
+          options[:deserializer] ||= {}
+          options[:deserializer][:writeable] = options.delete(:parse)
+        end
+
+        options[:writeable] ||= options.delete(:writable) if options.key?(:writable)
+
+        # for virtual collection we need at least to have the collection equal to [] to
+        # avoid issue when the populator
+        if (options.keys & %i[collection virtual]).size == 2
+          options = { default: [] }.merge(options)
+        end
+
+        definition = super # letdisposable and declarative gems sort out inheriting of properties, and so on.
         definition.merge!(deserializer: {}) unless definition[:deserializer] # always keep :deserializer per property.
 
         deserializer_options = definition[:deserializer]
@@ -33,10 +59,10 @@ module Reform
         external_populator = Populator::External.new
 
         # always compute a parse_pipeline for each property of the deserializer and inject it via :parse_pipeline.
-        # first, let representable compute the pipeline functions by invoking #parse_functions.
+        # first, letrepresentable compute the pipeline functions by invoking #parse_functions.
         if definition[:nested]
-          parse_pipeline = ->(input, options) do
-            functions = options[:binding].send(:parse_functions)
+          parse_pipeline = ->(input, opts) do
+            functions = opts[:binding].send(:parse_functions)
             pipeline  = Representable::Pipeline[*functions] # Pipeline[StopOnExcluded, AssignName, ReadFragment, StopOnNotFound, OverwriteOnNil, Collect[#<Representable::Function::CreateObject:0xa6148ec>, #<Representable::Function::Decorate:0xa6148b0>, Deserialize], Set]
 
             pipeline  = Representable::Pipeline::Insert.(pipeline, external_populator,            replace: Representable::CreateObject::Instance)
@@ -45,12 +71,12 @@ module Reform
             pipeline  = Representable::Pipeline::Insert.(pipeline, Representable::SetValue,       delete: true) # FIXME: only diff to options without :populator
           end
         else
-          parse_pipeline = ->(input, options) do
-            functions = options[:binding].send(:parse_functions)
+          parse_pipeline = ->(input, opts) do
+            functions = opts[:binding].send(:parse_functions)
             pipeline  = Representable::Pipeline[*functions] # Pipeline[StopOnExcluded, AssignName, ReadFragment, StopOnNotFound, OverwriteOnNil, Collect[#<Representable::Function::CreateObject:0xa6148ec>, #<Representable::Function::Decorate:0xa6148b0>, Deserialize], Set]
 
             # FIXME: this won't work with property :name, inherit: true (where there is a populator set already).
-            pipeline  = Representable::Pipeline::Insert.(pipeline, external_populator,            replace: Representable::SetValue) if definition[:populator] # FIXME: only diff to options without :populator
+            pipeline  = Representable::Pipeline::Insert.(pipeline, external_populator, replace: Representable::SetValue) if definition[:populator] # FIXME: only diff to options without :populator
             pipeline
           end
         end
@@ -62,12 +88,12 @@ module Reform
           deserializer_options.merge!(skip_parse: proc) # TODO: same with skip_parse ==> External
         end
 
-
         # per default, everything should be writeable for the deserializer (we're only writing on the form). however, allow turning it off.
-        deserializer_options.merge!(writeable: true) unless deserializer_options.has_key?(:writeable)
+        deserializer_options.merge!(writeable: true) unless deserializer_options.key?(:writeable)
 
         definition
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
     extend Property
 

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/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,27 @@ 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]
-
-          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?
+        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
-
-        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/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/version.rb

@@ -1,3 +1,3 @@
 module Reform
-  VERSION = "2.2.4"
+  VERSION = "2.6.2".freeze
 end

data/lib/reform.rb

@@ -6,3 +6,4 @@ require "reform/contract"
 require "reform/form"
 require "reform/form/composition"
 require "reform/form/module"
+require "reform/errors" # TODO: remove in Reform 3.

data/reform.gemspec

@@ -1,29 +1,29 @@
-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.4.1"
-  spec.add_dependency             "representable", ">= 2.4.0", "< 3.1.0"
+  spec.add_dependency             "disposable",     ">= 0.5.0", "< 1.0.0"
+  spec.add_dependency             "representable",  ">= 3.1.1", "< 4"
+  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 "multi_json"
-  spec.add_development_dependency "dry-validation", ">= 0.10.0"
+  spec.add_development_dependency "rake"
 end