lol_dba 2.1.5 → 2.1.6

data/lib/lol_dba/rails_compatibility.rb

@@ -0,0 +1,47 @@
+module LolDba
+  class RailsCompatibility
+    class << self
+      def migrator
+        ActiveRecord::Migrator.new(:up, migrations_path)
+      end
+
+      def tables
+        if ::ActiveRecord::VERSION::MAJOR >= 5
+          ActiveRecord::Base.connection.data_sources
+        else
+          ActiveRecord::Base.connection.tables
+        end
+      end
+
+      private
+
+      def migrations_path
+        ar_version = Gem::Version.new(ActiveRecord::VERSION::STRING)
+        if ar_version >= Gem::Version.new('5.2.0')
+          ar_5_2_0_migrations_path
+        elsif ar_version >= Gem::Version.new('5.0.0')
+          ar_5_0_0_migrations_path
+        elsif ar_version >= Gem::Version.new('4.0.0')
+          ar_4_0_0_migrations_path
+        else
+          ActiveRecord::Migrator.migrations_path
+        end
+      end
+
+      def ar_5_2_0_migrations_path
+        paths = ActiveRecord::Migrator.migrations_paths
+        ActiveRecord::MigrationContext.new(paths).migrations
+      end
+
+      def ar_5_0_0_migrations_path
+        paths = ActiveRecord::Migrator.migrations_paths
+        ActiveRecord::Migrator.migrations(paths)
+      end
+
+      def ar_4_0_0_migrations_path
+        path = ActiveRecord::Migrator.migrations_path
+        ActiveRecord::Migrator.migrations(path)
+      end
+    end
+  end
+end

data/lib/lol_dba/railtie.rb

@@ -4,7 +4,7 @@ require 'rails'
 module LolDba
   class Railtie < Rails::Railtie
     rake_tasks do
-      load "tasks/lol_dba.rake"
+      load 'tasks/lol_dba.rake'
     end
   end
-end
+end

data/lib/lol_dba/sql_migrations/migration.rb

@@ -0,0 +1,51 @@
+module LolDba
+  class Migration
+    attr_reader :full_name, :writer
+
+    def initialize(migration_file)
+      @full_name = File.basename(migration_file, '.rb')
+      @writer = LolDba::Writer.new("#{migration}.sql")
+      require Rails.root.join(migration_file)
+    end
+
+    def number
+      /^(\d+)_(.*)$/.match(full_name)[1]
+    end
+
+    def name
+      /^(\d+)_(.*)$/.match(full_name)[2]
+    end
+
+    def to_s
+      full_name
+    end
+
+    def migration_class
+      name.camelize.split('.')[0].constantize
+    end
+
+    def up
+      generate_instead_of_executing do
+        migration_class.migrate(:up)
+        connection.execute("INSERT INTO schema_migrations (version) VALUES (#{number})")
+      end
+    end
+
+    def down
+      generate_instead_of_executing do
+        migration_class.migrate(:down)
+        connection.execute("DELETE FROM schema_migrations WHERE version = #{number}")
+      end
+    end
+
+    def connection
+      ActiveRecord::Base.connection
+    end
+
+    def generate_instead_of_executing
+      LolDba::MigrationMocker.redefine_migration_methods(writer)
+      yield
+      LolDba::MigrationMocker.reset_methods
+    end
+  end
+end

data/lib/lol_dba/sql_migrations/migration_mocker.rb

