record_with_operator 0.0.22

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in record_with_operator.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,67 @@
+= RecordWithOperator
+
+== 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.
+
+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.
+
+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
+
+  > ./script/plugin install git://github.com/bbuchalter/record_with_operator.git
+
+== Example
+
+Create Note table with nessisary attributes:
+class CreateNotes < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :body
+      t.operator_stamps  #creates attributes for created_by, updated_by, deleted_by
+      t.timestamps
+    end
+  end
+
+
+Create a new note object with current_user:
+
+ note = Note.create(:body => "This is my first note.", :operator => current_user)
+ # note.operator will be current_user
+ # note.created_by will be current_user.id
+
+Get note objects with current_user:
+
+ notes = Note.find(:all, :for => current_user)
+ # 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.comments.create!(:body => params[:comment_body])
+ # comment's operator will be automatically set and used as created_by
+
+== Configuration
+
+You can change the operator's class name by setting RecordWithOperator.config[: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.
+For example, you can write the code under config/initializers.
+
+  RecordWithOperator.config[:user_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,
+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

data/Rakefile

@@ -0,0 +1,70 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+NAME = "record_with_operator"
+AUTHOR = "Yasuko Ohba"
+EMAIL = "y.ohba@everyleaf.com"
+DESCRIPTION = "Rails plugin to set created_by, updated_by, deleted_by to ActiveRecord objects. Supports associations."
+GITHUB_PROJECT = "record_with_operator"
+HOMEPAGE = "http://github.com/nay/#{GITHUB_PROJECT}/tree"
+BIN_FILES = %w( )
+CLEAN.include ['pkg']
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the record_with_operator plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  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
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = VER
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.rdoc", "MIT-LICENSE"]
+  s.rdoc_options += ['--line-numbers', '--inline-source']
+  s.summary = DESCRIPTION
+  s.description = DESCRIPTION
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.executables = BIN_FILES
+  s.bindir = "bin"
+  s.require_path = "lib"
+  s.test_files = Dir["test/*.{rb,yml}"]
+
+  s.add_dependency('activerecord', '>=2.2.0')
+  
+  s.files = %w(README.rdoc Rakefile MIT-LICENSE) +
+    %w(install.rb uninstall.rb) +
+    Dir.glob("{bin,doc,lib,tasks,rails}/**/*")
+
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true
+  p.gem_spec = spec
+end
+
+desc 'Update gem spec'
+task :gemspec do
+  open("#{NAME}.gemspec", "w").write spec.to_ruby
+end

data/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.instance_eval{include RecordWithOperator} unless ActiveRecord::Base.include?(RecordWithOperator)

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/association_with_operator.rb

@@ -0,0 +1,34 @@
+module AssociationWithOperator
+
+  def find(*args)
+    results = super
+    if results.kind_of? Array
+      results.each{|r| r.operator = proxy_owner.operator}
+    else
+      results.operator = proxy_owner.operator if results
+    end
+    results
+  end
+
+
+  def method_missing(method, *args)
+    results = super
+    unless ActiveRecord::NamedScope::Scope === results
+      if results.respond_to?(:operator=)
+        results.operator= proxy_owner.operator
+      elsif results.kind_of? Array
+        results.each{|r| r.operator = proxy_owner.operator if r.respond_to?(:operator=)}
+      end
+    end
+    results
+  end
+
+  def construct_join_attributes(associate)
+    join_attributes = super
+    if @owner.operator || associate.operator
+      join_attributes[:operator] ||= @owner.operator
+      join_attributes[:operator] ||= associate.operator
+    end
+    join_attributes
+  end
+end

data/lib/helpers/migration_helper.rb

@@ -0,0 +1,8 @@
+require 'active_record/connection_adapters/abstract/schema_definitions'
+ActiveRecord::ConnectionAdapters::TableDefinition.class_eval do
+  def operator_stamps
+    column(:created_by, :integer)
+    column(:updated_by, :integer)
+    column(:deleted_by, :integer)
+  end
+end

data/lib/record_with_operator.rb

@@ -0,0 +1,167 @@
+module RecordWithOperator
+  require 'helpers/migration_helper.rb'
+  
+  def self.config
+    @config ||= {:user_class_name => "User", :operator_association_options => {}}
+    @config
+  end
+
+  attr_accessor :operator
+
+  def self.included(base)
+    class << base
+      def reflections_with_operator
+        create_operator_associations
+        reflections_without_operator
+      end
+      alias_method_chain :reflections, :operator
+
+      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] << AssociationWithOperator
+        else
+          options[:extend] = AssociationWithOperator
+        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
+      alias_method_chain :has_many, :operator
+
+      def find_with_for(*args)
+        options = args.extract_options!
+        operator = options.delete(:for)
+        args << options
+        results = find_without_for(*args)
+        if operator
+          if results.kind_of? Array
+            results.each{|r| r.operator = operator}
+          elsif results
+            results.operator = operator
+          end
+        end
+        results
+      end
+
+      alias_method_chain :find, :for
+
+#       No longer valid in Rails 3
+#      def validate_find_options_with_for(options)
+#        if options
+#          options = options.dup
+#          options.delete(:for)
+#        end
+#        validate_find_options_without_for(options)
+#      end
+#
+#      alias_method :validate_find_options, :validate_find_options_with_for
+
+      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
+      alias_method_chain :association_accessor_methods, :operator
+
+      # 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
+      alias_method_chain :association_constructor_method, :operator
+    end
+
+    base.before_create :set_created_by
+    base.before_save :set_updated_by
+    base.before_destroy :set_deleted_by
+
+  end
+
+  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

