record_with_operator 0.1.0 → 1.0.0

data/README.rdoc

@@ -2,66 +2,96 @@
 
 == Introduction
 
-RecordWithOperator is a rails plugin that makes your all active record models to be saved or logically deleted with created_by, updated_by, deleted_by automatically.
-Also it makes creator, updater, deleter association (belongs_to) if the class has created_by, updated_by, deleted_by.
+RecordWithOperator is a gem that makes your active record models to be saved or logically deleted with created_by, updated_by, deleted_by (column names can be changed).
+Also it makes creator, updater, deleter association (belongs_to).
 
-You need to set 'operator' (it may be an User object) to the instance of the model you are trying to create/save/update/delete.
-(This cannot happen automatically as the current_user is stored in the session which models cannot access.)
-Once you have set an operator, it will be copied to objects in the association collection, so it might be enough to set an operator per request.
-Operators are also useful for your access control features on model's side.
-To set an operator, simply use operator= or get objects by find method with :for option.
+You can specify which action you want to save operator like this.
+
+  records_with_oprator_on :cerate, :update, destroy
+
+RecordWithOperator needs to know who is currently operating.
+For that, you need to set operator through one of the following ways.
+
+  # Every ActiveRecord object has operator= and operator.
+  record.operator = current_user
+  record.save
+
+  # RecordWithOperator module has operator= and operator.
+  RecordWithOperator.operator = current_user
+  obj = YourModel.find(id)
+  obj.attributes = some_params
+  obj.save
+
+In rails application, a nice place for setting operator whould be in filters.
+
+Operators whould be also useful for your access control features on model's side.
 
 The logical deletion function itself is out of this plugin's scope.
 This plugin assumes that the logical deletion is kicked by record.destory.
 
