granite-form 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb26aa530c266a54d01fe3723d4ee44a95bedbefb140a5358403ebcdf78ced5c
-  data.tar.gz: 1c63d7e31c87a934a6c858c24c396f0547e16268997dcd2c2e8dbeac16ba98d5
+  metadata.gz: ebac9979a786e2a3638b1dd7b21648320c779770c10f7fe63707b38a58c0164c
+  data.tar.gz: 604dcf0abda92863e1503b0d977a53ca1de7a39823bfc8a4aabab8d9c6a27045
 SHA512:
-  metadata.gz: 2b28feea4881f8c4f6635f1e626345b4ea534306b8596deb8a61f2a38ce428950eb957bd9b1c936699fbe049a22e1c41d36dce4ebd695c769b3fee39c3ecf716
-  data.tar.gz: e0fdbd61872e007edaf0cf4ffed388b382f14e53e2637a04979eae1f4e2f1b67aa0bad71569b9ab4b2ce8cd2363820e380661f402edec70584c480962aa7c0e1
+  metadata.gz: cfc2c624834fe5d0ad4fadb903e6b9a38eed17778cea3c0cf9430437fb095436429c1a0941fd418e143805b064c1a74c0c959fb57493d96fb9602cdca625f36d
+  data.tar.gz: 4937e3d02a378edf48daa770799206b3ecdb91ee71ed1025169e6e3bf4a25bc157c01aea9db54dcb70645728eeb0055ca42be7db23258f0b7f2744d8f7415dd9

data/.github/CODEOWNERS

@@ -0,0 +1,2 @@
+.github/workflows/ci.yml @toptal/coresmiths-team
+.github/workflows/main.yml @toptal/coresmiths-team

data/.rubocop_todo.yml

@@ -8,7 +8,7 @@
 
 # Offense count: 19
 Metrics/AbcSize:
-  Max: 54
+  Max: 55
 
 # Offense count: 2
 # Configuration parameters: CountComments.

data/CHANGELOG.md

@@ -1,73 +1,16 @@
 # master
 
-# Version 1.2.0
+## Next
+## v0.2.0
 
