reform 1.2.6 → 2.0.0.beta1

data/lib/reform/form/active_model.rb

@@ -3,18 +3,16 @@ require 'reform/form/active_model/model_validations'
 module Reform::Form::ActiveModel
   module FormBuilderMethods # TODO: rename to FormBuilderCompat.
     def self.included(base)
-      base.class_eval do
-        extend ClassMethods # ::model_name
-        register_feature FormBuilderMethods
-      end
+      base.extend ClassMethods # ::model_name
     end
 
     module ClassMethods
-      private
+    private
 
+      # TODO: add that shit in Form#present, not by overriding ::property.
       def property(name, options={}, &block)
         super.tap do |definition|
-          add_nested_attribute_compat(name) if definition[:form] # TODO: fix that in Rails FB#1832 work.
+          add_nested_attribute_compat(name) if definition[:twin] # TODO: fix that in Rails FB#1832 work.
         end
       end
 
@@ -25,11 +23,11 @@ module Reform::Form::ActiveModel
     end
 
     # Modify the incoming Rails params hash to be representable compliant.
-    def update!(params)
-      return super unless params.is_a?(Hash)
-      # TODO: run this only for hash deserialization, but generically (#deserialize_hash ?).
-
-      self.class.representer { |dfn| rename_nested_param_for!(params, dfn) }
+    def deserialize!(params)
+      # this only happens in a Hash environment. other engines have to overwrite this method.
+      schema.each do |dfn|
+        rename_nested_param_for!(params, dfn)
+      end
 
       super
     end
@@ -75,6 +73,11 @@ module Reform::Form::ActiveModel
     #
     #   class CoverSongForm < Reform::Form
     #     model :song
+    #
+    # or we can setup a isolated namespace model ( which defined in isolated rails egine )
+    #
+    #   class CoverSongForm < Reform::Form
+    #     model "api/v1/song", namespace: "api"
     def model(main_model, options={})
       self.model_options = [main_model, options]
     end
@@ -82,17 +85,19 @@ module Reform::Form::ActiveModel
     def model_name
       if model_options
         form_name = model_options.first.to_s.camelize
+        namespace = model_options.last[:namespace].present? ? model_options.last[:namespace].to_s.camelize.constantize : nil
       else
         form_name = name.sub(/(::)?Form$/, "") # Song::Form => "Song"
+        namespace = nil
       end
 
-      active_model_name_for(form_name)
+      active_model_name_for(form_name, namespace)
     end
 
   private
-    def active_model_name_for(string)
+    def active_model_name_for(string, namespace=nil)
       return ::ActiveModel::Name.new(OpenStruct.new(:name => string)) if Reform.rails3_0?
-      ::ActiveModel::Name.new(self, nil, string)
+      ::ActiveModel::Name.new(self, namespace, string)
     end
   end
 end

data/lib/reform/form/coercion.rb

@@ -1,17 +1,5 @@
 require 'representable/coercion'
 
+# TODO: make optional.
 module Reform::Form::Coercion
-  def self.included(base)
-    base.extend(ClassMethods)
-    base.send(:register_feature, self)
-  end
-
-  module ClassMethods
-    def representer_class # TODO: check out how we can utilise Config#features.
-      super.class_eval do
-        include Representable::Coercion
-        self
-      end
-    end
-  end
 end

data/lib/reform/form/composition.rb

@@ -1,4 +1,5 @@
 require "reform/form/active_model"
+require "disposable/twin/composition"
 
 module Reform::Form::Composition
   # Automatically creates a Composition object for you when initializing the form.
@@ -6,16 +7,11 @@ module Reform::Form::Composition
     base.class_eval do
       extend Reform::Form::ActiveModel::ClassMethods # ::model.
       extend ClassMethods
+      include Disposable::Twin::Composition
     end
   end
 
   module ClassMethods
-    #include Reform::Form::ActiveModel::ClassMethods # ::model.
-
-    def model_class # DISCUSS: needed?
-      @model_class ||= Reform::Composition.from(representer_class)
-    end
-
     # Same as ActiveModel::model but allows you to define the main model in the composition
     # using +:on+.
     #
@@ -36,22 +32,4 @@ module Reform::Form::Composition
       self
     end
   end
-
-  def initialize(models)
-    composition = self.class.model_class.new(models)
-    super(composition)
-  end
-
-  def to_nested_hash
-    model.nested_hash_for(to_hash)  # use composition to compute nested hash.
-  end
-
-  def to_hash(*args)
-    mapper.new(fields).to_hash(*args) # do not map names, yet. this happens in #to_nested_hash
-  end
-
-private
-  def aliased_model # we don't need an Expose as we save the Composition instance in the constructor.
-    model
-  end
 end

