reform 0.2.7 → 1.0.0

data/lib/reform/contract.rb

@@ -0,0 +1,109 @@
+require 'forwardable'
+require 'uber/inheritable_attr'
+
+require 'reform/representer'
+
+module Reform
+  # Gives you a DSL for defining the object structure and its validations.
+  class Contract # DISCUSS: make class?
+    extend Forwardable
+
+    extend Uber::InheritableAttr
+    inheritable_attr :representer_class
+    self.representer_class = Reform::Representer.for(:form_class => self)
+
+    inheritable_attr :features
+    self.features = []
+
+
+    module PropertyMethods
+      extend Forwardable
+
+      def property(name, options={}, &block)
+        options[:private_name] = options.delete(:as)
+
+        # at this point, :extend is a Form class.
+        options[:features] = features if block_given?
+        definition = representer_class.property(name, options, &block)
+        setup_form_definition(definition) if block_given? or options[:form]
+
+        create_accessor(name)
+        definition
+      end
+
+      def collection(name, options={}, &block)
+        options[:collection] = true
+
+        property(name, options, &block)
+      end
+
+      def properties(names, *args)
+        names.each { |name| property(name, *args) }
+      end
+
+      def setup_form_definition(definition)
+        options = {
+          :form         => definition[:form] || definition[:extend].evaluate(nil), # :form is always just a Form class name.
+          :pass_options => true, # new style of passing args
+          :prepare      => lambda { |form, args| form }, # always just return the form without decorating.
+          :representable => true, # form: Class must be treated as a typed property.
+        }
+
+        definition.merge!(options)
+      end
+
+    private
+      def create_accessor(name)
+        # Make a module that contains these very accessors, then include it
+        # so they can be overridden but still are callable with super.
+        accessors = Module.new do
+          extend Forwardable # DISCUSS: do we really need Forwardable here?
+          delegate [name, "#{name}="] => :fields
+        end
+        include accessors
+      end
+    end
+    extend PropertyMethods
+
+
+    # FIXME: make AM optional.
+    require 'active_model'
+    include ActiveModel::Validations
+
+
+    attr_accessor :model
+
+    require 'reform/contract/setup'
+    include Setup
+    require 'reform/contract/validate'
+    include Validate
+
+
+    def errors # FIXME: this is needed for Rails 3.0 compatibility.
+      @errors ||= Errors.new(self)
+    end
+
+
+  private
+    attr_accessor :fields
+    attr_writer :errors # only used in top form. (is that true?)
+
+    def mapper
+      self.class.representer_class
+    end
+
+    alias_method :aliased_model, :model
+
+
+    # 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 # Fields
+  end
+end
+
+require 'reform/contract/errors'

data/lib/reform/contract/errors.rb

@@ -0,0 +1,33 @@
+# The Errors class is planned to replace AM::Errors. It provides proper nested error messages.
+class Reform::Contract::Errors < ActiveModel::Errors
+  def messages
+    return super unless Reform.rails3_0?
+    self
+  end
+
+  # def each
+  #   messages.each_key do |attribute|
+  #     self[attribute].each { |error| yield attribute, Array.wrap(error) }
+  #   end
+  # end
+
+  def merge!(errors, prefix)
+    prefixes = prefix.join(".")
+
+    # TODO: merge into AM.
+    errors.messages.each do |field, msgs|
+      field = (prefix+[field]).join(".").to_sym # TODO: why is that a symbol in Rails?
+
+      msgs = [msgs] if Reform.rails3_0? # DISCUSS: fix in #each?
+
+      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
+
+  def valid? # TODO: test me in unit test.
+    blank?
+  end
+end # Errors

data/lib/reform/contract/setup.rb

@@ -0,0 +1,44 @@
+
+module Reform
+  class Contract
+    module Setup
+      def initialize(model)
+        @model  = model # we need this for #save.
+        @fields = setup_fields  # delegate all methods to Fields instance.
+      end
+
+      def setup_fields
+        representer = mapper.new(aliased_model).extend(Setup::Representer)
+
+        create_fields(representer.fields, representer.to_hash)
+      end
+
+      # DISCUSS: setting up the Validation (populating with values) will soon be handled with Disposable::Twin logic.
+      def create_fields(field_names, fields)
+        Fields.new(field_names, fields)
+      end
+
+
+      # Mechanics for setting up initial Field values.
+      module Representer
+        require 'reform/form/virtual_attributes' # FIXME: that shouldn't be here.
+
+        include Reform::Representer::WithOptions
+        include Reform::Form::EmptyAttributesOptions # FIXME: that shouldn't be here.
+
+        def to_hash(*)
+          nested_forms do |attr|
+            attr.merge!(
+              :representable => false, # don't call #to_hash.
+              :prepare       => lambda do |model, args|
+                args.binding[:form].new(model)
+              end
+            )
+          end
+
+          super # TODO: allow something like super(:exclude => empty_fields)
+        end
+      end # Representer
+    end
+  end # Validation
+end