data/lib/record_with_operator/version.rb

@@ -0,0 +1,3 @@
+module RecordWithOperator
+  VERSION = "0.0.22"
+end

data/lib/tasks/record_with_operator_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :record_with_operator do
+#   # Task goes here
+# end

data/record_with_operator.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "record_with_operator/version"
+
+Gem::Specification.new do |s|
+  s.name        = "record_with_operator"
+  s.version     = RecordWithOperator::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Yasuko Ohba"]
+  s.email       = ["y.ohba@everyleaf.com"]
+  s.homepage    = ""
+  s.summary     = %q{Rails plugin to set created_by, updated_by, deleted_by to ActiveRecord objects. Supports associations.}
+  s.description = %q{Rails plugin to set created_by, updated_by, deleted_by to ActiveRecord objects. Supports associations.}
+
+  s.rubyforge_project = "record_with_operator"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/record_with_operator/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/record_with_operator/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in record_with_operator.gemspec
+gemspec

data/record_with_operator/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/record_with_operator/lib/record_with_operator.rb

@@ -0,0 +1,3 @@
+module RecordWithOperator
+  # Your code goes here...
+end

data/record_with_operator/lib/record_with_operator/version.rb

@@ -0,0 +1,3 @@
+module RecordWithOperator
+  VERSION = "0.0.1"
+end

data/record_with_operator/record_with_operator.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "record_with_operator/version"
+
+Gem::Specification.new do |s|
+  s.name        = "record_with_operator"
+  s.version     = RecordWithOperator::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["TODO: Write your name"]
+  s.email       = ["TODO: Write your email address"]
+  s.homepage    = ""
+  s.summary     = %q{TODO: Write a gem summary}
+  s.description = %q{TODO: Write a gem description}
+
+  s.rubyforge_project = "record_with_operator"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/database.yml

@@ -0,0 +1,18 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: record_with_operator_plugin.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: record_with_operator_plugin.sqlite3.db
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: record_with_operator_plugin_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username:
+  :password:
+  :database: record_with_operator_plugin_test

data/test/record_with_operator_belongs_to_association_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+class User < ActiveRecord::Base
+end
+
+class NoteBelongsToMemo < ActiveRecord::Base
+  set_table_name "notes"
+  belongs_to :memo
+end
+
+class Memo < ActiveRecord::Base
+  set_table_name "memos"
+end
+
+class RecordWithOperatorBelongsTo < ActiveSupport::TestCase
+  def setup
+    RecordWithOperator.config[:user_class_name] = "User"
+    @user1 = User.create!(:name => "user1")
+    @user2 = User.create!(:name => "user2")
+    @note_created_by_user1 = NoteBelongsToMemo.create!(:body => "test", :operator => @user1)
+  end
+
+  # belongs_to Association Test
+  # build_association
+  def test_build_memo_should_have_operator
+    note = NoteBelongsToMemo.find(@note_created_by_user1.id, :for => @user2)
+    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)
+    memo = note.create_memo(:body => "memo")
+    assert_equal false, memo.new_record?
+    assert_equal @user2, memo.operator
+    assert_equal @user2.id, memo.created_by
+  end
+
+  # association=
+  def test_memo_eql_should_have_operator_and_created_by
+    note = NoteBelongsToMemo.find(@note_created_by_user1.id, :for => @user2)
+    memo = Memo.new(:body => "memo")
+    note.memo = memo # not save
+    assert_equal @user2, memo.operator
+  end
+
+  # association
+  def test_auto_found_memo_should_have_operator
+    note = NoteBelongsToMemo.find(@note_created_by_user1.id, :for => @user2)
+    note.create_memo(:body => "memo")
+    assert_equal @user2, note.memo(true).operator
+  end
+
+  # association.nil?
+  def test_memo_nil_should_be_false_if_note_belongs_to_memo
+    note = NoteBelongsToMemo.find(@note_created_by_user1.id)
+    note.create_memo(:body => "memo")
+    assert !note.memo.nil?
+  end
+
+  # association.nil?
+  def test_memo_nil_should_be_true_if_note_is_independent
+    note = NoteBelongsToMemo.find(@note_created_by_user1.id)
+    assert note.memo.nil?
+  end
+end

