reform 1.1.1 → 1.2.0.beta1

data/lib/reform/contract/validate.rb

@@ -2,9 +2,6 @@ module Reform::Contract::Validate
   module NestedValid
     def to_hash(*)
       nested_forms do |attr|
-        # attr.delete(:prepare)
-        # attr.delete(:extend)
-
         attr.merge!(
           :serialize => lambda { |object, args|
 
@@ -13,8 +10,6 @@ module Reform::Contract::Validate
             options[:prefix] = options[:prefix].dup # TODO: implement Options#dup.
             options[:prefix] << args.binding.name # FIXME: should be #as.
 
-            # puts "======= user_options: #{args.user_options.inspect}"
-
             object.validate!(options) # recursively call valid?
           },
         )
@@ -34,7 +29,6 @@ module Reform::Contract::Validate
     errors.valid?
   end
   def validate!(options)
-    # puts "validate! in #{self.class.name}: #{true.inspect}"
     prefix = options[:prefix]
 
     # call valid? recursively and collect nested errors.

data/lib/reform/form.rb

@@ -1,15 +1,7 @@
-require 'ostruct'
-
-require 'reform/contract'
-require 'reform/composition'
-require 'reform/form/module'
-
 module Reform
   class Form < Contract
     self.representer_class = Reform::Representer.for(:form_class => self)
 
-    require "reform/form/virtual_attributes"
-
     require 'reform/form/validate'
     include Validate # extend Contract#validate with additional behaviour.
     require 'reform/form/sync'
@@ -29,5 +21,11 @@ module Reform
 
     require 'reform/form/scalar'
     extend Scalar::Property # experimental feature!
+
+
+    # DISCUSS: should that be optional? hooks into #validate, too.
+    require 'reform/form/changed'
+    register_feature Changed
+    include Changed
   end
 end

data/lib/reform/form/active_model.rb

@@ -10,13 +10,14 @@ module Reform::Form::ActiveModel
     end
 
     module ClassMethods
-      def property(name, options={})
+      private
+
+      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.
         end
       end
 
-    private
       # The Rails FormBuilder "detects" nested attributes (which is what we want) by checking existance of a setter method.
       def add_nested_attribute_compat(name)
         define_method("#{name}_attributes=") {} # this is why i hate respond_to? in Rails.

data/lib/reform/form/active_model/model_validations.rb

@@ -29,12 +29,24 @@ module Reform::Form::ActiveModel
     private
 
       def add_validator(validator)
+        if validator.respond_to?(:attributes)
+          add_native_validator validator
+        else
+          add_custom_validator validator
+        end
+      end
+
+      def add_native_validator validator
         attributes = inverse_map_attributes(validator.attributes)
         if attributes.any?
           @form_class.validates(*attributes, {validator.kind => validator.options})
         end
       end
 
+      def add_custom_validator validator
+        @form_class.validates(nil, {validator.kind => validator.options})
+      end
+
       def inverse_map_attributes(attributes)
         @mapping.inverse_image(create_attributes(attributes))
       end
@@ -95,4 +107,4 @@ module Reform::Form::ActiveModel
     end
 
   end
-end
+end

data/lib/reform/form/active_record.rb

@@ -35,17 +35,11 @@ module Reform::Form::ActiveRecord
     end
   end
 
-
+  # TODO: this is no AR thing.
   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.get(name)[:on]
     model[model_name]
   end
-
-  # Delegate column for attribute to the model to support simple_form's
-  # attribute type interrogation.
-  def column_for_attribute(name)
-    model_for_property(name).column_for_attribute(name)
-  end
 end

data/lib/reform/form/changed.rb

@@ -0,0 +1,9 @@
+module Reform::Form::Changed
+  def changed?(name=nil)
+    !! changed[name.to_s]
+  end
+
+  def changed
+    @changed ||= {}
+  end
+end

data/lib/reform/form/json.rb

@@ -0,0 +1,13 @@
+require 'representable/json'
+
+module Reform
+  module Form::JSON
+    def self.included(base)
+      base.representer_class.send :include, Representable::JSON
+    end
+
+    def deserialize_method
+      :from_json
+    end
+  end
+end

data/lib/reform/form/model_reflections.rb

@@ -0,0 +1,18 @@
+# ModelReflections will be the interface between the form object and form builders like simple_form.
+#
+# This module is meant to collect all dependencies simple_form needs in addition to the ActiveModel ones.
+# Goal is to collect all methods and define a reflection API so simple_form works with all ORMs and Reform
+# doesn't have to "guess" what simple_form and other form helpers need.
+module Reform::Form::ModelReflections
+  def self.included(base)
+    base.register_feature self # makes it work in nested forms.
+  end
+
+  # Delegate column for attribute to the model to support simple_form's
+  # attribute type interrogation.
+  def column_for_attribute(name)
+    model_for_property(name).column_for_attribute(name)
+  end
+
+  # this should also contain to_param and friends as this is used by the form helpers.
+end

data/lib/reform/form/save.rb

@@ -15,17 +15,26 @@ module Reform::Form::Save
   end
 
   # Returns the result of that save invocation on the model.
-  def save(&block)
+  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?
 
     sync_models # recursion
-    save!
+    save!(options)
   end
 
-  def 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.
+
+      # puts "$$$$$$$$$ #{names.inspect}"
+      representer.to_hash(options.merge :include => names)
+    end
+
     result
   end
 
