reform 2.0.5 → 2.1.0.rc1

data/lib/reform/form/active_model/validations.rb

@@ -4,23 +4,34 @@ require "uber/delegates"
 
 module Reform::Form::ActiveModel
   # AM::Validations for your form.
-  #
   # Provides ::validates, ::validate, #validate, and #valid?.
+  #
+  # Most of this file contains unnecessary wiring to make ActiveModel's error message magic work.
+  # Since Rails still thinks it's a good idea to do things like object.class.human_attribute_name,
+  # we have some hacks in here to provide that. If it doesn't work for you, don't blame us.
   module Validations
     def self.included(includer)
       includer.instance_eval do
         include Reform::Form::ActiveModel
-        inheritable_attr :validator
-        self.validator = Class.new(Validator) # the actual validations happen in this instance.
 
         class << self
           extend Uber::Delegates
-          delegates :validator, :validates, :validate, :validates_with, :validate_with
-
-          # Hooray! Delegate translation back to Reform's Validator class which contains AM::Validations.
-          delegates :validator, :human_attribute_name, :lookup_ancestors, :i18n_scope # Rails 3.1.
+          # # Hooray! Delegate translation back to Reform's Validator class which contains AM::Validations.
+          delegates :active_model_really_sucks, :human_attribute_name, :lookup_ancestors, :i18n_scope # Rails 3.1.
+
+          def validation_group_class
+            Group
+          end
+
+          # this is to allow calls like Form::human_attribute_name (note that this is on the CLASS level) to be resolved.
+          # those calls happen when adding errors in a custom validation method, which is defined on the form (as an instance method).
+          def active_model_really_sucks
+            Class.new(Validator).tap do |v|
+              v.model_name = model_name
+            end
+          end
         end
-      end
+      end # ::included
     end
 
     def build_errors
@@ -33,6 +44,24 @@ module Reform::Form::ActiveModel
       send(name)
     end
 
+    class Group
+      def initialize
+        @validations = Class.new(Reform::Form::ActiveModel::Validations::Validator)
+      end
+
+      extend Uber::Delegates
+      delegates :@validations, :validates, :validate, :validates_with, :validate_with
+
+      def call(fields, errors, form) # FIXME.
+        validator = @validations.new(form)
+        validator.valid?
+
+        validator.errors.each do |name, error| # TODO: handle with proper merge, or something. validator.errors is ALWAYS AM::Errors.
+          errors.add(name, error)
+        end
+      end
+    end
+
 
     # Validator is the validatable object. On the class level, we define validations,
     # on instance, it exposes #valid?.
@@ -43,45 +72,33 @@ module Reform::Form::ActiveModel
 
       class << self
         def model_name
-          @_active_model_sucks || ActiveModel::Name.new(Reform::Form, nil, "Reform::Form")
+          @_active_model_sucks ||= ActiveModel::Name.new(Reform::Form, nil, "Reform::Form")
         end
 
         def model_name=(name)
           @_active_model_sucks = name
         end
 
-        def clone
-          Class.new(self)
+        def validates(*args, &block)
+          super(*Declarative::DeepDup.(args), &block)
+        end
+
+        # Prevent AM:V from mutating the validator class
+        def attr_reader(*)
+        end
+
+        def attr_writer(*)
         end
       end
 
-      def initialize(form, name)
+      def initialize(form)
         super(form)
-        self.class.model_name = name # one of the many reasons why i will drop support for AM::V in 2.1.
+        self.class.model_name = form.model_name # one of the many reasons why i will drop support for AM::V in 2.1. or maybe a bit later.
       end
 
       def method_missing(m, *args, &block)
         __getobj__.send(m, *args, &block) # send all methods to the form, even privates.
       end
     end
