mongoid_archival 0.1.0

data/lib/mongoid/archivable/depending.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Depending
+
+      STRATEGIES = STRATEGIES.dup + %i[archive archive_all]
+
+      def apply_archive_dependencies!
+        self.class._all_dependents.each do |association|
+          dependent = association.try(:dependent)
+          next if !dependent || dependent.in?(%i[delete_all destroy])
+          send(:"_dependent_#{dependent}!", association)
+        end
+      end
+
+      private
+
+      def _dependent_archive!(association)
+        return unless _warn_association_archivable?(association)
+        relation = send(association.name)
+        return unless relation
+        if relation.is_a?(Enumerable)
+          relation.entries
+          relation.each(&:archive)
+        elsif relation.try(:archivable?)
+          relation.archive
+        end
+      end
+
+      def _dependent_archive_all!(association)
+        return unless _warn_association_archivable?(association)
+        relation = send(association.name)
+        return unless relation
+        relation.set(archive_at: Time.zone.now)
+
+        # TODO: this code enables dependency recursion. Untested.
+        # dependents = relation.respond_to?(:dependents) && relation.dependents
+        # if dependents && dependents.reject {|dep| dep.try(:dependent).in?(%i[delete_all destroy]) }.blank?
+        #   relation.set(archive_at: Time.zone.now)
+        # else
+        #   ::Array.wrap(send(association.name)).each { |rel| rel.archive }
+        # end
+      end
+
+      def _warn_association_archivable?(association)
+        result = _association_archivable?(association)
+        Mongoid.logger.warn "Non-archivable association: #{association.name}" unless result
+        result
+      end
+
+      def _association_archivable?(association)
+        relations[association.name].class_name.constantize.try(:archivable?)
+      end
+    end
+  end
+end

data/lib/mongoid/archivable/protected.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Archivable
+    module Protected
+      extend ActiveSupport::Concern
+
+      included do
+        include Mongoid::Persistable::Deletable
+
+        alias :delete! :delete
+
+        def delete
+          raise '#delete not permitted. Use #archive_without_callbacks or #delete! instead.'
+        end
+        alias :remove :delete
+
+        def destroy
+          raise '#destroy not permitted. Use #archive or #destroy! instead.'
+        end
+
+        def destroy!(options = {})
+          raise Errors::ReadonlyDocument.new(self.class) if readonly?
+          self.flagged_for_destroy = true
+          result = run_callbacks(:destroy) do
+            if catch(:abort) { apply_destroy_dependencies! }
+              delete!(options || {})
+            else
+              false
+            end
+          end
+          self.flagged_for_destroy = false
+          result
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/archivable/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Archivable
+    VERSION = '0.1.0'
+  end
+end

data/lib/mongoid_archival.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'mongoid/archivable'

data/perf/scope.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'mongoid'
+require 'mongoid/archivable'
+require 'benchmark'
+
+Mongoid.configure do |config|
+  config.connect_to('my_little_test')
+end
+
+class Model
+  include Mongoid::Document
+  field :text, type: String
+
+  index({ text: 'text' })
+end
+
+class ArchivableModel
+  include Mongoid::Document
+  include Mongoid::Archivable
+  field :text, type: String
+
+  index({ text: 'text' })
+end
+
+class MetaArchivableModel
+  include Mongoid::Document
+  field :text, type: String
+  field :archived_at, type: Time
+  default_scope -> { where(archived_at: nil) }
+
+  index({ text: 'text' })
+end
+
+if ENV['FORCE']
+  Mongoid.purge!
+  ::Mongoid::Tasks::Database.create_indexes
+
+  n = 50_000
+  n.times {|_i| Model.create(text: "text #{i}") }
+  n.times {|_i| ArchivableModel.create(text: "text #{i}") }
+  n.times {|_i| MetaArchivableModel.create(text: "text #{i}") }
+end
+
+n = 100
+
+puts 'text_search benchmark ***'
+Benchmark.bm(20) do |x|
+  x.report('without') { n.times { Model.text_search('text').execute } }
+  x.report('with')    { n.times { ArchivableModel.text_search('text').execute } }
+  x.report('meta')    { n.times { MetaArchivableModel.text_search('text').execute } }
+  x.report('unscoped meta') { n.times { MetaArchivableModel.unscoped.text_search('text').execute } }
+  x.report('unscoped archivable') { n.times { ArchivableModel.unscoped.text_search('text').execute } }
+end
+
+puts ''
+puts 'Pluck all ids benchmark ***'
+Benchmark.bm(20) do |x|
+  x.report('without') { n.times { Model.all.pluck(:id) } }
+  x.report('with')    { n.times { ArchivableModel.all.pluck(:id) } }
+  x.report('meta')    { n.times { MetaArchivableModel.all.pluck(:id) } }
+  x.report('unscoped meta') { n.times { MetaArchivableModel.unscoped.all.pluck(:id) } }
+  x.report('unscoped archivable') { n.times { ArchivableModel.unscoped.all.pluck(:id) } }
+end

