schema_plus_indexes 0.1.0

data/lib/schema_plus_indexes/middleware/model.rb

@@ -0,0 +1,17 @@
+module SchemaPlusIndexes
+  module Middleware
+    module Model
+
+      def self.insert
+        SchemaMonkey::Middleware::Model::ResetColumnInformation.append ResetColumnInformation
+      end
+
+      class ResetColumnInformation < SchemaMonkey::Middleware::Base
+        def call(env)
+          continue env
+          env.model.reset_index_information
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus_indexes/middleware/sqlite3.rb

@@ -0,0 +1,25 @@
+module SchemaPlusIndexes
+  module Middleware
+    module Sqlite3
+      def self.insert
+        SchemaMonkey::Middleware::Query::Indexes.append LookupExtensions
+      end
+
+      class LookupExtensions < SchemaMonkey::Middleware::Base
+        def call(env)
+          continue env
+          indexes = Hash[env.index_definitions.map{ |d| [d.name, d] }]
+
+          env.connection.exec_query("SELECT name, sql FROM sqlite_master WHERE type = 'index'").map do |row|
+            if (desc_columns = row['sql'].scan(/['"`]?(\w+)['"`]? DESC\b/).flatten).any?
+              index = indexes[row['name']]
+              index.orders = Hash[index.columns.map {|column| [column, desc_columns.include?(column) ? :desc : :asc]}]
+            end
+          end
+
+          env.index_definitions
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus_indexes/version.rb

@@ -0,0 +1,3 @@
+module SchemaPlusIndexes
+  VERSION = "0.1.0"
+end

data/schema_dev.yml

@@ -0,0 +1,9 @@
+ruby:
+    - 1.9.3
+    - 2.1.5
+rails:
+    - 4.2
+db:
+    - mysql2
+    - sqlite3
+    - postgresql

data/schema_plus_indexes.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'schema_plus_indexes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "schema_plus_indexes"
+  spec.version       = SchemaPlusIndexes::VERSION
+  spec.authors       = ["ronen barzel"]
+  spec.email         = ["ronen@barzel.org"]
+  spec.summary       = %q{Adds shorthands and conveniences to ActiveRecord's handling of indexes}
+  spec.homepage      = "https://github.com/SchemaPlus/schema_plus_indexes"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", "~> 4.2"
+  spec.add_dependency "schema_monkey", "~> 0.2"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency "schema_dev", "~> 2.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-gem-profile"
+end

data/spec/index_definition_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+
+describe "Index definition" do
+
+  let(:migration) { ::ActiveRecord::Migration }
+
+  before(:all) do
+    define_schema(:auto_create => false) do
+      create_table :users, :force => true do |t|
+        t.string :login
+        t.datetime :deleted_at
+      end
+
+      create_table :posts, :force => true do |t|
+        t.text :body
+        t.integer :user_id
+        t.integer :author_id
+      end
+
+    end
+    class User < ::ActiveRecord::Base ; end
+    class Post < ::ActiveRecord::Base ; end
+  end
+
+  around(:each) do |example|
+    migration.suppress_messages do
+      example.run
+    end
+  end
+
+  after(:each) do
+    migration.remove_index :users, :name => 'users_login_index' if migration.index_name_exists? :users, 'users_login_index', true
+  end
+
+  context "when index is multicolumn" do
+    before(:each) do
+      migration.execute "CREATE INDEX users_login_index ON users (login, deleted_at)"
+      User.reset_column_information
+      @index = index_definition(%w[login deleted_at])
+    end
+
+    it "is included in User.indexes" do
+      expect(@index).not_to be_nil
+    end
+
+  end
+
+  it "should not crash on equality test with nil" do
+    index = ActiveRecord::ConnectionAdapters::IndexDefinition.new(:table, :column)
+    expect{index == nil}.to_not raise_error
+    expect(index == nil).to be false
+  end
+
+
+  context "when index is ordered", :mysql => :skip do
+
+    quotes = [
+      ["unquoted", ''],
+      ["double-quoted", '"'],
+    ]
+    quotes += [
+      ["single-quoted", "'"],
+      ["back-quoted", '`']
+    ] if SchemaDev::Rspec::Helpers.sqlite3?
+
+    quotes.each do |quotename, quote|
+      it "index definition includes orders for #{quotename} columns" do
+        migration.execute "CREATE INDEX users_login_index ON users (#{quote}login#{quote} DESC, #{quote}deleted_at#{quote} ASC)"
+        User.reset_column_information
+        index = index_definition(%w[login deleted_at])
+        expect(index.orders).to eq({"login" => :desc, "deleted_at" => :asc})
+      end
+
+    end
+  end
+
+  context "when index is partial" do
+    before(:each) do
+      migration.execute "CREATE INDEX users_login_index ON users(login) WHERE deleted_at IS NULL"
+      User.reset_column_information
+      @index = index_definition("login")
+    end
+
+    it "is included in User.indexes" do
+      expect(User.indexes.select { |index| index.columns == ["login"] }.size).to eq(1)
+    end
+
+    it "defines where" do
+      expect(@index.where).to match %r{[(]?deleted_at IS NULL[)]?}
+    end
+
+  end if ::ActiveRecord::Migration.supports_partial_index?
+
+
+  protected
+  def index_definition(column_names)
+    User.indexes.detect { |index| index.columns == Array(column_names) }
+  end
+
+
+end

data/spec/index_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe "index" do
+
+  let(:migration) { ::ActiveRecord::Migration }
+  let(:connection) { ::ActiveRecord::Base.connection }
+
+  describe "add_index" do
+
+    before(:each) do
+      connection.tables.each do |table| connection.drop_table table, cascade: true end
+
+      define_schema(:auto_create => false) do
+        create_table :users, :force => true do |t|
+          t.string :login
+          t.text :address
+          t.datetime :deleted_at
+        end
+
+        create_table :posts, :force => true do |t|
+          t.text :body
+          t.integer :user_id
+          t.integer :author_id
+        end
+
+      end
+      class User < ::ActiveRecord::Base ; end
+      class Post < ::ActiveRecord::Base ; end
+    end
+
+
+    after(:each) do
+      migration.suppress_messages do
+        migration.remove_index(:users, :name => @index.name) if (@index ||= nil)
+      end
+    end
+
+    it "should create index when called without additional options" do
+      add_index(:users, :login)
+      expect(index_for(:login)).not_to be_nil
+    end
+
+    it "should create unique index" do
+      add_index(:users, :login, :unique => true)
+      expect(index_for(:login).unique).to eq(true)
+    end
+
+    it "should assign given name" do
+      add_index(:users, :login, :name => 'users_login_index')
+      expect(index_for(:login).name).to eq('users_login_index')
+    end
+
+    it "should assign order", :mysql => :skip do
+      add_index(:users, [:login, :deleted_at], :order => {:login => :desc, :deleted_at => :asc})
+      expect(index_for([:login, :deleted_at]).orders).to eq({"login" => :desc, "deleted_at" => :asc})
+    end
+
+    context "for duplicate index" do
+      it "should not complain if the index is the same" do
+        add_index(:users, :login)
+        expect(index_for(:login)).not_to be_nil
+        expect(ActiveRecord::Base.logger).to receive(:warn).with(/login.*Skipping/)
+        expect { add_index(:users, :login) }.to_not raise_error
+        expect(index_for(:login)).not_to be_nil
+      end
+      it "should complain if the index is different" do
+        add_index(:users, :login, :unique => true)
+        expect(index_for(:login)).not_to be_nil
+        expect { add_index(:users, :login) }.to raise_error
+        expect(index_for(:login)).not_to be_nil
+      end
+    end
+
+    protected
+
+    def index_for(column_names)
+      @index = User.indexes.detect { |i| i.columns == Array(column_names).collect(&:to_s) }
+    end
+
+  end
+
+  describe "remove_index" do
+
+    before(:each) do
+      connection.tables.each do |table| connection.drop_table table, cascade: true end
+      define_schema(:auto_create => false) do
+        create_table :users, :force => true do |t|
+          t.string :login
+          t.datetime :deleted_at
+        end
+      end
+      class User < ::ActiveRecord::Base ; end
+    end
+
+
+    it "removes index by column name (symbols)" do
+      add_index :users, :login
+      expect(User.indexes.length).to eq(1)
+      remove_index :users, :login
+      expect(User.indexes.length).to eq(0)
+    end
+
+    it "removes index by column name (symbols)" do
+      add_index :users, :login
+      expect(User.indexes.length).to eq(1)
+      remove_index 'users', 'login'
+      expect(User.indexes.length).to eq(0)
+    end
+
+    it "removes multi-column index by column names (symbols)" do
+      add_index :users, [:login, :deleted_at]
+      expect(User.indexes.length).to eq(1)
+      remove_index :users, [:login, :deleted_at]
+      expect(User.indexes.length).to eq(0)
+    end
+
+    it "removes multi-column index by column names (strings)" do
+      add_index 'users', [:login, :deleted_at]
+      expect(User.indexes.length).to eq(1)
+      remove_index 'users', ['login', 'deleted_at']
+      expect(User.indexes.length).to eq(0)
+    end
+
+    it "removes index using column option" do
+      add_index :users, :login
+      expect(User.indexes.length).to eq(1)
+      remove_index :users, column: :login
+      expect(User.indexes.length).to eq(0)
+    end
+
+    it "removes index if_exists" do
+      add_index :users, :login
+      expect(User.indexes.length).to eq(1)
+      remove_index :users, :login, :if_exists => true
+      expect(User.indexes.length).to eq(0)
+    end
+
+    it "removes multi-column index if exists" do
+      add_index :users, [:login, :deleted_at]
+      expect(User.indexes.length).to eq(1)
+      remove_index :users, [:login, :deleted_at], :if_exists => true
+      expect(User.indexes.length).to eq(0)
+    end
+
+    it "removes index if_exists using column option" do
+      add_index :users, :login
+      expect(User.indexes.length).to eq(1)
+      remove_index :users, column: :login, :if_exists => true
+      expect(User.indexes.length).to eq(0)
+    end
+
+    it "raises exception if doesn't exist" do
+      expect {
+        remove_index :users, :login
+      }.to raise_error
+    end
+
+    it "doesn't raise exception with :if_exists" do
+      expect {
+        remove_index :users, :login, :if_exists => true
+      }.to_not raise_error
+    end
+  end
+
+  protected
+  def add_index(*args)
+    migration.suppress_messages do
+      migration.add_index(*args)
+    end
+    User.reset_column_information
+  end
+
+  def remove_index(*args)
+    migration.suppress_messages do
+      migration.remove_index(*args)
+    end
+    User.reset_column_information
+  end
+
+end

data/spec/migration_spec.rb

@@ -0,0 +1,188 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ActiveRecord::Migration do
+
+  before(:each) do
+    define_schema(:auto_create => true) do
+
+      create_table :users, :force => true do |t|
+        t.string :login, :index => { :unique => true }
+      end
+
+      create_table :members, :force => true do |t|
+        t.string :login
+      end
+
+      create_table :comments, :force => true do |t|
+        t.string :content
+        t.integer :user
+        t.integer :user_id
+      end
+
+      create_table :posts, :force => true do |t|
+        t.string :content
+      end
+    end
+    class User < ::ActiveRecord::Base ; end
+    class Post < ::ActiveRecord::Base ; end
+    class Comment < ::ActiveRecord::Base ; end
+  end
+
+  context "when table is created" do
+
+    before(:each) do
+      @model = Post
+    end
+
+    it "should create an index if specified on column" do
+      recreate_table(@model) do |t|
+        t.integer :state, :index => true
+      end
+      expect(@model).to have_index.on(:state)
+    end
+
+    it "should create a unique index if specified on column" do
+      recreate_table(@model) do |t|
+        t.integer :state, :index => { :unique => true }
+      end
+      expect(@model).to have_unique_index.on(:state)
+    end
+
+    it "should create a unique index if specified on column using shorthand" do
+      recreate_table(@model) do |t|
+        t.integer :state, :index => :unique
+      end
+      expect(@model).to have_unique_index.on(:state)
+    end
+
+    it "should pass index length option properly", :mysql => :only do
+      recreate_table(@model) do |t|
+        t.string :foo
+        t.string :bar, :index => { :with => :foo, :length => { :foo => 8, :bar => 12 }}
+      end
+      index = @model.indexes.first
+      expect(Hash[index.columns.zip(index.lengths.map(&:to_i))]).to eq({ "foo" => 8, "bar" => 12})
+    end
+
+    it "should create an index if specified explicitly" do
+      recreate_table(@model) do |t|
+        t.integer :state
+        t.index :state
+      end
+      expect(@model).to have_index.on(:state)
+    end
+
+    it "should create a unique index if specified explicitly" do
+      recreate_table(@model) do |t|
+        t.integer :state
+        t.index :state, :unique => true
+      end
+      expect(@model).to have_unique_index.on(:state)
+    end
+
+    it "should create a multiple-column index if specified" do
+      recreate_table(@model) do |t|
+        t.integer :city
+        t.integer :state,       :index => { :with => :city }
+      end
+      expect(@model).to have_index.on([:state, :city])
+    end
+
+    it "should create the index without modifying the input hash" do
+      hash = { :with => :foo, :length => { :foo => 8, :bar => 12 }}
+      hash_original = hash.dup
+      recreate_table(@model) do |t|
+        t.string :foo
+        t.string :bar, :index => hash
+      end
+      expect(hash).to eq(hash_original)
+    end
+
+  end
+
+  context "when table is changed" do
+    before(:each) do
+      @model = Post
+    end
+    [false, true].each do |bulk|
+      suffix = bulk ? ' with :bulk option' : ""
+
+      it "should create an index if specified on column"+suffix do
+        change_table(@model, :bulk => bulk) do |t|
+          t.integer :state, :index => true
+        end
+        expect(@model).to have_index.on(:state)
+      end
+
+    end
+  end
+
+  context "when column is added", :sqlite3 => :skip do
+
+    before(:each) do
+      @model = Comment
+    end
+
+    it "should create an index" do
+      add_column(:slug, :string, :index => true) do
+        expect(@model).to have_index.on(:slug)
+      end
+    end
+
+    it "should create an index if specified" do
+      add_column(:post_id, :integer, :index => true) do
+        expect(@model).to have_index.on(:post_id)
+      end
+    end
+
+    it "should create a unique index if specified" do
+      add_column(:post_id, :integer, :index => { :unique => true }) do
+        expect(@model).to have_unique_index.on(:post_id)
+      end
+    end
+
+    it "should create a unique index if specified by shorthand" do
+      add_column(:post_id, :integer, :index => :unique) do
+        expect(@model).to have_unique_index.on(:post_id)
+      end
+    end
+
+    it "should allow custom name for index" do
+      index_name = 'comments_post_id_unique_index'
+      add_column(:post_id, :integer, :index => { :unique => true, :name => index_name }) do
+        expect(@model).to have_unique_index(:name => index_name).on(:post_id)
+      end
+    end
+
+    protected
+
+    def add_column(column_name, *args)
+      table = @model.table_name
+      ActiveRecord::Migration.suppress_messages do
+        ActiveRecord::Migration.add_column(table, column_name, *args)
+        @model.reset_column_information
+        yield if block_given?
+        ActiveRecord::Migration.remove_column(table, column_name)
+      end
+    end
+
+  end
+
+
+  def recreate_table(model, opts={}, &block)
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.create_table model.table_name, opts.merge(:force => true), &block
+    end
+    model.reset_column_information
+  end
+
+  def change_table(model, opts={}, &block)
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.change_table model.table_name, opts, &block
+    end
+    model.reset_column_information
+  end
+
+end
+