-
-    private
-
-    # Needs to be implemented by every validation backend and implements the
-    # actual validation. See Reform::Form::Lotus, too!
-    def valid?
-      # we always pass the model_name into the validator now, so AM:V can do its magic. problem is that
-      # AM does validator.class.model_name so we have to hack the dynamic model name into the
-      # Validator class.
-      validator = self.class.validator.new(self, model_name)
-      validator.valid? # run the Validations object's validator with the form as context. this won't pollute anything in the form.
-
-      #errors.merge!(validator.errors, "")
-      validator.errors.each do |name, error| # TODO: handle with proper merge, or something. validator.errors is ALWAYS AM::Errors.
-        errors.add(name, error)
-      end
-
-      errors.empty?
-    end
   end
 end

data/lib/reform/form/dry.rb

@@ -0,0 +1,55 @@
+require "dry-validation"
+require "reform/validation"
+require "dry/validation/schema/form"
+
+module Reform::Form::Dry
+  module Validations
+
+    def build_errors
+      Reform::Contract::Errors.new(self)
+    end
+
+    module ClassMethods
+      def validation_group_class
+        Group
+      end
+    end
+
+    def self.included(includer)
+      includer.extend(ClassMethods)
+    end
+
+    class Group
+      def initialize
+        @validator = Class.new(ValidatorSchema)
+      end
+
+      def instance_exec(&block)
+        @validator.class_eval(&block)
+      end
+
+      def call(fields, reform_errors, form)
+        validator = @validator.new(form)
+
+        validator.call(fields).messages.each do |dry_error|
+          # a dry error message looks like this:
+          # [:email, [['Please provide your email', '']]]
+          dry_error[1].each do |attr_error|
+            reform_errors.add(dry_error[0], attr_error[0])
+          end
+        end
+      end
+    end
+
+    class ValidatorSchema < Dry::Validation::Schema::Form
+      def initialize(form)
+        @form = form
+        super()
+      end
+
+      def form
+        @form
+      end
+    end
+  end
+end

data/lib/reform/form/lotus.rb

@@ -4,11 +4,14 @@ require "lotus/validations"
 module Reform::Form::Lotus
   class Errors < Lotus::Validations::Errors
     def merge!(errors, prefix)
+      new_errors = {}
       errors.instance_variable_get(:@errors).each do |name, err|
         field = (prefix+[name]).join(".")
-        add(field, *err) # TODO: use namespace feature in Lotus here!
+        new_errors[field] = err
       end
       #   next if messages[field] and messages[field].include?(msg)
+
+      new_errors.each { |field, err| add(field, *err) } # TODO: use namespace feature in Lotus here!
     end
 
     def inspect

data/lib/reform/form/module.rb

@@ -1,29 +1,15 @@
 # Include this in every module that gets further included.
-# TODO: this could be implemented in Declarable, as we can use that everywhere.
 module Reform::Form::Module
   def self.included(base)
     base.extend ClassMethods
-    base.extend Included
-  end
-
-  module Included # TODO: use representable's inheritance mechanism.
-    def included(base)
-      super
-      instructions.each { |cfg|
-        args    = cfg[1].dup
-        options = args.extract_options!.dup # we need to duplicate options has as AM::Validations messes it up later.
 
-        base.send(cfg[0], *args, options, &cfg[2]) } # property :name, {} do .. end
-    end
+    base.extend Declarative::Heritage::DSL      # ::heritage
+    base.extend Declarative::Heritage::Included # ::included
   end
 
   module ClassMethods
     def method_missing(method, *args, &block)
-      instructions << [method, args, block]
-    end
-
-    def instructions
-      @instructions ||= []
+      heritage.record(method, *args, &block)
     end
   end
 end

data/lib/reform/form/multi_parameter_attributes.rb

@@ -45,13 +45,4 @@ module Reform::Form::MultiParameterAttributes
   def deserialize!(params)
     super DateTimeParamsFilter.new.call(params) # if params.is_a?(Hash) # this currently works for hash, only.
   end
-
-  # module BuildDefinition
-  #   def build_definition(name, options, &block)
-  #     return super unless options[:multi_params]
-
-  #     options[:parse_filter] << DateParamsFilter.new
-  #     super
-  #   end
-  # end
 end

