schema_plus_pg_indexes 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07fa2b71ce5644fe20cbee97ea3f62c18c608edf
-  data.tar.gz: 164420fd746ac63af76cf83348ed307b6d2c7047
+  metadata.gz: ef5750ecbe4c6463189603e306f2acfd9339753f
+  data.tar.gz: aa49a2061f4600f9652f4cf238c605db35d6c153
 SHA512:
-  metadata.gz: 414e5cd0a8822d29a9c414e8eefab09dc6948b5c2ff9b8fba1c961a547f9d76d4efe1267bd658d1e603d80c36ff0e5f532ef137363033db7760b90fbae95f15b
-  data.tar.gz: 0ce973e0818352c72a27f2d98acd47e3d459c002f7fdb8b0f1a0a9b664b58046fb3b36ec2b97922ee81c56c05e05d229c098712a29a5a9d51836bfe5e3992125
+  metadata.gz: 64722adf53223e3ade5a1169bf70873bccd90d1ececd0a3d705f8770aa79f6fac2b9c7171966edc56883e31c580c972a59855b3f34001219ea9f337a9376bf22
+  data.tar.gz: 8a59bb3f09a07c8ad2036b3fe7ac1b72cc2fb6adcb287ffb33ee5c0969351d10e3935e9c65f21580d678270168e055475307b371dd68e43b55ab8f15fb644aa6

data/README.md

@@ -61,6 +61,7 @@ schema_plus_pg_indexes is tested on
 
 ## History
 
