rails-indexes 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.textile

@@ -0,0 +1,37 @@
+h1. Rails Indexes
+
+Rails indexes is a small package of 2 rake tasks that scan your application models and displays a list of columns that _probably_ should be indexed.
+
+note: there should be mode fields depending on your application design and custom queries.
+
+h2. Installation
+
+as a rails plugin:
+<pre>script/plugin install git://github.com/eladmeidar/rails_indexes.git</pre>
+
+h2. Usage
+
+Display a migration for adding/removing all necessary indexes based on associations:
+<pre>rake db:index_migration</pre>
+
+Display a migration for adding/removing all necessary indexes based on AR::Base#find calls (including: find, find_by, find_all_by, find_by_x_and_y, find_all_by_x_and_y):
+<pre>rake db:find_query_indexes</pre>
+
+Note that it would probably make more sense running those tasks on production, where you *actually* need those indexes to be added.
+
+h2. Tests
+
+Requires SQLite3 installed, then just:
+<pre>rake</pre>
+to run the tests
+
+h4. Author:
+
+Elad Meidar - "http://blog.eizesus.com":http://blog.eizesus.com
+
+Thanks:
+Eric Davis - "http://littlestreamsoftware.com":http://littlestreamsoftware.com
+   
+Released under the same license as Ruby. No Support. No Warranty, no Pain.
+
+

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/rails-indexes.rb

@@ -0,0 +1,7 @@
+require "rails-indexes/version"
+require "rails-indexes/indexer"
+
+module TechnoGate
+  module RailsIndexes
+  end
+end

data/lib/rails-indexes/indexer.rb

