activerecord-redundancy 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea48053646bbb9a46bac56dbdfbb38421deba343
-  data.tar.gz: d773a73fa5b34e872888e085d82b4f623de8b53e
+  metadata.gz: faa2836ac314098d90878058bf77c1260a99decc
+  data.tar.gz: b6494ce4bbfdaf61a9eb799ad9daf418eeb76483
 SHA512:
-  metadata.gz: d23cb5550eff70b10fad7f3f57b6a97ca5e9e494d6b3695d40a1459696bce13d9223c19da9bdaa84aac380297fa25ba66530f70c9de346f232bf055210da997f
-  data.tar.gz: 39d26a0d4e8a438ed0aecb02af153188a1762719c5d6fbd76a6a078281705d5409ae3fbf229a3db7fcaae0be0fe40247476a00910462ba89a6f7f5e231a66d64
+  metadata.gz: 078c06ecc0f44628b258e97c6ca3290f0ce209ad450e5f84eb2f419e62c8c387e93fb236727e77179e35880c34b9499733e5de3e4a1ece02b954e98a37df0d02
+  data.tar.gz: 2f0cb3ee7453469962e52b95104450a40cae0308616447f775237dea18bf875d6a51cb923a25982d0e9a16e31c608c3af5283d62d110309f25cab0367028c4db

data/lib/redundancy.rb

@@ -1,73 +1,47 @@
-require 'redundancy/cache_column'
+require 'redundancy/utils'
 
 module Redundancy
   extend ActiveSupport::Concern
 
   included do
-    before_save :redundancy_update_cache_column_after_save
+    before_save :update_redundacies_before_save
+    after_save :update_redundacies_after_save
   end
 
   private
 
-  def redundancy_update_cache_column_after_save
-    self.class.cache_columns.each do |cache_column|
-      cache_column.update_record(self)
+  def update_redundacies_before_save
+    self.class.redundacies.each do |redundancy|
+      redundancy.before_save(self)
     end
   end
 
-  module ClassMethods
-    def redundancy association, attribute, options = {}
-      options.assert_valid_keys(:cache_column, :inverse_of)
-
-      reflection = self.reflect_on_association(association)
-      raise ArgumentError, "Unknown association :#{association}" unless reflection
-      raise ArgumentError, "BelongsTo or HasOne reflection needed" unless 
-        [:has_one, :belongs_to].include? reflection.macro
-
-      inverse_associations = options[:inverse_of] 
-      inverse_associations ||= [model_name.plural, model_name.singular].map(&:to_sym)
-
-      inverse_association = Array.wrap(inverse_associations).find do |inverse_association|
-        reflection.klass.reflect_on_association(inverse_association)
-      end
-
-      raise ArgumentError, "Could not find the inverse association for #{association} (#{inverse_associations.inspect} in #{reflection.klass})" unless inverse_association
-      
-      foreign_key = reflection.foreign_key
-      cache_column = options[:cache_column] || :"#{association}_#{attribute}"
-
-      local_klass = self
-      remote_klass = reflection.klass
-
-      case reflection.macro
-      when :belongs_to
-        local_klass.cache_columns << CacheColumn.new({
-          source: { association: association, attribute: attribute },
-          dist: { association: nil, attribute: cache_column },
-          change_if: foreign_key, klass: local_klass
-        })
-
-      when :has_one
-        remote_klass.cache_columns << CacheColumn.new({
-          source: { association: nil, attribute: attribute },
-          dist: { association: inverse_association, attribute: cache_column },
-          change_if: foreign_key, nil_unless: foreign_key, klass: remote_klass,
-          set_prev_nil: { klass: local_klass, attribute: foreign_key }
-        })
-      
-      end
+  def update_redundacies_after_save
+    self.class.redundacies.each do |redundancy|
+      redundancy.after_save(self)
+    end
+  end
 
-      remote_klass.cache_columns << CacheColumn.new({
-        source: { association: nil, attribute: attribute },
-        dist: { association: inverse_association, attribute: cache_column },
-        change_if: attribute, klass: remote_klass, update: true
-      })
+  def update_redundacies
+    self.class.redundacies.each do |redundancy|
+      redundancy.before_save(self)
+      redundancy.after_save(self)
+    end
+  end
 
+  module ClassMethods
+    def cache_column association, attribute, options = {}
+      options.assert_valid_keys(:cache_column, :inverse_of)
+      Utils.cache_column self, association, attribute, options
+    end
 