data/lib/reform/contract/validate.rb

@@ -0,0 +1,48 @@
+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|
+
+            # FIXME: merge with Validate::Writer
+            options = args.user_options.dup
+            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?
+          },
+        )
+      end
+
+      super
+    end
+  end
+
+  def validate
+    options = {:errors => errs = Reform::Contract::Errors.new(self), :prefix => []}
+
+    validate!(options)
+
+    self.errors = errs # if the AM valid? API wouldn't use a "global" variable this would be better.
+
+    errors.valid?
+  end
+  def validate!(options)
+    # puts "validate! in #{self.class.name}: #{true.inspect}"
+    prefix = options[:prefix]
+
+    # call valid? recursively and collect nested errors.
+    mapper.new(self).extend(NestedValid).to_hash(options)
+
+    valid?  # this validates on <Fields> using AM::Validations, currently.
+
+    options[:errors].merge!(self.errors, prefix)
+  end
+
+end

data/lib/reform/form.rb

@@ -1,323 +1,27 @@
-require 'forwardable'
 require 'ostruct'
 
+require 'reform/contract'
 require 'reform/composition'
-require 'reform/representer'
-
-require 'uber/inheritable_attr'
-
 
 module Reform
-  class Form
-    extend Forwardable
-
-    extend Uber::InheritableAttr
-    inheritable_attr :representer_class
-    self.representer_class = Class.new(Reform::Representer)
-
-
-    module PropertyMethods
-      extend Forwardable
-
-      def property(name, options={}, &block)
-        process_options(name, options, &block)
-
-        definition = representer_class.property(name, options, &block)
-        setup_form_definition(definition) if block_given? or options[:form]
-
-        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)
-        # TODO: allow Definition.form?
-        definition.options[:form] ||= definition.options.delete(:extend)
+  class Form < Contract
+    self.representer_class = Reform::Representer.for(:form_class => self)
 
-        definition.options[:parse_strategy] = :sync
-        definition.options[:instance] = true # just to make typed? work
-      end
-
-    private
-      def create_accessor(name)
-        # Make a module that contains these very accessors, then include it
-        # so they can be overridden but still are callable with super.
-        accessors = Module.new do
-          extend Forwardable # DISCUSS: do we really need Forwardable here?
-          delegate [name, "#{name}="] => :fields
-        end
-        include accessors
-      end
-
-      def process_options(name, options) # DISCUSS: do we need that hook?
-      end
-    end
-    extend PropertyMethods
-
-
-    def initialize(model)
-      @model  = model # we need this for #save.
-      @fields = setup_fields(model)  # delegate all methods to Fields instance.
+    def aliased_model
+      # TODO: cache the Expose.from class!
+      Reform::Expose.from(mapper).new(:model => model)
     end
 
-    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 }
-          next unless form # FIXME: this happens when the model's reader returns nil (property :song => nil). this shouldn't be considered by nested_forms!
-          res = validate_for(form, res, attr.from)
-        end
-
-        res
-      end
+    require "reform/form/virtual_attributes"
 
-    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.
+    require 'reform/form/validate'
+    include Validate # extend Contract#validate with additional behaviour.
+    require 'reform/form/sync'
+    include Sync
+    require 'reform/form/save'
+    include Save
 
-        errors.merge!(form.errors, prefix)
-        false
-      end
-    end
-    include ValidateMethods
     require 'reform/form/multi_parameter_attributes'
     include MultiParameterAttributes # TODO: make features dynamic.