-* Rails 6.1 and 7 support (#80). Thanks to @ojab and @rewritten
+- Replace typecasters with proper type definitions.
+  - Instead of `typecaster(type) { |value, _| ... }` you'll have to use `typecaster(type) { |value| ... }`.
+  - Consequently you can access type definition in typecaster, e.g. `typecaster('Object') { |value| value if value.class < type }`, here `type` comes from type definition.
 
-# Version 1.1.7
+## v0.1.1
 
-* Add typecasting from `ActionController::Parameters` to `Hash` (#73)
+- Fixed represented error message copying when represented model uses symbols for `message`. 
 
-# Version 1.1.6
+## v0.1.0
 
-* Fix Ruby 2.6 deprecations (#72)
-
-# Version 1.1.5
-
-* Rails 6 support (#70, #71)
-
-# Version 1.1.4
-
-## Changes
-
-* `came_from_default?` attribute method (#66)
-
-# Version 1.1.3
-
-## Changes
-
-* `came_from_user?` attribute method (#65)
-
-# Version 1.1.2
-
-## Changes
-
-* `ActiveData.base_concern` config option in addition to `ActiveData.base_class` (#64)
-
-# Version 1.1.1
-
-## Changes
-
-* `ActiveData.base_class` config option (#63)
-
-* ActiveModel 5.2 compatibility (#62)
-
-# Version 1.1.0
-
-## Incompatible changes
-
-* Represented attributes are not provided by default, to add them, `include ActiveData::Model::Representation` (#46)
-
-* `include ActiveData::Model::Associations::Validations` is not included by default anymore, to get `validate_ancestry!`, `valid_ancestry?` and `invalid_ancestry?` methods back you need to include this module manually
-
-## Changes
-
-* Introduce persistence adapters for associations (#24, #51)
-
-* `ActionController::Parameters` support (#43)
-
-* Nested attributes simple method overriding (#41)
-
-* Persistence for `references` associations (#28, #32)
-
-* Support `update_only` option on collection nested attributes (#30)
-
-* `embedder` accessor for embedded associations
-
-* Dynamic scopes for `references` associations (#27)
-
-## Bugfixes
-
-* Fixed multiple validations on represented attributes and associations (#44)
-
-* Proper boolean attributes defaults (#31, #33)
+- Forked from ActiveData, see https://github.com/pyromaniac/active_data/blob/v1.2.0/CHANGELOG.md for changes before this

data/README.md

@@ -3,7 +3,7 @@
 
 # Granite::Form
 
-Granite::Form is a ActiveModel-based front-end for your data. You might need to use it in the following cases:
+`Granite::Form` is an `ActiveModel`-based front-end for your data. It is useful in the following cases:
 
 * When you need a form objects pattern.
 
@@ -43,7 +43,7 @@ class ProfileController < ApplicationController
 end
 ```
 
-* When you need to work with data-storage in ActiveRecord style with
+* When you need to work with data storage à la `ActiveRecord`.
 
 ```ruby
 class Flight
@@ -75,7 +75,7 @@ class Flight
 end
 ```
 
-* When you need to implement embedded objects for ActiveRecord models
+* When you need to embed objects in `ActiveRecord` models.
 
 ```ruby
 class Answer
@@ -94,25 +94,25 @@ class Quiz < ActiveRecord::Base
   validates :answers, associated: true
 end
 
-q = Quiz.new
-q.answers.build(question_id: 42, content: 'blabla')
-q.save
+quiz = Quiz.new
+quiz.answers.build(question_id: 42, content: 'blabla')
+quiz.save
 ```
 
 ## Why?
 
-Granite::Form is an ActiveModel-based library that provides the following abilities:
+`Granite::Form` is an `ActiveModel-based library that provides the following functionalities:
 
   * Standard form objects building toolkit: attributes with typecasting, validations, etc.
   * High-level universal ORM/ODM library using any data source (DB, http, redis, text files).
-  * Embedding objects into your ActiveRecord entities. Quite useful with PG JSON capabilities.
+  * Embedding objects into ActiveRecord entities. Quite useful with PG JSON capabilities.
 
 Key features:
 
-  * Complete objects lifecycle support: saving, updating, destroying.
+  * Complete object lifecycle support: saving, updating, destroying.
   * Embedded and referenced associations.
-  * Backend-agnostic named scopes functionality.
-  * Callbacks, validations and dirty attributes inside.
+  * Backend-agnostic named scopes.
+  * Callbacks, validations and dirty attributes.
 
 ## Installation
 
@@ -130,11 +130,11 @@ Or install it yourself as:
 
 ## Usage
 
-Granite::Form has modular architecture, so it is required to include modules to obtain additional features. By default Granite::Form supports attributes definition and validations.
+`Granite::Form` has modular architecture, so it is required to include modules to obtain additional features. By default `Granite::Form` supports attributes definition and validations.
 
 ### Attributes
 
-Granite::Form provides several types of attributes and typecasts each attribute to its defined type upon initialization.
+`Granite::Form` provides several types of attributes and typecasts each attribute to its defined type upon initialization.
 
 ```ruby
 class Book
@@ -151,16 +151,16 @@ end
 attribute :full_name, String, default: 'John Talbot'
 ```
 
-By default, if type for attribute is not set, it is defined with `Object` type, so it would be a great idea to specify type for every attribute explicitly.
+If type for an attribute is not set, it defaults to `Object`. It is therefore recommended to specify the type for every attribute explicitly.
 
-Type is necessary for attribute typecasting. Here is the list of pre-defined basic typecasters:
+The type is necessary for attribute typecasting. Here is the list of pre-defined basic typecasters:
 
 ```irb
 [1] pry(main)> Granite::Form._typecasters.keys
 => ["Object", "String", "Array", "Hash", "Date", "DateTime", "Time", "ActiveSupport::TimeZone", "BigDecimal", "Float", "Integer", "Boolean", "Granite::Form::UUID"]
 ```
 
-In addition, you can provide any class type when defining the attribute, but in that case you will be able to only assign instances of that specific class or value nil:
+In addition, you can provide any class type when defining an attribute, but in that case you will be able to only assign instances of that specific class or `nil`:
 
 ```ruby
 attribute :template, MyCustomTemplateType
@@ -168,7 +168,7 @@ attribute :template, MyCustomTemplateType
 
 ##### Defaults
 
-It is possible to provide default values for attributes and they will act in the same way as AR or Mongoid default values:
+It is possible to provide default values for attributes and they will act in the same way as `ActiveRecord` or `Mongoid` default values:
 
 ```ruby
 attribute :check, Boolean, default: false # Simply false by default
@@ -179,7 +179,7 @@ attribute :today_wday, Integer, default: ->(instance) { instance.today.wday } #
 
 ##### Enums
 
-Enums restrict the scope of possible values for attribute. If assigned value is not included in provided list - then it turns to nil:
+Enums restrict the scope of possible values for an attribute. If the assigned value is not included in the provided list, the attribute value is set to `nil`:
 
 ```ruby
 attribute :direction, String, enum: %w[north south east west]
@@ -187,7 +187,7 @@ attribute :direction, String, enum: %w[north south east west]
 
 ##### Normalizers
 
-Normalizers are applied last, modifying typecast value. It is possible to provide a list of normalizers, they will be applied in the order. It is possible to pre-define normalizers to DRY code:
+Normalizers are applied last, modifying a typecast value. It is possible to provide a list of normalizers. They will be applied in the provided order. It is possible to pre-define normalizers to DRY code:
 
 ```ruby
 Granite::Form.normalizer(:trim) do |value, options, _attribute|
@@ -201,13 +201,13 @@ attribute :title, String, normalizers: [->(value) { value.strip }, trim: {length
 
 ```ruby
 attribute :name, String, readonly: true # Readonly forever
-attribute :name, String, readonly: ->{ true } # Conditionally readonly
+attribute :name, String, readonly: -> { true } # Conditionally readonly
 attribute :name, String, readonly: ->(instance) { instance.subject.present? } # Explicit instance
 ```
 
 #### Collection
 
-Collection is simply an array of equally-typed values:
+A collection is simply an array of equally-typed values:
 
 ```ruby
 class Panda
@@ -217,7 +217,7 @@ class Panda
 end
 ```
 
-Collection typecasts each value to specified type and also no matter what are you going to pass - it will be an array.
+A collection typecasts each value to the specified type. Also, it normalizes any given value to an array.
 
 ```irb
 [1] pry(main)> Panda.new
@@ -228,11 +228,11 @@ Collection typecasts each value to specified type and also no matter what are yo
 => #<Panda ids: [42, 33]>
 ```
 
-Default and enum modifiers are applied to every value, normalizer will be applied to the whole array.
+Default and enum modifiers are applied on each value, normalizers are applied on the array.
 
 #### Dictionary
 
-Dictionary field is a hash of specified type values with string keys:
+A dictionary field is a hash of specified type values with string keys:
 
 ```ruby
 class Foo
@@ -249,11 +249,11 @@ end
 => #<Foo ordering: {"name"=>"desc"}>
 ```
 
-Keys list might be restricted with `:keys` option, defaults and enums are applied to every value, normalizers are applied to the whole hash.
+The keys list might be restricted with the `:keys` option. Default and enum modifiers are applied on each value, normalizers are applied on the hash.
 
 #### Localized
 
-Localized is similar to how Globalize 3 attributes work.
+`localized` is similar to how `Globalize 3` attributes work.
 
 ```ruby
 localized :title, String
@@ -261,11 +261,11 @@ localized :title, String
 
 #### Represents
 
-Represents provides an easy way to expose model attributes through an interface.
-It will automatically set passed value to the represented object **before validation**.
-You can use any ActiveRecord, ActiveModel or Granite::Form object as a target of representation.
-A type of an attribute will be taken from it.
-If there is no type, it will be `Object` by default. You can set the type explicitly by passing the `type: TypeClass` option.
+`represents` provides an easy way to expose model attributes through an interface.
+It will automatically set the passed value to the represented object **before validation**.
+You can use any `ActiveRecord`, `ActiveModel` or `Granite::Form` object as a target of representation.
+The type of an attribute will be taken from it.
+If no type is defined, it will be `Object` by default. You can set the type explicitly by passing the `type: TypeClass` option.
 Represents will also add automatic validation of the target object.
 
 ```ruby
@@ -295,7 +295,7 @@ person.name
 
 ### Associations
 
-Granite::Form provides a set of associations. There are two types of them: referenced and embedded. The closest example of referenced association is AR `belongs_to` and as for embedded ones - Mongoid's embedded. Also these associations support `accepts_nested_attributes` call.
+`Granite::Form` provides a set of associations. There are two types: referenced and embedded. The closest example of referenced association is `AcitveRecord`'s `belongs_to`. For embedded ones - Mongoid's embedded. Also these associations support `accepts_nested_attributes` calls.
 
 #### EmbedsOne
 
@@ -312,11 +312,11 @@ embeds_one :profile do
 end
 ```
 
-Possible options:
+Оptions:
 
 * `:class_name` - association class name
-* `:validate` - true or false
-* `:default` - default value for association: attributes hash or instance of defined class
+* `:validate` - `true` or `false`
+* `:default` - default value for the association: an attributes hash or an instance of the defined class
 
 #### EmbedsMany
 
@@ -324,7 +324,7 @@ Possible options:
 embeds_many :tags
 ```
 
-Defines collection of embedded objects. Might be defined inline:
+Defines a collection of embedded objects. Might be defined inline:
 
 ```ruby
 embeds_many :tags do
@@ -332,9 +332,11 @@ embeds_many :tags do
 end
 ```
 
+Оptions:
+
 * `:class_name` - association class name
-* `:validate` - true or false
-* `:default` - default value for association: attributes hash collection or instances of defined class
+* `:validate` -  `true` or `false`
+* `:default` - default value for the association: an attributes hash or an instance of the defined class
 
 #### ReferencesOne
 
@@ -342,22 +344,22 @@ end
 references_one :user
 ```
 
-This will provide several methods to the object: `#user`, `#user=`, `#user_id` and `#user_id=`, just as would occur with an ActiveRecord association.
+Provides several methods to the object: `#user`, `#user=`, `#user_id` and `#user_id=`, similarly to an ActiveRecord association.
 
-Possible options:
+Оptions:
 
 * `:class_name` - association class name
-* `:primary_key` - associated object primary key (`:id` by default):
+* `:primary_key` - the associated object's primary key name (`:id` by default):
 
   ```ruby
   references_one :user, primary_key: :name
   ```
 
-  This will create the following methods: `#user`, `#user=`, `#user_name` and `#user_name=`
+  Creates the following methods: `#user`, `#user=`, `#user_name` and `#user_name=`.
 
 * `:reference_key` - redefines `#user_id` and `#user_id=` method names completely.
-* `:validate` - true or false
-* `:default` - default value for association: reference or object itself
+* `:validate` - `true` or `false`
+* `:default` - default value for the association: reference or the object itself
 
 #### ReferencesMany
 
@@ -365,18 +367,18 @@ Possible options:
 references_many :users
 ```
 
-This will provide several methods to the object: `#users`, `#users=`, `#user_ids` and `#user_ids=` just as an ActiveRecord relation does.
+Provides several methods to the object: `#users`, `#users=`, `#user_ids` and `#user_ids=`, similarly to an ActiveRecord association.
 
-Possible options:
+Options:
 
 * `:class_name` - association class name
-* `:primary_key` - associated object primary key (`:id` by default):
+* `:primary_key` - the associated object's primary key name (`:id` by default):
 
   ```ruby
   references_many :users, primary_key: :name
   ```
 
-  This will create the following methods: `#users`, `#users=`, `#user_names` and `#user_names=`
+  Creates the following methods: `#users`, `#users=`, `#user_names` and `#user_names=`.
 
 * `:reference_key` - redefines `#user_ids` and `#user_ids=` method names completely.
 * `:validate` - true or false
@@ -396,15 +398,15 @@ class Mongoid::Document
   end
 end
 ```
-Where
+where
 `ClassName` - name of model class or one of ancestors
 `data_source` - name of data source class
 `primary_key` - key to search data
 `scope_proc` - additional proc for filtering
 
-All required interface for adapters described in `Granite::Form::Model::Associations::PersistenceAdapters::Base`.
+All requirements for the adapter interfaces are described in `Granite::Form::Model::Associations::PersistenceAdapters::Base`.
 
-Adapter for ActiveRecord is `Granite::Form::Model::Associations::PersistenceAdapters::ActiveRecord`. So, all AR models will use `PersistenceAdapters::ActiveRecord` by default.
+The adapter for `ActiveRecord` is `Granite::Form::Model::Associations::PersistenceAdapters::ActiveRecord`. All `ActiveRecord` models use `PersistenceAdapters::ActiveRecord` by default.
 
 ### Primary
 

data/Rakefile

@@ -1,6 +1,10 @@
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'bump/tasks'
 
 RSpec::Core::RakeTask.new(:spec)
 
 task default: :spec
+
+Bump.tag_by_default = true
+Bump.changelog = true

data/granite-form.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'actionpack', '>= 4.0'
   gem.add_development_dependency 'activerecord', '>= 4.0'
   gem.add_development_dependency 'appraisal'
+  gem.add_development_dependency 'bump'
   gem.add_development_dependency 'database_cleaner'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec', '~> 3.7.0'

data/lib/granite/form/config.rb

@@ -4,7 +4,7 @@ module Granite
       include Singleton
 
       attr_accessor :include_root_in_json, :i18n_scope, :logger, :primary_attribute, :base_class, :base_concern,
-        :_normalizers, :_typecasters
+        :_normalizers, :types
 
       def self.delegated
         public_instance_methods - superclass.public_instance_methods - Singleton.public_instance_methods
@@ -16,7 +16,7 @@ module Granite
         @logger = Logger.new(STDERR)
         @primary_attribute = :id
         @_normalizers = {}
-        @_typecasters = {}
+        @types = {}
       end
 
       def normalizer(name, &block)
@@ -27,16 +27,16 @@ module Granite
         end
       end
 
-      def typecaster(*classes, &block)
-        classes = classes.flatten
-        if block
-          _typecasters[classes.first.to_s.camelize] = block
-        else
-          _typecasters[classes.detect do |klass|
-            _typecasters[klass.to_s.camelize]
-          end.to_s.camelize] or raise TypecasterMissing, classes
+      def typecaster(class_name, &block)
+        types[class_name.to_s.camelize] = Class.new(Types::Object) do
+          define_method(:typecast, &block)
         end
       end
+
+      def type_for(klass)
+        key = klass.ancestors.grep(Class).map(&:to_s).find(&types) or raise TypecasterMissing, klass
+        types.fetch(key)
+      end
     end
   end
 end

data/lib/granite/form/model/associations/nested_attributes.rb

@@ -74,7 +74,7 @@ module Granite
               primary_attribute_name = primary_name_for(association.reflection.klass)
               if existing_record
                 primary_attribute = existing_record.attribute(primary_attribute_name)
-                primary_attribute_value = primary_attribute.typecast(attributes[primary_attribute_name]) if primary_attribute
+                primary_attribute_value = primary_attribute.type_definition.ensure_type(attributes[primary_attribute_name]) if primary_attribute
               end
 
               if existing_record && (!primary_attribute || options[:update_only] || existing_record.primary_attribute == primary_attribute_value)
@@ -123,7 +123,7 @@ module Granite
                 else
                   existing_record = association.target.detect do |record|
                     primary_attribute_value = record.attribute(primary_attribute_name)
-                      .typecast(attributes[primary_attribute_name])
+                      .type_definition.ensure_type(attributes[primary_attribute_name])
                     record.primary_attribute == primary_attribute_value
                   end
                   if existing_record
@@ -162,7 +162,7 @@ module Granite
             end
 
             def self.destroy_flag?(hash)
-              Granite::Form.typecaster(Boolean).call(hash[DESTROY_ATTRIBUTE])
+              Types::Boolean.typecast(hash[DESTROY_ATTRIBUTE])
             end
 
             def self.reject_new_object?(object, association_name, attributes, options)

data/lib/granite/form/model/associations/reflections/references_many.rb

@@ -12,7 +12,9 @@ module Granite
 
               target.add_attribute(
                 Granite::Form::Model::Attributes::Reflections::ReferenceMany,
-                reflection.reference_key, association: name
+                reflection.reference_key,
+                type: reflection.persistence_adapter.primary_key_type,
+                association: name
               )
 
               reflection

data/lib/granite/form/model/associations/reflections/references_one.rb

@@ -14,7 +14,9 @@ module Granite
 
               target.add_attribute(
                 Granite::Form::Model::Attributes::Reflections::ReferenceOne,
-                reflection.reference_key, association: name
+                reflection.reference_key,
+                type: reflection.persistence_adapter.primary_key_type,
+                association: name
               )
 
               reflection

data/lib/granite/form/model/attributes/attribute.rb

@@ -14,7 +14,7 @@ module Granite
 
           def read
             variable_cache(:value) do
-              normalize(enumerize(typecast(read_before_type_cast)))
+              normalize(enumerize(type_definition.ensure_type(read_before_type_cast)))
             end
           end
 

data/lib/granite/form/model/attributes/base.rb

@@ -3,19 +3,16 @@ module Granite
     module Model
       module Attributes
         class Base
-          attr_reader :name, :owner
-          delegate :type, :typecaster, :readonly, to: :reflection
+          attr_reader :owner, :reflection
+          delegate :name, :readonly, to: :reflection
+          delegate :type, to: :type_definition
 
-          def initialize(name, owner)
-            @name = name
+          def initialize(reflection, owner)
+            @reflection = reflection
             @owner = owner
             @origin = :default
           end
 
-          def reflection
-            @owner.class._attributes[name]
-          end
-
           def write_value(value, origin: :user)
             reset
             @origin = origin
@@ -55,18 +52,14 @@ module Granite
             !(read.respond_to?(:zero?) ? read.zero? : read.blank?)
           end
 
-          def typecast(value)
-            if value.instance_of?(type)
-              value
-            else
-              typecaster.call(value, self) unless value.nil?
-            end
-          end
-
           def readonly?
             !!(readonly.is_a?(Proc) ? evaluate(&readonly) : readonly)
           end
 
+          def type_definition
+            @type_definition ||= build_type_definition(reflection.type)
+          end
+
           def inspect_attribute
             value = case read
             when Date, Time, DateTime
@@ -103,6 +96,10 @@ module Granite
 
         private
 
+          def build_type_definition(type)
+            Granite::Form.type_for(type).new(type, reflection, owner)
+          end
+
           def evaluate(*args, &block)
             if block.arity >= 0 && block.arity <= args.length
               owner.instance_exec(*args.first(block.arity), &block)

data/lib/granite/form/model/attributes/collection.rb

@@ -5,7 +5,7 @@ module Granite
         class Collection < Attribute
           def read
             @value ||= normalize(read_before_type_cast.map do |value|
-              enumerize(typecast(value))
+              enumerize(type_definition.ensure_type(value))
             end)
           end
 

data/lib/granite/form/model/attributes/dictionary.rb

@@ -11,7 +11,7 @@ module Granite
                          hash = hash.stringify_keys.slice(*keys) if keys.present?
 
                          normalize(Hash[hash.map do |key, value|
-                           [key, enumerize(typecast(value))]
+                           [key, enumerize(type_definition.ensure_type(value))]
                          end].with_indifferent_access).with_indifferent_access
                        end
           end

data/lib/granite/form/model/attributes/localized.rb

@@ -5,7 +5,7 @@ module Granite
         class Localized < Attribute
           def read
             @value ||= Hash[read_before_type_cast.map do |locale, value|
-              [locale.to_s, normalize(enumerize(typecast(value)))]
+              [locale.to_s, normalize(enumerize(type_definition.ensure_type(value)))]
             end]
           end
 

data/lib/granite/form/model/attributes/reference_many.rb

@@ -5,7 +5,7 @@ module Granite
         class ReferenceMany < ReferenceOne
           def type_casted_value
             variable_cache(:value) do
-              read_before_type_cast.map { |id| typecast(id) }
+              read_before_type_cast.map { |id| type_definition.ensure_type(id) }
             end
           end
 

data/lib/granite/form/model/attributes/reference_one.rb

@@ -24,7 +24,7 @@ module Granite
 
           def type_casted_value
             variable_cache(:value) do
-              typecast(read_before_type_cast)
+              type_definition.ensure_type(read_before_type_cast)
             end
           end
 
@@ -32,14 +32,6 @@ module Granite
             @value_cache
           end
 
-          def type
-            @type ||= association.reflection.persistence_adapter.primary_key_type
-          end
-
-          def typecaster
-            @typecaster ||= Granite::Form.typecaster(type.ancestors.grep(Class))
-          end
-
         private
 
           def association