@@ -0,0 +1,70 @@
+module LolDba
+  class MigrationMocker
+    def initialize(writer)
+      @writer = writer
+    end
+
+    def redefine_migration_methods
+      save_original_methods
+      redefine_metadata_methods
+      redefine_execute_methods(:execute)
+      # needed for activerecord-sqlserver-adapter
+      redefine_execute_methods(:do_execute)
+    end
+
+    def self.reset_methods
+      methods_to_modify.each do |method_name|
+        begin
+          connection_class.send(:alias_method, method_name, "orig_#{method_name}".to_sym)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+
+    private_class_method
+
+    def self.connection
+      ActiveRecord::Base.connection
+    end
+
+    def self.redefine_connection_method(method, &block)
+      connection.class.send(:define_method, method, block)
+    end
+
+    def self.methods_to_modify
+      %i[execute do_execute rename_column change_column column_for tables indexes select_all] & connection.methods
+    end
+
+    private
+
+    def save_original_methods
+      methods_to_modify.each do |method_name|
+        orig_name = "orig_#{method_name}".to_sym
+        connection.class.send(:alias_method, orig_name, method_name)
+      end
+    end
+
+    def redefine_metadata_methods
+      redefine_connection_method(:column_for) { |*args| args.last }
+      redefine_connection_method(:change_column) { |*_args| [] }
+      redefine_connection_method(:rename_column) { |*_args| [] }
+      redefine_connection_method(:tables) { |*_args| [] }
+      redefine_connection_method(:select_all) { |*_args| [] }
+      redefine_connection_method(:indexes) { |*_args| [] }
+      # returns always the default(args[2])
+      redefine_connection_method(:index_name_exists?) { |*args| args[2] }
+    end
+
+    def redefine_execute_methods(name)
+      redefine_connection_method(name) do |*args|
+        query = args.first
+        if query =~ /SELECT "schema_migrations"."version"/ || query =~ /^SHOW/
+          orig_execute(*args)
+        else
+          @writer.write(to_sql(query, args.last))
+        end
+      end
+    end
+  end
+end

data/lib/lol_dba/sql_migrations/sql_generator.rb

@@ -0,0 +1,49 @@
+module LolDba
+  class SqlGenerator
+    def initialize(which)
+      @which = which
+    end
+
+    def run
+      LolDba::Writer.reset_output_dir
+      migrations(@which).each do |file|
+        LolDba::Migration.new(file).up
+      end
+    end
+
+    private
+
+    def migrations(which)
+      if which == 'all'
+        migrator.migrations.collect(&:filename)
+      elsif which == 'pending'
+        pending_migrations
+      else
+        specific_migration(which)
+      end
+    end
+
+    def pending_migrations
+      pending = migrator.pending_migrations
+      if pending.empty?
+        puts 'No pending migrations.'
+        exit
+      end
+      pending.collect(&:filename)
+    end
+
+    def specific_migration(which)
+      migration = migrator.migrations.find { |m| m.version == which.to_i }
+      if migration.present?
+        [migration.filename]
+      else
+        puts "There are no migrations for version #{which}."
+        exit
+      end
+    end
+
+    def migrator
+      LolDba::RailsCompatibility.migrator
+    end
+  end
+end

data/lib/lol_dba/sql_migrations/writer.rb

@@ -0,0 +1,29 @@
+module LolDba
+  class Writer
+    def initialize(file_name)
+      @file_name = file_name
+    end
+
+    def self.reset_output_dir
+      FileUtils.rm_rf output_dir
+      Dir.mkdir output_dir
+    end
+
+    def write(string)
+      return unless @file_name.present?
+      File.open(path, 'a') { |file| file << string << ";\n" }
+    end
+
+    private_class_method
+
+    def self.output_dir
+      File.join(Rails.root, 'db', 'migrate_sql')
+    end
+
+    private
+
+    def path
+      File.join(output_dir, @file_name)
+    end
+  end
+end

data/lib/lol_dba/version.rb

@@ -1,3 +1,3 @@
 module LolDba
-  VERSION = "2.1.5" unless defined? LolDba::VERSION
+  VERSION = '2.1.6'.freeze unless defined? LolDba::VERSION
 end

data/lib/lol_dba.rb

@@ -1,190 +1,16 @@
 module LolDba
