millstone 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+.rvmrc
+.bundle
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=d

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Yoshikazu Ozawa
+
+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.md

@@ -0,0 +1,88 @@
+# Millstone
+
+ActiveRecord plugin which hides records instead of deleting them for Rails3
+
+Millstone is extending ActiveRecord::Relation
+
+## Credits
+
+This plugin was inspired by [rails3_acts_as_paranoid](https://github.com/goncalossilva/rails3_acts_as_paranoid) and [acts_as_paranoid](http://github.com/technoweenie/acts_as_paranoid).
+
+## Usage
+
+    class User < ActiveRecord::Base
+      millstone
+    end
+
+### Options
+
+- :column => 'deleted_at'
+- :type => 'time'
+
+### Filtering
+
+    User.all          # retrieves the non-deleted records
+    User.only_deleted # retrieves the deleted records
+    User.with_deleted # retrieves all records, deleted or not
+
+### Real deletion
+
+    user.destroy!
+    user.delete_all!(conditions)
+
+### Validation
+
+    class User < ActiveRecord::Base
+      acts_as_paranoid
+      validates_uniqueness_of :name
+    end
+
+    User.create(:name => 'foo').destroy
+    User.new(:name => 'foo').valid? #=> true
+
+
+    class User < ActiveRecord::Base
+      acts_as_paranoid
+      validates_uniqueness_of_with_deleted :name
+    end
+
+    User.create(:name => 'foo').destroy
+    User.new(:name => 'foo').valid? #=> false
+
+### Status
+
+    user = User.create(:name => 'foo')
+    user.deleted? #=> false
+    user.destroy
+    User.with_deleted.first.deleted? #=> true
+
+### Association options
+
+    class Parent < ActiveRecord::Base
+      acts_as_pranoid
+      has_many :children
+    end
+
+    class Child < ActiveRecord::Base
+      acts_as_paranoid
+      belongs_to :parent
+    end
+
+    parent = Parent.create(:name => "foo")
+    child = parent.children.create!(:name => "bar")
+    parent.destroy
+    child.parent # => nil
+  
+
+    class Child < ActiveRecord::Base
+      acts_as_paranoid
+      belongs_to :parent, :with_deleted => true
+    end
+ 
+    parent = Parent.create(:name => "foo")
+    child = parent.children.create!(:name => "bar")
+    parent.destroy
+    child.parent #=> #<Parent ... deleted_at: deleted_time>
+    child.parent.deleted? #=> true
+
+Copyright © 2011 Yoshikazu Ozawa, released under the MIT license

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+

data/lib/millstone/active_record/associations/belongs_to_association.rb

@@ -0,0 +1,14 @@
+module Millstone
+  module ActiveRecord
+    module Associations
+      class BelongsToAssociation < ::ActiveRecord::Associations::BelongsToAssociation
+        private
+          def find_target
+            @reflection.klass.send(:with_scope, :find => {:with_deleted => true}) do
+              super
+            end
+          end
+      end
+    end
+  end
+end

data/lib/millstone/active_record/associations/belongs_to_polymorphic_association.rb

@@ -0,0 +1,14 @@
+module Millstone
+  module ActiveRecord
+    module Associations
+      class BelongsToPolymorphicAssociation < ::ActiveRecord::Associations::BelongsToPolymorphicAssociation
+        private
+          def find_target
+            association_class.try(:send, :with_scope, :find => {:with_deleted => true}) do
+              super
+            end
+          end
+      end
+    end
+  end
+end

data/lib/millstone/active_record/associations/has_many_through_without_deleted_association.rb

@@ -0,0 +1,19 @@
+module Millstone
+  module ActiveRecord
+    module Associations
+      class HasManyThroughWithoutDeletedAssociation < ::ActiveRecord::Associations::HasManyThroughAssociation
+        def construct_conditions
+          return super unless @reflection.through_reflection.klass.as_millstone?
+
+          table_name = @reflection.through_reflection.quoted_table_name
+          conditions = construct_quoted_owner_attributes(@reflection.through_reflection).map do |attr, value|
+            "#{table_name}.#{attr} = #{value}"
+          end
+          conditions << @reflection.through_reflection.klass.millstone_without_deleted_conditions
+          conditions << sql_conditions if sql_conditions
+          "(" + conditions.join(') AND (') + ")"
+        end
+      end
+    end
+  end
+end

data/lib/millstone/active_record/associations.rb

@@ -0,0 +1,50 @@
+require 'millstone/active_record/associations/belongs_to_association'
+require 'millstone/active_record/associations/belongs_to_polymorphic_association'
+require 'millstone/active_record/associations/has_many_through_without_deleted_association'
+
+module Millstone
+  module ActiveRecord
+    module Associations
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          alias_method_chain :has_many, :millstone
+          alias_method_chain :belongs_to, :millstone
+        end
+      end
+
+      module ClassMethods
+        def has_many_with_millstone(association_id, options = {}, &extension)
+          with_deleted = options.delete :with_deleted
+          has_many_without_millstone(association_id, options, &extension).tap do
+            reflection = reflect_on_association(association_id)
+
+            if options[:through] and !with_deleted
+              collection_accessor_methods(reflection, Millstone::ActiveRecord::Associations::HasManyThroughWithoutDeletedAssociation)
+            end
+          end
+        end
+
+        def belongs_to_with_millstone(association_id, options = {})
+          with_deleted = options.delete :with_deleted
+          belongs_to_without_millstone(association_id, options).tap do
+            if with_deleted
+              reflection = reflect_on_association(association_id)
+              
+              if reflection.options[:polymorphic]
+                association_accessor_methods(reflection, Millstone::ActiveRecord::Associations::BelongsToPolymorphicAssociation)
+              else
+                association_accessor_methods(reflection, Millstone::ActiveRecord::Associations::BelongsToAssociation)
+                association_constructor_method(:build, reflection, Millstone::ActiveRecord::Associations::BelongsToAssociation)
+                association_constructor_method(:create, reflection, Millstone::ActiveRecord::Associations::BelongsToAssociation)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Millstone::ActiveRecord::Associations

data/lib/millstone/active_record/extension.rb

@@ -0,0 +1,137 @@
+require 'millstone/active_record/relation_methods'
+require 'millstone/active_record/validations/uniqueness_with_deleted'
+
+module Millstone
+  module ActiveRecord
+    class AlreadyMarkedDeletion < StandardError
+    end
+
+    module Extension
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          # for acts_as_paranoid
+          alias_method :acts_as_paranoid, :millstone
+          alias_method :paranoid?, :as_millstone?
+        end
+      end
+
+      module ClassMethods
+        def as_millstone?
+          self.included_modules.include?(InstanceMethods)
+        end
+
+        def millstone(options = {})
+          options = options.reverse_merge(:column => :deleted_at, :type => :time)
+
+          unless [:time, :boolean].include? options[:type]
+            raise ArgumentError, "'time' or 'boolean' expected for :type option, got #{options[:type]}"
+          end
+
+          class_attribute :millstone_configuration, :millstone_column_reference
+          self.millstone_configuration = options
+          self.millstone_column_reference = "#{self.table_name}.#{millstone_configuration[:column]}"
+          
+          return if as_millstone?
+
+          extend ClassMethods
+          include InstanceMethods
+          include Validations
+
+          self.class_eval do
+            alias_method :paranoid_value, :millstone_column_value
+          end
+
+          class << self
+            delegate :destroy!, :destroy_all!, :delete!, :delete_all!, :to => :scoped
+            delegate :with_deleted, :only_deleted, :to => :scoped
+            alias_method_chain :relation, :millstone
+
+            # for acts_as_paranoid
+            alias_method :paranoid_column, :millstone_column
+            alias_method :paranoid_column_type, :millstone_type
+            alias_method :paranoid_column_reference, :millstone_column_reference
+            alias_method :paranoid_configuration, :millstone_configuration
+          end
+        end
+
+        module ClassMethods
+          def millstone_column
+            millstone_configuration[:column].to_sym
+          end
+
+          def millstone_type
+            millstone_configuration[:type].to_sym
+          end
+
+          def millstone_generate_column_value
+            case millstone_type
+            when :time then Time.now
+            when :boolean then true
+            end
+          end
+
+          def millstone_without_deleted_conditions
+            sanitize_sql(["#{millstone_column_reference} IS ?", nil])
+          end
+
+          def millstone_only_deleted_conditions
+            sanitize_sql(["#{millstone_column_reference} IS NOT ?", nil])
+          end
+
+          private
+            def relation_with_millstone
+              relation = relation_without_millstone
+              relation.extending Millstone::ActiveRecord::RelationMethods
+            end
+        end
+
+        module InstanceMethods
+          def destroy
+            with_transaction_returning_status do
+              _run_destroy_callbacks do
+                raise AlreadyMarkedDeletion, "#{self.class.name} ID=#{self.id} already marked deletion." unless self.millstone_column_value.nil?
+                self.class.delete(self.id)
+                self.millstone_column_value = self.class.millstone_generate_column_value
+                freeze
+              end
+            end
+          end
+
+          def destroy!
+            with_transaction_returning_status do
+              _run_destroy_callbacks do
+                self.class.delete!(self.id)
+                freeze
+              end
+            end
+          end
+
+          def recover(options = {})
+            raise "Millstone is not support"
+          end
+
+          def recover_dependent_associations(window, options = {})
+            raise "Millstone is not support"
+          end
+
+          def deleted?
+            !millstone_column_value.nil?
+          end
+
+          def millstone_column_value
+            self.send(self.class.millstone_column)
+          end
+
+          private
+            def millstone_column_value=(value)
+              self.send("#{self.class.millstone_column}=", value)
+            end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Millstone::ActiveRecord::Extension

data/lib/millstone/active_record/relation_methods.rb

@@ -0,0 +1,120 @@
+module Millstone
+  module ActiveRecord
+    module RelationMethods
+      def self.extended(base)
+        base.class_eval do
+          attr_accessor :with_deleted_value, :only_deleted_value
+        end
+      end
+
+      def destroy_all!(conditions = nil)
+        if with_deleted_value.nil? and only_deleted_value.nil?
+          with_deleted.destroy_all!(conditions)
+        elsif conditions
+          where(conditions).destroy_all!
+        else
+          to_a.each {|object| object.destroy! }.tap { reset }
+        end
+      end
+
+      def destroy!(id)
+        if with_deleted_value.nil? and only_deleted_value.nil?
+          with_deleted.destroy!(id)
+        elsif id.is_a?(Array)
+          id.map {|one_id| destroy!(one_id) }
+        else
+          find(id).destroy!
+        end
+      end
+
+      def delete_all(conditions = nil)
+        conditions ? where(conditions).delete_all : update_all(@klass.millstone_column => @klass.millstone_generate_column_value)
+      end
+
+      def delete_all!(conditions = nil)
+        if with_deleted_value.nil? and only_deleted_value.nil?
+          with_deleted.delete_all!(conditions)
+        elsif conditions
+          where(conditions).delete_all!
+        else
+          arel.delete.tap { reset }
+        end
+      end
+
+      def delete(id_or_array)
+        where(@klass.primary_key => id_or_array).update_all(@klass.millstone_column => @klass.millstone_generate_column_value)
+      end
+
+      def delete!(id_or_array)
+        where(@klass.primary_key => id_or_array).delete_all!
+      end
+
+      def with_deleted(with = true)
+        relation = clone
+        relation.with_deleted_value = with
+        relation
+      end
+
+      def only_deleted(only = true)
+        relation = clone
+        relation.only_deleted_value = only
+        relation
+      end
+
+      def merge(r)
+        merged_relation = super
+        [:with_deleted, :only_deleted].each do |method|
+          value = r.send(:"#{method}_value")
+          merged_relation.send(:"#{method}_value=", value) unless value.nil?
+        end
+        merged_relation
+      end
+
+      def except(*skips)
+        result = super
+        ([:with_deleted, :only_deleted] - skips).each do |method|
+          result.send(:"#{method}_value=", send(:"#{method}_value"))
+        end
+        result
+      end
+
+      def only(*onlies)
+        result = super
+        ([:with_deleted, :only_deleted] & onlies).each do |method|
+          result.send(:"#{method}_value=", send(:"#{method}_value"))
+        end
+        result
+      end
+
+      def apply_finder_options(options)
+        return clone unless options
+
+        finders = options.dup
+        with_deleted = finders.delete(:with_deleted)
+        only_deleted = finders.delete(:only_deleted)
+
+        relation = super(finders)
+        relation = relation.with_deleted(with_deleted) unless with_deleted.nil?
+        relation = relation.only_deleted(only_deleted) unless only_deleted.nil?
+
+        relation
+      end
+
+      private
+        def build_arel
+          arel = super
+          return arel unless @klass.as_millstone?
+
+          if @with_deleted_value
+            # nothing
+          elsif @only_deleted_value
+            arel = collapse_wheres(arel, [@klass.millstone_only_deleted_conditions])
+          else
+            arel = collapse_wheres(arel, [@klass.millstone_without_deleted_conditions])
+          end
+
+          arel
+        end
+    end
+  end
+end

data/lib/millstone/active_record/validations/uniqueness_with_deleted.rb

@@ -0,0 +1,49 @@
+require 'active_support/core_ext/array/wrap'
+
+module Millstone
+  module ActiveRecord
+    module Validations
+      extend ActiveSupport::Concern
+
+      included do
+      end
+
+      class UniquenessWithDeletedValidator < ::ActiveRecord::Validations::UniquenessValidator
+        def validate_each(record, attribute, value)
+          finder_class = find_finder_class_for(record)
+          table = finder_class.unscoped
+
+          table_name   = record.class.quoted_table_name
+
+          if value && record.class.serialized_attributes.key?(attribute.to_s)
+            value = YAML.dump value
+          end
+
+          sql, params  = mount_sql_and_params(finder_class, table_name, attribute, value)
+
+          relation = table.with_deleted.where(sql, *params)  # find with deleted
+
+          Array.wrap(options[:scope]).each do |scope_item|
+            scope_value = record.send(scope_item)
+            relation = relation.where(scope_item => scope_value)
+          end
+
+          unless record.new_record?
+            # TODO : This should be in Arel
+            relation = relation.where("#{record.class.quoted_table_name}.#{record.class.primary_key} <> ?", record.send(:id))
+          end
+
+          if relation.exists?
+            record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+          end
+        end
+      end
+
+      module ClassMethods
+        def validates_uniqueness_of_with_deleted(*attr_names)
+          validates_with UniquenessWithDeletedValidator, _merge_attributes(attr_names)
+        end
+      end
+    end
+  end
+end

data/lib/millstone.rb

@@ -0,0 +1,2 @@
+require 'millstone/active_record/extension'
+require 'millstone/active_record/associations'

data/millstone.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'millstone'
+  s.version     = '0.0.2'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Yoshikazu Ozawa']
+  s.email       = ['yoshikazu.ozawa@gmail.com']
+  s.homepage    = 'https://github.com/relax4u/millstone'
+  s.summary     = 'ActiveRecord plugin which allows you to hide without actually deleting them for Rails3.'
+  s.description = 'ActiveRecord plugin which allows you to hide without actually deleting them for Rails3. Millstone is extending ActiveRecord::Relation'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.require_paths = ['lib']
+
+  s.licenses = ['MIT']
+
+  s.add_dependency 'rails', ['>= 3.0.6']
+  s.add_development_dependency 'bundler', ['>= 1.0.0']
+  s.add_development_dependency 'sqlite3', ['>= 0']
+  s.add_development_dependency 'rspec', ['>= 2.0.0']
+  s.add_development_dependency 'rspec-rails', ['>= 2.0.0']
+  s.add_development_dependency 'delorean', ['>= 0']
+end

data/spec/models/associations/belongs_to_association_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+class ParentHasChild < ActiveRecord::Base
+  set_table_name 'time_columns'
+  millstone
+  has_one :child, :class_name => 'Child', :foreign_key => 'parent_id'
+  has_one :child_with_millstone, :class_name => 'ChildWithDeleted', :foreign_key => 'parent_id'
+end
+
+class Child < ActiveRecord::Base
+  set_table_name 'children'
+  belongs_to :parent, :class_name => 'ParentHasChild', :foreign_key => 'parent_id'
+end
+
+class ChildWithDeleted < ActiveRecord::Base
+  set_table_name 'children'
+  belongs_to :parent, :class_name => 'ParentHasChild', :foreign_key => 'parent_id', :with_deleted => true
+end
+
+describe Millstone::ActiveRecord::Associations::BelongsToAssociation do
+  describe ActiveRecord::Base do
+    let(:parent) { ParentHasChild.create!(:context => "parent") }
+
+    describe ".belongs_to", "with_deleted => false (default)" do
+      let(:record) { parent.create_child(:context => "child") }
+      let(:record_which_destroyed_parent) do
+        record.parent.destroy
+        record.reload
+      end
+
+      specify { record.parent.should eq parent }
+      specify { record_which_destroyed_parent.parent.should be_nil }
+    end
+
+    describe ".belongs_to", "with_deleted => true" do
+      let(:record) { parent.create_child_with_millstone(:context => "child") }
+      let(:record_which_destroyed_parent) do
+        record.parent.destroy
+        record.reload
+      end
+
+      specify { record.parent.should eq parent }
+      specify { record_which_destroyed_parent.parent.should eq parent }
+    end
+  end
+end

data/spec/models/associations/belongs_to_polymorphic_association_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+class ParentHasPolymorphicChild < ActiveRecord::Base
+  set_table_name 'time_columns'
+  millstone
+  has_one :child, :class_name => 'PolymorphicChild', :as => :polymorphous
+  has_one :child_with_millstone, :class_name => 'PolymorphicChildWithDeleted', :as => :polymorphous
+end
+
+class PolymorphicChild < ActiveRecord::Base
+  set_table_name 'polymorphic_children'
+  belongs_to :polymorphous, :polymorphic => true
+end
+
+class PolymorphicChildWithDeleted < ActiveRecord::Base
+  set_table_name 'polymorphic_children'
+  belongs_to :polymorphous, :polymorphic => true, :with_deleted => true
+end
+
+describe Millstone::ActiveRecord::Associations::BelongsToPolymorphicAssociation do
+  describe ActiveRecord::Base do
+    let(:parent) { ParentHasPolymorphicChild.create!(:context => "parent") }
+
+    describe ".belongs_to", "with_deleted => false (default)" do
+      let(:record) { parent.create_child(:context => "child") }
+      let(:record_which_destroyed_parent) do
+        record.polymorphous.destroy
+        record.reload
+      end
+
+      specify { record.polymorphous.should eq parent }
+      specify { record_which_destroyed_parent.polymorphous.should be_nil }
+    end
+
+    describe ".belongs_to", "with_deleted => true" do
+      let(:record) { parent.create_child_with_millstone(:context => "child") }
+      let(:record_which_destroyed_parent) do
+        record.polymorphous.destroy
+        record.reload
+      end
+
+      specify { record.polymorphous.should eq parent }
+      specify { record_which_destroyed_parent.polymorphous.should eq parent }
+    end
+  end
+end