hydra_attribute 0.3.2 → 0.4.0.rc1

data/features/relation/query_methods/where.feature

@@ -0,0 +1,70 @@
+Feature: hydra attribute where conditions
+  When filter by hydra attribute and this value is not nil
+  Then records with this attribute should be selected
+
+  When filter by hydra attribute and this value is nil
+  Then records with nil and blank value should be selected
+
+  Background: create hydra attributes
+    Given create hydra attributes for "Product" with role "admin" as "hashes":
+      | name    | backend_type | white_list |
+      | code    | string       | [bool:t]   |
+      | summary | string       | [bool:t]   |
+      | title   | string       | [bool:t]   |
+      | price   | float        | [bool:t]   |
+      | active  | boolean      | [bool:t]   |
+      | state   | integer      | [bool:t]   |
+
+  Scenario: filter by one hydra attribute
+    Given create "Product" model with attributes as "hashes":
+      | code | price |
+      | 1    | 2.75  |
+      | 2    | 2.75  |
+      | 3    | 2.76  |
+      | 4    |       |
+    When filter "Product" by:
+      | field | value |
+      | price | 2.75  |
+    Then total records should be "2"
+    And records should have the following attributes:
+      | field | value |
+      | code  | 1     |
+      | code  | 2     |
+
+  Scenario: filter by one hydra attribute with nil value
+    Given create "Product" model with attributes as "hashes":
+      | code | price |
+      | 1    |       |
+      | 2    | 0     |
+      | 3    |       |
+    When filter "Product" by:
+      | field | value  |
+      | price | [nil:] |
+    Then total records should be "2"
+    And records should have the following attributes:
+      | field | value |
+      | code  | 1     |
+      | code  | 3     |
+
+  Scenario: filter by several fields including both the hydra and general attributes
+    Given create "Product" model with attributes as "hashes":
+      | name | code | title | price | active | state  | summary |
+      | toy  | 1    | story | 2.40  | 1      |        |         |
+      | toy  | 2    | story | 2.45  | 1      |        |         |
+      | toy  | 3    | story | 2.45  | 1      |        |         |
+      | toy  | 4    |       | 2.45  | 0      |        |         |
+      |      | 5    |       | 2.45  | 1      |        |         |
+      | toy  | 6    |       | 2.46  | 1      |        |         |
+    When filter "Product" by:
+      | field   | value        |
+      | name    | toy          |
+      | title   | story        |
+      | summary | [nil:]       |
+      | price   | [float:2.45] |
+      | active  | [bool:t]     |
+      | state   | [nil:]       |
+    Then total records should be "2"
+    And records should have the following attributes:
+      | field | value |
+      | code  | 2     |
+      | code  | 3     |

data/features/step_definitions/connections.rb

@@ -0,0 +1,65 @@
+Given /^create connection$/ do
+  spec        = ActiveRecord::Base::ConnectionSpecification.new({database: ':memory:', adapter: 'sqlite3'}, 'sqlite3_connection')
+  @connection = ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec).connection
+end
+
+Given /^(create|drop|migrate|rollback)(?:\sto|\sfrom)? hydra entity "([^"]+)"$/ do |method, table|
+  HydraAttribute::Migrator.send(method, @connection, table)
+end
+
+Given /^create table "([^"]+)"$/ do |table|
+  @connection.create_table(table)
+end
+
+Then /^should have the following (\d+) tables?:$/ do |count, table|
+  @connection.should have(count.to_i).tables
+
+  table.rows.flatten.each do |name|
+    @connection.tables.should include(name)
+  end
+end
+
+Then /^should not have any tables$/ do
+  @connection.should have(0).tables
+end
+
+Then /^table "([^"]+)" should have the following (columns|indexes):$/ do |table_name, method, table|
+  connection_params = @connection.send(method, table_name).sort_by(&:name)
+  checked_params    = table.hashes.map { |hash| type_cast_hash(hash) }.sort_by { |param| param['name'] }
+
+  unless connection_params.length == checked_params.length
+    raise %(Table "#{table_name}" has "#{connection_params.length}" #{method} but in our test "#{checked_params.length}". Diff: is "#{connection_params.map(&:name)}" but should be "#{checked_params.map { |h| h['name'] }}")
+  end
+
+  connection_params.zip(checked_params).each do |(real_params, params)|
+    params.keys.each do |name|
+      params[name].should == real_params.send(name)
+    end
+  end
+end
+
+Then /^table "([^"]+)" should have (\d+) records?$/ do |table_name, count|
+  result = ActiveRecord::Base.connection.select_one("SELECT COUNT(*) AS count FROM #{table_name}")
+  result['count'].should == count.to_i
+end
+
+Then /^table "([^"]+)" should have (\d+) records?:$/ do |table_name, count, table|
+  step %(table "#{table_name}" should have #{count} records)
+
+  table.hashes.each do |hash|
+    table  = Arel::Table.new(table_name, ActiveRecord::Base)
+    select = Arel.sql('COUNT(*)').as('count')
+    where  = hash.map { |name, value| table[name].eq(type_cast_value(value)) }.inject(:and)
+
+    result = ActiveRecord::Base.connection.select_one(table.project(select).where(where))
+    unless result['count']
+      raise %(Query "#{table.project(select).where(where).to_sql}" return nil)
+    end
+
+    unless result['count'] == 1
+      raise %(Query "#{table.project(select).where(where).to_sql}" return "#{result['count']}")
+    end
+    result['count'].should be(1)
+  end
+end
+

data/features/step_definitions/model_steps.rb

@@ -6,6 +6,34 @@ Given /^create "([^"]+)" model$/ do |klass|
   klass.constantize.create!
 end
 