-
-  require "lol_dba/writer"
-  require "lol_dba/migration"
-  require "lol_dba/railtie.rb" if defined?(Rails)
-
-  def self.form_migration_content(migration_name, index_array)
-    migration = <<EOM
-* run `rails g migration #{migration_name}` and add the following content:
-
-
-    class #{migration_name} < ActiveRecord::Migration
-      def change
-        #{index_array.sort.uniq.join("\n        ")}
-      end
-    end
-EOM
-  end
-
-  def self.get_through_foreign_key(target_class, reflection_options)
-    # has_many :through
-    reflection = target_class.reflections[reflection_options.options[:through].to_s]
-
-    # has_and_belongs_to_many
-    reflection = reflection_options unless reflection
-
-    # Guess foreign key?
-    if reflection.options[:foreign_key]
-      reflection.options[:foreign_key]
-    else
-      "#{target_class.name.tableize.singularize}_id"
-    end
-  end
-
-  def self.tables
-    ::ActiveRecord::VERSION::MAJOR >= 5 ? ActiveRecord::Base.connection.data_sources : ActiveRecord::Base.connection.tables
-  end
-
-  def self.validate_and_sort_indexes(indexes_required)
-    missing_indexes = {}
-    warning_messages = ""
-    indexes_required.each do |table_name, foreign_keys|
-      next if foreign_keys.blank?
-      begin
-        if tables.include?(table_name.to_s)
-          existing_indexes = ActiveRecord::Base.connection.indexes(table_name.to_sym).collect {|index| index.columns.size > 1 ? index.columns : index.columns.first}
-          existing_indexes += Array(ActiveRecord::Base.connection.primary_key(table_name.to_s))
-          keys_to_add = foreign_keys.uniq - existing_indexes
-          missing_indexes[table_name] = keys_to_add unless keys_to_add.empty?
-        else
-          warning_messages << "BUG: table '#{table_name.to_s}' does not exist, please report this bug.\n    "
-        end
-      rescue Exception => e
-        puts "ERROR: #{e}"
-      end
-    end
-    return missing_indexes, warning_messages
-  end
-
-  def self.form_data_for_migration(missing_indexes)
-    add = []
-    missing_indexes.each do |table_name, keys_to_add|
-      keys_to_add.each do |key|
-        next if key.blank?
-        next if key_exists?(table_name,key)
-        if key.is_a?(Array)
-          keys = key.collect {|k| ":#{k}"}
-          add << "add_index :#{table_name}, [#{keys.join(', ')}]"
-        else
-          add << "add_index :#{table_name}, :#{key}"
-        end
-      end
-    end
-    return add
-  end
-
-  def self.check_for_indexes(migration_format = false)
-    if defined?(Rails) && !Rails.env.test?
-      Rails.application.eager_load!
-    end
-
-    model_classes = []
-    ActiveRecord::Base.descendants.each do |obj|
-      if Class == obj.class && (!defined?(ActiveRecord::SessionStore::Session) || obj != ActiveRecord::SessionStore::Session)
-        model_classes << obj
-      end
-    end
-
-    @index_migrations = Hash.new([])
-
-    model_classes.each do |class_name|
-      unless class_name.descends_from_active_record?
-        index_name = [class_name.inheritance_column, class_name.base_class.primary_key].sort
-        @index_migrations[class_name.base_class.table_name] += [index_name]
-      end
-      reflections = class_name.reflections.stringify_keys
-      reflections.each_pair do |reflection_name, reflection_options|
-        begin
-          index_name = ""
-          case reflection_options.macro
-          when :belongs_to
-            # polymorphic?
-            table_name = class_name.table_name
-            if reflection_options.options[:polymorphic]
-              poly_type = "#{reflection_options.name.to_s}_type"
-              poly_id = "#{reflection_options.name.to_s}_id"
-              index_name = [poly_type, poly_id].sort
-            else
-              foreign_key = reflection_options.options[:foreign_key]
-              foreign_key ||= reflection_options.respond_to?(:primary_key_name) ? reflection_options.primary_key_name : reflection_options.foreign_key
-              next if foreign_key == "left_side_id" # not a clue why rails 4.1+ creates this left_side_id thing
-              index_name = foreign_key.to_s
-            end
-          when :has_and_belongs_to_many
-            table_name = reflection_options.options[:join_table]
-            table_name ||= [class_name.table_name, reflection_name.to_s].sort.join('_')
-            association_foreign_key = reflection_options.options[:association_foreign_key] ||= "#{reflection_name.to_s.singularize}_id"
-
-            foreign_key = get_through_foreign_key(class_name, reflection_options)
-            index_name = [association_foreign_key, foreign_key].map(&:to_s).sort
-          when :has_many
-            through = reflection_options.options[:through]
-            next unless through && reflections[through.to_s] # has_many tables are threaten by the other side of the relation
-
-            through_class = reflections[through.to_s].klass
-            table_name = through_class.table_name
-
-            foreign_key = get_through_foreign_key(class_name, reflection_options)
-
-            through_reflections = through_class.reflections.stringify_keys
-            if source = reflection_options.options[:source]
-              association_reflection = through_reflections[source.to_s]
-              next if association_reflection.options[:polymorphic]
-              association_foreign_key = get_through_foreign_key(association_reflection.klass, reflection_options)
-            elsif belongs_to_reflections = through_reflections[reflection_name.singularize]
-              # go to joining model through has_many and find belongs_to
-              association_foreign_key = belongs_to_reflections.options[:foreign_key]
-            end
-
-            #FIXME currently we don't support :through => :another_regular_has_many_and_non_through_relation
-            next if association_foreign_key.nil?
-            index_name = [association_foreign_key, foreign_key].map(&:to_s).sort
-          end
-
-          unless index_name == "" || reflection_options.options.include?(:class)
-            @index_migrations[table_name.to_s] += [index_name]
-          end
-
-        rescue Exception => e
-          puts "Some errors here:"
-          puts "Please, create an issue with the following information here https://github.com/plentz/lol_dba/issues:"
-          puts "***************************"
-          puts "Class: #{class_name}"
-          puts "Association type: #{reflection_options.macro}"
-          puts "Association options: #{reflection_options.options}"
-          puts "Exception: #{e.message}"
-          e.backtrace.each{|trace| puts trace}
-        end
-      end # case end
-    end # each_pair end
-    missing_indexes, warning_messages = validate_and_sort_indexes(@index_migrations)
-
-  end
-
-  def self.key_exists?(table,key_columns)
-    result = (Array(key_columns) - ActiveRecord::Base.connection.indexes(table).map { |i| i.columns }.flatten)
-    #FIXME: Primary key always indexes, but ActiveRecord::Base.connection.indexes not show it!
-    result = result - Array(ActiveRecord::Base.connection.primary_key(table)) if result
-    result.empty?
-  end
-
-  def self.puts_migration_content(migration_name, indexes, warning_messages)
-    puts warning_messages
-    add = form_data_for_migration(indexes)
-    if add.blank?
-      puts "Yey, no missing indexes found!"
-    else
-      tip = "* TIP: if you have a problem with the index name('index name too long') you can solve with the :name option. "
-      tip += "Something like :name => 'my_index'."
-      puts tip
-      puts form_migration_content(migration_name, add)
-    end
-  end
-
-  def self.simple_migration
-    missing_indexes, warning_messages = check_for_indexes(true)
-
-    puts_migration_content("AddMissingIndexes", missing_indexes, warning_messages)
-  end
+  require 'lol_dba/sql_migrations/writer'
+  require 'lol_dba/sql_migrations/migration'
+  require 'lol_dba/sql_migrations/migration_mocker'
+  require 'lol_dba/sql_migrations/sql_generator'
+  require 'lol_dba/index_finding/migration_formatter'
+  require 'lol_dba/index_finding/relation_inspector'
+  require 'lol_dba/index_finding/index_finder'
+  require 'lol_dba/index_finding/belongs_to'
+  require 'lol_dba/index_finding/error_logging'
+  require 'lol_dba/index_finding/has_and_belongs_to_many'
+  require 'lol_dba/index_finding/has_many'
+  require 'lol_dba/index_finding/relation_inspector_factory'
+  require 'lol_dba/rails_compatibility'
+  require 'lol_dba/railtie.rb' if defined?(Rails)
 end

