reform 0.2.7 → 1.0.0

data/lib/reform/form/active_model.rb

@@ -3,13 +3,15 @@ module Reform::Form::ActiveModel
     def self.included(base)
       base.class_eval do
         extend ClassMethods # ::model_name
+        features << FormBuilderMethods
       end
     end
 
     module ClassMethods
       def property(name, options={})
-        super
-        add_nested_attribute_compat(name) if options[:form] # TODO: fix that in Rails FB#1832 work.
+        super.tap do |definition|
+          add_nested_attribute_compat(name) if definition[:form] # TODO: fix that in Rails FB#1832 work.
+        end
       end
 
     private
@@ -20,7 +22,7 @@ module Reform::Form::ActiveModel
     end
 
     # Modify the incoming Rails params hash to be representable compliant.
-    def validate(params)
+    def update!(params)
       # DISCUSS: #validate should actually expect the complete params hash and then pick the right key as it knows the form name.
       # however, this would cause confusion?
       mapper.new(self).nested_forms do |attr, model| # FIXME: make this simpler.
@@ -36,16 +38,17 @@ module Reform::Form::ActiveModel
       return unless params.has_key?(nested_name)
 
       value = params["#{attr.name}_attributes"]
-      value = value.values if attr.options[:form_collection]
+      value = value.values if attr[:collection]
 
       params[attr.name] = value
     end
-  end
+  end # FormBuilderMethods
 
 
   def self.included(base)
     base.class_eval do
       extend ClassMethods
+      features << ActiveModel
 
       delegate [:persisted?, :to_key, :to_param, :id] => :model
 

data/lib/reform/form/active_record.rb

@@ -1,50 +1,43 @@
-class Reform::Form
-  module ActiveRecord
-    def self.included(base)
-      base.class_eval do
-        include Reform::Form::ActiveModel
-        extend ClassMethods
-      end
+module Reform::Form::ActiveRecord
+  def self.included(base)
+    base.class_eval do
+      include Reform::Form::ActiveModel
+      extend ClassMethods
     end
+  end
 
-    module ClassMethods
-      def validates_uniqueness_of(attribute)
-        validates_with UniquenessValidator, :attributes => [attribute]
-      end
-      def i18n_scope
-        :activerecord
-      end
+  module ClassMethods
+    def validates_uniqueness_of(attribute)
+      validates_with UniquenessValidator, :attributes => [attribute]
+    end
+    def i18n_scope
+      :activerecord
     end
+  end
 
-    class UniquenessValidator < ::ActiveRecord::Validations::UniquenessValidator
-      # when calling validates it should create the Vali instance already and set @klass there! # TODO: fix this in AM.
-      def validate(form)
-        property = attributes.first
+  class UniquenessValidator < ::ActiveRecord::Validations::UniquenessValidator
+    # when calling validates it should create the Vali instance already and set @klass there! # TODO: fix this in AM.
+    def validate(form)
+      property = attributes.first
 
-        # here is the thing: why does AM::UniquenessValidator require a filled-out record to work properly? also, why do we need to set
-        # the class? it would be way easier to pass #validate a hash of attributes and get back an errors hash.
-        # the class for the finder could either be infered from the record or set in the validator instance itself in the call to ::validates.
-        record = form.model_for_property(property)
-        record.send("#{property}=", form.send(property))
+      # here is the thing: why does AM::UniquenessValidator require a filled-out record to work properly? also, why do we need to set
+      # the class? it would be way easier to pass #validate a hash of attributes and get back an errors hash.
+      # the class for the finder could either be infered from the record or set in the validator instance itself in the call to ::validates.
+      record = form.model_for_property(property)
+      record.send("#{property}=", form.send(property))
 
-        @klass = record.class # this is usually done in the super-sucky #setup method.
-        super(record).tap do |res|
-          form.errors.add(property, record.errors.first.last) if record.errors.present?
-        end
+      @klass = record.class # this is usually done in the super-sucky #setup method.
+      super(record).tap do |res|
+        form.errors.add(property, record.errors.first.last) if record.errors.present?
       end
     end
+  end
 
-    def save(*)
-      super.tap do
-        model.save unless block_given? # DISCUSS: should we implement nested saving here?
-      end
-    end
 
