reform 1.2.6 → 2.0.0.beta1

data/Rakefile

@@ -5,6 +5,33 @@ task :default => [:test]
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'
   test.test_files = FileList['test/*_test.rb']
+
+  test.test_files = ["test/changed_test.rb",
+  "test/coercion_test.rb",
+  "test/feature_test.rb",
+
+  "test/contract_test.rb",
+
+  "test/populate_test.rb", "test/prepopulator_test.rb",
+
+  "test/readable_test.rb","test/setup_test.rb","test/skip_if_test.rb",
+
+  "test/validate_test.rb", "test/save_test.rb",
+
+  "test/writeable_test.rb","test/virtual_test.rb",
+
+  "test/form_builder_test.rb", "test/active_model_test.rb",
+
+  "test/readonly_test.rb",
+  "test/inherit_test.rb",
+  "test/uniqueness_test.rb",
+  "test/from_test.rb",
+  "test/composition_test.rb",
+  "test/form_option_test.rb"
+]
+
+
+
   test.verbose = true
 end
 

data/TODO.md

@@ -1,3 +1,15 @@
+# 2.0
+
+* make Coercible optional (include it to activate)
+* all options Uber:::Value with :method support
+
+
+
+# NOTES
+* use the same test setup everywhere (album -> songs -> composer)
+* copy things in tests
+* one test file per "feature": sync_test, sync_option_test.
+
 * fields is a Twin and sorts out all the changed? stuff.
 * virtual: don't read dont write
 * empty dont read, but write

data/gemfiles/Gemfile.rails-3.0

@@ -5,3 +5,4 @@ gemspec :path => '../'
 
 gem 'railties', '~> 3.0.11'
 gem 'activerecord', '~> 3.0.11'
+gem "disposable", github: "apotonick/disposable"

data/gemfiles/Gemfile.rails-3.1

@@ -5,3 +5,4 @@ gemspec :path => '../'
 
 gem 'railties', '~> 3.1.0'
 gem 'activerecord', '~> 3.1.0'
+gem "disposable", github: "apotonick/disposable"

data/gemfiles/Gemfile.rails-3.2

@@ -5,3 +5,4 @@ gemspec :path => '../'
 
 gem 'railties', '~> 3.2.0'
 gem 'activerecord', '~> 3.2.0'
+gem "disposable", github: "apotonick/disposable"

data/gemfiles/Gemfile.rails-4.0

@@ -6,3 +6,4 @@ gemspec :path => '../'
 gem 'railties', '~> 4.0.0'
 gem 'activerecord', '~> 4.0.0'
 gem 'minitest', '~> 4.2'
+gem "disposable", github: "apotonick/disposable"

data/lib/reform.rb

@@ -9,7 +9,6 @@ require 'reform/form'
 require 'reform/form/composition'
 require 'reform/form/active_model'
 require 'reform/form/module'
-require 'reform/composition'
 
 
 if defined?(Rails) # DISCUSS: is everyone ok with this?

data/lib/reform/contract.rb

@@ -1,172 +1,106 @@
 require 'forwardable'
 require 'uber/inheritable_attr'
 require 'uber/delegates'
-require 'ostruct'
-
-require 'reform/representer'
 
 module Reform
   # Gives you a DSL for defining the object structure and its validations.
-  class Contract # DISCUSS: make class?
-    extend Uber::Delegates
-
-    extend Uber::InheritableAttr
-    # representer_class gets inherited (cloned) to subclasses.
-    inheritable_attr :representer_class
-    self.representer_class = Reform::Representer.for(:form_class => self) # only happens in Contract/Form.
-    # this should be the only mechanism to inherit, features should be stored in this as well.
-
-
-    # each contract keeps track of its features and passes them onto its local representer_class.
-    # gets inherited, features get automatically included into inline representer.
-    # TODO: the representer class should handle that, e.g. in options (deep-clone when inheriting.)
-    inheritable_attr :features
-    self.features = {}
-
-
-    RESERVED_METHODS = [:model, :aliased_model, :fields, :mapper] # TODO: refactor that so we don't need that.
-
-
-    module PropertyMethods
-      def property(name, options={}, &block)
-        deprecate_as!(options)
-        options[:private_name] = options.delete(:from)
-        options[:coercion_type] = options.delete(:type)
-        options[:features] ||= []
-        options[:features] += features.keys if block_given?
-        options[:pass_options] = true
-
-        # readable and writeable is true as it's not == false
+  require "disposable/twin"
+  require "disposable/twin/setup"
+  class Contract < Disposable::Twin
+    require "disposable/twin/composition" # Expose.
+    include Expose
 