+    def cache_method association, attribute, options = {}
+      options.assert_valid_keys(:cache_column, :inverse_of)
+      Utils.cache_method self, association, attribute, options
     end
 
-    def cache_columns
-      @cache_columns ||= []
+    def redundacies
+      @redundacies ||= []
     end
 
   end
@@ -77,4 +51,4 @@ end
 # include in AR
 ActiveSupport.on_load(:active_record) do
   ActiveRecord::Base.send(:include, Redundancy)
-end
+end

data/lib/redundancy/update_base.rb

@@ -0,0 +1,88 @@
+module Redundancy
+
+  class UpdateBase
+    attr_reader :options
+    attr_reader :source, :dest, :klass
+    attr_reader :change_if, :update, :target, :value
+
+    def initialize options
+      @options = options
+      @source, @dest = options[:source], options[:dest]
+      @klass = options[:klass]
+
+      @change_if = options[:change_if]
+      @update = options[:update] || false
+    end
+
+    def before_save record
+    end
+
+    def after_save record
+    end
+
+    def get_target_from_association record
+      @target = dest[:association] ? record.send(dest[:association]) : record
+    end
+
+    def get_target_from_prev_id record
+      prev_id = record.send(:attribute_was, dest[:prev_id])
+      return unless prev_id
+      @target = dest[:klass].where(id: prev_id)
+    end
+
+    def get_target_from_relation_first_record
+      @target = @target.first if @target.kind_of? ActiveRecord::Relation
+    end
+
+    def get_value_from_association record
+      @value = source[:association] ? record.send(source[:association]) : record
+      @value = value && source[:attribute] && value.send(source[:attribute])
+      @value = nil if source[:nil_unless] && !record.send(source[:nil_unless])
+      @value
+    end
+
+    def get_value_from_source record
+      @value = source
+    end
+
+    def get_value_from_target record
+      @value = target && source[:attribute] && target.send(source[:attribute])
+    end
+
+    def raise_if_class_mismatch record
+      raise ArgumentError, "record class mismatch, expected #{klass}, got #{record.class}" unless record.kind_of? klass
+    end
+
+    def update_target record
+      case target
+      when ActiveRecord::Base
+        return if target.send(:read_attribute, dest[:attribute]) == value
+        log "#{ update ? "update" : "write" } #{target.class}(#{target.id})##{dest[:attribute]} with #{value.inspect}"
+        log "#{change_if}: #{record.send(change_if).inspect}, #{dest[:association]||"self"}.id: #{target.id}" if change_if
+        if update
+          target.send(:update_attribute, dest[:attribute], value)
+        else
+          target.send(:write_attribute, dest[:attribute], value)
+        end
+      when ActiveRecord::Relation
+        log "update #{target.class}##{dest[:attribute]} with #{value.inspect}"
+        target.send(:update_all, dest[:attribute] => value)
+      end
+    end
+
+    def force_update_target record
+      @update = true
+      update_target record
+    end
+
+    def need_update? record
+      !change_if || record.send(:attribute_changed?, change_if)
+    end
+
+    def log *message
+      # puts *message
+    end
+
+  end
+
+end

data/lib/redundancy/update_column.rb

@@ -0,0 +1,19 @@
+require 'redundancy/update_base'
+
+module Redundancy
+
+  class UpdateColumn < UpdateBase
+
+    def before_save record
+      raise_if_class_mismatch record
+      return unless need_update? record
+
+      get_target_from_association record
+      get_value_from_association record
+
+      update_target record
+    end
+
+  end
+
+end

data/lib/redundancy/update_method.rb

@@ -0,0 +1,19 @@
+require 'redundancy/update_base'
+
+module Redundancy
+
+  class UpdateMethod < UpdateBase
+
+    def after_save record
+      raise_if_class_mismatch record
+      return unless need_update? record
+
+      get_target_from_association record
+      get_value_from_target record
+
+      force_update_target record
+    end
+
+  end
+
+end

data/lib/redundancy/update_prev_column.rb

@@ -0,0 +1,19 @@
+require 'redundancy/update_base'
+
+module Redundancy
+
+  class UpdatePrevColumn < UpdateBase
+
+    def before_save record
+      raise_if_class_mismatch record
+      return unless need_update? record
+
+      get_target_from_prev_id record
+      get_value_from_source record
+
+      update_target record
+    end
+
+  end
+
+end

data/lib/redundancy/update_prev_method.rb