data/lib/reform/form/multi_parameter_attributes.rb

@@ -1,72 +1,53 @@
-Reform::Form.class_eval do
-  # TODO: this must be implemented with a parse_filter that is only applied to type: Time or Datetime properties.
-  # we then simply add the converted attribute to params.
-  module MultiParameterAttributes
-    # TODO: implement this with parse_filter, so we don't have to manually walk through the hash, etc.
-    def self.included(base)
-      base.send(:register_feature, self)
-    end
-
-    class DateTimeParamsFilter
-      def call(params)
-        params = params.dup # DISCUSS: not sure if that slows down form processing?
-        date_attributes = {}
-
-        params.each do |attribute, value|
-          if value.is_a?(Hash)
-            params[attribute] = call(value) # TODO: #validate should only handle local form params.
-          elsif matches = attribute.match(/^(\w+)\(.i\)$/)
-            date_attribute = matches[1]
-            date_attributes[date_attribute] = params_to_date(
-              params.delete("#{date_attribute}(1i)"),
-              params.delete("#{date_attribute}(2i)"),
-              params.delete("#{date_attribute}(3i)"),
-              params.delete("#{date_attribute}(4i)"),
-              params.delete("#{date_attribute}(5i)")
-            )
-          end
+module Reform::Form::MultiParameterAttributes
+  # TODO: implement this with parse_filter, so we don't have to manually walk through the hash, etc.
+  class DateTimeParamsFilter
+    def call(params)
+      params = params.dup # DISCUSS: not sure if that slows down form processing?
+      date_attributes = {}
+
+      params.each do |attribute, value|
+        if value.is_a?(Hash)
+          params[attribute] = call(value) # TODO: #validate should only handle local form params.
+        elsif matches = attribute.match(/^(\w+)\(.i\)$/)
+          date_attribute = matches[1]
+          date_attributes[date_attribute] = params_to_date(
+            params.delete("#{date_attribute}(1i)"),
+            params.delete("#{date_attribute}(2i)"),
+            params.delete("#{date_attribute}(3i)"),
+            params.delete("#{date_attribute}(4i)"),
+            params.delete("#{date_attribute}(5i)")
+          )
         end
-        params.merge!(date_attributes)
       end
+      params.merge!(date_attributes)
+    end
 
-    private
-      def params_to_date(year, month, day, hour, minute)
-        return nil if [year, month, day].any?(&:blank?)
+  private
+    def params_to_date(year, month, day, hour, minute)
+      return nil if [year, month, day].any?(&:blank?)
 
-        if hour.blank? && minute.blank?
-          Date.new(year.to_i, month.to_i, day.to_i) # TODO: test fails.
-        else
-          args = [year, month, day, hour, minute].map(&:to_i)
-          Time.zone ? Time.zone.local(*args) :
-            Time.new(*args)
-        end
+      if hour.blank? && minute.blank?
+        Date.new(year.to_i, month.to_i, day.to_i) # TODO: test fails.
+      else
+        args = [year, month, day, hour, minute].map(&:to_i)
+        Time.zone ? Time.zone.local(*args) :
+          Time.new(*args)
       end
     end
+  end
 
-    def validate(params)
-      # TODO: make it cleaner to hook into essential reform steps.
-      params = DateTimeParamsFilter.new.call(params) if params.is_a?(Hash) # this currently works for hash, only.
-      super
-    end
-
-
-    # module ClassMethods
-    #   def representer_class # TODO: check out how we can utilise Config#features.
-    #     super.class_eval do
-    #       extend BuildDefinition
-    #       self
-    #     end
-    #   end
-    # end
-
+  # this hooks into the format-specific #deserialize! method.
+  def deserialize!(params)
+    params = DateTimeParamsFilter.new.call(params) if params.is_a?(Hash) # this currently works for hash, only.
+    super
+  end
 
-    # module BuildDefinition
-    #   def build_definition(name, options, &block)
-    #     return super unless options[:multi_params]
+  # module BuildDefinition
+  #   def build_definition(name, options, &block)
+  #     return super unless options[:multi_params]
 
-    #     options[:parse_filter] << DateParamsFilter.new
-    #     super
-    #   end
-    # end
-  end
+  #     options[:parse_filter] << DateParamsFilter.new
+  #     super
+  #   end
+  # end
 end

data/lib/reform/form/populator.rb

