record_with_operator 0.0.22 → 0.1.0

data/.gitignore

@@ -3,3 +3,4 @@
 Gemfile.lock
 pkg/*
 .idea/*
+test/debug.log

data/README.rdoc

@@ -16,7 +16,12 @@ This plugin assumes that the logical deletion is kicked by record.destory.
 
 == Installation
 
-  > ./script/plugin install git://github.com/bbuchalter/record_with_operator.git
+  > ./script/plugin install git://github.com/nay/record_with_operator.git
+
+Or
+
+  ## Gemfile for Rails3
+  gem 'record_with_operator'
 
 == Example
 

data/Rakefile

@@ -5,15 +5,6 @@ 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
 
@@ -33,38 +24,3 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   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

@@ -1 +1 @@
-ActiveRecord::Base.instance_eval{include RecordWithOperator} unless ActiveRecord::Base.include?(RecordWithOperator)
+require 'record_with_operator'

data/lib/record_with_operator/associations/extension.rb

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,19 @@
+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

data/lib/record_with_operator/version.rb

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

data/lib/record_with_operator.rb

@@ -1,167 +1,6 @@
-module RecordWithOperator
-  require 'helpers/migration_helper.rb'
-  
-  def self.config
-    @config ||= {:user_class_name => "User", :operator_association_options => {}}
-    @config
-  end
+require 'record_with_operator/relation_methods'
+require 'record_with_operator/associations/extension'
+require 'record_with_operator/extension'
 
-  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
+ActiveRecord::Base.send :include, RecordWithOperator::Extension unless ActiveRecord::Base.include?(RecordWithOperator::Extension)
+ActiveRecord::Relation.send :include, RecordWithOperator::RelationMethods unless ActiveRecord::Relation.include?(RecordWithOperator::RelationMethods)

data/record_with_operator.gemspec

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# -*- mode: ruby; coding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
 require "record_with_operator/version"
 
@@ -8,14 +8,22 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Yasuko Ohba"]
   s.email       = ["y.ohba@everyleaf.com"]
-  s.homepage    = ""
+  s.homepage    = "https://github.com/nay/record_with_operator"
   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.description = %q{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.}
 
   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.extra_rdoc_files = ['README.rdoc']
   s.require_paths = ["lib"]
+
+  s.licenses = ["MIT"]
+
+  s.add_dependency 'activerecord', ['~> 3.0.0']
+  s.add_development_dependency 'bundler', ['>= 1.0.0']
+  s.add_development_dependency 'rake', ['>= 0.8.7']
+  s.add_development_dependency 'sqlite3', ['>= 0']
 end

data/test/database.yml

@@ -1,18 +1,18 @@
-sqlite:
-  :adapter: sqlite
-  :dbfile: record_with_operator_plugin.sqlite.db
+#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
+  :database: ':memory:'
+#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_has_many_dependent_test.rb

@@ -7,8 +7,10 @@ class NoteWithUserWithDependency < ActiveRecord::Base
   set_table_name "notes"
   has_many :memos, :class_name => "MemoWithUser", :foreign_key => "note_id", :dependent => :destroy
 
-  protected
-  def before_destroy
+  before_destroy :check_operator
+
+  private
+  def check_operator
     raise "can't destroy without operator" unless operator
   end
 end
@@ -16,8 +18,10 @@ end
 class MemoWithUserWithDependency < ActiveRecord::Base
   set_table_name "memos"
 
-  protected
-  def before_destroy
+  before_destroy :check_operator
+
+  private
+  def check_operator
     raise "can't destroy without operator" unless operator
   end
 end

data/test/record_with_operator_test.rb

@@ -7,27 +7,21 @@ 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"}
+  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]
+  alias_method :destroy!, :destroy
+
+  def destroy
+    with_transaction_returning_status do
+      _run_destroy_callbacks do
+        self.class.update_all({:deleted_at => Time.now}, {self.class.primary_key => self.id})
+      end
     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
+    !self.deleted_at.nil?
   end
 end
 
@@ -38,7 +32,7 @@ end
 class MemoWithUser < ActiveRecord::Base
   set_table_name "memos"
 
-  named_scope :new_arrivals, {:order => "updated_at desc"}
+  scope :new_arrivals, {:order => "updated_at desc"}
 end
 
 class UpdaterNoteWithUser < ActiveRecord::Base

data/test/test_helper.rb

@@ -1,15 +1,15 @@
-require 'rubygems'
-require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+$:.push File.expand_path('../../', __FILE__)
+
+require 'logger'
 require 'test/unit'
+require 'active_record'
 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'])
+ActiveRecord::Base.establish_connection(config['sqlite3'])
 
 load(File.dirname(__FILE__) + "/schema.rb")