+Given /^build "([^"]+)" model$/ do |klass|
+  @model = klass.constantize.new
+end
+
+Given /^build "([^"]+)" model:$/ do |klass, table|
+  @model = klass.constantize.new(type_cast_hash(table.rows_hash))
+end
+
+When /^set "([^"]+)" to "([^"]+)"$/ do |attribute, value|
+  @model.send("#{attribute}=", type_cast_value(value))
+end
+
+When /^(save|destroy) model$/ do |method|
+  @model.send(method)
+end
+
+When /^find "([^"]+)" model by attribute "([^"]+)" and value "([^"]+)"$/ do |class_name, attribute, value|
+  @model = class_name.constantize.send("find_by_#{attribute}", type_cast_value(value))
+end
+
+When /^find (first|last) "([^"]+)" model$/ do |method, class_name|
+  @model = class_name.constantize.send(method)
+end
+
+When /^reload model$/ do
+  @model.reload
+end
+
 Given /^create "([^"]+)" model with attributes as "([^"]+):"$/ do |klass, format, table|
   Array.wrap(table.send(format)).each do |hash|
     klass.constantize.create!(type_cast_hash(hash))
@@ -18,6 +46,26 @@ Given /^create hydra attributes for "([^"]+)" with role "([^"]+)" as "([^"]+)":$
   end
 end
 
+Given /^create hydra sets for "([^"]+)" as "([^"]+)":$/ do |klass, format, table|
+  Array.wrap(table.send(format)).each do |hash|
+    step %(create hydra set "#{hash['name']}" for "#{klass}")
+  end
+end
+
+Given /^create hydra set "([^"]+)" for "([^"]+)"$/ do |hydra_set_name, klass|
+  klass.constantize.hydra_sets.create!(name: type_cast_value(hydra_set_name))
+end
+
+Given /^add "([^"]+)" hydra attributes to hydra set:$/ do |klass, table|
+  klass = klass.constantize
+
+  Array.wrap(table.hashes).each do |hash|
+    Array.wrap(type_cast_value(hash['hydra set name'])).each do |set|
+      klass.hydra_sets.find_by_name(set).hydra_attributes << klass.hydra_attributes.find_by_name(type_cast_value(hash['hydra attribute name']))
+    end
+  end
+end
+
 Given /^(load and )?(save|create|update(?: all| attributes)?|destroy(?: all)?|delete(?: all)?)(?: for)? "([^"]+)" models? with attributes as "([^"]+)":$/ do |load, action, klass, format, table|
   action = action.gsub(' ', '_')
   klass  = klass.constantize
@@ -30,20 +78,45 @@ Given /^(load and )?(save|create|update(?: all| attributes)?|destroy(?: all)?|de
   end
 end
 
-Then /^model "([^"]+)" (should(?:\snot)?) respond to "([^"]+)"$/ do |klass, method, attributes|
-  model  = klass.constantize.new
+Then /^model (should(?:\snot)?) respond to "([^"]+)"$/ do |method, attributes|
+  method = method.gsub(/\s+/, '_')
+  attributes.split.each do |attribute|
+    @model.send(method, respond_to(attribute))
+  end
+end
+
+Then /^model attributes (should(?:\snot)?) include "([^"]+)"$/ do |method, attributes|
   method = method.gsub(/\s+/, '_')
   attributes.split.each do |attribute|
