reform 0.1.2 → 0.2.0

data/lib/reform/form/active_model.rb

@@ -1,31 +1,76 @@
 module Reform::Form::ActiveModel
+  module FormBuilderMethods # TODO: rename to FormBuilderCompat.
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods # ::model_name
+      end
+    end
+
+    module ClassMethods
+      def property(name, options={})
+        add_nested_attribute_compat(name) if block_given? # TODO: fix that in Rails FB#1832 work.
+        super
+      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.
+      end
+    end
+
+    # Modify the incoming Rails params hash to be representable compliant.
+    def validate(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.
+        if attr.options[:form_collection] # FIXME: why no array?
+          params[attr.name] = params["#{attr.name}_attributes"].values
+        else
+          params[attr.name] = params["#{attr.name}_attributes"]# DISCUSS: delete old key? override existing?
+        end
+      end
+
+      super
+    end
+  end
+
+
   def self.included(base)
     base.class_eval do
       extend ClassMethods
+
+      delegate [:persisted?, :to_key, :to_param, :id] => :model
+
+      def to_model # this is called somewhere in FormBuilder and ActionController.
+        self
+      end
     end
   end
 
   module ClassMethods
+    # Set a model name for this form if the infered is wrong.
+    #
+    #   class CoverSongForm < Reform::Form
+    #     model :song
     def model(main_model, options={})
-      @model_options    = [main_model, options]  # FIXME: make inheritable!
-      composition_model = options[:on] || main_model
-
-      delegate composition_model, :to => :model  # #song => model.song
-      delegate :persisted?, :to_key, :to_param, :to_model, :to => composition_model  # #to_key => song.to_key
-
-      alias_method main_model, composition_model # #hit => model.song.
-    end
-
-    def property(name, options={})
-      delegate options[:on], :to => :model
-      super
+      @model_options = [main_model, options]  # FIXME: make inheritable!
     end
 
     def model_name
-      name = @model_options.first.to_s.camelize
+      if @model_options
+        form_name = @model_options.first.to_s.camelize
+      else
+        form_name = name.sub(/Form$/, "")
+      end
+
+      active_model_name_for(form_name)
+    end
 
-      return ::ActiveModel::Name.new(OpenStruct.new(:name => name)) if ::ActiveModel::VERSION::MAJOR == 3 and ::ActiveModel::VERSION::MINOR == 0
-      ::ActiveModel::Name.new(self, nil, name)
+  private
+    def active_model_name_for(string)
+      return ::ActiveModel::Name.new(OpenStruct.new(:name => string)) if Reform.rails3_0?
+      ::ActiveModel::Name.new(self, nil, string)
     end
   end
 end

data/lib/reform/form/active_record.rb

@@ -2,7 +2,7 @@ class Reform::Form
   module ActiveRecord
     def self.included(base)
       base.class_eval do
-        include ActiveModel
+        include Reform::Form::ActiveModel
         extend ClassMethods
       end
     end
@@ -17,12 +17,12 @@ class Reform::Form
       # 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
-        model_name = form.send(:model).class.model_for_property(property)
+        #model_name = form.send(:model).class.model_for_property(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.send(model_name)
+        record = form.send(:model)
         record.send("#{property}=", form.send(property))
         @klass = record.class # this is usually done in the super-sucky #setup method.
         super(record).tap do |res|

data/lib/reform/form/composition.rb

@@ -0,0 +1,69 @@
+require "reform/form/active_model"
+
+class Reform::Form
+  # Automatically creates a Composition object for you when initializing the form.
+  module Composition
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    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 property(name, options={})
+        super
+        delegate options[:on] => :@model
+      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
+
+        delegate composition_model => :model # #song => model.song
+
+        # 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
+
+        alias_method main_model, composition_model # #hit => model.song.
+      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
+  end
+
+
+  # TODO: remove me in 1.3.
+  module DSL
+    include Composition
+
+    def self.included(base)
+      warn "[DEPRECATION] Reform::Form: `DSL` is deprecated.  Please use `Composition` instead."
+
+      base.class_eval do
+        extend Composition::ClassMethods
+      end
+    end
+  end
+end

data/lib/reform/form.rb

@@ -1,143 +1,246 @@
-require 'delegate'
+require 'forwardable'
 require 'ostruct'
 
+require 'reform/composition'
+require 'reform/representer'
+
 module Reform
-  class Form  < SimpleDelegator
+  class Form
+    extend Forwardable
     # reasons for delegation:
     # presentation: this object is used in the presentation layer by #form_for.
     # problem: #form_for uses respond_to?(:email_before_type_cast) which goes to an internal hash in the actual record.
     # validation: this object also contains the validation rules itself, should be separated.
-    # TODO: figure out #to_key issues.
 
-    def initialize(mapper_class, composition)
-      @mapper     = mapper_class
-      @model      = composition
+    # Allows using property and friends in the Form itself. Forwarded to the internal representer_class.
+    module PropertyMethods
+      extend Forwardable
+
+      def property(name, options={}, &block)
+        definition = representer_class.property(name, options, &block)
+        setup_form_definition(definition) if block_given?
+        create_accessor(name)
+      end
+
+      def collection(name, options={}, &block)
+        options[:form_collection] = true
+
+        property(name, options, &block)
+      end
+
+      def properties(names, *args)
+        names.each { |name| property(name, *args) }
+      end
+
+      def setup_form_definition(definition)
+        definition.options[:form] = definition.options.delete(:extend)
+
+        definition.options[:parse_strategy] = :sync
+        definition.options[:instance] = true # just to make typed? work
+      end
+
+      def representer_class
+        @representer_class ||= Class.new(Reform::Representer)
+      end
+
+    private
+      def create_accessor(name)
+        delegate [name, "#{name}="] => :fields
+      end
+    end
+    extend PropertyMethods
+
 
-      super(setup_fields(mapper_class, composition))  # delegate all methods to Fields instance.
+    def initialize(model)
+      @model  = model # we need this for #save.
+      @fields = setup_fields(model)  # delegate all methods to Fields instance.
     end
 
-    def validate(params)
-      # here it would be cool to have a validator object containing the validation rules representer-like and then pass it the formed model.
-      update_with(params)
+    module ValidateMethods # TODO: introduce Base module.
+      def validate(params)
+        # here it would be cool to have a validator object containing the validation rules representer-like and then pass it the formed model.
+        from_hash(params)
+
+        res = valid?  # this validates on <Fields> using AM::Validations, currently.
+        #inject(true) do |res, form| # FIXME: replace that!
+        mapper.new(@fields).nested_forms do |attr, form| #.collect { |attr, form| nested[attr.from] = form }
+          res = validate_for(form, res, attr.from)
+        end
+
+        res
+      end
+
+    private
+      def validate_for(form, res, prefix=nil)
+        return res if form.valid? # FIXME: we have to call validate here, otherwise this works only one level deep.
+
+        errors.merge!(form.errors, prefix)
+        false
+      end
 
-      valid?  # this validates on <Fields> using AM::Validations, currently.
     end
+    include ValidateMethods
 
     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?
 
-      @mapper.new(model).from_hash(to_hash) # DISCUSS: move to Composition?
+      save_to_models
     end
 
     # Use representer to return current key-value form hash.
-    def to_hash
+    def to_hash(*)
       mapper.new(self).to_hash
     end
 
     def to_nested_hash
-      model.nested_hash_for(to_hash)  # use composition to compute nested hash.
+      symbolize_keys(to_hash)
+    end
+
+    def from_hash(params, *args)
+      mapper.new(self).from_hash(params) # sets form properties found in params on self.
+    end
+
+    def errors
+      @errors ||= Errors.new(self)
     end
 
   private
-    attr_accessor :mapper, :model
+    attr_accessor :model, :fields
+
+    def symbolize_keys(hash)
+      hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    end
+
+    def mapper
+      self.class.representer_class
+    end
 
-    def setup_fields(mapper_class, composition)
-      # decorate composition and transform to hash.
-      representer = mapper_class.new(composition)
+    def setup_fields(model)
+      representer = Class.new(mapper).new(model)
+
+      setup_nested_forms(representer)
 
       create_fields(representer.fields, representer.to_hash)
     end
 
+    def setup_nested_forms(representer)
+      # TODO: we should simply give a FormBuilder instance to representer.to_hash that does this kind of mapping:
+      # after this, Fields contains scalars and Form instances and Forms with form instances.
+      representer.nested_forms do |attr, model|
+        form_class = attr.options[:form]
+
+        attr.options.merge!(
+          :getter   => lambda do |*|
+            nested_model  = send(attr.getter) # decorated.hit # TODO: use bin.get
+
+            if attr.options[:form_collection]
+              Forms.new(nested_model.collect { |mdl| form_class.new(mdl)})
+            else
+              form_class.new(nested_model)
+            end
+          end,
+          :instance => false, # that's how we make it non-typed?.
+        )
+      end
+
+      #representer.to_hash override: { write: lambda { |doc, value|  } }
+
+      # DISCUSS: this would be cool in representable:
+      # to_hash(hit: lambda { |value| form_class.new(..) })
+
+      # steps:
+      # - bin.get
+      # - map that: Forms.new( orig ) <-- override only this in representable (how?)
+      # - mapped.to_hash
+    end
+
     def create_fields(field_names, fields)
       Fields.new(field_names, fields)
     end
 
-    def update_with(params)
-      mapper.new(self).from_hash(params) # sets form properties found in params on self.
+    def save_to_models
+      representer = mapper.new(model)
+
+      representer.nested_forms do |attr, model|
+        attr.options.merge!(
+          :decorator => attr.options[:form].representer_class
+        )
+
+        if attr.options[:form_collection]
+          attr.options.merge!(
+            :collection => true
+          )
+        end
+      end
+
+      representer.from_hash(to_hash)
     end
 
     # FIXME: make AM optional.
     require 'active_model'
     include ActiveModel::Validations
-  end
-
-  # Keeps values of the form fields. What's in here is to be displayed in the browser!
-  # we need this intermediate object to display both "original values" and new input from the form after submitting.
-  class Fields < OpenStruct
-    def initialize(properties, values={})
-      fields = properties.inject({}) { |hsh, attr| hsh.merge!(attr => nil) }
-      super(fields.merge!(values))  # TODO: stringify value keys!
-    end
-  end
-
-  # Keeps composition of models and knows how to transform a plain hash into a nested hash.
-  class Composition
-    class << self
-      def map(options)
-        @attr2obj = {}  # {song: ["title", "track"], artist: ["name"]}
-
-        options.each do |mdl, meths|
-          create_accessors(mdl, meths)
-          attr_reader mdl # FIXME: unless already defined!!
 
-          meths.each { |m| @attr2obj[m.to_s] = mdl }
-        end
+    # The Errors class is planned to replace AM::Errors. It provides proper nested error messages.
+    class Errors < ActiveModel::Errors
+      def messages
+        return super unless Reform.rails3_0?
+        self
       end
 
-      # Specific to representable.
-      def map_from(representer)
-        options = {}
-        representer.representable_attrs.each do |cfg|
-          options[cfg.options[:on]] ||= []
-          options[cfg.options[:on]] << cfg.name
-        end
+      # def each
+      #   messages.each_key do |attribute|
+      #     self[attribute].each { |error| yield attribute, Array.wrap(error) }
+      #   end
+      # end
 
-        map options
-      end
+      def merge!(errors, prefix=nil)
+        # TODO: merge into AM.
+        errors.messages.each do |field, msgs|
+          field = "#{prefix}.#{field}" if prefix
 
-      def model_for_property(name)
-        @attr2obj.fetch(name.to_s)
-      end
+          msgs = [msgs] if Reform.rails3_0? # DISCUSS: fix in #each?
 
-    private
-      def create_accessors(model, methods)
-        accessors = methods.collect { |m| [m, "#{m}="] }.flatten
-        delegate *accessors << {:to => :"#{model}"}
+          msgs.each do |msg|
+            next if messages[field] and messages[field].include?(msg)
+            add(field, msg)
+          end # Forms now contains a plain errors hash. the errors for each item are still available in item.errors.
+        end
       end
     end
 
-    # TODO: make class method?
-    def nested_hash_for(attrs)
-      {}.tap do |hsh|
-        attrs.each do |name, val|
-          obj = self.class.model_for_property(name)
-          hsh[obj] ||= {}
-          hsh[obj][name.to_sym] = val
+    require "representable/hash/collection"
+    require 'active_model'
+    class Forms < Array # DISCUSS: this should be a Form subclass.
+      include Form::ValidateMethods
+
+      def valid?
+        inject(true) do |res, form|
+          res = validate_for(form, res)
         end
       end
-    end
 
-    def initialize(models)
-      models.each do |name, obj|
-        instance_variable_set(:"@#{name}", obj)
+      def errors
+        @errors ||= Form::Errors.new(self)
       end
+
+      # this gives us each { to_hash }
+      include Representable::Hash::Collection
+      items :parse_strategy => :sync, :instance => true
     end
   end
 
-  require 'representable/hash'
-  class Representer < Representable::Decorator
-    include Representable::Hash
 
-    def self.properties(names, *args)
-      names.each do |name|
-        property(name, *args)
-      end
+  # Keeps values of the form fields. What's in here is to be displayed in the browser!
+  # we need this intermediate object to display both "original values" and new input from the form after submitting.
+  class Fields < OpenStruct
+    def initialize(properties, values={})
+      fields = properties.inject({}) { |hsh, attr| hsh.merge!(attr => nil) }
+      super(fields.merge!(values))  # TODO: stringify value keys!
     end
+  end
 
-    # Returns hash of all property names.
-    def fields
-      representable_attrs.collect { |cfg| cfg.name }
-    end
+  def self.rails3_0?
+    ::ActiveModel::VERSION::MAJOR == 3 and ::ActiveModel::VERSION::MINOR == 0
   end
 end

data/lib/reform/rails.rb

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

data/lib/reform/representer.rb

@@ -0,0 +1,38 @@
+require 'representable/hash'
+require 'representable/decorator'
+
+module Reform
+  class Representer < Representable::Decorator
+    include Representable::Hash
+
+    # Returns hash of all property names.
+    def fields
+      representable_attrs.map(&:name)
+    end
+
+    def nested_forms(&block)
+      clone_config!.
+        find_all { |attr| attr.options[:form] }.
+        collect  { |attr| [attr, represented.send(attr.getter)] }. # DISCUSS: can't we do this with the Binding itself?
+        each(&block)
+    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
+
+    def self.inline_representer(base_module, &block) # DISCUSS: separate module?
+      Class.new(Form) do
+        instance_exec &block
+
+        def self.name # FIXME: needed by ActiveModel::Validation - why?
+          "AnonInlineForm"
+        end
+      end
+    end
+  end
+end

data/lib/reform/version.rb

@@ -1,3 +1,3 @@
 module Reform
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/reform.rb

@@ -1,4 +1,7 @@
-require 'reform/version'
 require 'reform/form'
-require 'reform/form/dsl'
+require 'reform/form/composition'
 require 'reform/form/active_model'
+
+if defined?(Rails) # DISCUSS: is everyone ok with this?
+  require 'reform/rails'
+end

data/reform.gemspec

@@ -18,12 +18,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency             "representable", ">= 1.5.3"
+  spec.add_dependency             "representable",  "~> 1.7.0"
   spec.add_dependency             "activemodel"
   spec.add_development_dependency "bundler",        "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake",           ">= 10.1.0"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "virtus"
+  spec.add_development_dependency "rails"
 end