reform 1.0.4 → 1.1.0

data/lib/reform/form/module.rb

@@ -0,0 +1,27 @@
+# Include this in every module that gets further included.
+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| base.send(cfg[0], *cfg[1], &cfg[2]) } # property :name, {} do .. end
+    end
+  end
+
+  module ClassMethods
+    def property(*args, &block)
+      instructions << [:property, args, block]
+    end
+    def validates(*args, &block)
+      instructions << [:validates, args, block]
+    end
+
+    def instructions
+      @instructions ||= []
+    end
+  end
+end

data/lib/reform/form/multi_parameter_attributes.rb

@@ -1,7 +1,7 @@
 Reform::Form.class_eval do
   module MultiParameterAttributes
     def self.included(base)
-      base.features << self
+      base.send(:register_feature, self)
     end
 
     class DateParamsFilter
@@ -38,9 +38,29 @@ Reform::Form.class_eval do
     def validate(params)
       # TODO: make it cleaner to hook into essential reform steps.
       # TODO: test with nested.
-      DateParamsFilter.new.call(params)
+      DateParamsFilter.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
+
+
+    # module BuildDefinition
+    #   def build_definition(name, options, &block)
+    #     return super unless options[:multi_params]
+
+    #     options[:parse_filter] << DateParamsFilter.new
+    #     super
+    #   end
+    # end
   end
 end

data/lib/reform/form/save.rb

@@ -14,9 +14,9 @@ module Reform::Form::Save
     end
   end
 
-  def save
+  def save(&block)
     # DISCUSS: we should never hit @mapper here (which writes to the models) when a block is passed.
-    return yield self, to_nested_hash if block_given?
+    return deprecate_first_save_block_arg(&block) if block_given?
 
     sync_models # recursion
     save!
@@ -37,8 +37,7 @@ module Reform::Form::Save
       # Transform form data into a nested hash for #save.
       nested_forms do |attr|
         attr.merge!(
-          :instance  => lambda { |fragment, *| fragment },
-          :serialize => lambda { |object, args| object.to_nested_hash },
+          :serialize => lambda { |object, args| object.to_nested_hash }
         )
       end
 
@@ -50,10 +49,24 @@ module Reform::Form::Save
     end
   end
 
+
   require "active_support/hash_with_indifferent_access" # DISCUSS: replace?
-  def to_nested_hash
+  def to_nested_hash(*)
     map = mapper.new(fields).extend(NestedHash)
 
     ActiveSupport::HashWithIndifferentAccess.new(map.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 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)
+    end
+
+    yield to_nested_hash # new behaviour.
+  end
 end

data/lib/reform/form/scalar.rb

@@ -0,0 +1,52 @@
+module Reform::Form::Scalar
+  # IDEA: what if every "leaf" property would be represented by a Scalar form?
+  def self.included(base)
+    base.extend ClassMethods
+    base.extend Forwardable
+  end
+
+  def update!(object)
+    @fields = object # @scalar is "I came from the outside." or <ArbitraryObject>.
+  end
+
+  def scalar
+    fields
+  end
+
+  def save!
+  end
+
+  def sync!
+    model.replace(fields)
+    # FIXME: how to sync that, if it's not responds to replace? or what if we don't want to write (e.g. image with paperdragon)?
+  end
+
+  def to_nested_hash
+    scalar
+  end
+
+
+  module ClassMethods
+    def validates(name, options={})
+      if name.is_a?(Hash)
+        name, options = :scalar, name # per default, validate #scalar (e.g. "Hello").
+      else
+        def_delegator :scalar, name
+      end
+
+      super(name, options)
+    end
+  end
+
+
+  # TODO: change the way i hook into ::property.
+  module Property
+    def property(name, options={}, &block)
+      if options[:scalar]
+        options.merge!(:features => [Reform::Form::Scalar], populate_if_empty: String)
+      end
+
+      super
+    end
+  end
+end

data/lib/reform/form/sync.rb

@@ -11,8 +11,8 @@ module Reform::Form::Sync
       nested_forms do |attr|
         attr.merge!(
           :instance     => lambda { |fragment, *| fragment },
-          :deserialize => lambda { |object, *| object.sync! },
-          :setter => lambda { |*| } # don't write hit=<Form>.
+          :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
 
@@ -34,7 +34,6 @@ module Reform::Form::Sync
           :representable  => false,
           :prepare        => lambda { |obj, *| obj }
         )
-
       end
 
       super