@@ -0,0 +1,85 @@
+# TODO: move somewhere else!
+# TODO: make inheritable? and also, there's a lot of noise. shorten.
+# Implements the :populator option.
+#
+#  populator: -> (fragment, twin, options)
+#  populator: -> (fragment, collection[twin], index, options)
+#
+# 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.
+  end
+
+  def call(form, fragment, *args)
+    options = args.last
+
+    # FIXME: the optional index parameter SUCKS.
+    twin = call!(form, fragment, options.binding.get, *args)
+
+    # 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?
+
+    # since Populator#call is invoked as :instance, we always need to return a twin/form here.
+    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)
+  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)
+  end
+
+
+  class IfEmpty < self # Populator
+    # FIXME: the optional index parameter SUCKS.
+    def call!(form, fragment, twin, *args)
+      options = args.last
+
+      if options.binding.array? # FIXME: ifs suck.
+        index = args.first
+        item = twin.original[index] and return item
+
+        twin.insert(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)
+      end
+    end
+
+  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)
+    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]
+      else
+        model
+      end
+    end
+  end
+end

data/lib/reform/form/prepopulate.rb

@@ -1,54 +1,24 @@
-# this will soon be handled in Disposable.
+# prepopulate!(options)
+# prepopulator: ->(model, user_options)
 module Reform::Form::Prepopulate
-  def prepopulate!
-    # TODO: representer.new(fields).from_object(fields)
-    hash = prepopulate_representer.new(fields).to_hash(:parent_form => self)
-    prepopulate_representer.new(fields).from_hash(hash)
+  def prepopulate!(options={})
+    prepopulate_local!(options)  # call #prepopulate! on local properties.
+    prepopulate_nested!(options) # THEN call #prepopulate! on nested forms.
 
-    recursive_prepopulate_representer.new(fields).to_hash # not sure if i leave that like this, consider private.
     self
   end
-private
-  def prepopulate_representer
-    self.class.representer(:prepopulate, :all => true) do |dfn|
-      next unless block = dfn[:prepopulate] or dfn[:form]
-
-      if dfn[:form]
-        dfn.merge!(
-          :render_filter => lambda do |v, h, options|
-            parent_form = options.user_options[:parent_form] # TODO: merge with Validate/populate_if_empty.
-
-            # execute in form context, pass user optioins.
-            object = parent_form.instance_exec(options.user_options, &options.binding[:prepopulate])
-
-            if options.binding.array?
-              object.collect { |item| options.binding[:form].new(item) }
-            else
-              options.binding[:form].new(object)
-            end
-          end,
-          :representable  => false,
 
-          :instance => lambda { |obj, *| obj } # needed for from_hash. TODO: make that in one go.
-        )
-      else
-        dfn.merge!(:render_filter => lambda do |v, h, options|
-          parent_form = options.user_options[:parent_form] # TODO: merge with Validate/populate_if_empty.
-
-          # execute in form context, pass user optioins.
-          parent_form.instance_exec(options.user_options, &options.binding[:prepopulate])
-        end)
-      end
+private
+  def prepopulate_local!(options)
+    schema.each do |dfn|
+      next unless block = dfn[:prepopulator]
+      Uber::Options::Value.new(block).evaluate(self, options)
     end
   end
 
-  def recursive_prepopulate_representer
-    self.class.representer(:recursive_prepopulate_representer) do |dfn|
-      dfn.merge!(
-        :serialize => lambda { |object, *| model = object.prepopulate! } # sync! returns the synced model.
-        # representable's :setter will do collection=([..]) or property=(..) for us on the model.
-      )
+  def prepopulate_nested!(options)
+    schema.each(twin: true) do |dfn|
+      Disposable::Twin::PropertyProcessor.new(dfn, self).() { |form| form.prepopulate!(options) }
     end
   end
-
 end

data/lib/reform/form/validate.rb

@@ -1,53 +1,13 @@
 # Mechanics for writing to forms in #validate.
 module Reform::Form::Validate
-  module Populator
-    # This might change soon (e.g. moved into disposable).
-    class PopulateIfEmpty
-      include Uber::Callable
-
-      def call(fields, fragment, *args)
-        index   = args.first
-        options = args.last
-        binding = options.binding
-        form    = binding.get
-
-        parent_form =  options.user_options[:parent_form]
-
-        # FIXME: test those cases!!!
-        return form[index] if binding.array? and form and form[index] # TODO: this should be handled by the Binding.
-        return form if !binding.array? and form
-        # only get here when above form is nil.
-
-
-        if binding[:populate_if_empty].is_a?(Proc)
-          model = parent_form.instance_exec(fragment, options.user_options, &binding[:populate_if_empty]) # call user block.
-        else
-          model = binding[:populate_if_empty].new
-        end
-
-        form  = binding[:form].new(model) # free service: wrap model with Form. this usually happens in #setup.
-
-        if binding.array?
-          # TODO: please extract this into Disposable.
-          fields = fields.send(:fields)
-
-          fields.send("#{binding.setter}", []) unless fields.send("#{binding.getter}") # DISCUSS: why do I have to initialize this here?
-          fields.send("#{binding.getter}")[index] = form
-        else
-          fields.send("#{binding.setter}", form) # :setter is currently overwritten by :parse_strategy.
-        end
-      end
-    end # PopulateIfEmpty
-  end
-
-
   module Skip
     class AllBlank
       include Uber::Callable
 
       def call(form, params, options)
         # TODO: hahahahahaha.