data/spec/app/models/address.rb

@@ -0,0 +1,71 @@
+class Address
+  include Mongoid::Document
+
+  field :_id, type: String, default: ->{ street.try(:parameterize) }
+
+  attr_accessor :mode
+
+  field :address_type
+  field :number, type: Integer
+  field :street
+  field :city
+  field :state
+  field :post_code
+  field :parent_title
+  field :services, type: Array
+  field :latlng, type: Array
+  field :map, type: Hash
+  field :move_in, type: DateTime
+  field :s, type: String, as: :suite
+  field :name, localize: true
+
+  embeds_one :code, validate: false
+  embeds_one :target, as: :targetable, validate: false
+
+  embedded_in :addressable, polymorphic: true do
+    def extension
+      'Testing'
+    end
+    def doctor?
+      title == 'Dr'
+    end
+  end
+
+  accepts_nested_attributes_for :code, :target
+
+  belongs_to :account
+
+  scope :without_postcode, -> {where(postcode: nil)}
+  scope :rodeo, -> {
+    where(street: 'Rodeo Dr') do
+      def mansion?
+        all? { |address| address.street == 'Rodeo Dr' }
+      end
+    end
+  }
+
+  validates_presence_of :street, on: :update
+  validates_format_of :street, with: /\D/, allow_nil: true
+
+  def set_parent=(set = false)
+    self.parent_title = addressable.title if set
+  end
+
+  def <=>(other)
+    street <=> other.street
+  end
+
+  class << self
+    def california
+      where(state: 'CA')
+    end
+
+    def homes
+      where(address_type: 'Home')
+    end
+
+    def streets
+      all.map(&:street)
+    end
+  end
+end

data/spec/app/models/appointment.rb

@@ -0,0 +1,7 @@
+class Appointment
+  include Mongoid::Document
+  field :active, type: Boolean, default: true
+  field :timed, type: Boolean, default: true
+  embedded_in :person
+  default_scope ->{where(active: true)}
+end

data/spec/app/models/archivable_phone.rb

@@ -0,0 +1,25 @@
+class ArchivablePhone
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  attr_accessor :after_archive_called, :before_archive_called
+
+  field :number, type: String
+
+  embedded_in :person
+
+  before_archive :before_archive_stub, :halt_me
+  after_archive :after_archive_stub
+
+  def before_archive_stub
+    self.before_archive_called = true
+  end
+
+  def after_archive_stub
+    self.after_archive_called = true
+  end
+
+  def halt_me
+    throw :abort if person.age == 42
+  end
+end

data/spec/app/models/archivable_post.rb

@@ -0,0 +1,66 @@
+class ArchivablePost
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  field :title, type: String
+
+  attr_accessor :after_archive_called, :before_archive_called,
+                :after_restore_called, :before_restore_called,
+                :after_archive_called, :before_archive_called,
+                :around_before_restore_called, :around_after_restore_called
+
+  belongs_to :person
+
+  has_and_belongs_to_many :tags
+  has_many :authors, dependent: :delete_all, inverse_of: :post
+  has_many :titles, dependent: :restrict_with_error
+  has_one :fish, dependent: :archive
+
+  scope :recent, -> { where(created_at: { '$lt' => Time.now, '$gt' => 30.days.ago }) }
+
+  before_archive :before_archive_stub
+  after_archive  :after_archive_stub
+
+  before_archive :before_archive_stub
+  after_archive  :after_archive_stub
+
+  before_restore :before_restore_stub
+  after_restore  :after_restore_stub
+  around_restore :around_restore_stub
+
+  def before_archive_stub
+    self.before_archive_called = true
+  end
+
+  def after_archive_stub
+    self.after_archive_called = true
+  end
+
+  def before_archive_stub
+    self.before_archive_called = true
+  end
+
+  def after_archive_stub
+    self.after_archive_called = true
+  end
+
+  def before_restore_stub
+    self.before_restore_called = true
+  end
+
+  def after_restore_stub
+    self.after_restore_called = true
+  end
+
+  def around_restore_stub
+    self.around_before_restore_called = true
+    yield
+    self.around_after_restore_called = true
+  end
+
+  class << self
+    def old
+      where(created_at: { '$lt' => 30.days.ago })
+    end
+  end
+end