-    model.send(method, respond_to(attribute))
+    @model.attributes.keys.send(method, include(attribute))
   end
 end
 
-Then /^(last|first) created "([^"]+)" (should|should not) have the following attributes:$/ do |method, klass, match, table|
-  table.rows_hash.each_with_object(klass.constantize.send(method)) do |(attribute, value), model|
-    model.send(attribute).send(match) == type_cast_value(value)
+Then /^model attributes (should(?:\snot)?) match "([^"]+)"$/ do |match, attribute|
+  @model.attributes.keys.send(match) =~ Array(type_cast_value(attribute))
+end
+
+Then /^model "([^"]+)" (should(?:\snot)?) respond to "([^"]+)"$/ do |klass, method, attributes|
+  @model = klass.constantize.new
+  step %(model #{method} respond to "#{attributes}")
+end
+
+Then /^error "([^"]+)" (should(?:\snot)?) be risen when methods? "([^"]+)" (?:is|are) called$/ do |error_class, expect, methods|
+  Array.wrap(methods.split).each do |method|
+    lambda { @model.send(method) }.send(expect.gsub(/\s+/, '_'), raise_error(error_class.constantize))
   end
 end
 
+Then /^(last|first) created "([^"]+)" (should|should not) have the following attributes:$/ do |position, klass, match, table|
+  table.rows_hash.each do |attribute, value|
+    step %(#{position} created "#{klass}" #{match} have attribute "#{attribute}" with value "#{value}")
+  end
+end
+
+Then /^(last|first) created "([^"]+)" (should|should not) have attribute "([^"]+)" with value "([^"]+)"$/ do |position, klass, match, attribute, value|
+  klass.constantize.send(position).send(attribute).send(match) == type_cast_value(value)
+end
+
 Then /^class "([^"]+)" (should(?:\snot)?) have "([^"]+)" in white list$/ do |klass, accept, attribute|
   method = accept.sub(' ', '_')
   klass.constantize.accessible_attributes.send(method, include(attribute))

data/features/step_definitions/query_methods.rb

@@ -5,7 +5,7 @@ end
 
 When /^filter "([^"]+)" records by "([^"]+)"$/ do |klass, attribute|
   @records = Object.const_get(klass)
-  step %Q(filter records by "#{attribute}")
+  step %(filter records by "#{attribute}")
 end
 
 When /^filter records by "([^"]+)"$/ do |attribute|
@@ -15,7 +15,7 @@ end
 
 When /^group "([^"]+)" by "([^"]+)"$/ do |klass, attributes|
   @records = Object.const_get(klass)
-  step %Q(group by "#{attributes}")
+  step %(group by "#{attributes}")
 end
 
 When /^group by "([^"]+)"$/ do |attributes|
@@ -24,7 +24,7 @@ end
 
 When /^(order|reorder) "([^"]+)" records by "([^"]+)"$/ do |sort_method, klass, attributes|
   @records = Object.const_get(klass)
-  step %Q(#{sort_method} records by "#{attributes}")
+  step %(#{sort_method} records by "#{attributes}")
 end
 
 When /^(order|reorder) records by "([^"]+)"$/ do |sort_method, attributes|

data/features/step_definitions/record_steps.rb

@@ -58,11 +58,10 @@ Then /^records should have only the following "([^"]+)" names$/ do |attributes|
   end
 end
 