@@ -0,0 +1,335 @@
+module TechnoGate
+  module RailsIndexes
+    module Indexer
+
+      def self.sortalize(array)
+        Marshal.load(Marshal.dump(array)).each do |element|
+          element.sort! if element.is_a?(Array)
+        end
+      end
+
+      def self.check_for_indexes(migration_format = false)
+        model_names = []
+        Dir.chdir(Rails.root) do
+          model_names = Dir["**/app/models/**/*.rb"].collect {|filename| File.basename(filename) }.uniq
+        end
+
+        model_classes = []
+        model_names.each do |model_name|
+          class_name = model_name.sub(/\.rb$/,'').camelize
+          begin
+            klass = class_name.split('::').inject(Object){ |klass,part| klass.const_get(part) }
+            if klass < ActiveRecord::Base && !klass.abstract_class?
+              model_classes << klass
+            end
+          rescue
+            # No-op
+          end
+        end
+
+        @index_migrations = Hash.new([])
+
+        model_classes.each do |class_name|
+
+          # check if this is an STI child instance
+          if class_name.base_class.name != class_name.name && (class_name.column_names.include?(class_name.base_class.inheritance_column) || class_name.column_names.include?(class_name.inheritance_column))
+
+            # add the inharitance column on the parent table
+            # index migration for STI should require both the primary key and the inheritance_column in a composite index.
+            @index_migrations[class_name.base_class.table_name] += [[class_name.inheritance_column, class_name.base_class.primary_key].sort] unless @index_migrations[class_name.base_class.table_name].include?([class_name.base_class.inheritance_column].sort)
+          end
+          #puts "class name: #{class_name}"
+          class_name.reflections.each_pair do |reflection_name, reflection_options|
+            #puts "reflection => #{reflection_name}"
+            case reflection_options.macro
+            when :belongs_to
+              # polymorphic?
+              @table_name = class_name.table_name.to_s
+              if reflection_options.options.has_key?(:polymorphic) && (reflection_options.options[:polymorphic] == true)
+                poly_type = "#{reflection_options.name.to_s}_type"
+                poly_id = "#{reflection_options.name.to_s}_id"
+
+                @index_migrations[@table_name.to_s] += [[poly_type, poly_id].sort] unless @index_migrations[@table_name.to_s].include?([poly_type, poly_id].sort)
+              else
+
+                foreign_key = reflection_options.options[:foreign_key] ||= reflection_options.primary_key_name
+                  @index_migrations[@table_name.to_s] += [foreign_key] unless @index_migrations[@table_name.to_s].include?(foreign_key)
+              end
+            when :has_and_belongs_to_many
+              table_name = reflection_options.options[:join_table] ||= [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"
+
+              # Guess foreign key?
+              if reflection_options.options[:foreign_key]
+                foreign_key = reflection_options.options[:foreign_key]
+              elsif reflection_options.options[:class_name]
+                foreign_key = reflection_options.options[:class_name].foreign_key
+              else
+                foreign_key = "#{class_name.name.tableize.singularize}_id"
+              end
+
+              composite_keys = [association_foreign_key, foreign_key]
+
+              @index_migrations[table_name.to_s] += [composite_keys] unless @index_migrations[table_name].include?(composite_keys)
+              @index_migrations[table_name.to_s] += [composite_keys.reverse] unless @index_migrations[table_name].include?(composite_keys.reverse)
+
+            else
+              #nothing
+            end
+          end
+        end
+
+        @missing_indexes = {}
+
+        @index_migrations.each do |table_name, foreign_keys|
+
+          unless foreign_keys.blank?
+            existing_indexes = ActiveRecord::Base.connection.indexes(table_name.to_sym).collect {|index| index.columns.size > 1 ? index.columns : index.columns.first}
+            keys_to_add = foreign_keys.uniq - existing_indexes #self.sortalize(foreign_keys.uniq) - self.sortalize(existing_indexes)
+            @missing_indexes[table_name] = keys_to_add unless keys_to_add.empty?
+          end
+        end
+
+        @missing_indexes
+      end
+
+      def self.scan_finds
+
+
+        # Collect all files that can contain queries, in app/ directories (includes plugins and such)
+        # TODO: add lib too ?
+        file_names = []
+
+        Dir.chdir(Rails.root) do
+          file_names = Dir["**/app/**/*.rb"].uniq.reject {|file_with_path| file_with_path.include?('test')}
+        end
+
+        @indexes_required = Hash.new([])
+
+        # Scan each file
+        file_names.each do |file_name|
+          current_file = File.open(File.join(Rails.root, file_name), 'r')
+
+          # Scan each line
+          current_file.each do |line|
+
+            # by default, try to add index on primary key, based on file name
+            # this will fail if the file isnot a model file
+
+            begin
+              current_model_name = File.basename(file_name).sub(/\.rb$/,'').camelize
+            rescue
+              # NO-OP
+            end
+
+            # Get the model class
+            klass = current_model_name.split('::').inject(Object){ |klass,part| klass.const_get(part) } rescue nil
+
+            # Only add primary key for active record dependent classes and non abstract ones too.
+            if klass.present? && klass < ActiveRecord::Base && !klass.abstract_class?
+              current_model = current_model_name.constantize
+              primary_key = current_model.primary_key
+              table_name = current_model.table_name
+              @indexes_required[table_name] += [primary_key] unless @indexes_required[table_name].include?(primary_key)
+            end
+
+            check_line_for_find_indexes(file_name, line)
+
+          end
+        end
+
+        @missing_indexes = {}
+        @indexes_required.each do |table_name, foreign_keys|
+
+          unless foreign_keys.blank?
+            begin
+              if ActiveRecord::Base.connection.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}
+                keys_to_add = self.sortalize(foreign_keys.uniq) - self.sortalize(existing_indexes)
+                @missing_indexes[table_name] = keys_to_add unless keys_to_add.empty?
+              else
+                puts "BUG: table '#{table_name.to_s}' does not exist, please report this bug."
+              end
+            rescue Exception => e
+              puts "ERROR: #{e}"
+            end
+          end
+        end
+
+        @indexes_required
+      end
+
+      # Check line for find* methods (include find_all, find_by and just find)
+      def self.check_line_for_find_indexes(file_name, line)
+
+        # TODO: Assumes that you have a called on #find. you can actually call #find without a caller in a model code. ex:
+        # def something
+        #   find(self.id)
+        # end
+        #
+        # find_regexp = Regexp.new(/([A-Z]{1}[A-Za-z]+|self).(find){1}((_all){0,1}(_by_){0,1}([A-Za-z_]+))?\(([0-9A-Za-z"\':=>. \[\]{},]*)\)/)
+
+        find_regexp = Regexp.new(/(([A-Z]{1}[A-Za-z]+|self).)?(find){1}((_all){0,1}(_by_){0,1}([A-Za-z_]+))?\(([0-9A-Za-z"\':=>. \[\]{},]*)\)/)
+
+        # If line matched a finder
+        if matches = find_regexp.match(line)
+
+          model_name, column_names, options = matches[2], matches[7], matches[8]
+
+          # if the finder class is "self" or empty (can be a simple "find()" in a model)
+          if model_name == "self" || model_name.blank?
+            model_name = File.basename(file_name).sub(/\.rb$/,'').camelize
+            table_name = model_name.constantize.table_name
+          else
+            if model_name.respond_to?(:constantize)
+              if model_name.constantize.respond_to?(:table_name)
+                table_name = model_name.constantize.table_name
+              end
+            end
+          end
+
+          # Check that all prerequisites are met
+          if model_name.present? && table_name.present? && model_name.constantize.ancestors.include?(ActiveRecord::Base)
+            primary_key = model_name.constantize.primary_key
+            @indexes_required[table_name] += [primary_key] unless @indexes_required[table_name].include?(primary_key)
+
+            if column_names.present?
+              column_names = column_names.split('_and_')
+
+              # remove find_by_sql references.
+              column_names.delete("sql")
+
+              column_names = model_name.constantize.column_names & column_names
+
+              # Check if there were more than 1 column
+              if column_names.size == 1
+                column_name = column_names.first
+                @indexes_required[table_name] += [column_name] unless @indexes_required[table_name].include?(column_name)
+              else
+                @indexes_required[table_name] += [column_names] unless @indexes_required[table_name].include?(column_names)
+                @indexes_required[table_name] += [column_names.reverse] unless @indexes_required[table_name].include?(column_names.reverse)
+              end
+            end
+          end
+        end
+      end
+
+      def self.key_exists?(table,key_columns)
+        result = (key_columns.to_a - ActiveRecord::Base.connection.indexes(table).map { |i| i.columns }.flatten)
+        result.empty?
+      end
+
+      def self.simple_migration
+        migration_format = true
+        missing_indexes = check_for_indexes(migration_format)
+
+        unless missing_indexes.keys.empty?
+          add = []
+          remove = []
+          missing_indexes.each do |table_name, keys_to_add|
+            keys_to_add.each do |key|
+              next if key_exists?(table_name,key)
+              next if key.blank?
+              if key.is_a?(Array)
+                keys = key.collect {|k| ":#{k}"}
+                add << "add_index :#{table_name}, [#{keys.join(', ')}]"
+                remove << "remove_index :#{table_name}, :column => [#{keys.join(', ')}]"
+              else
+                add << "add_index :#{table_name}, :#{key}"
+                remove << "remove_index :#{table_name}, :#{key}"
+              end
+
+            end
+          end
+
+          migration = <<-EOM
+    class AddMissingIndexes < ActiveRecord::Migration
+      def self.up
+
+        # These indexes were found by searching for AR::Base finds on your application
+        # It is strongly recommanded that you will consult a professional DBA about your infrastucture and implemntation before
+        # changing your database in that matter.
+        # There is a possibility that some of the indexes offered below is not required and can be removed and not added, if you require
+        # further assistance with your rails application, database infrastructure or any other problem, visit:
+        #
+        # http://www.railsmentors.org
+        # http://www.railstutor.org
+        # http://guides.rubyonrails.org
+
+
+        #{add.uniq.join("\n    ")}
+      end
+
+      def self.down
+        #{remove.uniq.join("\n    ")}
+      end
+    end
+    EOM
+
+          puts "## Drop this into a file in db/migrate ##"
+          puts migration
+        end
+      end
+
+      def self.indexes_list
+        check_for_indexes.each do |table_name, keys_to_add|
+          puts "Table '#{table_name}' => #{keys_to_add.to_sentence}"
+        end
+      end
+
+      def self.ar_find_indexes(migration_mode=true)
+        find_indexes = self.scan_finds
+
+        if migration_mode
+          unless find_indexes.keys.empty?
+            add = []
+            remove = []
+            find_indexes.each do |table_name, keys_to_add|
+              keys_to_add.each do |key|
+                next if key_exists?(table_name,[key].flatten)
+                next if key.blank?
+                if key.is_a?(Array)
+                  keys = key.collect {|k| ":#{k}"}
+                  add << "add_index :#{table_name}, [#{keys.join(', ')}]"
+                  remove << "remove_index :#{table_name}, :column => [#{keys.join(', ')}]"
+                else
+                  add << "add_index :#{table_name}, :#{key}"
+                  remove << "remove_index :#{table_name}, :#{key}"
+                end
+
+              end
+            end
+
+            migration = <<-EOM
+    class AddFindsMissingIndexes < ActiveRecord::Migration
+      def self.up
+
+        # These indexes were found by searching for AR::Base finds on your application
+        # It is strongly recommanded that you will consult a professional DBA about your infrastucture and implemntation before
+        # changing your database in that matter.
+        # There is a possibility that some of the indexes offered below is not required and can be removed and not added, if you require
+        # further assistance with your rails application, database infrastructure or any other problem, visit:
+        #
+        # http://www.railsmentors.org
+        # http://www.railstutor.org
+        # http://guides.rubyonrails.org
+
+        #{add.uniq.join("\n    ")}
+      end
+
+      def self.down
+        #{remove.uniq.join("\n    ")}
+      end
+    end
+    EOM
+
+            puts "## Drop this into a file in db/migrate ##"
+            puts migration
+          end
+        end
+      else
+        find_indexes
+      end
+    end
+  end
+end

data/lib/rails-indexes/version.rb

@@ -0,0 +1,5 @@
+module TechnoGate
+  module RailsIndexes
+    VERSION = "0.0.1"
+  end
+end

data/lib/tasks/indexer.rake

@@ -0,0 +1,12 @@
+require 'rails-indexes'
+
+namespace :db do
+  desc "collect indexes based on AR::Base.find calls."
+  task :find_query_indexes => :environment do
+    TechnoGate::RailsIndexes::Indexer.ar_find_indexes
+  end
+
+  task :index_migration => :environment do
+    TechnoGate::RailsIndexes::Indexer.simple_migration
+  end
+end

data/rails-indexes.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rails-indexes/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rails-indexes"
+  s.version     = TechnoGate::RailsIndexes::VERSION
+  s.authors     = ["Elad Meidar", "Wael Nasreddine"]
+  s.email       = ["elad@eizesus.com","wael.nasreddine@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A rake task to track down missing database indexes. does not assume that all foreign keys end with the convention of _id.}
+  s.description = %q{A rake task to track down missing database indexes. does not assume that all foreign keys end with the convention of _id.}
+
+  s.rubyforge_project = "rails-indexes"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/fixtures/app/controllers/cats_controller.rb

@@ -0,0 +1,14 @@
+class CatsController < ActionController::Base
+  
+  before_filter :find_commentable
+  
+  def index
+    @cats = nil
+  end
+  
+  protected
+  
+  def find_commentable
+    #do something awesome
+  end
+end

data/test/fixtures/app/controllers/users_controller.rb

@@ -0,0 +1,8 @@
+class UsersController < ActionController::Base
+  
+  
+  def index
+    @freelancer = Freelancer.find_all_by_name(param[:name])
+    @user = User.find(1)
+  end
+end

data/test/fixtures/app/models/address.rb

@@ -0,0 +1,5 @@
+class Address < ActiveRecord::Base
+  
+  belongs_to :addressable, :polymorphic => true
+  belongs_to :country
+end

data/test/fixtures/app/models/company.rb

@@ -0,0 +1,11 @@
+class Company < ActiveRecord::Base
+
+  belongs_to :owner, :foreign_key => 'owner_id', :class_name => 'User'
+  belongs_to :country
+  
+  has_one :address, :as => :addressable
+  
+  has_many :users
+  
+  has_and_belongs_to_many :freelancers
+end

data/test/fixtures/app/models/country.rb

@@ -0,0 +1,4 @@
+class Country < ActiveRecord::Base
+  has_many :addresses
+  has_many :companies
+end

data/test/fixtures/app/models/freelancer.rb

@@ -0,0 +1,3 @@
+class Freelancer < ActiveRecord::Base
+  has_and_belongs_to_many :companies
+end

data/test/fixtures/app/models/gift.rb

@@ -0,0 +1,10 @@
+class Gift < ActiveRecord::Base
+  
+  set_primary_key :custom_primary_key
+  has_and_belongs_to_many :users, :join_table => "purchases", :association_foreign_key => 'buyer_id', :foreign_key => 'present_id'
+  
+  def search_all(name, price)
+    Gift.find_all_by_name_and_price(name, price)
+  end
+  
+end

data/test/fixtures/app/models/god.rb

@@ -0,0 +1,3 @@
+class God < ActiveRecord::Base
+  self.abstract_class = true
+end

data/test/fixtures/app/models/user.rb

@@ -0,0 +1,17 @@
+class User < ActiveRecord::Base
+  
+  has_one :company, :foreign_key => 'owner_id'
+  has_one :address, :as => :addressable 
+
+  has_and_belongs_to_many :users, :join_table => "purchases", :association_foreign_key => 'present_id', :foreign_key => 'buyer_id'
+  
+  validates_uniqueness_of :name
+  
+  def search_via_email(email = "user@domain.com")
+    self.find_by_email(email)
+  end
+  
+  def search_via_email_and_name(email, name)
+    self.find_by_email_and_name(email, name)
+  end
+end

data/test/fixtures/app/sweepers/user_sweeper.rb

@@ -0,0 +1,9 @@
+class UserSweeper < ActionController::Caching::Sweeper
+  # This sweeper is going to keep an eye on the Product model
+  observe User
+
+  # If our sweeper detects that a Product was created call this
+  def after_create(product)
+    logger.info "Sweeped!"
+  end
+end

data/test/fixtures/schema.rb

@@ -0,0 +1,46 @@
+ActiveRecord::Schema.define do
+  create_table "users", :force => true do |t|
+    t.column "name",  :text
+    t.column "email", :text
+  end
+  
+  create_table "companies", :force => true do |t|
+    t.column "name",  :text
+    t.column "owned_id", :integer
+    t.column "country_id", :integer
+  end
+  
+  add_index :companies, :country_id
+  
+  create_table "addresses", :force => true do |t|
+    t.column "addressable_type", :string
+    t.column "addressable_id", :integer
+    t.column "address", :text
+    t.column "country_id", :integer
+  end
+  
+  create_table "freelancers", :force => true do |t|
+    t.column "name", :string
+    t.column "price_per_hour", :integer
+  end
+  
+  create_table "companies_freelancers", :force => true do |t|
+    t.column "freelancer_id", :integer
+    t.column "company_id", :integer
+  end
+  
+  create_table "gifts", :force => true do |t|
+    t.column "custom_primary_key", :integer
+    t.column "name", :string
+    t.column "price", :integer
+  end
+  
+  create_table "purchases", :force => true do |t|
+    t.column "present_id", :integer
+    t.column "buyer_id", :integer
+  end
+  
+  create_table "countries", :force => true do |t|
+    t.column "name", :string
+  end
+end

data/test/rails_indexes_test.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+class RailsIndexesTest < ActiveSupport::TestCase
+  
+  test "relationship indexes are found" do
+    @relationship_indexes = Indexer.check_for_indexes
+
+    assert @relationship_indexes.size > 0
+    
+    assert @relationship_indexes.has_key?("companies")
+    assert @relationship_indexes.has_key?("companies_freelancers")
+    assert @relationship_indexes.has_key?("addresses")
+    assert @relationship_indexes.has_key?("purchases")
+  end
+  
+  # should add 2 composite indexes or each pair
+  test "has_and_belongs_to_many" do
+    @relationship_indexes = Indexer.check_for_indexes(true)
+    
+    assert @relationship_indexes["companies_freelancers"].include?(["company_id", "freelancer_id"])
+    assert @relationship_indexes["companies_freelancers"].include?(["freelancer_id", "company_id"])
+  end
+  
+  test "has_and_belongs_to_many with custom columns" do
+    @relationship_indexes = Indexer.check_for_indexes(true)
+    
+    assert @relationship_indexes["purchases"].include?(["present_id", "buyer_id"])
+    assert @relationship_indexes["purchases"].include?(["buyer_id", "present_id"])
+  end
+  
+  test "belongs_to" do
+    @relationship_indexes = Indexer.check_for_indexes(true)
+    assert @relationship_indexes["addresses"].include?("country_id")
+  end
+  
+  test "belongs_to with a custom foreign key" do
+    @relationship_indexes = Indexer.check_for_indexes(true)
+    assert @relationship_indexes["companies"].include?("owner_id")
+  end
+  
+  test "should not add an already existing index" do
+    @relationship_indexes = Indexer.check_for_indexes(true)
+    assert !(@relationship_indexes["companies"].include?("country_id"))
+  end
+  
+  test "default find_by indexes for primary keys" do
+    @find_by_indexes = Indexer.ar_find_indexes(false)
+    
+    # Default added the primary key for each table
+    assert @find_by_indexes.has_key?("users")
+    assert @find_by_indexes.has_key?("companies")
+    assert @find_by_indexes.has_key?("gifts")
+    assert @find_by_indexes.has_key?("freelancers")
+    assert @find_by_indexes.has_key?("countries")
+  end
+  
+  test "default find_by indexes for custom primary keys" do
+    @find_by_indexes = Indexer.ar_find_indexes(false)
+
+    assert @find_by_indexes["gifts"].include?("custom_primary_key")
+  end
+  
+  test "find_by indexes for self.find_by_email_and_name" do
+    @find_by_indexes = Indexer.ar_find_indexes(false)
+    
+    assert @find_by_indexes["users"].include?(["name", "email"])
+    assert @find_by_indexes["users"].include?(["email", "name"])
+  end
+  
+  test "find_by indexes for Gift.find_all_by_name_and_price" do
+    @find_by_indexes = Indexer.ar_find_indexes(false)
+    
+    assert @find_by_indexes["gifts"].include?(["name", "price"])
+    assert @find_by_indexes["gifts"].include?(["price", "name"])
+  end
+  
+  test "find_by indexes from UsersController" do
+    @find_by_indexes = Indexer.ar_find_indexes(false)
+    
+    assert @find_by_indexes["freelancers"].include?("name")
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+
+require 'test/unit'
+
+require 'active_record'
+require 'active_record/fixtures'
+require 'active_support'
+require 'active_support/test_case'
+require 'action_controller'
+
+require 'indexer'
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlite3",
+  :database => ":memory:"
+)
+
+class Rails
+  def self.root
+    "test/fixtures/"
+  end
+end
+
+load 'test/fixtures/schema.rb'
+
+# Load models
+Dir['test/fixtures/app/models/**/*.rb'].each { |f| require f }
+
+# load controllers
+Dir['test/fixtures/app/controllers/**/*.rb'].each { |f| require f }

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: rails-indexes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Elad Meidar
+- Wael Nasreddine
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-03 00:00:00.000000000 +02:00
+default_executable: 
+dependencies: []
+description: A rake task to track down missing database indexes. does not assume that
+  all foreign keys end with the convention of _id.
+email:
+- elad@eizesus.com
+- wael.nasreddine@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.textile
+- Rakefile
+- lib/rails-indexes.rb
+- lib/rails-indexes/indexer.rb
+- lib/rails-indexes/version.rb
+- lib/tasks/indexer.rake
+- rails-indexes.gemspec
+- test/fixtures/app/controllers/cats_controller.rb
+- test/fixtures/app/controllers/users_controller.rb
+- test/fixtures/app/models/address.rb
+- test/fixtures/app/models/company.rb
+- test/fixtures/app/models/country.rb
+- test/fixtures/app/models/freelancer.rb
+- test/fixtures/app/models/gift.rb
+- test/fixtures/app/models/god.rb
+- test/fixtures/app/models/user.rb
+- test/fixtures/app/sweepers/user_sweeper.rb
+- test/fixtures/schema.rb
+- test/rails_indexes_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rails-indexes
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A rake task to track down missing database indexes. does not assume that
+  all foreign keys end with the convention of _id.
+test_files:
+- test/fixtures/app/controllers/cats_controller.rb
+- test/fixtures/app/controllers/users_controller.rb
+- test/fixtures/app/models/address.rb
+- test/fixtures/app/models/company.rb
+- test/fixtures/app/models/country.rb
+- test/fixtures/app/models/freelancer.rb
+- test/fixtures/app/models/gift.rb
+- test/fixtures/app/models/god.rb
+- test/fixtures/app/models/user.rb
+- test/fixtures/app/sweepers/user_sweeper.rb
+- test/fixtures/schema.rb
+- test/rails_indexes_test.rb
+- test/test_helper.rb