-    def model_for_property(name)
-      return model unless is_a?(Reform::Form::Composition) # i am too lazy for proper inheritance. there should be a ActiveRecord::Composition that handles this.
+  def model_for_property(name)
+    return model unless is_a?(Reform::Form::Composition) # i am too lazy for proper inheritance. there should be a ActiveRecord::Composition that handles this.
 
-      model_name = mapper.representable_attrs[name].options[:on]
-      send(model_name)
-    end
+    model_name = mapper.representable_attrs[name][:on]
+    send(model_name)
   end
 end

data/lib/reform/form/coercion.rb

@@ -1,17 +1,16 @@
 require 'representable/decorator/coercion'
 
-class Reform::Form
-  module Coercion
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+module Reform::Form::Coercion
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.features << self
+  end
 
-    module ClassMethods
-      def representer_class
-        super.class_eval do
-          include Representable::Decorator::Coercion unless self < Representable::Decorator::Coercion # DISCUSS: include it once. why do we have to check this?
-          self
-        end
+  module ClassMethods
+    def representer_class
+      super.class_eval do
+        include Representable::Decorator::Coercion unless self < Representable::Decorator::Coercion # DISCUSS: include it once. why do we have to check this?
+        self
       end
     end
   end

data/lib/reform/form/composition.rb

@@ -1,70 +1,60 @@
 require "reform/form/active_model"
 
-class Reform::Form
+module Reform::Form::Composition
   # Automatically creates a Composition object for you when initializing the form.
-  module Composition
-    def self.included(base)
-      base.class_eval do
-        extend Reform::Form::ActiveModel::ClassMethods # ::model.
-        extend ClassMethods
-      end
+  def self.included(base)
+    base.class_eval do
+      extend Reform::Form::ActiveModel::ClassMethods # ::model.
+      extend ClassMethods
     end
+  end
 
-    module ClassMethods
-      #include Reform::Form::ActiveModel::ClassMethods # ::model.
+  module ClassMethods
+    #include Reform::Form::ActiveModel::ClassMethods # ::model.
 
-      def model_class # DISCUSS: needed?
-        rpr = representer_class
-        @model_class ||= Class.new(Reform::Composition) do
-          map_from rpr
-        end
-      end
+    def model_class # DISCUSS: needed?
+      @model_class ||= Reform::Composition.from(representer_class)
+    end
 
-      def property(name, options={})
-        super
-        delegate options[:on] => :@model
+    def property(name, options={})
+      super.tap do |definition|
+        delegate options[:on] => :@model # form.band -> composition.band
       end
+    end
 
-      # Same as ActiveModel::model but allows you to define the main model in the composition
-      # using +:on+.
-      #
-      # class CoverSongForm < Reform::Form
-      #   model :song, on: :cover_song
-      def model(main_model, options={})
-        super
-
-        composition_model = options[:on] || main_model
+    # Same as ActiveModel::model but allows you to define the main model in the composition
+    # using +:on+.
+    #
+    # class CoverSongForm < Reform::Form
+    #   model :song, on: :cover_song
+    def model(main_model, options={})
+      super
 
-        delegate composition_model => :model # #song => model.song
+      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.
-        delegate [:persisted?, :to_key, :to_param] => composition_model  # #to_key => song.to_key
+      delegate composition_model => :model # #song => model.song
 
-        alias_method main_model, composition_model # #hit => model.song.
-      end
-    end
+      # FIXME: this should just delegate to :model as in FB, and the comp would take care of it internally.
+      delegate [:persisted?, :to_key, :to_param] => composition_model  # #to_key => song.to_key
 
-    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.
+      alias_method main_model, composition_model # #hit => model.song.
     end
   end
 
+  def initialize(models)
+    composition = self.class.model_class.new(models)
+    super(composition)
+  end
 
-  # TODO: remove me in 1.3.
-  module DSL
-    include Composition
+  def aliased_model # we don't need an Expose as we save the Composition instance in the constructor.
+    model
+  end
 
-    def self.included(base)
-      warn "[DEPRECATION] Reform::Form: `DSL` is deprecated.  Please use `Composition` instead."
+  def to_nested_hash
+    model.nested_hash_for(to_hash)  # use composition to compute nested hash.
+  end
 
-      base.class_eval do
-        extend Composition::ClassMethods
-      end
-    end
+  def to_hash(*args)
+    mapper.new(self).to_hash(*args)
   end
-end
+end

data/lib/reform/form/multi_parameter_attributes.rb