data/lib/tasks/lol_dba.rake

@@ -2,14 +2,13 @@ require 'lol_dba'
 require 'lol_dba/sql_generator'
 
 namespace :db do
-  desc "Display a migration for adding/removing all necessary indexes based on associations"
-  task :find_indexes => :environment do
-    LolDba.simple_migration
+  desc 'Display a migration for adding/removing all necessary indexes based on associations'
+  task find_indexes: :environment do
+    LolDba::IndexFinder.run
   end
-  desc "Generate .sql files for your migrations inside db/migrate_sql folder"
-  task :migrate_sql, [:which] => :environment do |t, args|
-    args.with_defaults(:which => 'all')
-    LolDba::SqlGenerator.generate(args[:which])
+  desc 'Generate .sql files for your migrations inside db/migrate_sql folder'
+  task :migrate_sql, [:which] => :environment do |_t, args|
+    args.with_defaults(which: 'all')
+    LolDba::SqlGenerator.run(args[:which])
   end
-  
 end

data/lol_dba.gemspec

@@ -1,27 +1,30 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__), "lib")
-require "lol_dba/version.rb"
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'lol_dba/version.rb'
 
 Gem::Specification.new do |s|
-  s.name = "lol_dba"
+  s.name = 'lol_dba'
   s.version = LolDba::VERSION
   s.platform = Gem::Platform::RUBY
 
