reform 2.2.3 → 2.3.2

data/lib/reform/errors.rb

@@ -0,0 +1,61 @@
+# Provides the old API for Rails and friends.
+# Note that this might become an optional "deprecation" gem in Reform 3.
+class Reform::Contract::Result::Errors
+  def initialize(result, form)
+    @result        = result # DISCUSS: we don't use this ATM?
+    @form          = form
+    @dotted_errors = {} # Reform does not endorse this style of error msgs.
+
+    DottedErrors.(@form, [], @dotted_errors)
+  end
+
+  # PROTOTYPING. THIS WILL GO TO A SEPARATE GEM IN REFORM 2.4/3.0.
+  DottedErrors = ->(form, prefix, hash) do
+    result = form.to_result
+    result.messages.collect { |k, v| hash[[*prefix, k].join(".").to_sym] = v }
+
+    form.schema.each(twin: true) do |dfn|
+      Disposable::Twin::PropertyProcessor.new(dfn, form).() do |frm, i|
+        form_obj = i ? form.send(dfn[:name])[i] : form.send(dfn[:name])
+        DottedErrors.(form_obj, [*prefix, dfn[:name]], hash)
+      end
+    end
+  end
+
+  def messages(*args)
+    @dotted_errors
+  end
+
+  def full_messages
+	  @dotted_errors.collect { |path, errors|
+		  human_field = path.to_s.gsub(/([\.\_])+/, " ").gsub(/(\b\w)+/) { |s| s.capitalize }
+			 errors.collect { |message| "#{human_field} #{message}" }
+		}.flatten
+  end
+
+  def [](name)
+  	@dotted_errors[name] || []
+  end
+
+  def size
+    messages.size
+  end
+
+  # needed for rails form helpers
+  def empty?
+    messages.empty?
+  end
+
+  # we need to delegate adding error to result because every time we call form.errors
+  # a new instance of this class is created so we need to update the @results array
+  # to be able to add custom errors here.
+  # This method will actually work only AFTER a validate call has been made
+  def add(key, error_test)
+    @result.add_error(key, error_test)
+  end
+end
+
+# Ensure that we can return Active Record compliant full messages when using dry
+# we only want unique messages in our array
+#
+# @full_errors.add()

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/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,67 +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
-    def build_errors
-      Reform::Contract::Errors.new(self)
-    end
-
-    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
-        @schemas = []
-      end
-
-      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
-      end
-
-      class Builder < Array
-        def initialize(array)
-          super(array)
-          @validator = Dry::Validation.Form({}, &shift)
-        end
-
-        def validation_graph
-          build_graph(@validator)
-        end
-
-
-        private
-
-        def build_graph(validator)
-          if empty?
-            return validator
-          end
-          build_graph(Dry::Validation.Schema(validator, {}, &shift))
-        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,47 @@
+::Dry::Validation.load_extensions(:hints)
+
+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 = {})
+          @validator = options.fetch(:schema, Contract)
+          @schema_inject_params = options.fetch(:with, {})
+        end
+
+        attr_reader :validator, :schema_inject_params, :block
+
+        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
+
+          dynamic_options = { form: form }
+          inject_options = schema_inject_params.merge(dynamic_options)
+
+          validator.build(inject_options, &block).call(input_hash(form))
+        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

@@ -5,11 +5,9 @@
 #
 # For collections, the entire collection and the currently deserialised index is passed in.
 class Reform::Form::Populator
-  include Uber::Callable
-
   def initialize(user_proc)
     @user_proc = user_proc # the actual `populator: ->{}` block from the user, via ::property.
-    @value     = Uber::Options::Value.new(user_proc) # we can now process Callable, procs, :symbol.
+    @value     = Declarative::Option(user_proc, instance_exec: true, callable: Object) # we can now process Callable, procs, :symbol.
   end
 
   def call(input, options)
@@ -28,13 +26,11 @@ class Reform::Form::Populator
     twin
   end
 
-private
+  private
+
   def call!(options)
     form = options[:represented]
-
-    deprecate_positional_args(form, @user_proc, options) do
-      @value.(form, options)
-    end
+    @value.(form, options) # Declarative::Option call.
   end
 
   def handle_fail(twin, options)
@@ -42,20 +38,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.
@@ -75,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.
 
@@ -91,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
 
@@ -118,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