reform 2.1.0 → 2.2.0.rc1

data/gemfiles/Gemfile.rails-3.2

@@ -1,7 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in reform.gemspec
-gemspec :path => '../'
-
-gem 'railties', '~> 3.2.0'
-gem 'activerecord', '~> 3.2.0'

data/gemfiles/Gemfile.rails-4.0

@@ -1,8 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in reform.gemspec
-gemspec :path => '../'
-
-gem 'railties', '~> 4.0.0'
-gem 'activerecord', '~> 4.0.0'
-gem 'minitest', '~> 4.2'

data/gemfiles/Gemfile.rails-4.1

@@ -1,8 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in reform.gemspec
-gemspec :path => '../'
-
-gem 'railties', '~> 4.1.0'
-gem 'activerecord', '~> 4.1.0'
-gem 'minitest'

data/gemfiles/Gemfile.rails-4.2

@@ -1,8 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in reform.gemspec
-gemspec :path => '../'
-
-gem 'railties', '~> 4.2.0'
-gem 'activerecord', '~> 4.2.0'
-gem 'minitest'

data/lib/reform/active_record.rb

@@ -1,4 +0,0 @@
-require "reform/form/active_model"
-require "reform/form/orm"
-require "reform/form/active_record"
-require "reform/form/active_model/model_reflections" # only load this in AR context as simple_form currently is bound to AR.

data/lib/reform/form/active_model.rb

@@ -1,87 +0,0 @@
-require "reform/form/active_model/model_validations"
-require "reform/form/active_model/form_builder_methods"
-require "uber/delegates"
-
-module Reform::Form::ActiveModel
-  def self.included(base)
-    base.class_eval do
-      extend ClassMethods
-      register_feature ActiveModel
-
-      extend Uber::Delegates
-      delegates :model, *[:persisted?, :to_key, :to_param, :id] # Uber::Delegates
-
-      def to_model # this is called somewhere in FormBuilder and ActionController.
-        self
-      end
-    end
-  end
-
-
-  module ClassMethods
-    # this module is only meant to extend (not include). # DISCUSS: is this a sustainable concept?
-    def self.extended(base)
-      base.class_eval do
-        extend Uber::InheritableAttribute
-        inheritable_attr :model_options
-      end
-    end
-
-    # DISCUSS: can we achieve that somehow via features in build_inline?
-    def property(*)
-      super.tap do |dfn|
-        return dfn unless dfn[:nested]
-        _name = dfn[:name]
-        dfn[:nested].instance_eval do
-          @_name = _name.singularize.camelize
-          # this adds Form::name for AM::Validations and I18N.
-          def name
-            @_name
-          end
-        end
-      end
-    end
-
-
-    # Set a model name for this form if the infered is wrong.
-    #
-    #   class CoverSongForm < Reform::Form
-    #     model :song
-    #
-    # or we can setup a isolated namespace model ( which defined in isolated rails egine )
-    #
-    #   class CoverSongForm < Reform::Form
-    #     model "api/v1/song", namespace: "api"
-    def model(main_model, options={})
-      self.model_options = [main_model, options]
-    end
-
-    def model_name
-      if model_options
-        form_name = model_options.first.to_s.camelize
-        namespace = model_options.last[:namespace].present? ? model_options.last[:namespace].to_s.camelize.constantize : nil
-      else
-        if name
-          form_name = name.sub(/(::)?Form$/, "") # Song::Form => "Song"
-          namespace = nil
-        else # anonymous forms. let's drop AM and forget about all this.
-          form_name = "reform"
-          namespace = nil
-        end
-      end
-
-      active_model_name_for(form_name, namespace)
-    end
-
-  private
-    def active_model_name_for(string, namespace=nil)
-      return ::ActiveModel::Name.new(OpenStruct.new(:name => string)) if Reform.rails3_0?
-      ::ActiveModel::Name.new(self, namespace, string)
-    end
-  end # ClassMethods
-
-
-  def model_name(*args)
-    self.class.model_name(*args)
-  end
-end

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