@@ -0,0 +1,25 @@
+require 'redundancy/update_base'
+
+module Redundancy
+
+  class UpdatePrevMethod < UpdateBase
+
+    def before_save record
+      raise_if_class_mismatch record
+      return unless need_update? record
+
+      get_target_from_prev_id record
+    end
+
+    def after_save record
+      return unless need_update? record
+      return unless target
+
+      get_target_from_relation_first_record
+      get_value_from_target record
+      force_update_target record
+    end
+
+  end
+
+end

data/lib/redundancy/utils.rb

@@ -0,0 +1,102 @@
+require 'redundancy/update_column'
+require 'redundancy/update_prev_column'
+require 'redundancy/update_method'
+require 'redundancy/update_prev_method'
+
+module Redundancy
+
+  module Utils
+
+    def self.cache_column klass, association, attribute, options
+      local_klass = klass
+
+      reflection = get_reflection local_klass, association
+      raise ArgumentError, "BelongsTo or HasOne reflection required" unless
+        [:has_one, :belongs_to].include? reflection.macro
+
+      foreign_key = reflection.foreign_key
+      remote_klass = reflection.klass
+
+      inverse_association = get_inverse_association local_klass, remote_klass, options
+
+      cache_column = options[:cache_column] || :"#{association}_#{attribute}"
+
+      case reflection.macro
+      when :belongs_to
+        local_klass.redundacies << UpdateColumn.new(
+          source: { association: association, attribute: attribute },
+          dest: { association: nil, attribute: cache_column },
+          change_if: foreign_key, klass: local_klass
+        )
+
+      when :has_one
+        remote_klass.redundacies << UpdateColumn.new(
+          source: { association: nil, attribute: attribute, nil_unless: foreign_key },
+          dest: { association: inverse_association, attribute: cache_column },
+          change_if: foreign_key, klass: remote_klass
+        )
+
+        remote_klass.redundacies << UpdatePrevColumn.new(
+          source: options[:default],
+          dest: { klass: local_klass, prev_id: foreign_key, attribute: cache_column },
+          change_if: foreign_key, klass: remote_klass
+        )
+
+      end
+
+      remote_klass.redundacies << UpdateColumn.new(
+        source: { association: nil, attribute: attribute },
+        dest: { association: inverse_association, attribute: cache_column },
+        change_if: attribute, klass: remote_klass, update: true
+      )
+    end
+
+    def self.cache_method klass, association, attribute, options
+      local_klass = klass
+
+      reflection = get_reflection local_klass, association
+      raise ArgumentError, "BelongsTo reflection required" unless
+        [:belongs_to].include? reflection.macro
+
+      foreign_key = reflection.foreign_key
+      remote_klass = reflection.klass
+
+      cache_method = options[:cache_method] || :"raw_#{attribute}"
+
+      local_klass.redundacies << UpdateMethod.new(
+        source: { attribute: cache_method },
+        dest: { association: association, attribute: attribute },
+        change_if: options[:change_if], klass: local_klass
+      )
+
+      local_klass.redundacies << UpdatePrevMethod.new(
+        source: { attribute: cache_method },
+        dest: { klass: remote_klass, prev_id: foreign_key, attribute: attribute },
+        change_if: foreign_key, klass: local_klass
+      )
+
+    end
+
+    def self.get_reflection klass, association
+      reflection = klass.reflect_on_association(association)
+      raise ArgumentError, "Unknown association :#{association}" unless reflection
+      reflection
+    end
+
+    def self.get_inverse_association klass, reflection_klass, options
+      model_name = klass.model_name
+      inverse_associations = options[:inverse_of]
+      inverse_associations ||= [model_name.plural, model_name.singular].map(&:to_sym)
+
+      inverse_association = Array.wrap(inverse_associations).find do |inverse_association|
+        reflection_klass.reflect_on_association(inverse_association)
+      end
+
+      raise ArgumentError, "Could not find the inverse association for #{association} (#{inverse_associations.inspect} in #{reflection_klass})" unless inverse_association
+      inverse_association
+    end
+
+
+  end
+
+end

data/lib/redundancy/version.rb

@@ -1,3 +1,3 @@
 module Redundancy
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/{belongs_to_has_one_association_test.rb → cache_column/belongs_to_has_one_association_test.rb}

@@ -21,6 +21,7 @@ class BelongsToHasOneAssociationTest < ActiveSupport::TestCase
 
     account.update_attribute(:user, user)
     assert_equal user.name, account.user_name
