reform 1.2.0.beta2 → 1.2.1

data/lib/reform/form/json.rb

@@ -10,4 +10,4 @@ module Reform
       :from_json
     end
   end
-end
+end

data/lib/reform/form/save.rb

@@ -1,23 +1,8 @@
 module Reform::Form::Save
-  module RecursiveSave
-    def to_hash(*)
-      # process output from InputRepresenter {title: "Mint Car", hit: <Form>}
-      # and just call sync! on nested forms.
-      nested_forms do |attr|
-        attr.merge!(
-          :instance  => lambda { |fragment, *| fragment },
-          :serialize => lambda { |object, args| object.save! unless args.binding[:save] === false },
-        )
-      end
-
-      super
-    end
-  end
-
   # Returns the result of that save invocation on the model.
   def save(options={}, &block)
     # DISCUSS: we should never hit @mapper here (which writes to the models) when a block is passed.
-    return deprecate_first_save_block_arg(&block) if block_given?
+    return yield to_nested_hash if block_given?
 
     sync_models # recursion
     save!(options)
@@ -25,15 +10,10 @@ module Reform::Form::Save
 
   def save!(options={}) # FIXME.
     result = save_model
-    mapper.new(fields).extend(RecursiveSave).to_hash # save! on all nested forms.  # TODO: only include nested forms here.
 
-    names = options.keys & changed.keys.map(&:to_sym)
-    if names.size > 0
-      representer = save_dynamic_representer.new(fields) # should be done once, on class instance level.
+    save_representer.new(fields).to_hash # save! on all nested forms.
 
-      # puts "$$$$$$$$$ #{names.inspect}"
-      representer.to_hash(options.merge :include => names)
-    end
+    dynamic_save!(options)
 
     result
   end
@@ -43,54 +23,44 @@ module Reform::Form::Save
   end
 
 
-  def save_dynamic_representer
-    # puts mapper.superclass.superclass.inspect
-    Class.new(mapper).apply do |dfn|
+  require "active_support/hash_with_indifferent_access" # DISCUSS: replace?
+  def to_nested_hash(*)
+    ActiveSupport::HashWithIndifferentAccess.new(nested_hash_representer.new(fields).to_hash)
+  end
+  alias_method :to_hash, :to_nested_hash
+  # NOTE: it is not recommended using #to_hash and #to_nested_hash in your code, consider them private.
+
+private
+  def save_representer
+    self.class.representer(:save) do |dfn|
       dfn.merge!(
-        :serialize => lambda { |object, options|
-          puts "$$ #{options.user_options.inspect}"
-          options.user_options[options.binding.name.to_sym].call(object, options) },
-        :representable => true
+        :instance  => lambda { |form, *| form },
+        :serialize => lambda { |form, args| form.save! unless args.binding[:save] === false }
       )
     end
   end
 
+  def nested_hash_representer
+    self.class.representer(:nested_hash, :all => true) do |dfn|
+      dfn.merge!(:serialize => lambda { |form, args| form.to_nested_hash }) if dfn[:form]
 
-  module NestedHash
-    def to_hash(*)
-      # Transform form data into a nested hash for #save.
-      nested_forms do |attr|
-        attr.merge!(
-          :serialize => lambda { |object, args| object.to_nested_hash }
-        )
-      end
-
-      representable_attrs.each do |attr|
-        attr.merge!(:as => attr[:private_name] || attr.name)
-      end
-
-      super
+      dfn.merge!(:as => dfn[:private_name] || dfn.name)
     end
   end
 
+  def dynamic_save!(options)
+    names = options.keys & changed.keys.map(&:to_sym)
+    return if names.size == 0
 
-  require "active_support/hash_with_indifferent_access" # DISCUSS: replace?
-  def to_nested_hash(*)
-    map = mapper.new(fields).extend(NestedHash)
-
-    ActiveSupport::HashWithIndifferentAccess.new(map.to_hash)
+    dynamic_save_representer.new(fields).to_hash(options.merge(:include => names))
   end
-  alias_method :to_hash, :to_nested_hash
-  # NOTE: it is not recommended using #to_hash and #to_nested_hash in your code, consider
-  # them private.
 