+* v0.1.9 - Bug fix: multiple expression indexes (#8)
 * v0.1.8 - Bug fix: expression with operator class (#7)
 * v0.1.7 - Bug fix: mix of columns & expressions (#5)
 * v0.1.6 - Bug fix: operator class & multiple columns (#4).  Thanks to [@nbudin](https://github.com/nbudin)

data/lib/schema_plus_pg_indexes/middleware/postgresql/migration.rb

@@ -12,11 +12,24 @@ module SchemaPlusPgIndexes
                 env.options[proper] = env.options.delete(deprecated)
               end
             end
+
+            case env.caller.class.name
+            when /TableDefinition/
+              # When index creation is in table definition, create a dummy value for column_names,
+              # since index definitions are indexed by column names
+              env.column_names = dummy_column_names(env) if env.column_names.blank?
+            else
+              # For actual index creation, strip out the dummy column name
+              # value
+              env.column_names = [] if env.column_names == dummy_column_names(env)
+            end
           end
-        end
 
+          def dummy_column_names(env)
+            ["--expression--", env.options[:expression]]
+          end
+        end
       end
     end
   end
 end
-

data/lib/schema_plus_pg_indexes/version.rb

@@ -1,3 +1,3 @@
 module SchemaPlusPgIndexes
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

data/spec/index_spec.rb

@@ -4,162 +4,81 @@ describe "index" do
 
   let(:migration) { ::ActiveRecord::Migration }
 
-  describe "add_index" do
+  class User < ::ActiveRecord::Base ; end
 
-    class User < ::ActiveRecord::Base ; end
-
-    after(:each) do
-      User.reset_column_information
-    end
-
-    context "extra features" do
-
-      before(:each) do
-        define_schema do
-          create_table :users do |t|
-            t.string :login
-            t.text :address
-            t.jsonb :json_col
-            t.datetime :deleted_at
-          end
-        end
-      end
-
-      it "should assign expression, where and using" do
-        add_index(:users, :expression => "USING hash (upper(login)) WHERE deleted_at IS NULL", :name => 'users_login_index')
-        index = User.indexes.detect { |i| i.expression.present? }
-        expect(index.expression).to eq("upper((login)::text)")
-        expect(index.where).to eq("(deleted_at IS NULL)")
-        expect(index.using).to       eq(:hash)
-      end
-
-      it "should allow to specify expression, where and using separately" do
-        add_index(:users, :using => "hash", :expression => "upper(login)", :where => "deleted_at IS NULL", :name => 'users_login_index')
-        index = User.indexes.detect { |i| i.expression.present? }
-        expect(index.expression).to eq("upper((login)::text)")
-        expect(index.where).to eq("(deleted_at IS NULL)")
-        expect(index.using).to eq(:hash)
-      end
-
-      it "should assign operator_class" do
-        add_index(:users, :login, :operator_class => 'varchar_pattern_ops')
-        expect(index_for(:login).operator_classes).to eq({"login" => 'varchar_pattern_ops'})
-      end
-
-      it "should assign multiple operator_classes" do
-        add_index(:users, [:login, :address], :operator_class => {:login => 'varchar_pattern_ops', :address => 'text_pattern_ops'})
-        expect(index_for([:login, :address]).operator_classes).to eq({"login" => 'varchar_pattern_ops', "address" => 'text_pattern_ops'})
-      end
-
-      it "should allow to specify actual expression only" do
-        add_index(:users, :expression => "upper(login)", :name => 'users_login_index')
-        index = User.indexes.detect { |i| i.name == 'users_login_index' }
-        expect(index.expression).to eq("upper((login)::text)")
-      end
-
-      it "should create proper sql with jsonb expressions (schema_plus #212)" do
-        add_index :users, :name => "json_expression", :using => :gin, :expression => "(json_col -> 'field')"
-        index = User.indexes.detect(&its.name == "json_expression")
-        expect(index.expression).to eq("(json_col -> 'field'::text)")
-      end
-
-      it "should raise if no column given and expression is missing" do
-        expect { add_index(:users, :name => 'users_login_index') }.to raise_error(ArgumentError, /expression/)
-      end
-
-      it "should raise if expression without name is given" do
-        expect { add_index(:users, :expression => "upper(login)") }.to raise_error(ArgumentError, /name/)
-      end
+  after(:each) do
+    User.reset_column_information
+  end
 
-      it "should raise if expression is given and case_sensitive is false" do
-        expect { add_index(:users, :name => 'users_login_index', :expression => "upper(login)", :case_sensitive => false) }.to raise_error(ArgumentError, /use LOWER/i)
+  before(:each) do
+    define_schema do
+      create_table :users do |t|
+        t.string :login
+        t.text :address
+        t.jsonb :json_col
+        t.datetime :deleted_at
       end
-
     end
+  end
 
-    context "create table" do
-      it "defines index with expression only" do
-        define_schema do
-          create_table :users do |t|
-            t.string :login
-            t.index :expression => "upper(login)", name: "no_column"
-          end
-        end
-        expect(User.indexes.first.expression).to eq("upper((login)::text)")
-        expect(User.indexes.first.name).to eq("no_column")
-      end
+  it "should assign expression, where and using" do
+    add_index(:users, :expression => "USING hash (upper(login)) WHERE deleted_at IS NULL", :name => 'users_login_index')
+    index = User.indexes.detect { |i| i.expression.present? }
+    expect(index.expression).to eq("upper((login)::text)")
+    expect(index.where).to eq("(deleted_at IS NULL)")
+    expect(index.using).to       eq(:hash)
+  end
 
-      it "defines index with expression as column option" do
-        define_schema do
-          create_table :users do |t|
-            t.string :login, index: { expression: "upper(login)" }
-          end
-        end
-        expect(User.indexes.first.expression).to eq("upper((login)::text)")
-        expect(User.indexes.first.name).to eq("index_users_on_login")
-        expect(User.indexes.first.columns).to be_empty
-      end
+  it "should allow to specify expression, where and using separately" do
+    add_index(:users, :using => "hash", :expression => "upper(login)", :where => "deleted_at IS NULL", :name => 'users_login_index')
+    index = User.indexes.detect { |i| i.expression.present? }
+    expect(index.expression).to eq("upper((login)::text)")
+    expect(index.where).to eq("(deleted_at IS NULL)")
+    expect(index.using).to eq(:hash)
+  end
 
-      it "defines multi-column index with expression as column option" do
-        define_schema do
-          create_table :users do |t|
-            t.string :name
-            t.string :login, index: { with: "name", expression: "upper(login)" }
-          end
-        end
-        expect(User.indexes.first.expression).to eq("upper((login)::text)")
-        expect(User.indexes.first.name).to eq("index_users_on_login_and_name")
-        expect(User.indexes.first.columns).to eq(["name"])
-      end
+  it "should assign operator_class" do
+    add_index(:users, :login, :operator_class => 'varchar_pattern_ops')
+    expect(index_for(:login).operator_classes).to eq({"login" => 'varchar_pattern_ops'})
+  end
 
-      it "defines multi-column index with column option expression that doesn't reference column" do
-        define_schema do
-          create_table :users do |t|
-            t.string :name
-            t.string :login, index: { expression: "upper(name)" }
-          end
-        end
-        expect(User.indexes.first.expression).to eq("upper((name)::text)")
-        expect(User.indexes.first.name).to eq("index_users_on_login")
-        expect(User.indexes.first.columns).to eq(["login"])
-      end
-    end
+  it "should assign multiple operator_classes" do
+    add_index(:users, [:login, :address], :operator_class => {:login => 'varchar_pattern_ops', :address => 'text_pattern_ops'})
+    expect(index_for([:login, :address]).operator_classes).to eq({"login" => 'varchar_pattern_ops', "address" => 'text_pattern_ops'})
+  end
 
-    context "change table" do
-      it "defines index with expression only" do
-        define_schema do
-          create_table :users, :force => true do |t|
-            t.string :login
-          end
-          change_table :users do |t|
-            t.index :expression => "upper(login)", name: "no_column"
-          end
-        end
-        expect(User.indexes.first.expression).to eq("upper((login)::text)")
-        expect(User.indexes.first.name).to eq("no_column")
-      end
-    end
+  it "should allow to specify actual expression only" do
+    add_index(:users, :expression => "upper(login)", :name => 'users_login_index')
+    index = User.indexes.detect { |i| i.name == 'users_login_index' }
+    expect(index.expression).to eq("upper((login)::text)")
+  end
 
-    protected
+  it "should create proper sql with jsonb expressions (schema_plus #212)" do
+    add_index :users, :name => "json_expression", :using => :gin, :expression => "(json_col -> 'field')"
+    index = User.indexes.detect(&its.name == "json_expression")
+    expect(index.expression).to eq("(json_col -> 'field'::text)")
+  end
 
-    def index_for(column_names)
-      User.indexes.detect { |i| i.columns == Array(column_names).collect(&:to_s) }
-    end
+  it "should raise if no column given and expression is missing" do
+    expect { add_index(:users, :name => 'users_login_index') }.to raise_error(ArgumentError, /expression/)
+  end
 
+  it "should raise if expression without name is given" do
+    expect { add_index(:users, :expression => "upper(login)") }.to raise_error(ArgumentError, /name/)
+  end
+
+  it "should raise if expression is given and case_sensitive is false" do
+    expect { add_index(:users, :name => 'users_login_index', :expression => "upper(login)", :case_sensitive => false) }.to raise_error(ArgumentError, /use LOWER/i)
   end
 
   protected
-  def add_index(*args)
-    migration.suppress_messages do
-      migration.add_index(*args)
-    end
-    User.reset_column_information
+
+  def index_for(column_names)
+    User.indexes.detect { |i| i.columns == Array(column_names).collect(&:to_s) }
   end
 
-  def remove_index(*args)
-    migration.suppress_messages do
-      migration.remove_index(*args)
-    end
+  def add_index(*args)
+    migration.add_index(*args)
     User.reset_column_information
   end
 

data/spec/schema_spec.rb

@@ -0,0 +1,88 @@
+
+require 'spec_helper'
+
+describe "schema" do
+
+  class User < ::ActiveRecord::Base ; end
+
+
+  before(:each) do
+    User.reset_column_information
+  end
+
+  context "create table" do
+    it "defines index with expression only" do
+      define_schema do
+        create_table :users do |t|
+          t.string :login
+          t.index :expression => "upper(login)", name: "no_column"
+        end
+      end
+      expect(User.indexes.first.expression).to eq("upper((login)::text)")
+      expect(User.indexes.first.name).to eq("no_column")
+    end
+
+    it "defines two indexes with expression only" do
+      define_schema do
+        create_table :users do |t|
+          t.string :one
+          t.string :two
+          t.index :expression => "upper(one)", name: "index_one"
+          t.index :expression => "upper(two)", name: "index_two"
+        end
+      end
+      expect(User.indexes.map(&:name)).to eq(["index_one", "index_two"])
+      expect(User.indexes.map(&:expression)).to eq(["upper((one)::text)", "upper((two)::text)"])
+    end
+
+    it "defines index with expression as column option" do
+      define_schema do
+        create_table :users do |t|
+          t.string :login, index: { expression: "upper(login)" }
+        end
+      end
+      expect(User.indexes.first.expression).to eq("upper((login)::text)")
+      expect(User.indexes.first.name).to eq("index_users_on_login")
+      expect(User.indexes.first.columns).to be_empty
+    end
+
+    it "defines multi-column index with expression as column option" do
+      define_schema do
+        create_table :users do |t|
+          t.string :name
+          t.string :login, index: { with: "name", expression: "upper(login)" }
+        end
+      end
+      expect(User.indexes.first.expression).to eq("upper((login)::text)")
+      expect(User.indexes.first.name).to eq("index_users_on_login_and_name")
+      expect(User.indexes.first.columns).to eq(["name"])
+    end
+
+    it "defines multi-column index with column option expression that doesn't reference column" do
+      define_schema do
+        create_table :users do |t|
+          t.string :name
+          t.string :login, index: { expression: "upper(name)" }
+        end
+      end
+      expect(User.indexes.first.expression).to eq("upper((name)::text)")
+      expect(User.indexes.first.name).to eq("index_users_on_login")
+      expect(User.indexes.first.columns).to eq(["login"])
+    end
+  end
+
+  context "change table" do
+    it "defines index with expression only" do
+      define_schema do
+        create_table :users, :force => true do |t|
+          t.string :login
+        end
+        change_table :users do |t|
+          t.index :expression => "upper(login)", name: "no_column"
+        end
+      end
+      expect(User.indexes.first.expression).to eq("upper((login)::text)")
+      expect(User.indexes.first.name).to eq("no_column")
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schema_plus_pg_indexes
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - ronen barzel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-24 00:00:00.000000000 Z
+date: 2016-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -159,6 +159,7 @@ files:
 - spec/index_spec.rb
 - spec/named_schema_spec.rb
 - spec/schema_dumper_spec.rb
+- spec/schema_spec.rb
 - spec/spec_helper.rb
 - spec/support/matchers/have_index.rb
 homepage: https://github.com/SchemaPlus/schema_plus_pg_indexes
@@ -192,5 +193,6 @@ test_files:
 - spec/index_spec.rb
 - spec/named_schema_spec.rb
 - spec/schema_dumper_spec.rb
+- spec/schema_spec.rb
 - spec/spec_helper.rb
 - spec/support/matchers/have_index.rb