-== Installation
+== API Changes
+
+:for option in find method has been removed.
+(It's no use since operator is now global.)
+Please set operator before search if you need operator at that timing.
 
-  > ./script/plugin install git://github.com/nay/record_with_operator.git
+Also, operator_stamps is removed.
 
-Or
+== Installation
 
-  ## Gemfile for Rails3
+  ## Gemfile
   gem 'record_with_operator'
 
 == Example
 
 Create Note table with nessisary attributes:
 class CreateNotes < ActiveRecord::Migration
-  def self.up
+  def change
     create_table :users do |t|
       t.string :body
-      t.operator_stamps  #creates attributes for created_by, updated_by, deleted_by
+      t.integer :created_by
+      t.integer :updated_by
+      t.integer :deleted_by
+
+      t.boolean :deleted
+
       t.timestamps
     end
   end
 
+Set an operator in some filter
+
+  def set_operator
+    RecordWithOperator.operator = current_user
+  end
 
-Create a new note object with current_user:
+Create a new note object:
 
- note = Note.create(:body => "This is my first note.", :operator => current_user)
+ note = Note.create(:body => "This is my first note.")
  # note.operator will be current_user
  # note.created_by will be current_user.id
 
-Get note objects with current_user:
+Get note objects:
 
- notes = Note.find(:all, :for => current_user)
+ notes = Note.all
  # notes.first.operator will be current_user
- # notes.find_by_body("This is my first note.").operator will be current_user
 
 Create note's comments:
 
- note = Note.find(params[:id], :for => current_user)
+ note = Note.find(params[:id])
  note.comments.create!(:body => params[:comment_body])
- # comment's operator will be automatically set and used as created_by
+ # comment.operator will be current_user
+ # comment.created_by will be current_user.id
 
 == Configuration
 
-You can change the operator's class name by setting RecordWithOperator.config[:user_class_name].
+You can change the operator's class name by setting RecordWithOperator.config[:operator_class_name]. (It was renamed from :user_class_name. )
 The default is 'User'.
-Note that it is required to change the value before the model's creator/updater/deleter is firstly called.
+
+Note that it is required to change this value before your model classes are loaded.
 For example, you can write the code under config/initializers.
 
-  RecordWithOperator.config[:user_class_name] = "AdminUser"
+  RecordWithOperator.config[:operator_class_name] = "AdminUser"
 
 It's also possible to modify options for creator/updater/deleter associations.
 For example, in the case you use acts_as_paranoid and want to get creator/updater/deleter even if they are deleted,
@@ -69,4 +99,8 @@ the configuration will be look like this.
 
   RecordWithOperator.config[:operator_association_options] = {:with_deleted => true}
 
-Copyright (c) 2009-2010 Yasuko Ohba, released under the MIT license
+You can cange created_by, updated_by, deleted_by column name by changing RecordWithOperator.config with keys :creator_column, :updater_column and :deleter_column.
+
+The association names (such as creator, updater and deleter) can not be changed in this version.
+
+Copyright (c) 2009-2013 Yasuko Ohba, released under the MIT license

data/Rakefile

@@ -2,8 +2,8 @@ require 'rubygems'
 require 'rake'
 require 'rake/clean'
 require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
+#require 'rdoc/task'
+#require 'rake/gempackagetask'
 
 desc 'Default: run unit tests.'
 task :default => :test
@@ -16,11 +16,11 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = true
 end
 
-desc 'Generate documentation for the record_with_operator plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'RecordWithOperator'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+#desc 'Generate documentation for the record_with_operator plugin.'
+#Rake::RDocTask.new(:rdoc) do |rdoc|
+#  rdoc.rdoc_dir = 'rdoc'
+#  rdoc.title    = 'RecordWithOperator'
+#  rdoc.options << '--line-numbers' << '--inline-source'
+#  rdoc.rdoc_files.include('README.rdoc')
+#  rdoc.rdoc_files.include('lib/**/*.rb')
+#end

data/lib/record_with_operator/operator.rb

@@ -0,0 +1,11 @@
+module RecordWithOperator
+  module Operator
+    def operator=(o)
+      Thread.current[:operator] = o
+    end
+
+    def operator
+      Thread.current[:operator]
+    end
+  end
+end

data/lib/record_with_operator/recorder.rb

@@ -0,0 +1,58 @@
+module RecordWithOperator
+  module Recorder
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    private
+
+    def set_creator
+      send("#{RecordWithOperator.creator_column}=", operator.try(:id))
+    end
+
+    def set_updater
+      return unless changed? # no use setting updating_by when it's not changed
+      return unless operator # avoid changing value to be nil
+      send("#{RecordWithOperator.updater_column}=", operator.id)
+    end
+
+    def update_deleter
+      return if frozen?
+      return unless operator
+      self.class.update_all("#{RecordWithOperator.deleter_column} = #{operator.id}", ["#{self.class.primary_key} = ?", id])
+      send("#{RecordWithOperator.deleter_column}=", operator.id)
+    end
+
+    module ClassMethods
+      VALID_ACTIONS = %w(create update destroy)
+
+      def records_with_operator_on(*args)
+        raise "valid actions are #{VALID_ACTIONS.inspect}." unless args.all?{|arg| VALID_ACTIONS.include?(arg.to_s) }
+
+        @records_on = args.map(&:to_s)
+
+        before_create :set_creator if records_creator?
+        before_save :set_updater if records_updater?
+        before_destroy :update_deleter if records_deleter?
+
+        if self.table_exists?
+          belongs_to :creator, {:foreign_key => "created_by", :class_name => RecordWithOperator.config[:operator_class_name]}.merge(RecordWithOperator.config[:operator_association_options]) if records_creator?
+          belongs_to :updater, {:foreign_key => "updated_by", :class_name => RecordWithOperator.config[:operator_class_name]}.merge(RecordWithOperator.config[:operator_association_options]) if records_updater?
+          belongs_to :deleter, {:foreign_key => "deleted_by", :class_name => RecordWithOperator.config[:operator_class_name]}.merge(RecordWithOperator.config[:operator_association_options]) if records_deleter?
+        end
+      end
+
+      def records_creator?
+        @records_on.include?("create")
+      end
+
+      def records_updater?
+        @records_on.include?("update")
+      end
+
+      def records_deleter?
+        @records_on.include?("destroy")
+      end
+    end
+  end
+end

data/lib/record_with_operator/version.rb

@@ -1,3 +1,3 @@
 module RecordWithOperator
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/lib/record_with_operator.rb

@@ -1,6 +1,35 @@
-require 'record_with_operator/relation_methods'
-require 'record_with_operator/associations/extension'
-require 'record_with_operator/extension'
+module RecordWithOperator
+  def self.config
+    @config ||= {
+      :operator_class_name => "User",
+      :creator_column => "created_by",
+      :updater_column => "updated_by",
+      :deleter_column => "deleted_by",
+      :operator_association_options => {}}
+    @config
+  end
 
-ActiveRecord::Base.send :include, RecordWithOperator::Extension unless ActiveRecord::Base.include?(RecordWithOperator::Extension)
-ActiveRecord::Relation.send :include, RecordWithOperator::RelationMethods unless ActiveRecord::Relation.include?(RecordWithOperator::RelationMethods)
+  def self.operator_class_name
+    config[:operator_class_name]
+  end
+
+  def self.creator_column
+    config[:creator_column]
+  end
+
+  def self.updater_column
+    config[:updater_column]
+  end
+
+  def self.deleter_column
+    config[:deleter_column]
+  end
+end
+
+require 'record_with_operator/operator'
+require 'record_with_operator/recorder'
+
+RecordWithOperator.send :extend, RecordWithOperator::Operator
+
+ActiveRecord::Base.send :include, RecordWithOperator::Operator
+ActiveRecord::Base.send :include, RecordWithOperator::Recorder

data/record_with_operator.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
 
   s.licenses = ["MIT"]
 
-  s.add_dependency 'activerecord', ['~> 3.0.0']
+  s.add_dependency 'activerecord'
   s.add_development_dependency 'bundler', ['>= 1.0.0']
   s.add_development_dependency 'rake', ['>= 0.8.7']
   s.add_development_dependency 'sqlite3', ['>= 0']

data/test/record_with_operator_belongs_to_association_test.rb

@@ -6,15 +6,19 @@ end
 class NoteBelongsToMemo < ActiveRecord::Base
   set_table_name "notes"
   belongs_to :memo
+
+  records_with_operator_on :create, :update, :destroy
 end
 
 class Memo < ActiveRecord::Base
   set_table_name "memos"
+
+  records_with_operator_on :create, :update, :destroy
 end
 
 class RecordWithOperatorBelongsTo < ActiveSupport::TestCase
   def setup
-    RecordWithOperator.config[:user_class_name] = "User"
+    RecordWithOperator.config[:operator_class_name] = "User"
     @user1 = User.create!(:name => "user1")
     @user2 = User.create!(:name => "user2")
     @note_created_by_user1 = NoteBelongsToMemo.create!(:body => "test", :operator => @user1)
@@ -23,14 +27,16 @@ class RecordWithOperatorBelongsTo < ActiveSupport::TestCase
   # belongs_to Association Test
   # build_association
   def test_build_memo_should_have_operator
-    note = NoteBelongsToMemo.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteBelongsToMemo.find(@note_created_by_user1.id)
     memo = note.build_memo(:body => "memo")
     assert_equal @user2, memo.operator
   end
 
   # create_association
   def test_create_memo_should_have_operator_and_created_by
-    note = NoteBelongsToMemo.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteBelongsToMemo.find(@note_created_by_user1.id)
     memo = note.create_memo(:body => "memo")
     assert_equal false, memo.new_record?
     assert_equal @user2, memo.operator
@@ -39,7 +45,8 @@ class RecordWithOperatorBelongsTo < ActiveSupport::TestCase
 
   # association=
   def test_memo_eql_should_have_operator_and_created_by
-    note = NoteBelongsToMemo.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteBelongsToMemo.find(@note_created_by_user1.id)
     memo = Memo.new(:body => "memo")
     note.memo = memo # not save
     assert_equal @user2, memo.operator
@@ -47,7 +54,8 @@ class RecordWithOperatorBelongsTo < ActiveSupport::TestCase
 
   # association
   def test_auto_found_memo_should_have_operator
-    note = NoteBelongsToMemo.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteBelongsToMemo.find(@note_created_by_user1.id)
     note.create_memo(:body => "memo")
     assert_equal @user2, note.memo(true).operator
   end

data/test/record_with_operator_has_many_dependent_test.rb

@@ -5,7 +5,7 @@ end
 
 class NoteWithUserWithDependency < ActiveRecord::Base
   set_table_name "notes"
-  has_many :memos, :class_name => "MemoWithUser", :foreign_key => "note_id", :dependent => :destroy
+  has_many :memos, :class_name => "MemoWithUserWithDependency", :foreign_key => "note_id", :dependent => :destroy
 
   before_destroy :check_operator
 
@@ -29,7 +29,7 @@ end
 
 class RecordWithOperatorHasManyDependentTest < ActiveSupport::TestCase
   def setup
-    RecordWithOperator.config[:user_class_name] = "User"
+    RecordWithOperator.config[:operator_class_name] = "User"
     @user1 = User.create!(:name => "user1")
     raise "@user1.id is nil" unless @user1.id
     @user2 = User.create!(:name => "user2")

data/test/record_with_operator_has_one_association_test.rb

@@ -6,31 +6,38 @@ end
 class NoteHasOneMemo < ActiveRecord::Base
   set_table_name "notes"
   has_one :memo, :class_name => "Memo", :foreign_key => "note_id"
+
+  records_with_operator_on :create, :update, :destroy
 end
 
 class Memo < ActiveRecord::Base
   set_table_name "memos"
+
+  records_with_operator_on :create, :update, :destroy
 end
 
 class RecordWithOperatorHasOneAssociationTest < ActiveSupport::TestCase
   def setup
-    RecordWithOperator.config[:user_class_name] = "User"
+    RecordWithOperator.config[:operator_class_name] = "User"
     @user1 = User.create!(:name => "user1")
     @user2 = User.create!(:name => "user2")
-    @note_created_by_user1 = NoteHasOneMemo.create!(:body => "test", :operator => @user1)
+    RecordWithOperator.operator = @user1
+    @note_created_by_user1 = NoteHasOneMemo.create!(:body => "test")
   end
 
   # has_one Association Test
   # build_association
   def test_build_memo_should_have_operator
-    note = NoteHasOneMemo.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteHasOneMemo.find(@note_created_by_user1.id)
     memo = note.build_memo(:body => "memo")
     assert_equal @user2, memo.operator
   end
 
   # create_association
   def test_create_memo_should_have_operator_and_created_by
-    note = NoteHasOneMemo.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteHasOneMemo.find(@note_created_by_user1.id)
     memo = note.create_memo(:body => "memo")
     assert_equal false, memo.new_record?
     assert_equal @user2, memo.operator
@@ -39,7 +46,8 @@ class RecordWithOperatorHasOneAssociationTest < ActiveSupport::TestCase
 
   # association=
   def test_memo_eql_should_have_operator_and_created_by
-    note = NoteHasOneMemo.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteHasOneMemo.find(@note_created_by_user1.id)
     memo = Memo.new(:body => "memo")
     note.memo = memo
     assert_equal false, memo.new_record?
@@ -49,7 +57,8 @@ class RecordWithOperatorHasOneAssociationTest < ActiveSupport::TestCase
 
   # association
   def test_auto_found_memo_should_have_operator
-    note = NoteHasOneMemo.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteHasOneMemo.find(@note_created_by_user1.id)
     note.create_memo(:body => "memo")
     assert_equal @user2, note.memo(true).operator
   end

data/test/record_with_operator_reflection_test.rb

@@ -5,15 +5,19 @@ end
 
 class NoteForReflectionTest < ActiveRecord::Base
   set_table_name "notes"
+
+  records_with_operator_on :create, :update, :destroy
 end
 
 class CreatorNoteForReflectionTest < ActiveRecord::Base
   set_table_name "creator_notes"
+
+  records_with_operator_on :create
 end
 
 class RecordWithOperatorReflectionTest < ActiveSupport::TestCase
   def setup
-    RecordWithOperator.config[:user_class_name] = "User"
+    RecordWithOperator.config[:operator_class_name] = "User"
     @user1 = User.create!(:name => "user1")
     raise "@user1.id is nil" unless @user1.id
     @note = NoteForReflectionTest.create!(:body => "test", :operator => @user1)

data/test/record_with_operator_test.rb

@@ -11,6 +11,8 @@ class NoteWithUser < ActiveRecord::Base
 
   alias_method :destroy!, :destroy
 
+  records_with_operator_on :create, :update, :destroy
+
   def destroy
     with_transaction_returning_status do
       _run_destroy_callbacks do
@@ -33,21 +35,26 @@ class MemoWithUser < ActiveRecord::Base
   set_table_name "memos"
 
   scope :new_arrivals, {:order => "updated_at desc"}
+
+  records_with_operator_on :create, :update, :destroy
 end
 
 class UpdaterNoteWithUser < ActiveRecord::Base
   set_table_name "updater_notes"
 
+  records_with_operator_on :update
 end
 
 class DeleterNoteWithUser < ActiveRecord::Base
   set_table_name "deleter_notes"
 
+  records_with_operator_on :destroy
+
 end
 
 class RecordWithOperatorTest < ActiveSupport::TestCase
   def setup
-    RecordWithOperator.config[:user_class_name] = "User"
+    RecordWithOperator.config[:operator_class_name] = "User"
     @user1 = User.create!(:name => "user1")
     raise "@user1.id is nil" unless @user1.id
     @user2 = User.create!(:name => "user2")
@@ -104,12 +111,14 @@ class RecordWithOperatorTest < ActiveSupport::TestCase
 
   # find with :for
   def test_note_should_be_found_with_for
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     assert_equal(@user2, note.operator)
   end
 
   def test_note_should_be_found_with_for_through_named_scope
-    note = NoteWithUser.new_arrivals.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.new_arrivals.find(@note_created_by_user1.id)
     assert_equal(@user2, note.operator)
   end
 
@@ -130,7 +139,8 @@ class RecordWithOperatorTest < ActiveSupport::TestCase
   end
 
   def test_note_should_be_updated_with_updated_by
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     note.body = "changed"
     note.save!
     assert_equal(@user2.id, note.updated_by)
@@ -139,7 +149,8 @@ class RecordWithOperatorTest < ActiveSupport::TestCase
   end
 
   def test_note_should_be_destroyed_with_deleted_by
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     note.destroy # logically
     note = NoteWithUser.find(@note_created_by_user1.id)
     raise "not deleted" unless note.deleted?
@@ -155,7 +166,8 @@ class RecordWithOperatorTest < ActiveSupport::TestCase
 
   # has_many Association Test
   def test_builded_memo_should_have_operator
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     memo = note.memos.build(:body => "memo")
     assert_equal @user2, memo.operator
   end
@@ -168,7 +180,8 @@ class RecordWithOperatorTest < ActiveSupport::TestCase
 
 
   def test_created_memo_should_have_operator_and_created_by
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     memo = note.memos.create(:body => "memo")
     assert_equal false, memo.new_record?
     assert_equal @user2, memo.operator
@@ -176,70 +189,82 @@ class RecordWithOperatorTest < ActiveSupport::TestCase
   end
 
   def test_auto_found_memo_should_have_operator
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     note.memos.create!(:body => "memo")
     assert_equal @user2, note.memos(true).first.operator
   end
 
   def test_manualy_found_memo_should_have_operator
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     note.memos.create!(:body => "memo")
     assert_equal @user2, note.memos.find(:first).operator
   end
 
   def test_dynamically_found_memo_should_have_operator
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     note.memos.create!(:body => "memo")
     assert_equal @user2, note.memos.find_by_body("memo").operator
   end
 
   def test_dynamically_found_memos_should_have_operator
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     note.memos.create!(:body => "memo")
     assert note.memos.find_all_by_body("memo").all?{|m| m.operator == @user2}
   end
 
   def test_found_memo_through_named_scope_should_have_operator
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     note.memos.create!(:body => "memo")
     assert_equal @user2, note.memos.new_arrivals.first.operator
   end
 
   def test_dynamically_found_memo_through_named_scope_should_have_operator
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     note.memos.create!(:body => "memo")
     assert_equal @user2, note.memos.new_arrivals.find_by_body("memo").operator
   end
 
   def test_auto_found_memo_first_should_be_nil_if_note_has_no_memo
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     assert_equal nil, note.memos.first
     assert_equal nil, note.memos(true).first
   end
 
   def test_auto_found_memo_last_should_be_nil_if_note_has_no_memo
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     assert_equal nil, note.memos.last
     assert_equal nil, note.memos(true).last
   end
 
   def test_manualy_found_memo_first_should_be_nil_if_note_has_no_memo
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     assert_equal nil, note.memos.find(:first)
   end
 
   def test_manualy_found_memo_last_should_be_nil_if_note_has_no_memo
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     assert_equal nil, note.memos.find(:last)
   end
 
   def test_dynamically_found_memos_first_should_be_nil_if_note_has_no_memo
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     assert_equal nil, note.memos.find_all_by_body("memo").first
   end
 
   def test_found_memo_through_named_scope_last_should_be_nil_if_note_has_no_memo
-    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithUser.find(@note_created_by_user1.id)
     assert_equal nil, note.memos.new_arrivals.last
   end
 end

data/test/record_with_operator_user_class_name_test.rb

@@ -1,9 +1,13 @@
 
 require 'test_helper'
 
+RecordWithOperator.config[:operator_class_name] = "AdminUser"
+
 class NoteWithAdminUser < ActiveRecord::Base
   set_table_name "notes"
 
+  records_with_operator_on :create, :update, :destroy
+
   def destroy_with_deleted_at
     NoteWithAdminUser.update_all("deleted_at = '#{Time.now.to_s(:db)}'", "id = #{self.id}")
   end
@@ -23,7 +27,6 @@ end
 
 class RecordWithOperatorUserClassNameTest < ActiveSupport::TestCase
   def setup
-    RecordWithOperator.config[:user_class_name] = "AdminUser"
     @user1 = AdminUser.create!(:name => "user1")
     @user2 = AdminUser.create!(:name => "user2")
     @note_created_by_user1 = NoteWithAdminUser.create!(:body => "test", :operator => @user1)
@@ -43,12 +46,14 @@ class RecordWithOperatorUserClassNameTest < ActiveSupport::TestCase
   end
 
   def test_note_should_be_found_with_for
-    note = NoteWithAdminUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithAdminUser.find(@note_created_by_user1.id)
     assert_equal(@user2, note.operator)
   end
 
   def test_note_should_be_updated_with_updated_by
-    note = NoteWithAdminUser.find(@note_created_by_user1.id, :for => @user2)
+    RecordWithOperator.operator = @user2
+    note = NoteWithAdminUser.find(@note_created_by_user1.id)
     note.body = "changed"
     note.save!
     assert_equal(@user2.id, note.updated_by)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: record_with_operator
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
-  - 0
   - 1
   - 0
-  version: 0.1.0
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Yasuko Ohba
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-11 00:00:00 +09:00
+date: 2013-08-28 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -24,14 +24,12 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 3
         segments: 
-        - 3
-        - 0
         - 0
-        version: 3.0.0
+        version: "0"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -99,10 +97,8 @@ files:
 - install.rb
 - lib/helpers/migration_helper.rb
 - lib/record_with_operator.rb
-- lib/record_with_operator/associations/extension.rb
-- lib/record_with_operator/extension.rb
-- lib/record_with_operator/relation_methods.rb
-- lib/record_with_operator/utility.rb
+- lib/record_with_operator/operator.rb
+- lib/record_with_operator/recorder.rb
 - lib/record_with_operator/version.rb
 - lib/tasks/record_with_operator_tasks.rake
 - record_with_operator.gemspec

data/lib/record_with_operator/associations/extension.rb

@@ -1,24 +0,0 @@
-require 'record_with_operator/utility'
-
-module RecordWithOperator
-  module Associations
-    module Extension
-      include RecordWithOperator::Utility
-
-      def find(*args)
-        set_operator_to_records(super, @owner.operator)
-      end
-
-      def method_missing(method, *args)
-        set_operator_to_records(super, @owner.operator)
-      end
-
-      protected
-        def construct_scope
-          scoping = super
-          scoping[:find][:for] = @owner.operator
-          scoping
-        end
-    end
-  end
-end

data/lib/record_with_operator/extension.rb

@@ -1,146 +0,0 @@
-require 'helpers/migration_helper.rb'
-
-module RecordWithOperator
-  def self.config
-    @config ||= {:user_class_name => "User", :operator_association_options => {}}
-    @config
-  end
-
-  module Extension
-    extend ActiveSupport::Concern
-
-    included do
-      attr_accessor :operator
-
-      before_create :set_created_by
-      before_save :set_updated_by
-      before_destroy :set_deleted_by
-
-      class << self
-        alias_method_chain :reflections, :operator
-        alias_method_chain :has_many, :operator
-        alias_method_chain :association_accessor_methods, :operator
-        alias_method_chain :association_constructor_method, :operator
-      end
-    end
-
-    module ClassMethods
-      def reflections_with_operator
-        create_operator_associations
-        reflections_without_operator
-      end
-
-      def operator_associations_created?
-        @operator_associations_created
-      end
-
-      def create_operator_associations
-        return if operator_associations_created?
-        @operator_associations_created = true
-
-        if self.table_exists?
-          belongs_to :creator, {:foreign_key => "created_by", :class_name => RecordWithOperator.config[:user_class_name]}.merge(RecordWithOperator.config[:operator_association_options]) if column_names.include?('created_by')
-          belongs_to :updater, {:foreign_key => "updated_by", :class_name => RecordWithOperator.config[:user_class_name]}.merge(RecordWithOperator.config[:operator_association_options]) if column_names.include?('updated_by')
-          belongs_to :deleter, {:foreign_key => "deleted_by", :class_name => RecordWithOperator.config[:user_class_name]}.merge(RecordWithOperator.config[:operator_association_options]) if column_names.include?('deleted_by')
-        end
-      end
-
-      def has_many_with_operator(*args, &extension)
-        options = args.extract_options!
-        # add AssociationWithOprator to :extend
-        if options[:extend]
-          options[:extend] = [options[:extend]] unless options[:extend].kind_of? Array
-          options[:extend] << RecordWithOperator::Associations::Extension
-        else
-          options[:extend] = RecordWithOperator::Associations::Extension
-        end
-        # add :set_operator to :before_add
-        if options[:before_add]
-          options[:before_add] = [options[:before_add]] unless options[:before_add].kind_of? Array
-          options[:before_add] << :set_operator
-        else
-          options[:before_add] = :set_operator
-        end
-        args << options
-        has_many_without_operator(*args, &extension)
-      end
-
-      private
-      # define_method association, association= ...
-      def association_accessor_methods_with_operator(reflection, association_proxy_class)
-        association_accessor_methods_without_operator(reflection, association_proxy_class)
-        define_method("#{reflection.name}_with_operator") do |*params|
-          r = send("#{reflection.name}_without_operator", *params)
-          r.operator ||= self.operator if r && r.respond_to?(:operator=)
-          r
-        end
-        alias_method_chain "#{reflection.name}".to_sym, :operator
-
-        define_method("#{reflection.name}_with_operator=") do |new_value|
-          new_value.operator ||= self.operator if new_value.respond_to?(:operator=)
-          send("#{reflection.name}_without_operator=", new_value)
-        end
-        alias_method_chain "#{reflection.name}=".to_sym, :operator
-      end
-
-      # define_method build_association, create_association ...
-      def association_constructor_method_with_operator(constructor, reflection, association_proxy_class)
-        association_constructor_method_without_operator(constructor, reflection, association_proxy_class)
-        define_method("#{constructor}_#{reflection.name}_with_operator") do |*params|
-          options = { :operator => self.operator }
-          params.empty? ? params[0] = options : params.first.merge!(options)
-          self.send("#{constructor}_#{reflection.name}_without_operator", *params)
-        end
-        alias_method_chain "#{constructor}_#{reflection.name}".to_sym, :operator
-      end
-    end
-
-    module InstanceMethods
-      def respond_to?(name, priv=false)
-        case name.to_sym
-        when :creator
-          respond_to? :created_by
-        when :updater
-          respond_to? :updated_by
-        when :deleter
-          respond_to? :deleted_by
-        else
-          super
-        end
-      end
-
-      private
-      def set_operator(child)
-        child.operator ||= self.operator
-      end
-
-      def method_missing(method, *args)
-        return super unless respond_to?(method)
-        case method.to_sym
-        when :creator, :updater, :deleter
-          self.class.create_operator_associations
-          send(method, *args)
-        else
-          super
-        end
-      end
-
-      def set_created_by
-        return unless respond_to?(:created_by=) && operator
-        self.created_by = operator.id
-      end
-
-      def set_updated_by
-        return unless respond_to?(:updated_by=) && operator && changed? # no use setting updating_by when it's not changed
-        self.updated_by = operator.id
-      end
-
-      def set_deleted_by
-        return unless self.class.column_names.include?("deleted_by") && operator
-        return if frozen?
-        self.class.update_all("deleted_by = #{operator.id}", ["#{self.class.primary_key} = ?", id])
-        self.deleted_by = operator.id
-      end
-    end
-  end
-end

data/lib/record_with_operator/relation_methods.rb

@@ -1,66 +0,0 @@
-require 'record_with_operator/utility'
-
-module RecordWithOperator
-  module RelationMethods
-    extend ActiveSupport::Concern
-
-    included do
-      attr_accessor :operator
-    end
-
-    module InstanceMethods
-      include RecordWithOperator::Utility
-
-      def merge(r)
-        merged_relation = super
-        merged_relation.operator ||= r.operator
-        merged_relation
-      end
-
-      def except(*skips)
-        result = super
-        result.operator ||= operator
-        result
-      end
-
-      def only(*onlies)
-        result = super
-        result.operator ||= operator
-        result
-      end
-
-      def for(operator)
-        relation = clone
-        relation.operator ||= operator
-        relation
-      end
-
-      def apply_finder_options(options)
-        finders = options.dup
-        operator = finders.delete(:for)
-        relation = super(finders)
-        relation.for(operator)
-      end
-
-      def find(*args)
-        set_operator_to_records(super, operator)
-      end
-
-      def first(*args)
-        set_operator_to_records(super, operator)
-      end
-
-      def last(*args)
-        set_operator_to_records(super, operator)
-      end
-
-      def all(*args)
-        set_operator_to_records(super, operator)
-      end
-
-      def to_a
-        set_operator_to_records(super, operator)
-      end
-    end
-  end
-end

data/lib/record_with_operator/utility.rb

@@ -1,19 +0,0 @@
-module RecordWithOperator
-  module Utility
-    private
-      def set_operator_to_records(records, operator)
-        return records unless operator
-
-        unless ActiveRecord::Relation === records
-          if records.respond_to?(:operator=)
-            records.operator = operator
-          elsif Array === records
-            records.each do |record|
-              record.operator = operator if record.respond_to?(:operator=)
-            end
-          end
-        end
-        records
-      end
-  end
-end