data/spec/app/models/author.rb

@@ -0,0 +1,7 @@
+class Author
+  include Mongoid::Document
+
+  field :name, type: String
+
+  belongs_to :post, class_name: 'ArchivablePost'
+end

data/spec/app/models/fish.rb

@@ -0,0 +1,10 @@
+class Fish
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  def self.fresh
+    where(fresh: true)
+  end
+
+  belongs_to :post, class_name: 'ArchivablePost'
+end

data/spec/app/models/person.rb

@@ -0,0 +1,21 @@
+class Person
+  include Mongoid::Document
+
+  field :age, type: Integer, default: '100'
+  field :score, type: Integer
+
+  attr_reader :rescored
+
+  embeds_many :phone_numbers, class_name: 'Phone', validate: false
+  embeds_many :phones, store_as: :mobile_phones, validate: false
+  embeds_many :addresses, as: :addressable, validate: false
+
+  embeds_many :appointments, validate: false
+  embeds_many :archivable_phones, validate: false
+
+  has_many :archivable_posts, validate: false
+  belongs_to :archivable_post
+
+  accepts_nested_attributes_for :addresses
+  accepts_nested_attributes_for :archivable_phones
+end

data/spec/app/models/phone.rb

@@ -0,0 +1,11 @@
+class Phone
+  include Mongoid::Document
+
+  attr_accessor :number_in_observer
+
+  field :_id, type: String, default: ->{ number }
+
+  field :number
+  embeds_one :country_code
+  embedded_in :person
+end

data/spec/app/models/relations.rb