-Then /^records should raise "([^"]+)" when call the following "([^"]+)"$/ do |error, methods|
-  error_class = error.constantize
+Then /^records should raise "([^"]+)" when call the following "([^"]+)"$/ do |error_class, methods|
   @records.each do |record|
     methods.split(/\s+/).each do |method|
-      lambda { record.send(method) }.should raise_error(error_class)
+      lambda { record.send(method) }.should raise_error(error_class.constantize)
     end
   end
 end
@@ -73,7 +72,7 @@ end
 
 Then /^total "([^"]+)" records should be "([^"]+)"$/ do |klass, count|
   @records = klass.constantize.scoped
-  step %Q(total records should be "#{count}")
+  step %(total records should be "#{count}")
 end
 
 Then /^records "(should|should_not)" have loaded associations:$/ do |should, table|

data/features/support/env.rb

@@ -1,19 +1,33 @@
 require 'active_record'
 require 'hydra_attribute'
 require 'database_cleaner'
-require 'database_cleaner/cucumber'
 
 ActiveSupport.on_load(:active_record) do
   self.default_timezone = :utc
-  unless ActiveRecord::VERSION::STRING.start_with?('3.1.')
+  unless ActiveRecord::VERSION::STRING.start_with?('3.1.') # @COMPATIBILITY with 3.1.x. active_record 3.1 doesn't have "mass_assignment_sanitizer" method
     self.mass_assignment_sanitizer = :strict
   end
-  extend HydraAttribute::ActiveRecord
+
+  ActiveRecord::Migration.send(:include, HydraAttribute::ActiveRecord::Migration)
 end
 
 ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
 DatabaseCleaner.strategy = :truncation
 
+class Migration < ActiveRecord::Migration
+  def up
+    create_hydra_entity :products do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+
+  def down
+  end
+end
+
+Migration.new.up
+
 Before do
   redefine_hydra_entity('Product')
   DatabaseCleaner.start

data/features/support/world.rb

@@ -3,15 +3,19 @@ module HydraAttribute
     module World
       def type_cast_value(schema)
         return schema unless schema.is_a?(String)
-        type, value = schema.gsub(/\[|\]/, '').split(':', 2)
+        type, value = schema.gsub(/(^\[)|(\]$)/, '').split(':', 2)
         return schema if schema == type && value.nil?
 
         case type
-        when 'integer'  then value.to_i
-        when 'float'    then value.to_f
-        when 'boolean'  then value == 'true' ? true : false
-        when 'nil'      then nil
-        when 'datetime' then ActiveSupport::TimeZone.new('UTC').parse(value)
+        when 'int'   then type_cast_value(value).to_i
+        when 'float' then type_cast_value(value).to_f
+        when 'bool'  then ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(type_cast_value(value))
+        when 'nil'   then nil
+        when 'date'  then ActiveSupport::TimeZone.new('UTC').parse(type_cast_value(value))
+        when 'sym'   then type_cast_value(value).to_sym
+        when 'array' then value.split(',').map { |v| type_cast_value(v) }
+        when 'eval'  then eval(type_cast_value(value))
+        when 'str'   then type_cast_value(value).to_s
         else value
         end
       end
@@ -22,7 +26,8 @@ module HydraAttribute
       end
 
       def type_cast_attributes(attributes)
-        attributes.split(/(?<=\])\s+/).flatten.each_with_object({}) do |attribute, hash|
+        # 'a=[b c] c=a c=[v abc]' => ["a=[b c]", "c=a", "c=[v abc]"]
+        attributes.gsub(/\s+(\w+=)/, '<###>\1').split('<###>').each_with_object({}) do |attribute, hash|
           name, value = type_cast_attribute(attribute)
           hash[name]  = value
         end
@@ -39,15 +44,15 @@ module HydraAttribute
 
         Object.send(:remove_const, klass.to_sym) if Object.const_defined?(klass.to_sym)
 
-        ::HydraAttribute::SUPPORT_TYPES.each do |type|
+        ::HydraAttribute::SUPPORTED_BACKEND_TYPES.each do |type|
           class_name = "Hydra#{type.capitalize}#{klass}".to_sym
           ::HydraAttribute.send(:remove_const, class_name) if ::HydraAttribute.const_defined?(class_name)
         end
 
         Object.const_set(klass.to_sym, Class.new(::ActiveRecord::Base))
         klass.to_s.constantize.send(:accessible_attributes_configs).values.each(&:clear)
-        klass.to_s.constantize.attr_accessible :name
-        klass.to_s.constantize.use_hydra_attributes
+        klass.to_s.constantize.attr_accessible :name, :hydra_set_id
+        klass.to_s.constantize.send(:include, ::HydraAttribute::ActiveRecord)
       end
     end
   end

data/gemfiles/3.1.gemfile.lock

@@ -1,22 +1,22 @@
 PATH
   remote: /Users/kostyantyn/Sites/github/gems/hydra_attribute
   specs:
-    hydra_attribute (0.3.2.beta)
+    hydra_attribute (0.4.0.beta)
       activerecord (>= 3.1.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.1.6)
-      activesupport (= 3.1.6)
+    activemodel (3.1.7)
+      activesupport (= 3.1.7)
       builder (~> 3.0.0)
       i18n (~> 0.6)
-    activerecord (3.1.6)
-      activemodel (= 3.1.6)
-      activesupport (= 3.1.6)
+    activerecord (3.1.7)
+      activemodel (= 3.1.7)
+      activesupport (= 3.1.7)
       arel (~> 2.2.3)
       tzinfo (~> 0.3.29)
-    activesupport (3.1.6)
+    activesupport (3.1.7)
       multi_json (>= 1.0, < 1.3)
     appraisal (0.4.1)
       bundler
@@ -33,17 +33,17 @@ GEM
     gherkin (2.11.1)
       json (>= 1.4.6)
     i18n (0.6.0)
-    json (1.7.3)
+    json (1.7.4)
     multi_json (1.2.0)
     rake (0.9.2.2)
-    rspec (2.10.0)
-      rspec-core (~> 2.10.0)
-      rspec-expectations (~> 2.10.0)
-      rspec-mocks (~> 2.10.0)
-    rspec-core (2.10.1)
-    rspec-expectations (2.10.0)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.10.1)
+    rspec-mocks (2.11.1)
     sqlite3 (1.3.6)
     tzinfo (0.3.33)
 