@@ -42,8 +41,6 @@ module Reform::Form::Sync
   end
 
 
-### TODO: add ToHash with :prepare => lambda { |form, args| form },
-
   def sync_models
     sync!
   end
@@ -56,6 +53,8 @@ module Reform::Form::Sync
 
     input = input_representer.to_hash
 
-    mapper.new(aliased_model).extend(Writer).from_hash(input)
+    mapper.new(aliased_model).extend(Writer).from_hash(input) # sync properties to Song.
+
+    model
   end
 end

data/lib/reform/form/validate.rb

@@ -1,16 +1,29 @@
 # 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.delete(:prepare)
-        attr.delete(:extend)
-
         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.
+
           :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]
       end
 
       super
@@ -19,26 +32,26 @@ module Reform::Form::Validate
 
 
   module Populator
+    # This might change soon (e.g. moved into disposable).
     class PopulateIfEmpty
-      def initialize(*args)
-        @fields, @fragment, args = args
-        @index = args.first
-        @args  = args.last
-      end
+      include Uber::Callable
 
-      def call
-        binding = @args.binding
+      def call(fields, fragment, *args)
+        index   = args.first
+        options = args.last
+        binding = options.binding
         form    = binding.get
 
-        parent_form =  @args.user_options[:parent_form]
-        form_model    = parent_form.model # FIXME: sort out who's responsible for sync.
+        parent_form =  options.user_options[:parent_form]
 
-        return if binding.array? and form and form[@index] # TODO: this should be handled by the Binding.
-        return if !binding.array? and 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, @args, &binding[:populate_if_empty]) # call user block.
+          model = parent_form.instance_exec(fragment, options.user_options, &binding[:populate_if_empty]) # call user block.
         else
           model = binding[:populate_if_empty].new
         end
@@ -46,65 +59,35 @@ module Reform::Form::Validate
         form  = binding[:form].new(model) # free service: wrap model with Form. this usually happens in #setup.
 
         if binding.array?
-          form_model.send("#{binding.getter}") << model # FIXME: i don't like this, but we have to add the model to the parent object to make associating work. i have to use #<< to stay compatible with AR's has_many API. DISCUSS: what happens when we get out-of-sync here?
-          @fields.send("#{binding.getter}")[@index] = form
+          fields.send("#{binding.getter}")[index] = form
         else
-          form_model.send("#{binding.setter}", model) # FIXME: i don't like this, but we have to add the model to the parent object to make associating work.
-          @fields.send("#{binding.setter}", form) # :setter is currently overwritten by :parse_strategy.
+          fields.send("#{binding.setter}", form) # :setter is currently overwritten by :parse_strategy.
         end
       end
     end # PopulateIfEmpty
-
-
-    def from_hash(params, args)
-      populated_attrs = []
-
-      nested_forms do |attr|
-        next unless attr[:populate_if_empty]
-
-        attr.merge!(
-          # DISCUSS: it would be cool to move the lambda block to PopulateIfEmpty#call.
-          :populator => lambda do |fragment, *args|
-            PopulateIfEmpty.new(self, fragment, args).call
-          end
-        )
-      end
-
-
-      nested_forms do |attr|
-        next unless attr[:populator]
-
-        attr.merge!(
-          :parse_strategy => attr[:populator],
-          :representable  => false
-          )
-        populated_attrs << attr.name.to_sym
-      end
-
-      super(params, {:include => populated_attrs}.merge(args))
-    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.
   def validate(params)
     update!(params)
 
-    super()
+    super() # run the actual validation on self.
   end
 
   def update!(params)
-    populate!(params)
     deserialize!(params)
   end
 
 private
-  def populate!(params)
-    # populate only happens for nested forms, if you override that setter it's your fault.
-    mapper.new(fields).extend(Populator).from_hash(params, :parent_form => self) # TODO: remove model(form) once we found out how to synchronize the model correctly. see https://github.com/apotonick/reform/issues/86#issuecomment-43402047
-  end
-
   def deserialize!(params)
     # using self here will call the form's setters like title= which might be overridden.
-    mapper.new(self).extend(Update).from_hash(params)
+    # from_hash(params, parent_form: self)
+    mapper.new(self).extend(Update).send(deserialize_method, params, :parent_form => self)
+  end
+
+  def deserialize_method
+    :from_hash
   end
 end

data/lib/reform/rails.rb

@@ -1,9 +1,9 @@
 require 'reform/form/active_model'