@@ -0,0 +1,246 @@
+class NormBase
+  include Mongoid::Document
+
+  has_one :norm_has_one, dependent: :destroy
+  has_one :arch_has_one, dependent: :archive
+
+  has_many :norm_has_many, dependent: :destroy
+  has_many :arch_has_many, dependent: :archive
+
+  has_many :norm_has_many_poly, dependent: :destroy
+  has_many :arch_has_many_poly, dependent: :archive
+
+  belongs_to :norm_belongs_to_one, dependent: :destroy
+  belongs_to :arch_belongs_to_one, dependent: :archive
+
+  belongs_to :norm_belongs_to, dependent: :destroy
+  belongs_to :arch_belongs_to, dependent: :archive
+
+  has_and_belongs_to_many :norm_habtm, dependent: :destroy
+  has_and_belongs_to_many :arch_habtm, dependent: :archive
+
+  embeds_one :norm_embeds_one
+  embeds_one :arch_embeds_one
+
+  embeds_many :norm_embeds_many
+  embeds_many :arch_embeds_many
+
+  embeds_many :norm_embeds_many_poly
+  embeds_many :arch_embeds_many_poly
+end
+
+class ArchBase
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  has_one :norm_has_one, dependent: :destroy
+  has_one :arch_has_one, dependent: :archive
+
+  has_many :norm_has_many, dependent: :destroy
+  has_many :arch_has_many, dependent: :archive
+
+  has_many :norm_has_many_poly, dependent: :destroy
+  has_many :arch_has_many_poly, dependent: :archive
+
+  belongs_to :norm_belongs_to_one, dependent: :destroy
+  belongs_to :arch_belongs_to_one, dependent: :archive
+
+  belongs_to :norm_belongs_to, dependent: :destroy
+  belongs_to :arch_belongs_to, dependent: :archive
+
+  has_and_belongs_to_many :norm_habtm, dependent: :destroy
+  has_and_belongs_to_many :arch_habtm, dependent: :archive
+
+  embeds_one :norm_embeds_one
+  embeds_one :arch_embeds_one
+
+  embeds_many :norm_embeds_many
+  embeds_many :arch_embeds_many
+
+  embeds_many :norm_embeds_many_poly
+  embeds_many :arch_embeds_many_poly
+end
+
+class NormHasOne
+  include Mongoid::Document
+
+  belongs_to :norm_base
+  belongs_to :arch_base
+
+  has_one :norm_belongs_to, dependent: :destroy
+  has_one :arch_belongs_to, dependent: :archive
+
+  has_one :norm_habtm, dependent: :destroy
+  has_one :norm_habtm, dependent: :destroy
+end
+
+class NormHasMany
+  include Mongoid::Document
+
+  belongs_to :norm_base
+  belongs_to :arch_base
+
+  has_many :norm_belongs_to, dependent: :destroy
+  has_many :arch_belongs_to, dependent: :archive
+
+  has_many :norm_habtm, dependent: :destroy
+  has_many :norm_habtm, dependent: :destroy
+end
+
+class NormHasManyPoly
+  include Mongoid::Document
+
+  belongs_to :base, polymorphic: true
+end
+
+class NormBelongsToOne
+  include Mongoid::Document
+
+  has_one :norm_base
+  has_one :arch_base
+end
+
+class NormBelongsTo
+  include Mongoid::Document
+
+  has_many :norm_base
+  has_many :arch_base
+
+  belongs_to :norm_has_one, dependent: :destroy
+  belongs_to :arch_has_one, dependent: :archive
+
+  belongs_to :norm_has_many, dependent: :destroy
+  belongs_to :arch_has_many, dependent: :archive
+end
+
+class NormHabtm
+  include Mongoid::Document
+
+  has_and_belongs_to_many :norm_base
+  has_and_belongs_to_many :arch_base
+
+  belongs_to :norm_has_one, dependent: :destroy
+  belongs_to :arch_has_one, dependent: :archive
+
+  belongs_to :norm_has_many, dependent: :destroy
+  belongs_to :arch_has_many, dependent: :archive
+
+  has_and_belongs_to_many :recursive, class_name: 'NormHabtm', inverse_of: :recursive, dependent: :archive
+  has_and_belongs_to_many :arch_habtm, dependent: :archive
+end
+
+class NormEmbedsOne
+  include Mongoid::Document
+
+  embedded_in :norm_base
+  embedded_in :arch_base
+end
+
+class NormEmbedsMany
+  include Mongoid::Document
+
+  embedded_in :norm_base
+  embedded_in :arch_base
+end
+
+class NormEmbedsManyPoly
+  include Mongoid::Document
+
+  embedded_in :base, polymorphic: true
+end
+
+class ArchHasOne
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  belongs_to :norm_base
+  belongs_to :arch_base
+
+  has_one :norm_belongs_to, dependent: :destroy
+  has_one :arch_belongs_to, dependent: :archive
+
+  has_one :norm_habtm, dependent: :destroy
+  has_one :norm_habtm, dependent: :destroy
+end
+
+class ArchHasMany
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  belongs_to :norm_base
+  belongs_to :arch_base
+
+  has_many :norm_belongs_to, dependent: :destroy
+  has_many :arch_belongs_to, dependent: :archive
+
+  has_many :norm_habtm, dependent: :destroy
+  has_many :norm_habtm, dependent: :destroy
+end
+
+class ArchHasManyPoly
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  belongs_to :base, polymorphic: true
+end
+
+class ArchBelongsToOne
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  has_one :norm_base
+  has_one :arch_base
+end
+
+class ArchBelongsTo
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  has_many :norm_base
+  has_many :arch_base
+
+  belongs_to :norm_has_one, dependent: :destroy
+  belongs_to :arch_has_one, dependent: :archive
+
+  belongs_to :norm_has_many, dependent: :destroy
+  belongs_to :arch_has_many, dependent: :archive
+end
+
+class ArchHabtm
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  has_and_belongs_to_many :norm_base
+  has_and_belongs_to_many :arch_base
+
+  belongs_to :norm_has_one, dependent: :destroy
+  belongs_to :arch_has_one, dependent: :archive
+
+  belongs_to :norm_has_many, dependent: :destroy
+  belongs_to :arch_has_many, dependent: :archive
+
+  has_and_belongs_to_many :norm_habtm, dependent: :destroy
+end
+
+class ArchEmbedsOne
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  embedded_in :norm_base
+  embedded_in :arch_base
+end
+
+class ArchEmbedsMany
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  embedded_in :norm_base
+  embedded_in :arch_base
+end
+
+class ArchEmbedsManyPoly
+  include Mongoid::Document
+  include Mongoid::Archivable
+
+  embedded_in :base, polymorphic: true
+end