data/lib/reform/form/populator.rb

@@ -1,7 +1,7 @@
 # Implements the :populator option.
 #
-#  populator: -> (fragment, twin, options)
-#  populator: -> (fragment, collection[twin], index, options)
+#  populator: -> (fragment:, model:, :binding)
+#  populator: -> (fragment:, collection:, index:, binding:)
 #
 # For collections, the entire collection and the currently deserialised index is passed in.
 class Reform::Form::Populator
@@ -12,49 +12,66 @@ class Reform::Form::Populator
     @value     = Uber::Options::Value.new(user_proc) # we can now process Callable, procs, :symbol.
   end
 
-  def call(form, fragment, *args)
-    options = args.last
+  def call(input, options)
+    model = get(options)
+    twin  = call!(options.merge(model: model, collection: model))
 
-    # FIXME: the optional index parameter SUCKS.
-    twin = call!(form, fragment, options.binding.get, *args)
+    return twin if twin == Representable::Pipeline::Stop
 
     # this kinda sucks. the proc may call self.composer = Artist.new, but there's no way we can
     # return the twin instead of the model from the #composer= setter.
-    twin = options.binding.get unless options.binding.array?
+    twin = get(options) unless options[:binding].array?
 
-    # since Populator#call is invoked as :instance, we always need to return a twin/form here.
+    # we always need to return a twin/form here so we can call nested.deserialize().
     handle_fail(twin, options)
 
     twin
   end
 
 private
-  # DISCUSS: this signature could change soon.
-  # FIXME: the optional index parameter SUCKS.
-  def call!(form, fragment, model, *args)
-    # FIXME: use U:::Value.
-    form.instance_exec(fragment, model, *args, &@user_proc)
+  def call!(options)
+    form = options[:represented]
+
+    deprecate_positional_args(form, @user_proc, options) do
+      @value.(form, options)
+    end
   end
 
   def handle_fail(twin, options)
-    raise "[Reform] Your :populator did not return a Reform::Form instance for `#{options.binding.name}`." if options.binding[:twin] && !twin.is_a?(Reform::Form)
+    raise "[Reform] Your :populator did not return a Reform::Form instance for `#{options[:binding].name}`." if options[:binding][:nested] && !twin.is_a?(Reform::Form)
+  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)
   end
 
 
   class IfEmpty < self # Populator
-    # FIXME: the optional index parameter SUCKS.
-    def call!(form, fragment, twin, *args)
-      options = args.last
+    def call!(options)
+      binding, twin, index, fragment = options[:binding], options[:model], options[:index], options[:fragment] # TODO: remove once we drop 2.0.
+      form = options[:represented]
 
-      if options.binding.array? # FIXME: ifs suck.
-        index = args.first
+      if binding.array?
         item = twin.original[index] and return item
 
-        twin.insert(index, run!(form, fragment, options)) # form.songs.insert(Song.new)
+        new_index = [index, twin.count].min # prevents nil items with initially empty/smaller collections and :skip_if's.
+        # this means the fragment index and populated nested form index might be different.
+
+        twin.insert(new_index, run!(form, fragment, options)) # form.songs.insert(Song.new)
       else
         return if twin
 
-        form.send(options.binding.setter, run!(form, fragment, options)) # form.artist=(Artist.new)
+        form.send(binding.setter, run!(form, fragment, options)) # form.artist=(Artist.new)
       end
     end
 
@@ -62,22 +79,47 @@ 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.
 
-      @value.evaluate(form, fragment, options.user_options)
+      deprecate_positional_args(form, @user_proc, options) do
+        @value.(form, options)
+      end
+    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 :prepopulate 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"
+
+      @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!(form, fragment, model, *args)
-      options = args.last
-
-      if options.binding.array?
-        index = args.first
-        return model[index]
+    def call!(options)
+      if options[:binding].array?
+        return options[:model][options[:index]]
       else