@@ -1,48 +0,0 @@
-module Reform::Form::ActiveModel
-  # Including FormBuilderMethods will allow using form instances with form_for, simple_form, etc.
-  # in Rails. It will further try to translate Rails' suboptimal songs_attributes weirdness
-  # back to normal `songs: ` naming in +#valiate+.
-  module FormBuilderMethods
-    def self.included(base)
-      base.extend ClassMethods # ::model_name
-    end
-
-    module ClassMethods
-    private
-
-      # TODO: add that shit in Form#present, not by overriding ::property.
-      def property(name, options={}, &block)
-        super.tap do |definition|
-          add_nested_attribute_compat(name) if definition[:nested] # TODO: fix that in Rails FB#1832 work.
-        end
-      end
-
-      # 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 deserialize!(params)
-      # this only happens in a Hash environment. other engines have to overwrite this method.
-      schema.each do |dfn|
-        rename_nested_param_for!(params, dfn)
-      end
-
-      super(params)
-    end
-
-  private
-    def rename_nested_param_for!(params, dfn)
-      name        = dfn[:name]
-      nested_name = "#{name}_attributes"
-      return unless params.has_key?(nested_name)
-
-      value = params["#{name}_attributes"]
-      value = value.values if dfn[:collection]
-
-      params[name] = value
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-# 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.
-class Reform::Form < Reform::Contract
-  module ActiveModel::ModelReflections
-    def self.included(base)
-      base.extend ClassMethods
-      base.send :register_feature, self # makes it work in nested forms.
-    end
-
-    module ClassMethods
-      # Delegate reflect_on_association to the model class to support simple_form's
-      # association input.
-      def reflect_on_association(*args)
-        model_name.to_s.constantize.reflect_on_association(*args)
-      end
-
-      # this is needed in simpleform to infer required fields.
-      def validators_on(*args)
-        validation_groups.collect { |k, group| group.instance_variable_get(:@validations).validators_on(*args) }.flatten
-      end
-    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
-
-    def has_attribute?(name)
-      model_for_property(name).has_attribute?(name)
-    end
-
-    def defined_enums
-      return model.defined_enums unless is_a?(Reform::Form::Composition)
-
-      mapper.each.with_object({}) { |m,h| h.merge! m.defined_enums }
-    end
-
-    # this should also contain to_param and friends as this is used by the form helpers.
-  end
-
-  ModelReflections = ActiveModel::ModelReflections
-end

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

@@ -1,110 +0,0 @@
-module Reform::Form::ActiveModel
-  module ModelValidations
-    # TODO: extract Composition behaviour.
-    # reduce code in Mapping.
-
-    class ValidationCopier
-
-      def self.copy(form_class, mapping, models)
-        if models.is_a?(Hash)
-          models.each do |model_name, model|
-            new(form_class, mapping, model, model_name).copy
-          end
-        else
-          new(form_class, mapping, models).copy
-        end
-      end
-
-      def initialize(form_class, mapping, model, model_name=nil)
-        @form_class = form_class
-        @mapping = mapping
-        @model = model
-        @model_name = model_name
-      end
-
-      def copy
-        @model.validators.each(&method(:add_validator))
-      end
-
-    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
-
-      def create_attributes(attributes)
-        attributes.map do |attribute|
-          [@model_name, attribute].compact
-        end
-      end
-
-    end
-
-    class Mapping
-      def self.from_representable_attrs(attrs)
-        new.tap do |mapping|
-          attrs.each do |dfn|
-            from = dfn[:name].to_sym
-            to = [dfn[:on], (dfn[:private_name] || dfn[:name])].compact.map(&:to_sym)
-            mapping.add(from, to)
-          end
-        end
-      end
-
-      def initialize
-        @forward_map = {}
-        @inverse_map = {}
-      end
-
-      # from is a symbol attribute
-      # to is an 1 or 2 element array, depending on whether the attribute is 'namespaced', as it is with composite forms.
-      # eg, add(:phone_number, [:person, :phone])
-      def add(from, to)
-        raise 'Mapping is not one-to-one' if @forward_map.has_key?(from) || @inverse_map.has_key?(to)
-        @forward_map[from] = to
-        @inverse_map[to] = from
-      end
-
-      def forward_image(attrs)
-        @forward_map.values_at(*attrs).compact
-      end
-
-      def forward(attr)
-        @forward_map[attr]
-      end
-
-      def inverse_image(attrs)
-        @inverse_map.values_at(*attrs).compact
-      end
-
-      def inverse(attr)
-        @inverse_map[attr]
-      end
-
-    end
-
-    def copy_validations_from(models)
-      ValidationCopier.copy(self, Mapping.from_representable_attrs(definitions), models)
-    end
-
-  end
-end

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