data/gemfiles/3.2.gemfile.lock

@@ -1,21 +1,21 @@
 PATH
   remote: /Users/kostyantyn/Sites/github/gems/hydra_attribute
   specs:
-    hydra_attribute (0.3.2.beta)
+    hydra_attribute (0.4.0.beta)
       activerecord (>= 3.1.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.2.6)
-      activesupport (= 3.2.6)
+    activemodel (3.2.7)
+      activesupport (= 3.2.7)
       builder (~> 3.0.0)
-    activerecord (3.2.6)
-      activemodel (= 3.2.6)
-      activesupport (= 3.2.6)
+    activerecord (3.2.7)
+      activemodel (= 3.2.7)
+      activesupport (= 3.2.7)
       arel (~> 3.0.2)
       tzinfo (~> 0.3.29)
-    activesupport (3.2.6)
+    activesupport (3.2.7)
       i18n (~> 0.6)
       multi_json (~> 1.0)
     appraisal (0.4.1)
@@ -33,17 +33,17 @@ GEM
     gherkin (2.11.1)
       json (>= 1.4.6)
     i18n (0.6.0)
-    json (1.7.3)
+    json (1.7.4)
     multi_json (1.3.6)
     rake (0.9.2.2)
-    rspec (2.10.0)
-      rspec-core (~> 2.10.0)
-      rspec-expectations (~> 2.10.0)
-      rspec-mocks (~> 2.10.0)
-    rspec-core (2.10.1)
-    rspec-expectations (2.10.0)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.10.1)
+    rspec-mocks (2.11.1)
     sqlite3 (1.3.6)
     tzinfo (0.3.33)
 

data/lib/hydra_attribute/active_record/association.rb

@@ -2,76 +2,112 @@ module HydraAttribute
   module ActiveRecord
     class Association < ::ActiveRecord::Associations::HasManyAssociation
 
-      def find_model(attributes = {})
+      def find_model(hydra_attribute_id)
         load_target unless loaded?
-        target.detect do |model|
-          model.hydra_attribute_id == attributes[:hydra_attribute_id]
+
+        hydra_set_target.detect do |model|
+          model.hydra_attribute_id == hydra_attribute_id
         end
       end
 
-      def find_model_or_build(attributes = {})
-        find_model(attributes) || build(attributes)
+      def find_model_or_build(options = {})
+        find_model(options[:hydra_attribute_id]) || build(options)
       end
 
       def build(attributes = {}, options = {}, &block)
-        return if locked_for_build? and white_list_for_build.exclude?(attributes[:hydra_attribute_id])
+        return if hydra_attribute_ids.exclude?(attributes[:hydra_attribute_id])
+        return if target.any? { |model| model.hydra_attribute_id == attributes[:hydra_attribute_id] }
+
         super
       end
 
       def all_models
         unless @full_loaded