@@ -34,6 +43,19 @@ module Reform::Form::Save
   end
 
 
+  def save_dynamic_representer
+    # puts mapper.superclass.superclass.inspect
+    Class.new(mapper).apply 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
+      )
+    end
+  end
+
+
   module NestedHash
     def to_hash(*)
       # Transform form data into a nested hash for #save.

data/lib/reform/form/scalar.rb

@@ -16,7 +16,7 @@ module Reform::Form::Scalar
   def save!
   end
 
-  def sync!
+  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
@@ -41,6 +41,8 @@ module Reform::Form::Scalar
 
   # TODO: change the way i hook into ::property.
   module Property
+    private
+
     def property(name, options={}, &block)
       if options[:scalar]
         options.merge!(:features => [Reform::Form::Scalar], populate_if_empty: String)
@@ -49,4 +51,4 @@ module Reform::Form::Scalar
       super
     end
   end
-end
+end

data/lib/reform/form/sync.rb

@@ -11,7 +11,8 @@ module Reform::Form::Sync
       nested_forms do |attr|
         attr.merge!(
           :instance     => lambda { |fragment, *| fragment },
-          :deserialize => lambda { |object, *| model = object.sync! } # sync! returns the synced model.
+            # 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
@@ -20,14 +21,36 @@ module Reform::Form::Sync
     end
   end
 
+  module Setter
+    def from_hash(*)
+      clone_config!
+
+      representable_attrs.each do |dfn|
+        next unless setter = dfn[:sync]
+
+        setter_proc = lambda do |value, options|
+          # puts "~~ #{value}~ #{options.user_options.inspect}"
+
+          if options.binding[:sync] == true
+            options.user_options[options.binding.name.to_sym].call(value, options)
+            next
+          end
+
+          # evaluate the :sync block in form context (should we do that everywhere?).
+          options.user_options[:form].instance_exec(value, options, &setter)
+        end
+
+        dfn.merge!(:setter => setter_proc)
+      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
-
+    # receives Representer::Options hash.
     def to_hash(*)
       nested_forms do |attr|
         attr.merge!(
@@ -41,20 +64,67 @@ module Reform::Form::Sync
   end
 
 
-  def sync_models
-    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! # semi-public.
-    input_representer = mapper.new(fields).extend(InputRepresenter)
+  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
 
-    input = input_representer.to_hash
+    options.delete(:exclude) # TODO: can we use 2 options?
 
-    mapper.new(aliased_model).extend(Writer).from_hash(input) # sync properties to Song.
+    mapper.new(aliased_model).extend(Writer).extend(Setter).from_hash(input, options) # sync properties to Song.
 
     model
   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)
+    end
+  end
+  include SyncHash
+
+
+  # Excludes :virtual properties from #sync in this form.
+  module ReadOnly
+    def sync_hash(options)
+      readonly_fields = mapper.fields { |dfn| dfn[:virtual] }
+
+      options.exclude!(readonly_fields.map(&:to_sym))
+
+      super
+    end
+  end
+  include ReadOnly
+
+
+  # This will skip unchanged properties in #sync. To use this for all nested form do as follows.
+  #
+  #   class SongForm < Reform::Form
+  #     feature Synd::SkipUnchanged
+  module SkipUnchanged
+    def sync_hash(options)
+      # DISCUSS: we currently don't track if nested forms have changed (only their attributes). that's why i include them all here, which
+      # is additional sync work/slightly wrong. solution: allow forms to form.changed? not sure how to do that with collections.
+      scalars   = mapper.fields { |dfn| !dfn[:form] }
+      unchanged = scalars - changed.keys
+
+      # exclude unchanged scalars, nested forms and changed scalars still go in here!
+      options.exclude!(unchanged.map(&:to_sym))
+      super
+    end
+  end
 end

data/lib/reform/form/validate.rb

@@ -26,6 +26,16 @@ module Reform::Form::Validate
       # 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
@@ -73,6 +83,34 @@ module Reform::Form::Validate
     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
+
+        properties.each { |name| params[name].present? and return false }
+        true # skip
+      end
+    end
+  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.

data/lib/reform/rails.rb

@@ -1,6 +1,6 @@
 require 'reform/form/active_model'
 
-require 'reform/form/active_record' if defined?(ActiveRecord)
+require 'reform/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

data/lib/reform/representer.rb

@@ -10,41 +10,32 @@ module Reform
     # 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
-      class Options < Hash
-        def include!(names)
-          self[:include] ||= []
-          self[:include] += names
-          self
-        end
-
-        def exclude!(names)
-          self[:exclude] ||= []
-          self[:exclude] +=  names
-          self
-        end
+    class Options < ::Hash
+      def include!(names)
+        includes.push(*names) #if names.size > 0
+        self
       end
 
-      def options
-        Options.new
+      def exclude!(names)
+        excludes.push(*names) #if names.size > 0
+        self
       end
 
-      def to_hash(*)
-        super(options)
+      def excludes
+        self[:exclude] ||= []
       end
 
-      def from_hash(*)
-        super(options)
+      def includes
+        self[:include] ||= []
       end
     end
 
+
     include Representable::Hash
 
     # Returns hash of all property names.
-    def fields
-      representable_attrs.map(&:name)
+    def self.fields(&block)
+      representable_attrs.find_all(&block).map(&:name)
     end
 
     def nested_forms(&block)