-        if reform_2_0
-          if options.delete(:virtual)
-            options[:_readable]  = false
-            options[:_writeable] = false
-          else
-            options[:_readable]  = options.delete(:readable)
-            options[:_writeable] = options.delete(:writeable)
-          end
-
-        else # TODO: remove me in 2.0.
-          deprecate_virtual_and_empty!(options)
-        end
-
-        validates(name, options.delete(:validates).dup) if options[:validates]
-
-        definition = representer_class.property(name, options, &block)
-        setup_form_definition(definition) if block_given? or options[:form]
-
-        create_accessor(name)
-        definition
-      end
-
-      def properties(*args)
-        options = args.extract_options!
-
-        if args.first.is_a? Array # TODO: REMOVE in 2.0.
-          warn "[Reform] Deprecation: Please pass a list of names instead of array to ::properties, like `properties :title, :id`."
-          args = args.first
-        end
-        args.each { |name| property(name, options.dup) }
-      end
+    feature Setup
+    feature Setup::SkipSetter
 
-      def collection(name, options={}, &block)
-        options[:collection] = true
+    extend Uber::Delegates
 
-        property(name, options, &block)
+    representer_class.instance_eval do
+      def default_inline_class
+        Contract
       end
-
-      def setup_form_definition(definition)
-        options = {
-          # TODO: make this a bit nicer. why do we need :form at all?
-          :form         => (definition.representer_module) || definition[:form], # :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
+    # FIXME: THIS sucks because we're building two representers.
+    representer_class.instance_eval do
+      def default_inline_class
+        Contract
       end
+    end
 
-    private
-
-      def create_accessor(name)
-        handle_reserved_names(name)
+    def self.property(name, options={}, &block)
+      options.merge!(pass_options: true)
 
-        delegates :fields, name, "#{name}=" # Uber::Delegates
+      if twin = options.delete(:form)
+        options[:twin] = twin
       end
 
-      def handle_reserved_names(name)
-        raise "[Reform] the property name '#{name}' is reserved, please consider something else using :as." if RESERVED_METHODS.include?(name)
-      end
+      super
     end
-    extend PropertyMethods
 
+    # FIXME: test me.
+    def self.properties(*args)
+      options = args.extract_options!
+      args.each { |name| property(name, options.dup) }
+    end
 
     # FIXME: make AM optional.
     require 'active_model'
     include ActiveModel::Validations
 
-
-
-    attr_accessor :model
-
-    require 'reform/contract/setup'
-    include Setup
-
-    def self.representers # keeps all transformation representers for one class.
-      @representers ||= {}
-    end
-
-    def self.representer(name=nil, options={}, &block)
-      return representer_class.each(&block) if name == nil
-      return representers[name] if representers[name] # don't run block as this representer is already setup for this form class.
-
-      only_forms = options[:all] ? false : true
-      base       = options[:superclass] || representer_class
-
-      representers[name] = Class.new(base).each(only_forms, &block) # let user modify representer.
-    end
-
     require 'reform/contract/validate'
-    include Validate
+    include Reform::Contract::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 # FIXME: do we need this with class-level representers?
-      self.class.representer_class
+    # DISCUSS: can we achieve that somehow via features in build_inline?
+    # TODO: check out if that is needed with Lotus::Validations and make it a AM feature.
+    def self.process_inline!(mod, definition)
+      _name = definition.name
+      mod.instance_eval do
+        @_name = _name.singularize.camelize
+        def name # this adds Form::name for AM::Validations and I18N. i know it's retarded.
+          # something weird happens here: somewhere in Rails, this creates a constant (e.g. User). if this name doesn't represent a valid
+          # constant, the reloading in dev will fail with weird messages. i'm not sure if we should just get rid of Rails validations etc.
+          # or if i should look into this?
+          @_name
+        end
+      end
     end
 
-    def self.deprecate_as!(options) # TODO: remove me in 2.0.
-      return unless as = options.delete(:as)
-      options[:from] = as
-      warn "[Reform] The :as options got renamed to :from. See https://github.com/apotonick/reform/wiki/Migration-Guide and have a nice day."
-    end
 
-    def self.deprecate_virtual_and_empty!(options) # TODO: remove me in 2.0.
-      if options.delete(:virtual)
-        warn "[Reform] The :virtual option has changed! Check https://github.com/apotonick/reform/wiki/Migration-Guide and have a good day."
-        options[:_readable] = true
-        options[:_writeable] = false
+    # DISCUSS: separate file?
+    module Readonly
+      def readonly?(name)
+        options_for(name)[:writeable] == false
       end
-
-      if options[:empty]
-        warn "[Reform] The :empty option has changed! Check https://github.com/apotonick/reform/wiki/Migration-Guide and have a good day."
-        options[:_readable]  = false
-        options[:_writeable] = false
+      def options_for(name)
+       self.class.options_for(name)
       end
     end
+    def self.options_for(name)
+      representer_class.representable_attrs.get(name)
+    end
+    include Readonly
+
 
-    def self.register_feature(mod)
-      features[mod] = true
+    def self.clone # TODO: test. THIS IS ONLY FOR Trailblazer when contract gets cloned in suboperation.
+      Class.new(self)
     end
+  end
+
+  class Contract_ # DISCUSS: make class?
+    extend Uber::InheritableAttr
+
+    RESERVED_METHODS = [:model] # TODO: refactor that so we don't need that.
+      def handle_reserved_names(name)
+        raise "[Reform] the property name '#{name}' is reserved, please consider something else using :as." if RESERVED_METHODS.include?(name)
+      end
+
 
     # allows including representers from Representable, Roar or disposable.
     def self.inherit_module!(representer) # called from Representable::included.
@@ -182,48 +116,8 @@ module Reform
       end
     end
 
-    def self.clone
-      Class.new(self)
-    end
-
     require 'reform/schema'
     extend Schema
-
-    alias_method :aliased_model, :model
-
-    module Readonly
-      def readonly?(name)
-        options_for(name)[:writeable] == false
-      end
-
-      def options_for(name)
-        self.class.representer_class.representable_attrs.get(name)
-      end
-    end
-    include Readonly
-
-    # TODO: remove me in 2.0.
-    module Reform20Switch
-      def self.included(base)
-        base.register_feature(Reform20Switch)
-      end
-    end
-    def self.reform_2_0!
-      include Reform20Switch
-    end
-    def self.reform_2_0
-      features[Reform20Switch]
-    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 # Fields
   end
 end
 

data/lib/reform/contract/validate.rb

@@ -12,8 +12,7 @@ module Reform::Contract::Validate
   def validate!(options)
     prefix = options[:prefix]
 
-    # call valid? recursively and collect nested errors.
-    valid_representer.new(fields).to_hash(options) # TODO: only include nested forms here.
+    validate_nested!(options) # call valid? recursively and collect nested errors.
 
     valid?  # this validates on <Fields> using AM::Validations, currently.
 
@@ -23,17 +22,15 @@ module Reform::Contract::Validate
 private
 
   # runs form.validate! on all nested forms
-  def valid_representer
-    self.class.representer(:valid) do |dfn|
-      dfn.merge!(
-        :serialize => lambda { |form, args|
-          options = args.user_options.dup
-          options[:prefix] = options[:prefix].dup # TODO: implement Options#dup.
-          options[:prefix] << args.binding.name # FIXME: should be #as.
-
-          form.validate!(options) # recursively call valid? on nested form.
-        }
-      )
+  def validate_nested!(options)
+    schema.each(twin: true) do |dfn|
+      property_options = options.dup
+
+      property_options[:prefix] = options[:prefix].dup # TODO: implement Options#dup.
+      property_options[:prefix] << dfn.name
+
+      # recursively call valid? on nested form.
+      Disposable::Twin::PropertyProcessor.new(dfn, self).() { |form| form.validate!(property_options) }
     end
   end
 end

data/lib/reform/form.rb

@@ -1,33 +1,88 @@
 module Reform
   class Form < Contract
-    self.representer_class = Reform::Representer.for(:form_class => self)
+    representer_class.instance_eval do
+      def default_inline_class
+        Form
+      end
+    end
 
     require "reform/form/validate"
     include Validate # extend Contract#validate with additional behaviour.
-    require "reform/form/sync"
-    include Sync
-    require "reform/form/save"
-    include Save
-    require "reform/form/prepopulate"
-    include Prepopulate
 
-    require "reform/form/multi_parameter_attributes"
-    include MultiParameterAttributes # TODO: make features dynamic.
+    require "reform/form/populator"
+
+    module Property
+      # add macro logic, e.g. for :populator.
+      def property(name, options={}, &block)
+        if options.delete(:virtual)
+          options[:writeable] = options[:readable] = false # DISCUSS: isn't that like an #option in Twin?
+        end
+
+        if deserializer = options[:deserializer] # this means someone is explicitly specifying :deserializer.
+          options[:deserializer] = Representable::Cloneable::Hash[deserializer]
+        end
+
+        definition = super # let representable sort out inheriting of properties, and so on.
+        definition.merge!(deserializer: Representable::Cloneable::Hash.new) unless definition[:deserializer] # always keep :deserializer per property.
+
+
+        deserializer_options = definition[:deserializer]
+
+        # TODO: make this pluggable.
+        # DISCUSS: Populators should be a representable concept?
+
+        # Populators
+        # * they assign created data, no :setter (hence the name).
+        # * they (ab)use :instance, this is why they need to return a twin form.
+        # * they are only used in the deserializer.
+
 
-  private
-    def aliased_model
-      # TODO: cache the Expose.from class!
-      Reform::Expose.from(mapper).new(:model => model)
+
+        if populator = options.delete(:populate_if_empty)
+          deserializer_options.merge!({instance: Populator::IfEmpty.new(populator)})
+          deserializer_options.merge!({setter: nil})
+        elsif populator = options.delete(:populator)
+          deserializer_options.merge!({instance: Populator.new(populator)})
+          deserializer_options.merge!({setter: nil}) #if options[:collection] # collections don't need to get re-assigned, they don't change.
+        end
+
+
+        # TODO: shouldn't that go into validate?
+        if proc = options.delete(:skip_if)
+          proc = Reform::Form::Validate::Skip::AllBlank.new if proc == :all_blank
+
+          deserializer_options.merge!(skip_parse: proc)
+        end
+
+        # default:
+        # add Sync populator to nested forms.
+        # FIXME: this is, of course, ridiculous and needs a better structuring.
+        if (deserializer_options == {} || deserializer_options.keys == [:skip_parse]) && block_given? && !options[:inherit] # FIXME: hmm. not a fan of this: only add when no other option given?
+          deserializer_options.merge!(instance: Populator::Sync.new(nil), setter: nil)
+        end
+
+        # per default, everything should be writeable for the deserializer (we're only writing on the form). however, allow turning it off.
+        deserializer_options.merge!(writeable: true) unless deserializer_options.has_key?(:writeable)
+
+        definition
+      end
     end
+    extend Property
+
+
+    require "reform/form/multi_parameter_attributes"
 
+    require "disposable/twin/changed"
+    feature Disposable::Twin::Changed
 
-    require "reform/form/scalar"
-    extend Scalar::Property # experimental feature!
+    require "disposable/twin/sync"
+    feature Disposable::Twin::Sync
+    feature Disposable::Twin::Sync::SkipGetter
 
+    require "disposable/twin/save"
+    feature Disposable::Twin::Save
 
-    # DISCUSS: should that be optional? hooks into #validate, too.
-    require "reform/form/changed"
-    register_feature Changed
-    include Changed
+    require "reform/form/prepopulate"
+    include Prepopulate
   end
 end