-private
-  def deprecate_first_save_block_arg(&block)
-    if block.arity == 2
-      warn "[Reform] Deprecation Warning: The first block argument in `save { |form, hash| .. }` is deprecated and its new signature is `save { |hash| .. }`. If you need the form instance, use it in the block. Have a good day."
-      return yield(self, to_nested_hash)
+  def dynamic_save_representer
+    self.class.representer(:dynamic_save, :all => true) do |dfn|
+      dfn.merge!(
+        :serialize     => lambda { |object, options| options.user_options[options.binding.name.to_sym].call(object, options) },
+        :representable => true
+      )
     end
-
-    yield to_nested_hash # new behaviour.
   end
 end

data/lib/reform/form/sync.rb

@@ -2,113 +2,95 @@
 #   1. assign scalars to model (respecting virtual, excluded attributes)
 #   2. call sync! on nested
 module Reform::Form::Sync
-  # Mechanics for writing input to model.
-  # Writes input to model.
-  module Writer
-    def from_hash(*)
-      # process output from InputRepresenter {title: "Mint Car", hit: <Form>}
-      # and just call sync! on nested forms.
-      nested_forms do |attr|
-        attr.merge!(
-          :instance     => lambda { |fragment, *| fragment },
-            # FIXME: do we allow options for #sync for nested forms?
-          :deserialize => lambda { |object, *| model = object.sync!({}) } # sync! returns the synced model.
-          # representable's :setter will do collection=([..]) or property=(..) for us on the model.
-        )
-      end
-
-      super
-    end
+  def sync_models(options={})
+    sync!(options)
   end
+  alias_method :sync, :sync_models
 
-  module Setter
-    def from_hash(*)
-      clone_config!
+  # reading from fields allows using readers in form for presentation
+  # and writers still pass to fields in #validate????
+  def sync!(options) # semi-public.
+    options = Reform::Representer::Options[options.merge(:form => self)] # options local for this form, only.
 
-      representable_attrs.each do |dfn|
-        next unless setter = dfn[:sync]
+    input = sync_hash(options)
+    # if aliased_model was a proper Twin, we could do changed? stuff there.
 
-        setter_proc = lambda do |value, options|
-          # puts "~~ #{value}~ #{options.user_options.inspect}"
+    options.delete(:exclude) # TODO: can we use 2 options?
 
-          if options.binding[:sync] == true
-            options.user_options[options.binding.name.to_sym].call(value, options)
-            next
-          end
+    dynamic_sync_representer.new(aliased_model).from_hash(input, options) # sync properties to Song.
 
-          # evaluate the :sync block in form context (should we do that everywhere?).
-          options.user_options[:form].instance_exec(value, options, &setter)
-        end
+    model
+  end
 
-        dfn.merge!(:setter => setter_proc)
-      end
+private
 
-      super
+  # Transforms form input into what actually gets written to model.
+  # output: {title: "Mint Car", hit: <Form>}
+  def input_representer
+    self.class.representer(:input) do |dfn|
+      dfn.merge!(
+        :representable  => false,
+        :prepare        => lambda { |obj, *| obj }
+      )
     end
   end
 