-  s.authors =  ["Diego Plentz", "Elad Meidar", "Eric Davis", "Muness Alrubaie", "Vladimir Sharshov"]
-  s.email =  ["diego@plentz.org", "elad@eizesus.com", "", "vsharshov@gmail.com"]
-  s.homepage = "https://github.com/plentz/lol_dba"
-  s.summary = "A small package of rake tasks to track down missing database indexes and generate sql migration scripts"
-  s.description = "lol_dba is a small package of rake tasks that scan your application models and displays a list of columns that probably should be indexed. Also, it can generate .sql migration scripts."
-  s.license = "MIT"
+  s.authors =  ['Diego Plentz']
+  s.email =  ['diego@plentz.io']
+  s.homepage = 'https://github.com/plentz/lol_dba'
+  s.summary = 'A small package of rake tasks to track down missing database indexes and generate sql migration scripts'
+  s.description = 'lol_dba is a small package of rake tasks that scan your application models and displays a list of columns that probably should be indexed. Also, it can generate .sql migration scripts.'
+  s.license = 'MIT'
 
   s.files         = `git ls-files`.split("\n")
-  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.executables   = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.require_paths = ["lib", "lib/lol_dba"]
+  s.require_paths = ['lib', 'lib/lol_dba']
 
-  s.required_ruby_version = ">= 2.0.0"
-  s.add_dependency "activerecord", ">= 3.0"
-  s.add_dependency "actionpack", ">= 3.0"
-  s.add_dependency "railties", ">= 3.0"
+  s.required_ruby_version = '>= 2.0.0'
+  s.add_dependency 'actionpack', '>= 3.0', '< 6.0'
+  s.add_dependency 'activerecord', '>= 3.0', '< 6.0'
+  s.add_dependency 'railties', '>= 3.0', '< 6.0'
 
-  s.add_development_dependency "appraisal"
+  s.add_development_dependency 'appraisal', '~> 2.2'
+  s.add_development_dependency 'simplecov', '~> 0.1'
+  s.add_development_dependency 'sqlite3', '~> 1.3.5'
+  s.add_development_dependency 'rspec-rails'
 end