data/test/record_with_operator_has_many_dependent_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class User < ActiveRecord::Base
+end
+
+class NoteWithUserWithDependency < ActiveRecord::Base
+  set_table_name "notes"
+  has_many :memos, :class_name => "MemoWithUser", :foreign_key => "note_id", :dependent => :destroy
+
+  protected
+  def before_destroy
+    raise "can't destroy without operator" unless operator
+  end
+end
+
+class MemoWithUserWithDependency < ActiveRecord::Base
+  set_table_name "memos"
+
+  protected
+  def before_destroy
+    raise "can't destroy without operator" unless operator
+  end
+end
+
+
+class RecordWithOperatorHasManyDependentTest < ActiveSupport::TestCase
+  def setup
+    RecordWithOperator.config[:user_class_name] = "User"
+    @user1 = User.create!(:name => "user1")
+    raise "@user1.id is nil" unless @user1.id
+    @user2 = User.create!(:name => "user2")
+    raise "@user2.id is nil" unless @user2.id
+    @note_created_by_user1 = NoteWithUserWithDependency.create!(:body => "test", :operator => @user1)
+    @note_created_by_user1.memos.create!
+    @note_created_by_user1.memos.create!
+    @note_created_by_user1.reload
+  end
+
+  def test_memos_should_be_destroyed_when_note_is_destroyed
+    @note_created_by_user1.destroy
+    assert_nil NoteWithUserWithDependency.find_by_id(@note_created_by_user1.id)
+    assert MemoWithUserWithDependency.find_all_by_note_id(@note_created_by_user1.id).empty?
+  end
+
+end

data/test/record_with_operator_has_one_association_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class User < ActiveRecord::Base
+end
+
+class NoteHasOneMemo < ActiveRecord::Base
+  set_table_name "notes"
+  has_one :memo, :class_name => "Memo", :foreign_key => "note_id"
+end
+
+class Memo < ActiveRecord::Base
+  set_table_name "memos"
+end
+
+class RecordWithOperatorHasOneAssociationTest < ActiveSupport::TestCase
+  def setup
+    RecordWithOperator.config[:user_class_name] = "User"
+    @user1 = User.create!(:name => "user1")
+    @user2 = User.create!(:name => "user2")
+    @note_created_by_user1 = NoteHasOneMemo.create!(:body => "test", :operator => @user1)
+  end
+
+  # has_one Association Test
+  # build_association
+  def test_build_memo_should_have_operator
+    note = NoteHasOneMemo.find(@note_created_by_user1.id, :for => @user2)
+    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)
+    memo = note.create_memo(:body => "memo")
+    assert_equal false, memo.new_record?
+    assert_equal @user2, memo.operator
+    assert_equal @user2.id, memo.created_by
+  end
+
+  # association=
+  def test_memo_eql_should_have_operator_and_created_by
+    note = NoteHasOneMemo.find(@note_created_by_user1.id, :for => @user2)
+    memo = Memo.new(:body => "memo")
+    note.memo = memo
+    assert_equal false, memo.new_record?
+    assert_equal @user2, memo.operator
+    assert_equal @user2.id, memo.created_by
+  end
+
+  # association
+  def test_auto_found_memo_should_have_operator
+    note = NoteHasOneMemo.find(@note_created_by_user1.id, :for => @user2)
+    note.create_memo(:body => "memo")
+    assert_equal @user2, note.memo(true).operator
+  end
+
+  # association.nil?
+  def test_memo_nil_should_be_false_if_note_has_memo
+    note = NoteHasOneMemo.find(@note_created_by_user1.id)
+    note.create_memo(:body => "memo")
+    assert !note.memo.nil?
+  end
+
+  # association.nil?
+  def test_memo_nil_should_be_true_if_note_has_no_memo
+    note = NoteHasOneMemo.find(@note_created_by_user1.id)
+    assert note.memo.nil?
+  end
+end

