deleted_at 0.4.0rc1 → 0.5.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c164168eb496804835ab5f48676d72a12fb549dccb649b0249355403db9b5b7e
-  data.tar.gz: 6e684b4ef6a4146f40b6a0684b5aa18df975894df8da62ec62907d34bece3ec9
+  metadata.gz: df0de7db0fb5c4de89e941d080ac07fc08265ae29c2ae550e9e11b1057699763
+  data.tar.gz: e79f565b01952c39277e5c49f100441c3b19cfd6245056192b8261c4bd33541c
 SHA512:
-  metadata.gz: f16daa013ef9ba2c06a42dea4ed2cd1d3e4008d419daa987aa01224408c1a11dd2d38ad93c5685119acfc28b46db4de240ff66ab93a629a7feec2dc632ddf905
-  data.tar.gz: 916c6f5c3e8cf4ebabcb628b23e4015fb16f3c83eb57ef5c393bdfafdb16973149dbedafcf3cfba593bd68f7da6f6dd39200c527ce3c9555fec88d303081bcd2
+  metadata.gz: 0a18356dbbecaa30e77709349b85797ca3a50edadfde5474f62a3db841b52c28a14285ca4498318d17f4a3bf5b5b1e246936d69087b218e68592e6d99a0affe0
+  data.tar.gz: e16f8f3c9b010aa85a0922fe2673d14866eb0451a14988edc1bd6be3efe6d83e75993562046c1ea93ec2b188923d0b4e5596031fadd4439ac989369440a838d9

data/README.md