+    assert_equal user.name, account.reload.user_name
   end
 
   test "should update account.user_name when update account.user with nil" do
@@ -30,6 +31,7 @@ class BelongsToHasOneAssociationTest < ActiveSupport::TestCase
 
     account.update_attribute(:user, nil)
     assert_equal nil, account.user_name
+    assert_equal nil, account.reload.user_name
   end
 
   test "should update account.user_name when update account.user with other user" do
@@ -42,7 +44,8 @@ class BelongsToHasOneAssociationTest < ActiveSupport::TestCase
 
     account.update_attribute(:user, other_user)
     assert_equal other_user.name, account.user_name
-    assert_equal nil, other_account.reload.user
+    assert_equal other_user.name, account.reload.user_name
+    assert_equal nil, other_account.user
     assert_equal nil, other_account.reload.user_name
   end
 
@@ -53,8 +56,7 @@ class BelongsToHasOneAssociationTest < ActiveSupport::TestCase
 
     user.update_attribute(:name, "Other Name")
     assert_equal user.name, user.account.user_name
-
     assert_equal user.name, account.reload.user_name
   end
 
-end
+end

data/test/{has_many_belongs_to_association_test.rb → cache_column/has_many_belongs_to_association_test.rb}

@@ -3,6 +3,7 @@ require 'test_helper'
 class HasManyBelongsToAssociationTest < ActiveSupport::TestCase
 
   # has_many:belongs_to association
+  # cache_column
   test "should update post.user_name when create post" do
     user = users(:one)
     post = Post.create(title: 'title', content: 'content', user: user)
@@ -21,6 +22,7 @@ class HasManyBelongsToAssociationTest < ActiveSupport::TestCase
 
     post.update_attribute(:user, user)
     assert_equal user.name, post.user_name
+    assert_equal user.name, post.reload.user_name
   end
 
   test "should update post.user_name when update post.user with nil" do
@@ -30,6 +32,7 @@ class HasManyBelongsToAssociationTest < ActiveSupport::TestCase
 
     post.update_attribute(:user, nil)
     assert_equal nil, post.user_name
+    assert_equal nil, post.reload.user_name
   end
 
   test "should update post.user_name when update post.user with other user" do
@@ -42,6 +45,7 @@ class HasManyBelongsToAssociationTest < ActiveSupport::TestCase
 
     post.update_attribute(:user, other_user)
     assert_equal other_user.name, post.user_name
+    assert_equal other_user.name, post.reload.user_name
   end
 
   test "should update post.user_name when update user.name" do
@@ -53,8 +57,6 @@ class HasManyBelongsToAssociationTest < ActiveSupport::TestCase
     user.posts.each do |post|
       assert_equal user.name, post.user_name
     end
-
     assert_equal user.name, post.reload.user_name
   end
-
 end

data/test/{has_one_belongs_to_association_test.rb → cache_column/has_one_belongs_to_association_test.rb}

@@ -21,6 +21,7 @@ class HasOneBelongsToAssociationTest < ActiveSupport::TestCase
 
     user.update_attribute(:account, account)
     assert_equal account.email, user.account_email
+    assert_equal account.email, user.reload.account_email
   end
 
   test "should update user.account_email when update user.account with nil" do
@@ -30,6 +31,7 @@ class HasOneBelongsToAssociationTest < ActiveSupport::TestCase
 
     user.update_attribute(:account, nil)
     assert_equal nil, user.account_email
+    assert_equal nil, user.reload.account_email
   end
 
   test "should update user.account_email when update user.account with other account" do
@@ -42,8 +44,10 @@ class HasOneBelongsToAssociationTest < ActiveSupport::TestCase
 
     user.update_attribute(:account, other_account)
     assert_equal other_account.email, user.account_email
+    assert_equal other_account.email, user.reload.account_email
     assert_equal other_account, other_user.account
     assert_equal other_account.email, other_user.account_email
+    assert_equal other_account.email, other_user.reload.account_email
   end
 
   test "should update user.account_email when update account.email" do
@@ -57,4 +61,4 @@ class HasOneBelongsToAssociationTest < ActiveSupport::TestCase
     assert_equal account.email, user.reload.account_email
   end
 
-end
+end