data/test/record_with_operator_reflection_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+class User < ActiveRecord::Base
+end
+
+class NoteForReflectionTest < ActiveRecord::Base
+  set_table_name "notes"
+end
+
+class CreatorNoteForReflectionTest < ActiveRecord::Base
+  set_table_name "creator_notes"
+end
+
+class RecordWithOperatorReflectionTest < ActiveSupport::TestCase
+  def setup
+    RecordWithOperator.config[:user_class_name] = "User"
+    @user1 = User.create!(:name => "user1")
+    raise "@user1.id is nil" unless @user1.id
+    @note = NoteForReflectionTest.create!(:body => "test", :operator => @user1)
+
+    @creator_note = CreatorNoteForReflectionTest.create!(:body => "test", :operator => @user1)
+  end
+
+  def test_include
+    assert NoteForReflectionTest.find(:all, :include => [:creator, :updater])
+  end
+
+  def test_joins
+    assert NoteForReflectionTest.find(:all, :joins => [:creator, :updater])
+  end
+
+  def test_include_missing_association
+    assert_raise(ActiveRecord::ConfigurationError) { CreatorNoteForReflectionTest.find(:all, :include => [:updater]) }
+  end
+
+  def test_joins_missing_association
+    assert_raise(ActiveRecord::ConfigurationError) { CreatorNoteForReflectionTest.find(:all, :joins => [:updater]) }
+  end
+end

data/test/record_with_operator_test.rb