-        model
+        options[:model]
       end
     end
   end
-end
+
+  # This function is added to the deserializer's pipeline.
+  #
+  # When deserializing, the representer will call this function and thereby delegate the
+  # entire population process to the form. The form's :internal_populator will run its
+  # :populator option function and return the new/existing form instance.
+  # The deserializing representer will then continue on that returned form.
+  #
+  # Goal of this indirection is to leave all population logic in the form, while the
+  # representer really just traverses an incoming document and dispatches business logic
+  # (which population is) to the form.
+  class External
+    def call(input, options)
+      options[:represented].class.definitions.
+        get(options[:binding][:name])[:internal_populator].(input, options)
+    end
+  end
+end

data/lib/reform/form/validate.rb

@@ -4,9 +4,10 @@ module Reform::Form::Validate
     class AllBlank
       include Uber::Callable
 
-      def call(form, params, options)
+      def call(form, options)
+        params = options[:input]
         # TODO: Schema should provide property names as plain list.
-        properties = options.binding[:twin].representer_class.representable_attrs[:definitions].keys
+        properties = options[:binding][:nested].definitions.collect { |dfn| dfn[:name] }
 
         properties.each { |name| params[name].present? and return false }
         true # skip
@@ -15,20 +16,19 @@ module Reform::Form::Validate
   end
 
 
-  # 1. Populate the form object graph so that each incoming object has a representative form object.
-  # 2. Deserialize. This is wrong and should be done in 1.
-  # 3. Validate the form object graph.
   def validate(params)
-    deprecate_update!(params)
-
     # allow an external deserializer.
     block_given? ? yield(params) : deserialize(params)
 
     super() # run the actual validation on self.
-  # rescue Representable::DeserializeError
-  #   raise DeserializeError.new("[Reform] Deserialize error: You probably called #validate without setting up your nested models. Check https://github.com/apotonick/reform#populating-forms-for-validation on how to use populators.")
   end
 
+  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)
     # NOTE: it is completely up to the form user how they want to deserialize (e.g. using an external JSON-API representer).
@@ -38,42 +38,18 @@ module Reform::Form::Validate
     params
   end
 
-
-private
-  # Some users use this method to pre-populate a form. Not saying this is right, but we'll keep
-  # this method here.
-  # DISCUSS: this is only called once, on the top-level form.
-  def deprecate_update!(params)
-    return unless self.class.instance_methods(false).include?(:update!)
-    warn "[Reform] Form#update! is deprecated and will be removed in Reform 2.1. Please use #prepopulate!"
-    update!(params)
-  end
-
-  def deserialize(params)
-    params = deserialize!(params)
-
-    deserializer.new(self).from_hash(params)
-  end
-
   # Default deserializer for hash.
   # This is input-specific, e.g. Hash, JSON, or XML.
-  def deserializer # called on top-level, only, for now.
-    deserializer = Disposable::Twin::Schema.from(self.class,
-      include:          [Representable::Hash::AllowSymbols, Representable::Hash],
-      superclass:       Representable::Decorator,
-      representer_from: lambda { |inline| inline.representer_class },
-      options_from:     :deserializer,
-      exclude_options:  [:default], # Reform must not copy Disposable/Reform-only options that might confuse representable.
-    ) do |dfn|
-      # next unless dfn[:twin]
-      dfn.merge!(
-        deserialize: lambda { |decorator, params, options|
-          params = decorator.represented.deserialize!(params) # let them set up params. # FIXME: we could also get a new deserializer here.
-
-          decorator.from_hash(params) # options.binding.deserialize_method.inspect
-        }
-      ) if dfn[:twin]
-    end
+  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 },
+        options_from:     :deserializer,
+        exclude_options:  [:default, :populator] # Reform must not copy Disposable/Reform-only options that might confuse representable.
+      }.merge(options)
+    )
 
     deserializer
   end