-        properties = options.binding.representer_module.representer_class.representable_attrs[:definitions].keys
+        # FIXME: this is a bit ridiculous.
+        properties = options.binding[:twin].representer_class.representable_attrs[:definitions].keys
 
         properties.each { |name| params[name].present? and return false }
         true # skip
@@ -56,18 +16,6 @@ module Reform::Form::Validate
   end
 
 
-  class Changed
-    def call(fragment, params, options)
-      # options is a Representable::Options object holding all the stakeholders. this is here becaues of pass_options: true.
-      form = options.represented
-      name = options.binding.name
-
-      form.changed[name] = form.send(name) != fragment
-
-      fragment
-    end
-  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.
@@ -76,61 +24,52 @@ module Reform::Form::Validate
 
     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.")
+  # 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
 
   # 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 update!(params)
     deserialize!(params)
   end
 
 private
   def deserialize!(params)
-    # using self here will call the form's setters like title= which might be overridden.
-    # from_hash(params, parent_form: self)
-    # Go through all nested forms and call form.update!(hash).
-    populate_representer.new(self).send(deserialize_method, params, :parent_form => self)
-  end
+    require "disposable/twin/schema"
+    require "reform/form/coercion" # DISCUSS: make optional?
 
-  def deserialize_method
-    :from_hash
-  end
+    # NOTE: it is completely up to the form user how they want to deserialize (e.g. using an external JSON-API representer).
 
-  # IDEA: what if Populate was a Decorator that simply knows how to setup the Form object graph, nothing more? That would decouple
-  # the population from the validation (good and bad as less customizable).
-
-  # Don't get scared by this method. All this does is create a new representer class for this form.
-  # It then configures each property so the population of the form can happen in #validate.
-  # A lot of this code is simply renaming from Reform's API to representable's. # FIXME: unify that?
-  def populate_representer
-    self.class.representer(:populate, :all => true) do |dfn|
-      if dfn[:form]
-        dfn.merge!(
-          # set parse_strategy: sync> # DISCUSS: that kills the :setter directive, which usually sucks. at least document this in :populator.
-          :collection => dfn[:collection], # TODO: Def#merge! doesn't consider :collection if it's already set in dfn YET.
-          :parse_strategy => :sync, # just use nested objects as they are.
-
-          # :getter grabs nested forms directly from fields bypassing the reader method which could possibly be overridden for presentation.
-          :getter      => lambda { |options| fields.send(options.binding.name) },
-          :deserialize => lambda { |object, params, args| object.update!(params) },
+    deserializer = Disposable::Twin::Schema.from(self.class,
+        include:    [Representable::Hash::AllowSymbols, Representable::Hash, Representable::Coercion], # FIXME: how do we get this info?
+        superclass: Representable::Decorator,
+        representer_from: lambda { |inline| inline.representer_class },
+        options_from: :deserializer
         )
 
-        # TODO: :populator now is just an alias for :instance. handle in ::property.
-        dfn.merge!(:instance => dfn[:populator]) if dfn[:populator]
+    deserializer.representable_attrs.each do |dfn|
+      next unless dfn[:_inline] # FIXME: we have to standardize that!
 
-        dfn.merge!(:instance => Populator::PopulateIfEmpty.new) if dfn[:populate_if_empty]
-      end
+      # FIXME: collides with Schema?
+      dfn.merge!(
+        deserialize: lambda { |decorator, params, options|
+          decorator.represented.validate(params)
 
+          decorator.represented
+        }
+      )
+    end
 
-      dfn.merge!(:parse_filter => Representable::Coercion::Coercer.new(dfn[:coercion_type])) if dfn[:coercion_type]
+      deserializer.new(self).
+        # extend(Representable::Debug).
+        from_hash(params)
 
-      dfn.merge!(:skip_if => Skip::AllBlank.new) if dfn[:skip_if] == :all_blank
-      dfn.merge!(:skip_parse => dfn[:skip_if]) if dfn[:skip_if]
+      # use the deserializer as an external instance to operate on the Twin API,
+      # e.g. adding new items in collections using #<< etc.
 
-      dfn.merge!(:parse_filter => Changed.new) unless dfn[:form] # TODO: make changed? work for nested forms.
-    end
+    # DISCUSS: using self here will call the form's setters like title= which might be overridden.
   end
 
   class DeserializeError < RuntimeError