-  # Transforms form input into what actually gets written to model.
-  # output: {title: "Mint Car", hit: <Form>}
-  module InputRepresenter
-    # receives Representer::Options hash.
-    def to_hash(*)
-      nested_forms do |attr|
-        attr.merge!(
-          :representable  => false,
-          :prepare        => lambda { |obj, *| obj }
+  # Writes input to model.
+  def sync_representer
+    self.class.representer(:sync, :all => true) do |dfn|
+      if dfn[:form]
+        dfn.merge!(
+          :instance     => lambda { |fragment, *| fragment }, # use model's nested property for syncing.
+            # FIXME: do we allow options for #sync for nested forms?
+          :deserialize => lambda { |object, *| model = object.sync!({}) } # sync! returns the synced model.
+          # representable's :setter will do collection=([..]) or property=(..) for us on the model.
         )
       end
-
-      super
     end
   end
 
+  # This representer inherits from sync_representer and add functionality on top of that.
+  # It allows running custom dynamic blocks for properties when syncing.
+  def dynamic_sync_representer
+    self.class.representer(:dynamic_sync, superclass: sync_representer, :all => true) do |dfn|
+      next unless setter = dfn[:sync]
 
-  def sync_models(options={})
-    sync!(options)
-  end
-  alias_method :sync, :sync_models
-
-  # reading from fields allows using readers in form for presentation
-  # and writers still pass to fields in #validate????
-  def sync!(options) # semi-public.
-    options = Reform::Representer::Options[options.merge(:form => self)] # options local for this form, only.
-
-    input = sync_hash(options)
-    # if aliased_model was a proper Twin, we could do changed? stuff there.
-    # setter_module = Class.new(self.class.representer_class)
-    # setter_module.send :include, Setter
-
-    options.delete(:exclude) # TODO: can we use 2 options?
+      setter_proc = lambda do |value, options|
+        if options.binding[:sync] == true # sync: true will call the runtime lambda from the options hash.
+          options.user_options[options.binding.name.to_sym].call(value, options)
+          next
+        end
 
-    mapper.new(aliased_model).extend(Writer).extend(Setter).from_hash(input, options) # sync properties to Song.
+        # evaluate the :sync block in form context (should we do that everywhere?).
+        options.user_options[:form].instance_exec(value, options, &setter)
+      end
 
-    model
+      dfn.merge!(:setter => setter_proc)
+    end
   end
 
-private
+
   # API: semi-public.
   module SyncHash
     # This hash goes into the Writer that writes properties back to the model. It only contains "writeable" attributes.
     def sync_hash(options)
-      input_representer = mapper.new(fields).extend(InputRepresenter)
-      input_representer.to_hash(options)
+      input_representer.new(fields).to_hash(options)
     end
   end
   include SyncHash
 
 
-  # Excludes :virtual properties from #sync in this form.
-  module ReadOnly
+  # Excludes :virtual and readonly properties from #sync in this form.
+  module Writeable
     def sync_hash(options)
-      readonly_fields = mapper.fields { |dfn| dfn[:virtual] }
+      readonly_fields = mapper.fields { |dfn| dfn[:_writeable] == false }
 
       options.exclude!(readonly_fields.map(&:to_sym))
 
       super
     end
   end
-  include ReadOnly
+  include Writeable
 
 
   # This will skip unchanged properties in #sync. To use this for all nested form do as follows.

data/lib/reform/form/validate.rb

@@ -1,48 +1,5 @@
 # Mechanics for writing to forms in #validate.
 module Reform::Form::Validate
-  module Update
-    # 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).
-
-    # Go through all nested forms and call form.update!(hash).
-    def from_hash(*)
-      nested_forms do |attr|
-        attr.merge!(
-          # set parse_strategy: sync> # DISCUSS: that kills the :setter directive, which usually sucks. at least document this in :populator.
-          :collection => attr[:collection], # TODO: Def#merge! doesn't consider :collection if it's already set in attr 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) },
-        )
-
-        # TODO: :populator now is just an alias for :instance. handle in ::property.
-        attr.merge!(:instance => attr[:populator]) if attr[:populator]
-
-        attr.merge!(:instance => Populator::PopulateIfEmpty.new) if attr[:populate_if_empty]
-      end
-
-      # FIXME: solve this with a dedicated Populate Decorator per Form.
-      representable_attrs.each do |attr|
-        attr.merge!(:parse_filter => Representable::Coercion::Coercer.new(attr[:coercion_type])) if attr[:coercion_type]
-
-        attr.merge!(:skip_if => Skip::AllBlank.new) if attr[:skip_if] == :all_blank
-        attr.merge!(:skip_parse => attr[:skip_if]) if attr[:skip_if]
-      end
-
-
-      representable_attrs.each do |attr|
-        next if attr[:form]
-
-        attr.merge!(:parse_filter => Changed.new)
-      end
-
-      super
-    end
-  end
-
-
   module Populator
     # This might change soon (e.g. moved into disposable).
     class PopulateIfEmpty
@@ -130,10 +87,46 @@ 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)
-    mapper.new(self).extend(Update).send(deserialize_method, 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
 
   def deserialize_method
     :from_hash
   end
+
+  # 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) },
+        )
+
+        # TODO: :populator now is just an alias for :instance. handle in ::property.
+        dfn.merge!(:instance => dfn[:populator]) if dfn[:populator]
+
+        dfn.merge!(:instance => Populator::PopulateIfEmpty.new) if dfn[:populate_if_empty]
+      end
+
+
+      dfn.merge!(:parse_filter => Representable::Coercion::Coercer.new(dfn[:coercion_type])) if dfn[:coercion_type]
+
+      dfn.merge!(:skip_if => Skip::AllBlank.new) if dfn[:skip_if] == :all_blank
+      dfn.merge!(:skip_parse => dfn[:skip_if]) if dfn[:skip_if]
+
+      dfn.merge!(:parse_filter => Changed.new) unless dfn[:form] # TODO: make changed? work for nested forms.
+    end
+  end
 end