@@ -0,0 +1,251 @@
+require 'test_helper'
+
+class User < ActiveRecord::Base
+end
+
+class NoteWithUser < ActiveRecord::Base
+  set_table_name "notes"
+  has_many :memos, :class_name => "MemoWithUser", :foreign_key => "note_id"
+
+  named_scope :new_arrivals, {:order => "updated_at desc"}
+
+  def destroy_without_callbacks
+    unless new_record?
+      self.class.update_all self.class.send(:sanitize_sql, ["deleted_at = ?", (self.deleted_at = default_timezone == :utc ? Time.now.utc : Time.now)]), ["#{self.class.primary_key} = ?", id]
+    end
+    freeze
+  end
+
+  def destroy_with_callbacks!
+    return false if callback(:before_destroy) == false
+    result = destroy_without_callbacks!
+    callback(:after_destroy)
+    result
+  end
+  def destroy!
+    transaction { destroy_with_callbacks! }
+  end
+
+  def deleted?
+    self.deleted_at.to_time <= Time.now
+  end
+end
+
+class SimpleNoteWithUser < ActiveRecord::Base
+  set_table_name "simple_notes"
+end
+
+class MemoWithUser < ActiveRecord::Base
+  set_table_name "memos"
+
+  named_scope :new_arrivals, {:order => "updated_at desc"}
+end
+
+class UpdaterNoteWithUser < ActiveRecord::Base
+  set_table_name "updater_notes"
+
+end
+
+class DeleterNoteWithUser < ActiveRecord::Base
+  set_table_name "deleter_notes"
+
+end
+
+class RecordWithOperatorTest < ActiveSupport::TestCase
+  def setup
+    RecordWithOperator.config[:user_class_name] = "User"
+    @user1 = User.create!(:name => "user1")
+    raise "@user1.id is nil" unless @user1.id
+    @user2 = User.create!(:name => "user2")
+    raise "@user2.id is nil" unless @user2.id
+    @note_created_by_user1 = NoteWithUser.create!(:body => "test", :operator => @user1)
+  end
+
+  # creator/updater/deleter association operation
+  def test_note_should_be_respond_to_creator
+    assert NoteWithUser.new.respond_to? :creator
+  end
+
+  def test_simple_note_should_not_be_respond_to_creator
+    assert_equal false, SimpleNoteWithUser.new.respond_to?(:creator)
+  end
+
+  def test_note_should_be_respond_to_updater
+    assert NoteWithUser.new.respond_to? :updater
+  end
+
+  def test_simple_note_should_not_be_respond_to_updater
+    assert_equal false, SimpleNoteWithUser.new.respond_to?(:updater)
+  end
+
+  def test_note_should_be_respond_to_deleter
+    assert NoteWithUser.new.respond_to? :deleter
+  end
+
+  def test_simple_note_should_not_be_respond_to_deleter
+    assert_equal false, SimpleNoteWithUser.new.respond_to?(:deleter)
+  end
+
+  # test updater without creater, deleter
+  def test_updater_note_should_not_be_respond_to_creater
+    assert_equal false, UpdaterNoteWithUser.new.respond_to?(:creater)
+  end
+  def test_updater_note_should_be_respond_to_updater
+    assert UpdaterNoteWithUser.new.respond_to? :updater
+  end
+  def test_updater_note_should_not_be_respond_to_deleter
+    assert_equal false, UpdaterNoteWithUser.new.respond_to?(:deleter)
+  end
+
+  # test deleter without create, updater
+  def test_deleter_note_should_not_be_respond_to_creater
+    assert_equal false, DeleterNoteWithUser.new.respond_to?(:creater)
+  end
+  def test_deleter_note_should_not_be_respond_to_updater
+    assert_equal false, DeleterNoteWithUser.new.respond_to?(:updater)
+  end
+  def test_deleter_note_should_be_respond_to_deleter
+    assert DeleterNoteWithUser.new.respond_to?(:deleter)
+  end
+
+  # find with :for
+  def test_note_should_be_found_with_for
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    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)
+    assert_equal(@user2, note.operator)
+  end
+
+  # save or destory with xxxx_by and can get as a creator/updator/deleter
+
+  def test_note_should_be_created_with_operator
+    assert_equal @user1, @note_created_by_user1.operator
+  end
+
+  def test_note_should_be_created_with_created_by_and_updated_by
+    assert_equal @user1.id, @note_created_by_user1.created_by
+    assert_equal @user1.id, @note_created_by_user1.updated_by
+    @note_created_by_user1.reload
+    assert_equal @user1.id, @note_created_by_user1.created_by
+    assert_equal @user1.id, @note_created_by_user1.updated_by
+    assert_equal @user1, @note_created_by_user1.creator
+    assert_equal @user1, @note_created_by_user1.updater
+  end
+
+  def test_note_should_be_updated_with_updated_by
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    note.body = "changed"
+    note.save!
+    assert_equal(@user2.id, note.updated_by)
+    note.reload
+    assert_equal(@user2.id, note.updated_by)
+  end
+
+  def test_note_should_be_destroyed_with_deleted_by
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    note.destroy # logically
+    note = NoteWithUser.find(@note_created_by_user1.id)
+    raise "not deleted" unless note.deleted?
+    assert_equal @user2.id, note.deleted_by
+  end
+
+  # reload
+  def test_reload_should_not_change_operator
+    @note_created_by_user1.reload
+    assert_equal @user1, @note_created_by_user1.operator
+  end
+  
+
+  # has_many Association Test
+  def test_builded_memo_should_have_operator
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    memo = note.memos.build(:body => "memo")
+    assert_equal @user2, memo.operator
+  end
+
+  def test_builded_memo_should_have_own_set_operator
+    note = NoteWithUser.find(@note_created_by_user1.id)
+    memo = note.memos.build(:body => "memo", :operator => @user2)
+    assert_equal @user2, memo.operator
+  end
+
+
+  def test_created_memo_should_have_operator_and_created_by
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    memo = note.memos.create(:body => "memo")
+    assert_equal false, memo.new_record?
+    assert_equal @user2, memo.operator
+    assert_equal @user2.id, memo.created_by
+  end
+
+  def test_auto_found_memo_should_have_operator
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    assert_equal nil, note.memos.new_arrivals.last
+  end
+end

data/test/record_with_operator_user_class_name_test.rb