@@ -1,107 +0,0 @@
-require "active_model"
-require "uber/delegates"
-
-module Reform::Form::ActiveModel
-  # AM::Validations for your form.
-  # Provides ::validates, ::validate, #validate, and #valid?.
-  #
-  # Most of this file contains unnecessary wiring to make ActiveModel's error message magic work.
-  # Since Rails still thinks it's a good idea to do things like object.class.human_attribute_name,
-  # we have some hacks in here to provide that. If it doesn't work for you, don't blame us.
-  module Validations
-    def self.included(includer)
-      includer.instance_eval do
-        include Reform::Form::ActiveModel
-
-        class << self
-          extend Uber::Delegates
-          # # Hooray! Delegate translation back to Reform's Validator class which contains AM::Validations.
-          delegates :active_model_really_sucks, :human_attribute_name, :lookup_ancestors, :i18n_scope # Rails 3.1.
-
-          def validation_group_class
-            Group
-          end
-
-          # this is to allow calls like Form::human_attribute_name (note that this is on the CLASS level) to be resolved.
-          # those calls happen when adding errors in a custom validation method, which is defined on the form (as an instance method).
-          def active_model_really_sucks
-            Class.new(Validator).tap do |v|
-              v.model_name = model_name
-            end
-          end
-        end
-      end # ::included
-    end
-
-    def build_errors
-      Errors.new(self)
-    end
-
-    # The concept of "composition" has still not arrived in Rails core and they rely on 400 methods being
-    # available in one object. This is why we need to provide parts of the I18N API in the form.
-    def read_attribute_for_validation(name)
-      send(name)
-    end
-
-    class Group
-      def initialize
-        @validations = Class.new(Reform::Form::ActiveModel::Validations::Validator)
-      end
-
-      extend Uber::Delegates
-      delegates :@validations, :validates, :validate, :validates_with, :validate_with
-
-      def call(fields, errors, form) # FIXME.
-        validator = @validations.new(form)
-        validator.valid?
-
-        validator.errors.each do |name, error| # TODO: handle with proper merge, or something. validator.errors is ALWAYS AM::Errors.
-          errors.add(name, error)
-        end
-      end
-    end
-
-
-    # Validator is the validatable object. On the class level, we define validations,
-    # on instance, it exposes #valid?.
-    require "delegate"
-    class Validator < SimpleDelegator
-      # current i18n scope: :activemodel.
-      include ActiveModel::Validations
-
-      class << self
-        def model_name
-          @_active_model_sucks ||= ActiveModel::Name.new(Reform::Form, nil, "Reform::Form")
-        end
-
-        def model_name=(name)
-          @_active_model_sucks = name
-        end
-
-        def validates(*args, &block)
-          super(*Declarative::DeepDup.(args), &block)
-        end
-
-        # Prevent AM:V from mutating the validator class
-        def attr_reader(*)
-        end
-
-        def attr_writer(*)
-        end
-      end
-
-      def initialize(form)
-        super(form)
-        self.class.model_name = form.model_name # one of the many reasons why i will drop support for AM::V in 2.1. or maybe a bit later.
-      end
-
-      def method_missing(m, *args, &block)
-        __getobj__.send(m, *args, &block) # send all methods to the form, even privates.
-      end
-    end
-  end
-
-  class Errors < ActiveModel::Errors
-    include Reform::Form::Errors::Merge
-  end
-end