data/test/cache_method/has_many_belongs_to_association_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+class HasManyBelongsToAssociationTest < ActiveSupport::TestCase
+
+  # has_many:belongs_to association
+  # cache_method
+  test "should update user.posts_count when create post" do
+    user = users(:one)
+    post = Post.create(title: 'title', content: 'content', user: user)
+    assert_equal user.raw_posts_count, user.posts_count
+  end
+
+  test "should update user.posts_star when create post" do
+    user = users(:one)
+    post = Post.create(title: 'title', content: 'content', user: user, star: 5)
+    assert_equal user.raw_posts_star, user.posts_star
+  end
+
+  test "should update user.posts_star when create post without star" do
+    user = users(:one)
+    post = Post.create(title: 'title', content: 'content', user: user)
+    assert_equal user.raw_posts_star, user.posts_star
+  end
+
+  test "should update nothing when create post without user" do
+    post = Post.create(title: 'title', content: 'content')
+  end
+
+  test "should update user.posts_star when update post.user" do
+    user = users(:one)
+    post = posts(:two)
+    assert_equal user.raw_posts_star, user.posts_star
+
+    post.update_attribute(:user, user)
+    assert_equal user.raw_posts_star, user.reload.posts_star
+  end
+
+  test "should update user.posts_star when update post.user with nil" do
+    user = users(:one)
+    post = posts(:one)
+    assert_equal user.raw_posts_star, user.posts_star
+
+    post.update_attribute(:user, nil)
+    assert_equal user.raw_posts_star, user.reload.posts_star
+  end
+
+  test "should update user.posts_star when update post.user with other user" do
+    user = users(:one)
+    other_user = users(:two)
+    post = posts(:one)
+    other_post = posts(:two)
+    assert_equal user.raw_posts_star, user.posts_star
+    assert_equal other_user.raw_posts_star, other_user.posts_star
+
+    post.update_attribute(:user, other_user)
+    assert_equal user.raw_posts_star, user.reload.posts_star
+    assert_equal other_user.raw_posts_star, other_user.reload.posts_star
+  end
+
+  test "should update user.posts_star when update post.star" do
+    user = users(:one)
+    post = posts(:one)
+    assert_equal user.raw_posts_star, user.posts_star
+
+    post.update_attribute(:star, 5)
+    assert_equal user.raw_posts_star, post.user.posts_star
+    assert_equal user.raw_posts_star, user.reload.posts_star
+  end
+
+end

data/test/fixtures/posts.yml

@@ -7,6 +7,7 @@ one:
   user_id: 1
   user_name: Name 1
   username: Name 1
+  star: 3
 
 two:
   id: 2
@@ -15,3 +16,4 @@ two:
   user_id: 2
   user_name: Name 2
   username: Name 2
+  star: 5

data/test/fixtures/users.yml

@@ -5,9 +5,11 @@ one:
   name: Name 1
   account_id: 1
   account_email: one@one.com
+  posts_star: 3
 
 two:
   id: 2
   name: Name 2
   account_id: 2
   account_email: two@two.com
+  posts_star: 5

data/test/support/environment.rb

@@ -22,6 +22,7 @@ ActiveRecord::Schema.define do
     t.integer  "user_id"
     t.string   "user_name"
     t.string   "username"
+    t.integer  "star"
     t.string   "title"
     t.text     "content"
     t.datetime "created_at"
@@ -33,6 +34,8 @@ ActiveRecord::Schema.define do
   create_table "users", force: true do |t|
     t.integer  "account_id"
     t.string   "account_email"
+    t.integer  "posts_count"
+    t.integer  "posts_star"
     t.string   "name"
     t.datetime "created_at"
     t.datetime "updated_at"

data/test/support/models/account.rb

@@ -1,5 +1,5 @@
 class Account < ActiveRecord::Base
   has_one :user
-  
-  redundancy :user, :name
+
+  cache_column :user, :name
 end

data/test/support/models/post.rb

@@ -1,6 +1,9 @@
 class Post < ActiveRecord::Base
   belongs_to :user
 
-  redundancy :user, :name
-  redundancy :user, :name, cache_column: :username
+  cache_column :user, :name
+  cache_column :user, :name, cache_column: :username
+
+  cache_method :user, :posts_count
+  cache_method :user, :posts_star
 end

data/test/support/models/user.rb

@@ -2,5 +2,13 @@ class User < ActiveRecord::Base
   has_many :posts
   belongs_to :account
 
-  redundancy :account, :email
+  cache_column :account, :email
+
+  def raw_posts_count
+    posts.count
+  end
+
+  def raw_posts_star
+    posts.average(:star)
+  end
 end