@@ -0,0 +1,59 @@
+
+require 'test_helper'
+
+class NoteWithAdminUser < ActiveRecord::Base
+  set_table_name "notes"
+
+  def destroy_with_deleted_at
+    NoteWithAdminUser.update_all("deleted_at = '#{Time.now.to_s(:db)}'", "id = #{self.id}")
+  end
+  alias_method_chain :destroy, :deleted_at
+  def destory!
+    destory_without_deleted_at
+  end
+
+  def deleted?
+    self.deleted_at <= Time.now
+  end
+end
+
+class AdminUser < ActiveRecord::Base
+  set_table_name "users"
+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)
+  end
+
+  def test_note_should_be_created_with_operator
+    assert_equal @user1, @note_created_by_user1.operator
+  end
+
+  def test_note_should_be_created_with_created_by_and_updated_by
+    assert_equal @user1.id, @note_created_by_user1.created_by
+    assert_equal @user1.id, @note_created_by_user1.updated_by
+    @note_created_by_user1.reload
+    assert_equal @user1.id, @note_created_by_user1.created_by
+    assert_equal @user1.id, @note_created_by_user1.updated_by
+    assert @note_created_by_user1.creator.kind_of?(AdminUser)
+  end
+
+  def test_note_should_be_found_with_for
+    note = NoteWithAdminUser.find(@note_created_by_user1.id, :for => @user2)
+    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)
+    note.body = "changed"
+    note.save!
+    assert_equal(@user2.id, note.updated_by)
+    note.reload
+    assert_equal(@user2.id, note.updated_by)
+  end
+
+end

data/test/schema.rb

@@ -0,0 +1,50 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table :simple_notes, :force => true do |t|
+    t.column :body, :text
+  end
+
+  create_table :creator_notes, :force => true do |t|
+    t.column :body, :text
+    t.column :created_by, :integer
+    t.column :created_at, :datetime
+  end
+
+  create_table :updater_notes, :force => true do |t|
+    t.column :body, :text
+    t.column :updated_by, :integer
+    t.column :updated_at, :datetime
+  end
+
+  create_table :deleter_notes, :force => true do |t|
+    t.column :body, :text
+    t.column :deleted_by, :integer
+    t.column :deleted_at, :datetime
+  end
+
+  create_table :notes, :force => true do |t|
+    t.column :memo_id, :integer
+    t.column :body, :text
+    t.column :created_by, :integer
+    t.column :created_at, :datetime
+    t.column :updated_by, :integer
+    t.column :updated_at, :datetime
+    t.column :deleted_by, :integer
+    t.column :deleted_at, :datetime
+  end
+
+  create_table :memos, :force => true do |t|
+    t.column :note_id, :integer
+    t.column :body, :text
+    t.column :created_by, :integer
+    t.column :created_at, :datetime
+    t.column :updated_by, :integer
+    t.column :updated_at, :datetime
+    t.column :deleted_by, :integer
+    t.column :deleted_at, :datetime
+  end
+
+  create_table :users, :force => true do |t|
+    t.column :name, :string
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+
+require 'lib/association_with_operator'
+require 'lib/record_with_operator'
+require 'init'
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config['mysql'])
+
+load(File.dirname(__FILE__) + "/schema.rb")

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: record_with_operator
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.22
+platform: ruby
+authors: 
+- Yasuko Ohba
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-13 00:00:00 Z
+dependencies: []
+
+description: Rails plugin to set created_by, updated_by, deleted_by to ActiveRecord objects. Supports associations.
+email: 
+- y.ohba@everyleaf.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .idea/inspectionProfiles/Project_Default.xml
+- .idea/inspectionProfiles/profiles_settings.xml
+- .idea/workspace.xml
+- Gemfile
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- init.rb
+- install.rb
+- lib/association_with_operator.rb
+- lib/helpers/migration_helper.rb
+- lib/record_with_operator.rb
+- lib/record_with_operator/version.rb
+- lib/tasks/record_with_operator_tasks.rake
+- record_with_operator.gemspec
+- record_with_operator/.gitignore
+- record_with_operator/Gemfile
+- record_with_operator/Rakefile
+- record_with_operator/lib/record_with_operator.rb
+- record_with_operator/lib/record_with_operator/version.rb
+- record_with_operator/record_with_operator.gemspec
+- test/database.yml
+- test/record_with_operator_belongs_to_association_test.rb
+- test/record_with_operator_has_many_dependent_test.rb
+- test/record_with_operator_has_one_association_test.rb
+- test/record_with_operator_reflection_test.rb
+- test/record_with_operator_test.rb
+- test/record_with_operator_user_class_name_test.rb
+- test/schema.rb
+- test/test_helper.rb
+- uninstall.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: record_with_operator
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Rails plugin to set created_by, updated_by, deleted_by to ActiveRecord objects. Supports associations.
+test_files: []
+