data/lib/reform/representer.rb

@@ -38,10 +38,12 @@ module Reform
       representable_attrs.find_all(&block).map(&:name)
     end
 
-    def nested_forms(&block)
-      clone_config!.
-        find_all { |attr| attr[:form] }.
-        each(&block)
+    def self.each(only_form=true, &block)
+      definitions = representable_attrs
+      definitions = representable_attrs.find_all { |attr| attr[:form] } if only_form
+
+      definitions.each(&block)
+      self
     end
 
     def self.for(options)
@@ -59,12 +61,6 @@ module Reform
     end
 
   private
-    def clone_config!
-      # TODO: representable_attrs.clone! which does exactly what's done below.
-      attrs = Representable::Config.new
-      attrs.inherit!(representable_attrs) # since in every use case we modify Config we clone.
-      @representable_attrs = attrs
-    end
 
     # Inline forms always get saved in :extend.
     def self.build_inline(base, features, name, options, &block)

data/lib/reform/version.rb

@@ -1,3 +1,3 @@
 module Reform
-  VERSION = "1.2.0.beta2"
+  VERSION = "1.2.1"
 end

data/test/active_record_test.rb

@@ -105,6 +105,7 @@ end
 
 class PopulateWithActiveRecordTest < MiniTest::Spec
   class AlbumForm < Reform::Form
+
     property :title
 
     collection :songs, :populate_if_empty => Song do
@@ -188,6 +189,73 @@ class PopulateWithActiveRecordTest < MiniTest::Spec
       album.songs[1].title.must_equal "Check For A Pulse"
       album.songs[1].persisted?.must_equal true # TODO: with << strategy, this shouldn't be saved.
     end
+
+    describe 'using nested_models_attributes to modify nested collection' do
+      class ActiveModelAlbumForm < Reform::Form
+        include Reform::Form::ActiveModel
+        include Reform::Form::ActiveModel::FormBuilderMethods
+
+        property :title
+
+        collection :songs, :populate_if_empty => Song do
+          property :title
+        end
+      end
+
+      let (:album) { Album.create(:title => 'Greatest Hits') }
+      let (:form) { ActiveModelAlbumForm.new(album) }
+
+      it do
+        form.validate('songs_attributes' => {'0' => {'title' => 'Tango'}})
+
+        # form populated.
+        form.songs.size.must_equal 1
+        form.songs[0].model.must_be_kind_of Song
+        form.songs[0].title.must_equal 'Tango'
+
+        # model NOT populated.
+        album.songs.must_equal []
+
+        form.save
+
+        # nested model persisted.
+        first_song = album.songs[0]
+        assert first_song.id > 0
+
+        # form populated.
+        form.songs.size.must_equal 1
+
+        # model also populated.
+        album.songs.size.must_equal 1
+        album.songs[0].title.must_equal 'Tango'
+
+        form.validate('songs_attributes' => {'0' => {'id' => first_song.id, 'title' => 'Tango nuevo'}, '1' => {'title' => 'Waltz'}})
+
+        # form populated.
+        form.songs.size.must_equal 2
+        form.songs[0].model.must_be_kind_of Song
+        form.songs[1].model.must_be_kind_of Song
+        form.songs[0].title.must_equal 'Tango nuevo'
+        form.songs[1].title.must_equal 'Waltz'
+
+        # model NOT populated.
+        album.songs.size.must_equal 1
+        album.songs[0].title.must_equal 'Tango'
+
+        form.save
+
+        # form populated.
+        form.songs.size.must_equal 2
+
+        # model also populated.
+        album.songs.size.must_equal 2
+        album.songs[0].id.must_equal first_song.id
+        album.songs[0].persisted?.must_equal true
+        album.songs[1].persisted?.must_equal true
+        album.songs[0].title.must_equal 'Tango nuevo'
+        album.songs[1].title.must_equal 'Waltz'
+      end
+    end
   end
 
   # it do