-if defined?(ActiveRecord)
-  require 'reform/form/active_record'
-end
+
+require 'reform/form/active_record' if defined?(ActiveRecord)
 
 Reform::Form.class_eval do # DISCUSS: i'd prefer having a separate Rails module to be mixed into the Form but this is way more convenient for 99% users.
   include Reform::Form::ActiveModel
   include Reform::Form::ActiveModel::FormBuilderMethods
+  include Reform::Form::ActiveRecord if defined?(ActiveRecord)
 end

data/lib/reform/representer.rb

@@ -6,9 +6,10 @@ module Reform
     include Representable::Hash::AllowSymbols
 
     extend Uber::InheritableAttr
-    inheritable_attr :options
+    inheritable_attr :options # FIXME: this doesn't need to be inheritable.
     # self.options = {}
 
+
     # Invokes #to_hash and/or #from_hash with #options. This provides a hook for other
     # modules to add options for the representational process.
     module WithOptions
@@ -58,6 +59,10 @@ module Reform
       end
     end
 
+    def self.default_inline_class
+      options[:form_class]
+    end
+
     def self.clone # called in inheritable_attr :representer_class.
       Class.new(self) # By subclassing, representable_attrs.clone is called.
     end
@@ -66,18 +71,20 @@ module Reform
     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.
+      attrs.inherit!(representable_attrs) # since in every use case we modify Config we clone.
       @representable_attrs = attrs
     end
 
-    def self.inline_representer(base_module, name, options, &block)
+    # Inline forms always get saved in :extend.
+    def self.build_inline(base, features, name, options, &block)
       name = name.to_s.singularize.camelize
 
-      Class.new(self.options[:form_class]) do
-        # TODO: this will soon become a generic feature in representable.
-        include *options[:features].reverse if options[:features]
+      features = options[:features]
+
+      Class.new(base || default_inline_class) do
+        include *features
 
-        instance_exec &block
+        class_eval &block
 
         @form_name = name
 

data/lib/reform/version.rb

@@ -1,3 +1,3 @@
 module Reform
-  VERSION = "1.0.4"
+  VERSION = "1.1.0"
 end

data/reform.gemspec

@@ -18,15 +18,17 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency             "representable",  "~> 1.8.1"
-  spec.add_dependency             "disposable",     "~> 0.0.4"
-  spec.add_dependency             "uber",           "~> 0.0.4"
+  spec.add_dependency             "representable",  "~> 2.0.3"
+  spec.add_dependency             "disposable",     "~> 0.0.5"
+  spec.add_dependency             "uber",           "~> 0.0.8"
   spec.add_dependency             "activemodel"
   spec.add_development_dependency "bundler",        "~> 1.3"
-  spec.add_development_dependency "rake",           ">= 10.1.0"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest",       "4.2.0"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "virtus"
   spec.add_development_dependency "rails"
+
+  spec.add_development_dependency "actionpack"
 end

data/test/active_model_test.rb

@@ -110,10 +110,9 @@ class ActiveModelWithCompositionTest < MiniTest::Spec
   let (:duran) { OpenStruct.new }
   let (:form) { HitForm.new(:song => rio, :artist => duran) }
 
-  describe "main form reader #hit" do# TODO: remove in 1.2. we don't support this reader #hit anymore.
-    it "delegates to :on model" do
-      form.hit.must_equal rio # TODO: remove in 1.2.
-    end
+  describe "model accessors a la model#[:hit]" do
+    it { form.model[:song].must_equal rio }
+    it { form.model[:artist].must_equal duran }
 
     it "doesn't delegate when :on missing" do
       class SongOnlyForm < Reform::Form
@@ -123,29 +122,11 @@ class ActiveModelWithCompositionTest < MiniTest::Spec
         property :title,  :on => :song
 
         model :song
-      end.new(:song => rio, :artist => duran).song.must_equal rio
+      end.new(:song => rio, :artist => duran).model[:song].must_equal rio
     end
-
-    # it "delegates when you call ::model" do
-    #   class SongOnlyForm < Reform::Form
-    #     include Composition
-    #     include Reform::Form::ActiveModel
-
-    #     property :title,  :on => :song
-    #     model :song
-
-    #     self
-    #   end.new(:song => rio, :artist => duran).persisted?
-    # end
   end
 
 
-  it "creates composition readers" do
-    skip "we don't want those anymore since they don't represent the form internal state!"
-    form.song.must_equal rio
-    form.artist.must_equal duran
-  end
-
   it "provides ::model_name" do
     form.class.model_name.must_equal "Hit"
   end