-          (all_attribute_ids - target.map(&:hydra_attribute_id)).each do |hydra_attribute_id|
+          (hydra_attribute_ids - target.map(&:hydra_attribute_id)).each do |hydra_attribute_id|
             build(hydra_attribute_id: hydra_attribute_id)
           end
           @full_loaded = true
         end
-        target
+        hydra_set_target
       end
 
-      def locked_for_build
-        @locked_for_build ||= false
+      def save
+        changed = false
+        all_models.each do |model|
+          model.entity_id = owner.id
+          model.save
+          changed = true unless model.previous_changes.blank?
+        end
+        changed
       end
-      alias_method :locked_for_build?, :locked_for_build
 
-      def lock_for_build!(white_list_for_build = [])
-        @locked_for_build     = true
-        @white_list_for_build = Array(white_list_for_build)
+      def lock!(white_list = [])
+        @white_list = Array(white_list)
         loaded!
       end
 
-      def white_list_for_build
-        @white_list_for_build ||= []
+      def hydra_attributes
+        if @white_list
+          @hydra_attributes ||= owner.class.hydra_set_attributes_for_backend_type(owner.hydra_set_id, reflection.backend_type)
+        else
+          owner.class.hydra_set_attributes_for_backend_type(owner.hydra_set_id, reflection.backend_type)
+        end
       end
 
-      def all_attribute_ids
-        hydra_attribute_ids  = owner.class.grouped_hydra_attribute_ids(reflection.backend_type)
-        hydra_attribute_ids &= white_list_for_build if locked_for_build?
-        hydra_attribute_ids
+      def hydra_attribute_ids
+        if @white_list
+          @hydra_attribute_ids ||= owner.class.hydra_set_attribute_ids_for_backend_type(owner.hydra_set_id, reflection.backend_type) & @white_list
+        else
+          owner.class.hydra_set_attribute_ids_for_backend_type(owner.hydra_set_id, reflection.backend_type)
+        end
       end
 
-      private
+      def hydra_attribute_names
+        if @white_list
+          hydra_attributes.map(&:name)
+        else
+          owner.class.hydra_set_attribute_names_for_backend_type(owner.hydra_set_id, reflection.backend_type)
+        end
+      end
 
-      # Optimized method
-      # Remove unnecessary callbacks
-      def add_to_target(record)
-        @target << record
-        record
+      def hydra_set_target
+        @hydra_set_target ||= target.select do |model|
+          hydra_attribute_ids.include?(model.hydra_attribute_id)
+        end
       end
 
-      # Optimized method
-      # Attributes are written via low level function without additional checks
-      def build_record(attributes, _)
-        reflection.klass.new do |record|
-          unless attributes.has_key?(:value)
-            attributes[:value] = owner.class.hydra_attribute(attributes[:hydra_attribute_id]).default_value
-          end
+      def clear_cache!
+        @hydra_attributes    = nil
+        @hydra_attribute_ids = nil
+        @full_loaded         = nil
+        @hydra_set_target    = nil
+      end
+
+      private
 
-          record.send :write_attribute, 'id', attributes[:id]
-          record.send :write_attribute, 'entity_id', owner.id
-          record.send :write_attribute, 'hydra_attribute_id', attributes[:hydra_attribute_id]
-          record.send :write_attribute, 'value', attributes[:value]
+        # Optimized method
+        # Remove unnecessary callbacks
+        def add_to_target(record)
+          @target << record
+          record
+        end
+
+        # Optimized method
+        # Attributes are written via low level function without additional checks
+        def build_record(options, _)
+          reflection.klass.new do |record|
+            unless options.has_key?(:value)
+              options[:value] = owner.class.hydra_attribute(options[:hydra_attribute_id]).default_value
+            end
+
+            record.send :write_attribute, 'id', options[:id]
+            record.send :write_attribute, 'entity_id', owner.id
+            record.send :write_attribute, 'hydra_attribute_id', options[:hydra_attribute_id]
+            record.send :write_attribute, 'value', options[:value]
+
+            hydra_set_target << record unless hydra_set_target.include?(record)
+          end
         end
-      end
     end
   end
 end