@@ -1,17 +1,17 @@
 [![Version      ](https://img.shields.io/gem/v/deleted_at.svg?maxAge=2592000)](https://rubygems.org/gems/deleted_at)
 [![Build Status ](https://travis-ci.org/TwilightCoders/deleted_at.svg)](https://travis-ci.org/TwilightCoders/deleted_at)
-[![Code Climate ](https://api.codeclimate.com/v1/badges/762cdcd63990efa768b0/maintainability)](https://codeclimate.com/github/TwilightCoders/deleted_at)
+[![Code Climate ](https://api.codeclimate.com/v1/badges/762cdcd63990efa768b0/maintainability)](https://codeclimate.com/github/TwilightCoders/deleted_at/maintainability)
 [![Test Coverage](https://codeclimate.com/github/TwilightCoders/deleted_at/badges/coverage.svg)](https://codeclimate.com/github/TwilightCoders/deleted_at/coverage)
+[![Dependencies ](https://gemnasium.com/badges/github.com/TwilightCoders/deleted_at.svg)](https://gemnasium.com/github.com/TwilightCoders/deleted_at)
 
 # DeletedAt
 
-Deleting data is never good. A common solution is to use `default_scope`, but conventional wisdom (and for good reason) deams this a bad practice. So how do we achieve the same effect with minimal intervention. What we're looking for is the cliche "clean" solution.
-
-DeletedAt leverages the power of SQL views to achieve the same effect. It also takes advantage of Ruby's flexibility.
+Hide your "deleted" data (unless specifically asked for) without resorting to `default_scope` by leveraging in-line sub-selects.
 
 ## Requirements
 
-`DeletedAt` requires PostgreSQL 9.1+ and Ruby 2.0.0+ (as the `pg` gem requires Ruby 2.0.0).
+- Ruby 2.3+
+- ActiveRecord 4.2+
 
 ## Installation
 
@@ -31,45 +31,59 @@ Or install it yourself as:
 
 ## Usage
 
-Using `DeletedAt` is very simple. It follows a familiar pattern seen throughout the rest of the Ruby/Rails community.
+Invoking `with_deleted_at` sets the class up to use the `deleted_at` functionality.
 
 ```ruby
 class User < ActiveRecord::Base
-  # Feel free to include/extend other modules before or after, as you see fit...
-
   with_deleted_at
 
   # the rest of your model code...
 end
 ```
 
-You'll (probably) need to migrate your database for `deleted_at` to work properly.
+To work properly, the tables that back these models must have a `deleted_at` timestamp column.
 
 ```ruby
 class AddDeletedAtColumnToUsers < ActiveRecord::Migration
 
   def up
     add_column :users, :deleted_at, 'timestamp with time zone'
-
-    DeletedAt.install(User)
   end
 
   def down
-    DeletedAt.uninstall(User)
-
     remove_column :users, :deleted_at, 'timestamp with time zone'
   end
 
 end
 ```
 
+If you're starting with a brand-new table, the existing `timestamps` DSL has been extended to accept `deleted_at: true` as an option, for convenience. Or you can do it seperately as shown above.
+
+```ruby
+class CreatCommentsTable < ActiveRecord::Migration
+
+  def up
+    create_table :comments do |t|
+      # ...
+      #  to the `timestamps` DSL
+      t.timestamps null: false, deleted_at: true
+    end
+  end
+
+  def down
+    drop_table :comments
+  end
+
+end
+```
+
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bundle` to install dependencies. Then, run `bundle exec rspec` to run the tests.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/deleted_at. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/TwilightCoders/deleted_at. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

data/lib/deleted_at.rb

@@ -1,15 +1,18 @@
-require "deleted_at/version"
-require 'deleted_at/views'
-require 'deleted_at/active_record/base'
-require 'deleted_at/active_record/relation'
-require 'deleted_at/active_record/connection_adapters/abstract/schema_definition'
-
+require 'deleted_at/version'
 require 'deleted_at/railtie' if defined?(Rails::Railtie)
 
 module DeletedAt
 
+  MissingColumn = Class.new(StandardError)
+
+  DEFAULT_OPTIONS = {
+    column: :deleted_at,
+    proc: -> { Time.now.utc }
+  }
+
   class << self
     attr_writer :logger
+    attr_reader :disabled
 
     def logger
       @logger ||= Logger.new($stdout).tap do |log|
@@ -19,37 +22,34 @@ module DeletedAt
     end
   end
 
-  def self.load
-    ::ActiveRecord::Relation.send :prepend, DeletedAt::ActiveRecord::Relation
-    ::ActiveRecord::Base.send :include, DeletedAt::ActiveRecord::Base
-    ::ActiveRecord::ConnectionAdapters::TableDefinition.send :prepend, DeletedAt::ActiveRecord::ConnectionAdapters::TableDefinition
-  end
-
-  def self.install(model)
-    return false unless model.has_deleted_at_column?
-
-    DeletedAt::Views.install_present_view(model)
-    DeletedAt::Views.install_deleted_view(model)
+  @disabled = false
 
-    # Now that the views have been installed, initialize the new class extensions
-    # e.g. User -> User::All and User::Deleted
-    model.with_deleted_at
+  def self.disabled?
+    @disabled == true
   end
 
-  def self.uninstall(model)
-    return false unless model.has_deleted_at_column?
+  def self.disable
+    @disabled = true
+  end
 
-    DeletedAt::Views.uninstall_deleted_view(model)
-    DeletedAt::Views.uninstall_present_view(model)
+  def self.enable
+    @disabled = false
+  end
 
-    # We've removed the database views, now remove the class extensions
-    DeletedAt::ActiveRecord::Base.remove_class_views(model)
+  def self.gemspec
+    @gemspec ||= eval(`gem spec deleted_at --ruby`).freeze
   end
 
-  def self.testify(value)
-    value == true || value == 't' || value == 1 || value == '1'
+  def self.install(model)
+    logger.warn <<-STR
+    Great news! You're using the new and improved version of DeletedAt. No more table renaming.
+    You'll want to migrate your old models to use the new (non-view based) functionality.
+    Follow the instructions at #{gemspec.homepage}.
+    STR
   end
 
-  private
+  def self.uninstall(model)
+
+  end
 
 end

data/lib/deleted_at/active_record.rb

@@ -0,0 +1,37 @@
+require 'active_record'
+require 'deleted_at/relation'
+
+module DeletedAt
+  module ActiveRecord
+
+    def self.prepended(subclass)
+      subclass.const_get(:ActiveRecord_Relation).prepend(DeletedAt::Relation)
+      subclass.const_get(:ActiveRecord_AssociationRelation).prepend(DeletedAt::Relation)
+      subclass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def inherited(subclass)
+        super
+        subclass.with_deleted_at self.deleted_at
+      end
+
+      def all
+        const_get(:Present)
+      end
+
+      def const_missing(const)
+        case const
+        when :All, :Deleted, :Present
+          all_without_deleted_at.tap do |rel|
+            rel.deleted_at_scope = const
+          end
+        else super
+        end
+      end
+    end
+
+  end
+
+end

data/lib/deleted_at/core.rb

@@ -0,0 +1,51 @@
+require 'deleted_at/active_record'
+
+module DeletedAt
+
+  module Core
+
+    def self.prepended(subclass)
+      class << subclass
+        cattr_accessor :deleted_at do
+          DeletedAt::DEFAULT_OPTIONS
+        end
+        alias all_without_deleted_at all
+      end
+
+      subclass.extend(ClassMethods)
+    end
+
+    def self.raise_missing(klass)
+      message = "Missing `#{klass.deleted_at[:column]}` in `#{klass.name}` when trying to employ `deleted_at`"
+      raise(DeletedAt::MissingColumn, message)
+    end
+
+    def self.has_deleted_at_column?(klass)
+      klass.columns.map(&:name).include?(klass.deleted_at[:column].to_s)
+    end
+
+    module ClassMethods
+
+      def with_deleted_at(options={}, &block)
+        return if ::DeletedAt.disabled?
+
+        self.deleted_at.merge(options)
+        self.deleted_at[:proc] = block if block_given?
+
+        DeletedAt::Core.raise_missing(self) unless Core.has_deleted_at_column?(self)
+
+        self.prepend(DeletedAt::ActiveRecord)
+
+      end
+
+      def deleted_at_attributes
+        attributes = {
+          deleted_at[:column] => deleted_at[:proc].call
+        }
+      end
+
+    end # End ClassMethods
+
+  end
+
+end

data/lib/deleted_at/{views.rb → legacy.rb}

@@ -1,15 +1,30 @@
 module DeletedAt
-  module Views
+  module Legacy
+    def self.uninstall(model)
+      return false unless model.has_deleted_at_column?
 
-    def self.install_present_view(model)
+      uninstall_deleted_view(model)
       uninstall_present_view(model)
+    end
+
+    def self.install(model)
+      return false unless model.has_deleted_at_column?
+
+      install_present_view(model)
+      install_deleted_view(model)
+    end
+
+    private
+
+    def self.install_present_view(model)
+      # uninstall_present_view(model)
       present_table_name = present_view(model)
 
       while_spoofing_table_name(model, all_table(model)) do
         model.connection.execute("ALTER TABLE \"#{present_table_name}\" RENAME TO \"#{model.table_name}\"")
         model.connection.execute <<-SQL
           CREATE OR REPLACE VIEW "#{present_table_name}"
-          AS #{ model.where(model.deleted_at_column => nil).to_sql }
+          AS #{ model.select('*').where(model.deleted_at_column => nil).to_sql }
         SQL
       end
     end
@@ -21,7 +36,7 @@ module DeletedAt
       while_spoofing_table_name(model, all_table(model)) do
         model.connection.execute <<-SQL
           CREATE OR REPLACE VIEW "#{table_name}"
-          AS #{ model.where.not(model.deleted_at_column => nil).to_sql }
+          AS #{ model.select('*').where.not(model.deleted_at_column => nil).to_sql }
         SQL
       end
     end
@@ -29,23 +44,23 @@ module DeletedAt
     def self.all_table_exists?(model)
       query = model.connection.execute <<-SQL
         SELECT EXISTS (
-          SELECT 1
+          SELECT true
           FROM   information_schema.tables
           WHERE  table_name = '#{all_table(model)}'
         ) AS exists;
       SQL
-      DeletedAt.testify(query.first['exists'])
+      query.first['exists']
     end
 
     def self.deleted_view_exists?(model)
       query = model.connection.execute <<-SQL
         SELECT EXISTS (
-          SELECT 1
+          SELECT true
           FROM   information_schema.tables
           WHERE  table_name = '#{deleted_view(model)}'
         ) AS exists;
       SQL
-      DeletedAt.testify(query.first['exists'])
+      query.first['exists']
     end
 
     def self.present_view(model)
@@ -61,9 +76,6 @@ module DeletedAt
     end
 
     def self.uninstall_present_view(model)
-      # Legacy
-      model.connection.execute("DROP VIEW IF EXISTS \"#{model.table_name}/present\"")
-      # New
       return unless all_table_exists?(model)
       model.connection.execute("DROP VIEW IF EXISTS \"#{present_view(model)}\"")
       model.connection.execute("ALTER TABLE \"#{all_table(model)}\" RENAME TO \"#{present_view(model)}\"")
@@ -73,14 +85,11 @@ module DeletedAt
       model.connection.execute("DROP VIEW IF EXISTS \"#{deleted_view(model)}\"")
     end
 
-    private
-
     def self.while_spoofing_table_name(model, new_name, &block)
       old_name = model.table_name
       model.table_name = new_name
       yield
       model.table_name = old_name
     end
-
   end
 end

data/lib/deleted_at/railtie.rb

@@ -1,13 +1,14 @@
 require 'rails/railtie'
+require 'deleted_at/core'
+require 'deleted_at/table_definition'
 
 module DeletedAt
   class Railtie < Rails::Railtie
-
-    initializer 'deleted_at.load' do
+    initializer 'deleted_at.load' do |_app|
       ActiveSupport.on_load(:active_record) do
-        DeletedAt.load
+        ::ActiveRecord::Base.prepend(DeletedAt::Core)
+        ::ActiveRecord::ConnectionAdapters::TableDefinition.prepend(DeletedAt::TableDefinition)
       end
     end
-
   end
 end

data/lib/deleted_at/relation.rb

@@ -0,0 +1,72 @@
+module DeletedAt
+
+  module Relation
+
+    def self.prepended(subclass)
+      subclass.class_eval do
+        attr_writer :deleted_at_scope
+      end
+    end
+
+    def deleted_at_scope
+      @deleted_at_scope ||= :Present
+    end
+
+    def deleted_at_select
+      scoped_arel = case deleted_at_scope
+      when :Deleted
+        table.where(table[deleted_at[:column]].not_eq(nil))
+      when :Present
+        table.where(table[deleted_at[:column]].eq(nil))
+      end
+    end
+
+
+    def deleted_at_subselect(arel)
+      if (subselect = deleted_at_select)
+        subselect.project(arel_columns(columns.map(&:name)))
+        Arel::Nodes::TableAlias.new(Arel::Nodes::Grouping.new(subselect.ast), table_name)
+      end
+    end
+
+    def build_arel
+      super.tap do |arel|
+        if (subselect = deleted_at_subselect(arel)) && !arel.froms.include?(subselect)
+          DeletedAt.logger.debug("DeletedAt sub-selecting from #{subselect.to_sql}")
+          arel.from(subselect)
+        end
+      end
+    end
+
+    # Deletes the records matching +conditions+ without instantiating the records
+    # first, and hence not calling the +destroy+ method nor invoking callbacks. This
+    # is a single SQL DELETE statement that goes straight to the database, much more
+    # efficient than +destroy_all+. Be careful with relations though, in particular
+    # <tt>:dependent</tt> rules defined on associations are not honored. Returns the
+    # number of rows affected.
+    #
+    #   Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')")
+    #   Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else'])
+    #   Post.where(person_id: 5).where(category: ['Something', 'Else']).delete_all
+    #
+    # Both calls delete the affected posts all at once with a single DELETE statement.
+    # If you need to destroy dependent associations or call your <tt>before_*</tt> or
+    # +after_destroy+ callbacks, use the +destroy_all+ method instead.
+    #
+    # If an invalid method is supplied, +delete_all+ raises an ActiveRecord error:
+    #
+    #   Post.limit(100).delete_all
+    #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit
+    def delete_all(*args)
+      conditions = args.pop
+      if conditions
+        ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
+          Passing conditions to delete_all is not supported in DeletedAt
+          To achieve the same use where(conditions).delete_all.
+        MESSAGE
+      end
+      update_all(klass.deleted_at_attributes)
+    end
+  end
+
+end