data/test/test_helper.rb

@@ -20,3 +20,5 @@ ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
 class ActiveSupport::TestCase
   fixtures :all
 end
+
+ActiveSupport.test_order = :sorted

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-redundancy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Theo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-18 00:00:00.000000000 Z
+date: 2015-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -58,6 +58,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -83,15 +97,21 @@ files:
 - Rakefile
 - lib/activerecord-redundancy.rb
 - lib/redundancy.rb
-- lib/redundancy/cache_column.rb
+- lib/redundancy/update_base.rb
+- lib/redundancy/update_column.rb
+- lib/redundancy/update_method.rb
+- lib/redundancy/update_prev_column.rb
+- lib/redundancy/update_prev_method.rb
+- lib/redundancy/utils.rb
 - lib/redundancy/version.rb
-- test/belongs_to_has_one_association_test.rb
+- test/cache_column/belongs_to_has_one_association_test.rb
+- test/cache_column/has_many_belongs_to_association_test.rb
+- test/cache_column/has_one_belongs_to_association_test.rb
+- test/cache_column/options_test.rb
+- test/cache_method/has_many_belongs_to_association_test.rb
 - test/fixtures/accounts.yml
 - test/fixtures/posts.yml
 - test/fixtures/users.yml
-- test/has_many_belongs_to_association_test.rb
-- test/has_one_belongs_to_association_test.rb
-- test/options_test.rb
 - test/support/environment.rb
 - test/support/models/account.rb
 - test/support/models/post.rb
@@ -117,18 +137,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Redundancy for better performance, non painful
 test_files:
-- test/belongs_to_has_one_association_test.rb
+- test/cache_column/belongs_to_has_one_association_test.rb
+- test/cache_column/has_many_belongs_to_association_test.rb
+- test/cache_column/has_one_belongs_to_association_test.rb
+- test/cache_column/options_test.rb
+- test/cache_method/has_many_belongs_to_association_test.rb
 - test/fixtures/accounts.yml
 - test/fixtures/posts.yml
 - test/fixtures/users.yml
-- test/has_many_belongs_to_association_test.rb
-- test/has_one_belongs_to_association_test.rb
-- test/options_test.rb
 - test/support/environment.rb
 - test/support/models/account.rb
 - test/support/models/post.rb

data/lib/redundancy/cache_column.rb

@@ -1,59 +0,0 @@
-module Redundancy
-
-  class CacheColumn
-    attr_reader :options
-    attr_reader :source, :dist, :klass
-    attr_reader :change_if, :nil_unless, :update, :set_prev_nil
-
-    def initialize options
-      @options = options
-      @source, @dist = options[:source], options[:dist]
-      @klass = options[:klass]
-
-      @change_if = options[:change_if]
-      @nil_unless = options[:nil_unless]
-      @update = options[:update] || false
-      @set_prev_nil = options[:set_prev_nil]
-    end
-
-    def update_record record
-      raise ArgumentError, "record class mismatch, expected #{klass}, got #{record.class}" unless record.kind_of? klass
-      return unless need_update?(record)
-      
-      src = source[:association] ? record.send(source[:association]) : record
-      src = src && source[:attribute] && src.send(source[:attribute])
-      src = nil if nil_unless && !record.send(nil_unless) 
-
-      dst = dist[:association] ? record.send(dist[:association]) : record
-
-      set_prev_nil[:klass].where(id: record.send(:attribute_was, set_prev_nil[:attribute]))
-        .update_all(dist[:attribute] => nil) if set_prev_nil
-
-      case dst
-      when ActiveRecord::Base
-        return if dst.send(:read_attribute, dist[:attribute]) == src
-        log "#{ update ? "update" : "write" } #{dst.class}(#{dst.id})##{dist[:attribute]} with #{src.inspect}"
-        log "#{change_if}: #{record.send(change_if).inspect}, #{dist[:association]||"self"}.id: #{dst.id}"
-        if update
-          dst.send(:update_attribute, dist[:attribute], src)
-        else
-          dst.send(:write_attribute, dist[:attribute], src)
-        end
-      when ActiveRecord::Relation
-        log "update #{dst.class}##{dist[:attribute]} with #{src.inspect}"
-        dst.send(:update_all, dist[:attribute] => src)
-      end
-
-    end
-
-    def need_update? record
-      record.send(:attribute_changed?, change_if)
-    end
-
-    def log *message
-      # puts *message
-    end
-
-  end
-
-end