-
-    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?
-
-      save_to_models
-    end
-
-    # Use representer to return current key-value form hash.
-    def to_hash(*args)
-      mapper.new(self).to_hash(*args)
-    end
-
-    require "active_support/hash_with_indifferent_access" # DISCUSS: replace?
-    def to_nested_hash
-      map = mapper.new(self)
-
-      ActiveSupport::HashWithIndifferentAccess.new(map.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)
-      @errors
-    end
-
-    attr_accessor :model
-
-  private
-    attr_accessor :fields
-
-    def mapper
-      self.class.representer_class
-    end
-
-    def setup_fields(model)
-      representer = mapper.new(model).extend(Setup::Representer)
-
-      create_fields(representer.fields, representer.to_hash)
-    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
-
-
-    def create_fields(field_names, fields)
-      Fields.new(field_names, fields)
-    end
-
-
-    require "reform/form/virtual_attributes"
-
-    # Mechanics for setting up initial Field values.
-    module Setup
-      module Representer
-        include Reform::Representer::WithOptions
-        include EmptyAttributesOptions
-
-        def to_hash(*)
-          setup_nested_forms
-
-          super # TODO: allow something like super(:exclude => empty_fields)
-        end
-
-      private
-        def setup_nested_forms
-          nested_forms do |attr, model|
-            form_class = attr.options[:form]
-
-            attr.options.merge!(
-              :getter   => lambda do |*|
-                # FIXME: this is where i have to fix stuff.
-                nested_model  = send(attr.getter) # or next # decorated.hit # TODO: use bin.get # DISCUSS: next moves on if property empty. this should be handled with representable's built-in mechanics.
-
-                if attr.options[:form_collection]
-                  nested_model ||= []
-                  Forms.new(nested_model.collect { |mdl| form_class.new(mdl)}, attr.options)
-                else
-                  next unless nested_model # DISCUSS: do we want that?
-                  form_class.new(nested_model)
-                end
-              end,
-              :instance => false, # that's how we make it non-typed?.
-            )
-          end
-        end
-      end
-    end
-
-    # Mechanics for writing input to model.
-    module Sync
-      # Writes input to model.
-      module Representer
-        def from_hash(*)
-          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
-
-          super
-        end
-      end
-
-      # Transforms form input into what actually gets written to model.
-      module InputRepresenter
-        include Reform::Representer::WithOptions
-        # TODO: make dynamic.
-        include EmptyAttributesOptions
-        include ReadonlyAttributesOptions
-      end
-    end
-
-
-    def save_to_models # TODO: rename to #sync_models
-      representer = mapper.new(model)
-
-      representer.extend(Sync::Representer)
-
-      input_representer = mapper.new(self).extend(Sync::InputRepresenter)
-
-      representer.from_hash(input_representer.to_hash)
-    end
-
-    # FIXME: make AM optional.
-    require 'active_model'
-    include ActiveModel::Validations
-
-    # 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
-
-      # def each
-      #   messages.each_key do |attribute|
-      #     self[attribute].each { |error| yield attribute, Array.wrap(error) }
-      #   end
-      # end
-
-      def merge!(errors, prefix=nil)
-        # TODO: merge into AM.
-        errors.messages.each do |field, msgs|
-          field = "#{prefix}.#{field}" if prefix
-
-          msgs = [msgs] if Reform.rails3_0? # DISCUSS: fix in #each?
-
-          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
-
-    require "representable/hash/collection"
-    require 'active_model'
-    class Forms < Array # DISCUSS: this should be a Form subclass.
-      def initialize(ary, options)
-        super(ary)
-        @options = options
-      end
-
-      include Form::ValidateMethods
-
-      # TODO: make valid?(errors) the only public method.
-      def valid?
-       res= validate_cardinality & validate_items
-      end
-
-      def errors
-        @errors ||= Form::Errors.new(self)
-      end
-
-      # this gives us each { to_hash }
-      include Representable::Hash::Collection
-      items :parse_strategy => :sync, :instance => true
-
-    private
-      def validate_items
-        inject(true) do |res, form|
-          res = validate_for(form, res)
-        end
-      end
-
-      def validate_cardinality
-        return true unless @options[:cardinality]
-        # TODO: use AM's cardinality validator here.
-        res = size >= @options[:cardinality][:minimum].to_i
-
-        errors.add(:size, "#{@options[:as]} size is 0 but must be #{@options[:cardinality].inspect}") unless res
-        res
-      end
-    end
-  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
-
-  def self.rails3_0?
-    ::ActiveModel::VERSION::MAJOR == 3 and ::ActiveModel::VERSION::MINOR == 0
   end
 end