Cthulhu 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c4b7288760b69b6b550d647ea7f0c2b769a2c716
+  data.tar.gz: 43acd21b68e3c87204e3074b568faf7896358c61
+SHA512:
+  metadata.gz: a4bde1eb17bc1df9a4aa656147475ee4400fac963f0afad59ca6b2a0cb670db8382bc807d74e01b9ecde54ef0ce1869fe95b354a32d0e2c0e4852bcf676ee947
+  data.tar.gz: b2613453c30e869b5cbec7f006fec13c7c1a422301ad0eda98cac6a22c4484ac2048f81bbdf5d4ac1eacec98cddbf68e72168c0fbf1308e9fb78d4e86e3d8dc1

data/.gitignore

@@ -0,0 +1,19 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# vim swap files:
+*.swp
+*.swo
+
+# OS specific files
+.DS_Store
+
+# gem file
+*.gem

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 2.2.3
+services:
+  - postgresql
+env: POSTGRESQL_DB_USER=postgres
+before_script: bundle exec rake create_databases
+script: bundle exec rake test
+after_script: bundle exec rake drop_databases

data/Cthulhu.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cthulhu/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "Cthulhu"
+  spec.version       = Cthulhu::VERSION
+  spec.authors       = ["behrooz shabani (everplays)\n"]
+  spec.email         = ["everplays@gmail.com"]
+
+  spec.summary       = %q{replacement for ActiveRecord dependent and Database's cascade}
+  spec.description   = %q{If you do not want to setup foreign keys with cascade and ActiveRecord's dependent is too slow for your big database, this is what you are looking for.}
+  spec.homepage      = "https://github.com/bookingexperts/cthulhu"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "pg", '~> 0'
+  spec.add_development_dependency "schema_dev", '~> 0'
+  spec.add_development_dependency "pry", '~> 0'
+  spec.add_development_dependency "factory_girl", '~> 0'
+  spec.add_development_dependency "database_cleaner", '~> 0'
+
+  spec.add_dependency "activerecord", "~> 4.2"
+end

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 BookingExperts
+
+Author: behrooz shabani (everplays)
+
+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,166 @@
+# Cthulhu
+
+![Cthulhu, the destroyer of words](Cthulhu.jpg?raw=true "Cthulhu")
+
+By using this gem, you will be able to destroy objects and all of their associated children without fetching them from database or using cascade.
+
+This is useful for big applications that:
+
+ * have foreign keys but you do not want to setup cascades to protect users from removing stuff that they do not mean.
+ * Database is too big and you do not want to use ActiveRecord's `dependant: :destroy` for performance reasons.
+
+So as foreign keys are setup, you can not accidentally destroy a record and all of its children by doing something like this in console:
+
+```ruby
+User.destroy 1
+```
+
+However, if needed, you can remove it by:
+
+```ruby
+Cthulhu.destroy! User.find(1)
+```
+
+## Transaction
+
+Keep in mind that Cthulhu is destroyer, therefore, it is not wrapped in any transaction. To be safe, you need to call it within a transaction like so:
+
+```ruby
+user = User.find 1
+User.connection.transaction do
+  Cthulhu.destroy! user
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'Cthulhu'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install Cthulhu
+
+## How it works?
+
+Cthulhu crawls over all child associations (AKA `has_many`, `has_one`, `has_and_belongs_to_many`) of given record until it finds a model that does not have any child association and starts deleting records until it can destroy the actual record.
+
+So if you have an application that its database looks like this:
+
+```
+
+     users
+   /   |   \
+posts  |    \
+|   \  |     \
+ \ comments  |
+  \    |    /
+   \   |   /
+    \  |  /
+    images
+
+```
+(see test/models.rb)
+
+You can expect the following queries to be executed if you do `Cthulhu.destroy! User.find(5)`
+
+```sql
+-- images that belong to #5's posts
+DELETE FROM "images"
+WHERE  "images"."id" IN (SELECT "images"."id"
+                         FROM   "images"
+                                INNER JOIN "posts" AS "t0"
+                                        ON "t0"."id" = "images"."imagable_id"
+                                           AND "images"."imagable_type" IN (
+                                               'Post' )
+                                INNER JOIN "users" AS "t1"
+                                        ON "t1"."id" = "t0"."user_id"
+                         WHERE  "t1"."id" = 5);
+
+-- images that belong to #5's comments
+DELETE FROM "images"
+WHERE  "images"."id" IN (SELECT "images"."id"
+                         FROM   "images"
+                                INNER JOIN "comments" AS "t0"
+                                        ON "t0"."id" = "images"."imagable_id"
+                                           AND "images"."imagable_type" IN
+                                               ( 'Comment' )
+                                INNER JOIN "posts" AS "t1"
+                                        ON "t1"."id" = "t0"."post_id"
+                                INNER JOIN "users" AS "t2"
+                                        ON "t2"."id" = "t1"."user_id"
+                         WHERE  "t2"."id" = 5);
+
+-- Comments of #5's posts
+DELETE FROM "comments"
+WHERE  "comments"."id" IN (SELECT "comments"."id"
+                           FROM   "comments"
+                                  INNER JOIN "posts" AS "t0"
+                                          ON "t0"."id" = "comments"."post_id"
+                                  INNER JOIN "users" AS "t1"
+                                          ON "t1"."id" = "t0"."user_id"
+                           WHERE  "t1"."id" = 5);
+
+-- #5's posts
+DELETE FROM "posts"
+WHERE  "posts"."id" IN (SELECT "posts"."id"
+                        FROM   "posts"
+                               INNER JOIN "users" AS "t0"
+                                       ON "t0"."id" = "posts"."user_id"
+                        WHERE  "t0"."id" = 5);
+
+-- #5's comments
+DELETE FROM "comments"
+WHERE  "comments"."id" IN (SELECT "comments"."id"
+                           FROM   "comments"
+                                  INNER JOIN "users" AS "t0"
+                                          ON "t0"."id" = "comments"."user_id"
+                           WHERE  "t0"."id" = 5);
+
+-- #5's images
+DELETE FROM "images"
+WHERE  "images"."id" IN (SELECT "images"."id"
+                         FROM   "images"
+                                INNER JOIN "users" AS "t0"
+                                        ON "t0"."id" = "images"."user_id"
+                         WHERE  "t0"."id" = 5);
+
+-- #5
+DELETE FROM "users"
+WHERE  "users"."id" = 5;
+```
+
+In above scenario, it is possibly to nullify the comments and images of user instead of removing them completely without changing anything in actual association:
+
+```ruby
+Cthulhu.destroy! User.find(5),
+  blacklisted: [],
+  not_to_be_crawled: [],
+  overrides: {
+    User => {
+      comments: {
+        dependent: :nullify
+      },
+      uploaded_images: {
+        dependent: :nullify
+      }
+    }
+  }
+```
+
+Please note that as Cthulhu works based on crawling associations, you need to provide `inverse_of` option for associations that ActiveRecord can not determine by itself.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bookingexperts/cthulhu.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require 'schema_dev/tasks'
+
+# without this, we'll get a warning because DATABASES is already defined by
+# schema_dev.
+Object.send :remove_const, :DATABASES
+DATABASES = %w[cthulhu_test]
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :spec

data/lib/cthulhu.rb

@@ -0,0 +1,27 @@
+require "cthulhu/version"
+require "cthulhu/uncrawlable_hierarchy"
+require "cthulhu/scopper"
+require "cthulhu/destroyer"
+require "active_record"
+
+module Cthulhu
+
+  # Removes the object and all of its children by crawling through defined
+  # associations.
+  #
+  # * +active_record_object+ - the record to be destroyed.
+  # * +:blacklisted+ - models not to be destroyed. i.e. views that you are
+  # using through active record.
+  # * +:not_to_be_crawled+ - Association that should not be traveled. e.g.
+  # 'Post-Comment' means crawling from Post to Comment model is forbidden.
+  # * +:overrides+ - here you can override options of active record
+  # associations. For example, you can set inverse_of or dependent: :nullify
+  # without actually changing the association.
+  def self.destroy! active_record_object,
+    blacklisted: [],
+    not_to_be_crawled: [],
+    overrides: {}
+    Destroyer.new(active_record_object, blacklisted, not_to_be_crawled, overrides).destroy!
+  end
+
+end

data/lib/cthulhu/destroyer.rb

@@ -0,0 +1,113 @@
+module Cthulhu
+  class Destroyer
+
+    attr_reader :root, :root_klass, :option_overrides, :blacklisted
+    attr_accessor :skip
+
+    def initialize root, blacklisted = [], not_to_be_crawled = [], option_overrides = {}
+      @root = root
+      @root_klass = root.class
+      @skip = not_to_be_crawled.to_set
+      @option_overrides = option_overrides
+      @blacklisted = blacklisted
+    end
+
+    def destroy!
+      crawl root.class, [root.class]
+    end
+
+  private
+
+    def crawl crawling, chained_classes, chain = [], inverse_chain = []
+      has_and_belongs_to_many_usages = []
+
+      return if blacklisted.include? crawling
+      added = !skip.include?(crawling)
+      key = [chained_classes.second, crawling].compact.join('-')
+      return if skip.include? key
+      skip.add key
+
+      nullify = {}
+
+      crawling.reflections.each do |name, association|
+        if association.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+          has_and_belongs_to_many_usages << name
+          next
+        end
+        if !association.is_a?(ActiveRecord::Reflection::HasManyReflection) &&
+          !association.is_a?(ActiveRecord::Reflection::HasOneReflection) &&
+          next
+        end
+        next unless association.through_reflection.nil?
+        klass = association.klass rescue Object
+        next unless klass < ActiveRecord::Base
+
+        tmp_chain = chain.map do |link|
+          link.to_s.singularize
+        end
+        tmp_inverse_chain = inverse_chain.dup
+        tmp_chained_classes = chained_classes.dup
+
+        inverse_of = inverse_name_of association
+        if inverse_of.blank?
+          raise UncrawlableHierarchy,
+            "You need to set inverse_of for #{crawling}.#{name} association"
+        end
+        inverse_association = klass.reflections[inverse_of]
+        name_according_to_inverse = inverse_name_of inverse_association, name
+        if name_according_to_inverse.blank?
+          raise UncrawlableHierarchy,
+            "You need to set inverse_of for #{klass}.#{inverse_of} association"
+        end
+
+        singularized_inverse_of = inverse_of.singularize
+        if tmp_chain.first != singularized_inverse_of
+          tmp_chain.unshift singularized_inverse_of
+          tmp_inverse_chain << name
+          tmp_chained_classes.unshift klass
+        end
+
+        if option(association, :dependent) == :nullify
+          nullify[name] = [klass, tmp_chained_classes, tmp_chain, tmp_inverse_chain]
+          next
+        end
+
+        crawl klass, tmp_chained_classes, tmp_chain, tmp_inverse_chain
+      end
+
+      Scopper.new(
+        root,
+        crawling,
+        chained_classes,
+        chain,
+        inverse_chain,
+        has_and_belongs_to_many_usages,
+        nullify
+      ).delete!
+    end
+
+    def inverse_name_of association, default = nil
+      (
+        direct_inverse_of(association) ||
+        option_inverse_of(association) ||
+        default
+      ).to_s
+    end
+
+    def direct_inverse_of association
+      association.inverse_of.try(:name) rescue nil
+    end
+
+    def option_inverse_of association
+      option association, :inverse_of rescue nil
+    end
+
+    def option association, name
+      override = option_overrides[association.active_record].
+        try(:[], association.name).
+        try(:[], name)
+      override || association.options[name]
+    end
+
+  end
+end

data/lib/cthulhu/scopper.rb

@@ -0,0 +1,87 @@
+module Cthulhu
+  class Scopper < Struct.new(:root, :klass, :chained_classes, :chain, :inverse_chain, :has_and_belongs_to_many_usages, :nullify)
+
+    def scope
+      @scope ||= begin
+        result = klass.unscoped
+        left = []
+        right = []
+        @last_klass = klass
+        @last_inverse_klass = root.class
+        chain.each_with_index do |link, index|
+          reflection = @last_klass.reflections[link]
+          inverse_reflection = @last_inverse_klass.reflections[inverse_chain[index]]
+          left << reflection
+          right.unshift inverse_reflection
+          @last_klass = chained_classes[index + 1]
+          @last_inverse_klass = inverse_reflection.klass
+        end
+        left.each_with_index do |_, index|
+          result = result.joins join_expression(left[index], right[index], index)
+        end
+        last_table = left.length > 0 ? table_alias(left.length - 1) : root.class.table_name
+        result.reorder('').where last_table => { id: root.id }
+      end
+    end
+
+    def delete!
+      has_and_belongs_to_many_usages.each do |reflection_name|
+        reflection = scope.reflections[reflection_name]
+        table = t reflection.join_table
+        root.class.connection.
+          execute "delete from #{table} where #{table}.#{reflection.foreign_key} in (#{scope.select(:id).to_sql})"
+      end
+      nullify.each do |name, args|
+        Scopper.new(root, *args, [], {}).nullify! klass.reflections[name].foreign_key
+      end
+      scope.delete_all
+    end
+
+    def nullify! column
+      scope.update_all column => nil
+    end
+
+  private
+
+    def join_expression reflection, inverse_reflection, index
+      previous_table = t(index.zero? ? inverse_reflection.table_name : "t#{index - 1}")
+      current_table = t table_alias(index)
+      current_class = chained_classes[index + 1]
+      association_primary_key = reflection.association_primary_key rescue current_class.primary_key
+      [
+        "inner join #{current_class.quoted_table_name} as #{current_table} on ",
+        [
+          [
+            "#{current_table}.#{c(association_primary_key)}",
+            "#{previous_table}.#{c(reflection.foreign_key)}"
+          ].join('='),
+          (
+            if reflection.polymorphic?
+              types = ([current_class] + current_class.subclasses).map { |type| q type }
+              [
+                "#{previous_table}.#{c(reflection.foreign_type)} in (#{types.join(',')})"
+              ]
+            end
+          )
+        ].compact.join(' AND ')
+      ].join
+    end
+
+    def table_alias index
+      "t#{index}"
+    end
+
+    def c column
+      klass.connection.quote_column_name column
+    end
+
+    def q text
+      klass.connection.quote text
+    end
+
+    def t table
+      klass.connection.quote_table_name table
+    end
+
+  end
+end

data/lib/cthulhu/uncrawlable_hierarchy.rb

@@ -0,0 +1,4 @@
+module Cthulhu
+  class UncrawlableHierarchy < RuntimeError
+  end
+end

data/lib/cthulhu/version.rb

@@ -0,0 +1,3 @@
+module Cthulhu
+  VERSION = "0.1.1"
+end

data/schema_dev.yml

@@ -0,0 +1,6 @@
+ruby:
+  - 2.2.3
+activerecord:
+  - 4.2.6
+db:
+  - postgresql

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: Cthulhu
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- |
+  behrooz shabani (everplays)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: schema_dev
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: If you do not want to setup foreign keys with cascade and ActiveRecord's
+  dependent is too slow for your big database, this is what you are looking for.
+email:
+- everplays@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Cthulhu.gemspec
+- Cthulhu.jpg
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/cthulhu.rb
+- lib/cthulhu/destroyer.rb
+- lib/cthulhu/scopper.rb
+- lib/cthulhu/uncrawlable_hierarchy.rb
+- lib/cthulhu/version.rb
+- schema_dev.yml
+homepage: https://github.com/bookingexperts/cthulhu
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: replacement for ActiveRecord dependent and Database's cascade
+test_files: []