@@ -1,5 +1,9 @@
-class Reform::Form
+Reform::Form.class_eval do
   module MultiParameterAttributes
+    def self.included(base)
+      base.features << self
+    end
+
     class DateParamsFilter
       def call(params)
         date_attributes = {}
@@ -33,6 +37,7 @@ class Reform::Form
 
     def validate(params)
       # TODO: make it cleaner to hook into essential reform steps.
+      # TODO: test with nested.
       DateParamsFilter.new.call(params)
 
       super

data/lib/reform/form/save.rb

@@ -0,0 +1,61 @@
+Reform::Form.class_eval do
+  module 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
+
+    def save
+      # 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?
+
+      sync_models # recursion
+      save!
+    end
+
+    def save!
+      save_model
+      mapper.new(self).extend(RecursiveSave).to_hash # save! on all nested forms.
+    end
+
+    def save_model
+      model.save # TODO: implement nested (that should really be done by Twin/AR).
+    end
+
+
+    module NestedHash
+      def to_hash(*)
+        # 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 },
+          )
+        end
+
+        representable_attrs.each do |attr|
+          attr.merge!(:as => attr[:private_name] || attr.name)
+        end
+
+        super
+      end
+    end
+
+    require "active_support/hash_with_indifferent_access" # DISCUSS: replace?
+    def to_nested_hash
+      map = mapper.new(self).extend(Save::NestedHash)
+
+      ActiveSupport::HashWithIndifferentAccess.new(map.to_hash)
+    end
+  end
+end

data/lib/reform/form/sync.rb

@@ -0,0 +1,60 @@
+Reform::Form.class_eval do
+  # #sync!
+  #   1. assign scalars to model (respecting virtual, excluded attributes)
+  #   2. call sync! on nested
+  module 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 },
+            :deserialize => lambda { |object, *| object.sync! },
+            :setter => lambda { |*| } # don't write hit=<Form>.
+          )
+        end
+
+        super
+      end
+    end
+
+    # Transforms form input into what actually gets written to model.
+    # output: {title: "Mint Car", hit: <Form>}
+    module InputRepresenter
+      include Reform::Representer::WithOptions
+      # TODO: make dynamic.
+      include Reform::Form::EmptyAttributesOptions
+      include Reform::Form::ReadonlyAttributesOptions
+
+      def to_hash(*)
+        nested_forms do |attr|
+          attr.merge!(
+            :representable  => false,
+            :prepare        => lambda { |obj, *| obj }
+          )
+
+        end
+
+        super
+      end
+    end
+  end
+
+  ### TODO: add ToHash with :prepare => lambda { |form, args| form },
+
+  def sync_models
+    sync!
+  end
+  alias_method :sync, :sync_models
+
+  def sync! # semi-public.
+    input_representer = mapper.new(self).extend(Sync::InputRepresenter)
+
+    input = input_representer.to_hash
+
+    mapper.new(aliased_model).extend(Sync::Writer).from_hash(input)
+  end
+end

data/lib/reform/form/validate.rb

@@ -0,0 +1,104 @@
+# Mechanics for writing to forms in #validate.
+module Reform::Form::Validate
+  module Update
+    def from_hash(*)
+      nested_forms do |attr|
+        attr.delete(:prepare)
+        attr.delete(:extend)
+
+        attr.merge!(
+          :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) },
+        )
+      end
+
+      super
+    end
+  end
+
+
+  module Populator
+    class PopulateIfEmpty
+      def initialize(*args)
+        @form, @fragment, args = args
+        @index = args.first
+        @args  = args.last
+      end
+
+      def call
+        binding = @args.binding
+        form    = binding.get
+
+        return if binding.array? and form and form[@index] # TODO: this should be handled by the Binding.
+        return if !binding.array? and form
+        # only get here when above form is nil.
+
+        if binding[:populate_if_empty].is_a?(Proc)
+          model = @form.instance_exec(@fragment, @args, &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?
+          @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?
+          @form.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.
+          @form.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})
+    end
+  end
+
+
+  def validate(params)
+    update!(params)
+
+    super()
+  end
+
+  def update!(params)
+    # puts "updating in #{self.class.name}"
+    populate!(params)
+
+    mapper.new(self).extend(Update).from_hash(params)
+  end
+
+private
+  def populate!(params)
+    mapper.new(self).extend(Populator).from_hash(params)
+  end
+
+end