schema_plus 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57e14aaa2266c620a64f9807c8eda09e72d7f87a
-  data.tar.gz: a2a284774dd0bd02b0ff0c21421a79278e93813b
+  metadata.gz: f36351daeeb9863e7b0344d565b2f67125ed9cea
+  data.tar.gz: cb88da4066f4db2f2dfb35f018cc38d82cf6aebc
 SHA512:
-  metadata.gz: 51859b083b8f9e245733efad553563b7dd53d569705f70b8fe371c95987b90775b6efde32f033dea70232d629345c6128e5aaf1d5f7b8b1494036286f3c12f4e
-  data.tar.gz: 9818a2241a8d90f4c5898af00ddb37a34c33011518b70c771533fec90ef63d9d8042ce9ab8850bfd59db45658813f1d118ac4f529396c40336c3be90ead10813
+  metadata.gz: f7f2ab813dcf8bd3c02c780337fefc2ae2c5cd793dee59b1cecc76d1706749918bf534685d3d53b7c31bce4989b56e906d292ff1c254f26e9f80d56ac450aca3
+  data.tar.gz: 79c000eaa5312482df33ec2d09638d93038ba213320172eb6a029a077efbb41164996cc344a8f3325b06d4cb7702a9aaa3153eeba8f65acf9a9e33e2bc80a651

data/.gitignore

@@ -13,6 +13,9 @@ tmtags
 ## VIM
 .*.sw?
 
+## RubyMine
+/.idea/
+
 ## PROJECT::GENERAL
 coverage
 rdoc

data/.travis.yml

@@ -1,6 +1,7 @@
 rvm:
   - 1.9.3
   - 2.0.0
+  - jruby
 gemfile:
   - gemfiles/rails-3.2/Gemfile.postgresql
   - gemfiles/rails-3.2/Gemfile.sqlite3
@@ -26,3 +27,31 @@ matrix:
     - gemfile: gemfiles/rails-edge/Gemfile.postgresql
     - gemfile: gemfiles/rails-edge/Gemfile.sqlite3
     - gemfile: gemfiles/rails-edge/Gemfile.mysql2
+  exclude:
+    - rvm: jruby
+      gemfile: gemfiles/rails-3.2/Gemfile.sqlite3
+      env: 'POSTGRES_DB_USER=postgres MYSQL_DB_USER=""'
+    - rvm: jruby
+      gemfile: gemfiles/rails-3.2/Gemfile.mysql
+      env: 'POSTGRES_DB_USER=postgres MYSQL_DB_USER=""'
+    - rvm: jruby
+      gemfile: gemfiles/rails-3.2/Gemfile.mysql2
+      env: 'POSTGRES_DB_USER=postgres MYSQL_DB_USER=""'
+    - rvm: jruby
+      gemfile: gemfiles/rails-4.0/Gemfile.postgresql
+      env: 'POSTGRES_DB_USER=postgres MYSQL_DB_USER=""'
+    - rvm: jruby
+      gemfile: gemfiles/rails-4.0/Gemfile.sqlite3
+      env: 'POSTGRES_DB_USER=postgres MYSQL_DB_USER=""'
+    - rvm: jruby
+      gemfile: gemfiles/rails-4.0/Gemfile.mysql2
+      env: 'POSTGRES_DB_USER=postgres MYSQL_DB_USER=""'
+    - rvm: jruby
+      gemfile: gemfiles/rails-edge/Gemfile.postgresql
+      env: 'POSTGRES_DB_USER=postgres MYSQL_DB_USER=""'
+    - rvm: jruby
+      gemfile: gemfiles/rails-edge/Gemfile.sqlite3
+      env: 'POSTGRES_DB_USER=postgres MYSQL_DB_USER=""'
+    - rvm: jruby
+      gemfile: gemfiles/rails-edge/Gemfile.mysql2
+      env: 'POSTGRES_DB_USER=postgres MYSQL_DB_USER=""'

data/README.md

@@ -22,6 +22,10 @@ SchemaPlus supports all combinations of:
     3.2), or SQLite3 (using sqlite3 >= 3.7.7 which has foreign key support)
 *   MRI Ruby 1.9.3 or 2.0.0
 
+And also supports:
+
+* jruby with Rails 3.2 and PostgreSQL
+
 
 Note: As of version 1.0.0, SchemaPlus no longer supports Rails 2.3, 3.0 and
 3.1, and also no longer supports MRI Ruby 1.8.7; the last version
@@ -118,6 +122,8 @@ SchemaPlus also tidies some index-related behavior:
 *   If you rename a table, indexes named using rails' automatic naming
     convention will be renamed correspondingly.
 
+*   `remove_index` now accepts an `:if_exists` option to prevent errors from attempting to remove non-existent indexes.
+
 
 ### Foreign Key Constraints
 
@@ -290,6 +296,19 @@ of foreign key constraints, you can re-enable it:
 
 ## Release notes:
 
+### Master branch (to be released)
+
+* (nothing new yet)
+
+### 1.3.0
+
+* Added :if_exists option for remove_index
+* Initial jruby support (rails 3.2, postgresql), due to efforts of [@donv](https://github.com/donv)
+* Preliminatry groundwork for rails 4.1, due to efforts of [@tovodeverett](https://github.com/tovodeverett)
+* Bug fix for change_table
+* Bug fix for schema_dump postgresql non-btree indexes
+* Bug fix regarding expressions that cast non-string columns to strings in a lower()
+
 ### 1.2.0
 *   Now works with rails 4, due to efforts of [@tovodeverett](https://github.com/tovodeverett)
 *   Test against MRI ruby 2.0.0, no longer test against 1.9.2

data/gemfiles/rails-3.2/Gemfile.mysql

@@ -1,4 +1,10 @@
 require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
-gem "mysql", "~> 2.8.1"
+platform :ruby do
+  gem "mysql", "~> 2.8.1"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcmysql-adapter'
+end

data/gemfiles/rails-3.2/Gemfile.mysql2

@@ -1,4 +1,10 @@
 require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
-gem "mysql2"
+platform :ruby do
+  gem "mysql2"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcmysql-adapter'
+end

data/gemfiles/rails-3.2/Gemfile.postgresql

@@ -1,4 +1,10 @@
 require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
-gem "pg"
+platform :ruby do
+  gem "pg"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcpostgresql-adapter'
+end

data/gemfiles/rails-3.2/Gemfile.sqlite3

@@ -1,4 +1,10 @@
 require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
-gem "sqlite3"
+platform :ruby do
+  gem "sqlite3"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter', '>=1.3.0.beta2'
+end

data/gemfiles/rails-4.0/Gemfile.mysql2

@@ -1,4 +1,10 @@
 require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
-gem "mysql2"
+platform :ruby do
+  gem "mysql2"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcmysql-adapter'
+end

data/gemfiles/rails-4.0/Gemfile.postgresql

@@ -1,4 +1,10 @@
 require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
-gem "pg"
+platform :ruby do
+  gem "pg"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcpostgresql-adapter'
+end

data/gemfiles/rails-4.0/Gemfile.sqlite3

@@ -1,4 +1,10 @@
 require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
-gem "sqlite3"
+platform :ruby do
+  gem "sqlite3"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter', '>=1.3.0.beta2'
+end

data/gemfiles/rails-edge/Gemfile.mysql2

@@ -1,4 +1,10 @@
 require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
-gem "mysql2"
+platform :ruby do
+  gem "mysql2"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcmysql-adapter'
+end

data/gemfiles/rails-edge/Gemfile.postgresql

@@ -1,4 +1,10 @@
 require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
-gem "pg"
+platform :ruby do
+  gem "pg"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcpostgresql-adapter'
+end

data/gemfiles/rails-edge/Gemfile.sqlite3

@@ -1,4 +1,10 @@
 require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
-gem "sqlite3"
+platform :ruby do
+  gem "sqlite3"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter', '>=1.3.0.beta2'
+end

data/lib/schema_plus/active_record/column_options_handler.rb

@@ -73,7 +73,7 @@ module SchemaPlus::ActiveRecord
     def remove_foreign_key_if_exists(table_name, column_name) #:nodoc:
       foreign_keys = ActiveRecord::Base.connection.foreign_keys(table_name.to_s) rescue [] # no fks if table_name doesn't exist
       fk = foreign_keys.detect { |fk| fk.table_name == table_name.to_s && fk.column_names == Array(column_name).collect(&:to_s) }
-      remove_foreign_key(table_name, fk.name) if fk
+      remove_foreign_key(table_name, fk.column_names, fk.references_table_name, fk.references_column_names) if fk
     end
 
 
@@ -86,7 +86,7 @@ module SchemaPlus::ActiveRecord
 
     def remove_auto_index_if_exists(table_name, column_name)
       name = auto_index_name(table_name, column_name)
-      remove_index(table_name, :name => name) if index_exists?(table_name, column_name, :name => name)
+      remove_index(table_name, :name => name, :column => column_name, :if_exists => true)
     end
 
     def auto_index_name(table_name, column_name)

data/lib/schema_plus/active_record/connection_adapters/abstract_adapter.rb

@@ -13,6 +13,7 @@ module SchemaPlus
       module AbstractAdapter
         def self.included(base) #:nodoc:
           base.alias_method_chain :initialize, :schema_plus
+          base.alias_method_chain :remove_index, :schema_plus
         end
 
         def initialize_with_schema_plus(*args) #:nodoc:
@@ -31,6 +32,13 @@ module SchemaPlus
                       # for this.
           adapter_module = SchemaPlus::ActiveRecord::ConnectionAdapters.const_get(adapter)
           self.class.send(:include, adapter_module) unless self.class.include?(adapter_module)
+
+          if "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}".to_r >= "4.1".to_r
+            self.class.const_get(:SchemaCreation).send(:include, adapter_module.const_get(:AddColumnOptions))
+          else
+            self.class.send(:include, adapter_module.const_get(:AddColumnOptions))
+          end
+
           extend(SchemaPlus::ActiveRecord::ForeignKeys)
         end
 
@@ -57,17 +65,56 @@ module SchemaPlus
         # it's created.  If you're using Sqlite3, this method will raise an
         # error.)
         def add_foreign_key(table_name, column_names, references_table_name, references_column_names, options = {})
-          foreign_key = ForeignKeyDefinition.new(options[:name] || ForeignKeyDefinition.default_name(table_name, column_names), table_name, column_names, ::ActiveRecord::Migrator.proper_table_name(references_table_name), references_column_names, options[:on_update], options[:on_delete], options[:deferrable])
-          execute "ALTER TABLE #{quote_table_name(table_name)} ADD #{foreign_key.to_sql}"
+          foreign_key_sql = add_foreign_key_sql(table_name, column_names, references_table_name, references_column_names, options)
+          execute "ALTER TABLE #{quote_table_name(table_name)} #{foreign_key_sql}"
+        end
+
+        # called directly by AT's bulk_change_table, for migration
+        # change_table :name, :bulk => true { ... }
+        def add_foreign_key_sql(table_name, column_names, references_table_name, references_column_names, options = {}) #:nodoc:
+          foreign_key = _build_foreign_key(table_name, column_names, references_table_name, references_column_names, options)
+          "ADD #{foreign_key.to_sql}"
+        end
+
+        def _build_foreign_key(table_name, column_names, references_table_name, references_column_names, options = {}) #:nodoc:
+          ForeignKeyDefinition.new(options[:name] || ForeignKeyDefinition.default_name(table_name, column_names), table_name, column_names, ::ActiveRecord::Migrator.proper_table_name(references_table_name), references_column_names, options[:on_update], options[:on_delete], options[:deferrable])
         end
 
         # Remove a foreign key constraint
         #
+        # Arguments are the same as for add_foreign_key, or by name:
+        #
+        #    remove_foreign_key table_name, column_names, references_table_name, references_column_names
+        #    remove_foreign_key name: constraint_name
+        #
         # (NOTE: Sqlite3 does not support altering a table to remove
         # foreign-key constraints.  If you're using Sqlite3, this method will
         # raise an error.)
-        def remove_foreign_key(table_name, foreign_key_name)
-          execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{foreign_key_name}"
+        def remove_foreign_key(table_name, *args)
+          case sql = remove_foreign_key_sql(table_name, *args)
+          when String then execute "ALTER TABLE #{quote_table_name(table_name)} #{sql}"
+          end
+        end
+
+        def remove_foreign_key_sql(table_name, *args)
+          column_names, references_table_name, references_column_names, options = args
+          options ||= {}
+          foreign_key_name = case
+                             when args.length == 1
+                               case args[0]
+                               when Hash then   args[0][:name]
+                               else args[0]
+                               end
+                             else
+                               test_fk = _build_foreign_key(table_name, column_names, references_table_name, references_column_names, options)
+                               if foreign_keys(table_name).detect { |fk| fk == test_fk }
+                                 test_fk.name
+                               else
+                                 raise "SchemaPlus: no foreign key constraint found on #{table_name.inspect} matching #{args.inspect}" unless options[:if_exists]
+                                 nil
+                               end
+                             end
+          foreign_key_name ? "DROP CONSTRAINT #{foreign_key_name}" : []  # hack -- return empty array rather than nil, so that result will disappear when caller flattens but doesn't compact
         end
 
         # Extends rails' drop_table to include these options:
@@ -82,6 +129,14 @@ module SchemaPlus
           execute sql
         end
 
+        # Extends rails' remove_index to include this options:
+        #   :if_exists
+        def remove_index_with_schema_plus(table_name, options={})
+          return if options.delete(:if_exists) and not index_name_exists?(table_name, options[:name] || index_name(table_name, options), false)
+          options.delete(:column) if options[:name] and ::ActiveRecord::VERSION::MAJOR < 4
+          remove_index_without_schema_plus(table_name, options)
+        end
+
         # called from individual adpaters, after renaming table from old
         # name to
         def rename_indexes_and_foreign_keys(oldname, newname) #:nodoc:
@@ -113,26 +168,73 @@ module SchemaPlus
           false
         end
 
-        def add_column_options!(sql, options)
-          if options_include_default?(options)
-            default = options[:default]
-            if default.is_a? Hash
-              value = default[:value]
-              expr = sql_for_function(default[:expr]) || default[:expr] if default[:expr]
-            else
-              value = default
-              expr = sql_for_function(default)
-            end
-            if expr
-              raise ArgumentError, "Invalid default expression" unless default_expr_valid?(expr)
-              sql << " DEFAULT #{expr}"
+        module AddColumnOptions
+          def self.included(base) #:nodoc:
+            base.alias_method_chain :add_column_options!, :schema_plus
+          end
+
+          def add_column_options_with_schema_plus!(sql, options)
+            if options_include_default?(options)
+              default = options[:default]
+
+              if default.is_a? Hash
+                value = default[:value]
+                expr = sql_for_function(default[:expr]) || default[:expr] if default[:expr]
+              else
+                value = default
+                expr = sql_for_function(default)
+              end
+
+              if expr
+                raise ArgumentError, "Invalid default expression" unless default_expr_valid?(expr)
+                sql << " DEFAULT #{expr}"
+                # must explicitly check for :null to allow change_column to work on migrations
+                if options[:null] == false
+                  sql << " NOT NULL"
+                end
+              else
+                add_column_options_without_schema_plus!(sql, options.merge(default: value))
+              end
             else
-              sql << " DEFAULT #{quote(value, options[:column])}" unless value.nil?
+              add_column_options_without_schema_plus!(sql, options)
             end
           end
-          # must explicitly check for :null to allow change_column to work on migrations
-          if options[:null] == false
-            sql << " NOT NULL"
+
+          #####################################################################
+          #
+          # The functions below here are abstract; each subclass should
+          # define them all. Defining them here only for reference.
+
+          # (abstract) Return true if the passed expression can be used as a column
+          # default value.  (For most databases the specific expression
+          # doesn't matter, and the adapter's function would return a
+          # constant true if default expressions are supported or false if
+          # they're not.)
+          def default_expr_valid?(expr) raise "Internal Error: Connection adapter didn't override abstract function"; end
+
+          # (abstract) Return SQL definition for a given canonical function_name symbol.
+          # Currently, the only function to support is :now, which should
+          # return a DATETIME object for the current time.
+          def sql_for_function(function_name) raise "Internal Error: Connection adapter didn't override abstract function"; end
+        end
+
+        module VisitTableDefinition
+          def self.included(base) #:nodoc:
+            base.alias_method_chain :visit_TableDefinition, :schema_plus
+          end
+
+          def visit_TableDefinition_with_schema_plus(o) #:nodoc:
+            create_sql = visit_TableDefinition_without_schema_plus(o)
+            last_chunk = ") #{o.options}"
+
+            unless create_sql.end_with?(last_chunk)
+              raise "Internal Error: Can't find '#{last_chunk}' at end of '#{create_sql}' - Rails internals have changed!"
+            end
+
+            unless o.foreign_keys.empty?
+              create_sql[create_sql.size - last_chunk.size, 0] = ', ' + o.foreign_keys.map(&:to_sql) * ', '
+            end
+            create_sql
           end
         end
 
@@ -141,7 +243,7 @@ module SchemaPlus
         # The functions below here are abstract; each subclass should
         # define them all. Defining them here only for reference.
         #
-        
+
         # (abstract) Returns the names of all views, as an array of strings
         def views(name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
 
@@ -157,41 +259,6 @@ module SchemaPlus
         # (abstract) Return the ForeignKeyDefinition objects for foreign key
         # constraints defined on other tables that reference this table
         def reverse_foreign_keys(table_name, name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
-
-        # (abstract) Return true if the passed expression can be used as a column
-        # default value.  (For most databases the specific expression
-        # doesn't matter, and the adapter's function would return a
-        # constant true if default expressions are supported or false if
-        # they're not.)
-        def default_expr_valid?(expr) raise "Internal Error: Connection adapter didn't override abstract function"; end
-
-        # (abstract) Return SQL definition for a given canonical function_name symbol.
-        # Currently, the only function to support is :now, which should
-        # return a DATETIME object for the current time.
-        def sql_for_function(function_name) raise "Internal Error: Connection adapter didn't override abstract function"; end
-
-
-        if ::ActiveRecord::VERSION::MAJOR.to_i >= 4
-          module SchemaCreation
-            def self.included(base) #:nodoc:
-              base.alias_method_chain :visit_TableDefinition, :schema_plus
-            end
-
-            def visit_TableDefinition_with_schema_plus(o) #:nodoc:
-              create_sql = visit_TableDefinition_without_schema_plus(o)
-              last_chunk = ") #{o.options}"
-
-              unless create_sql.end_with?(last_chunk)
-                raise "Internal Error: Can't find '#{last_chunk}' at end of '#{create_sql}' - Rails internals have changed!"
-              end
-
-              unless o.foreign_keys.empty?
-                create_sql[create_sql.size - last_chunk.size, 0] = ', ' + o.foreign_keys.map(&:to_sql) * ', '
-              end
-              create_sql
-            end
-          end
-        end
       end
     end
   end

data/lib/schema_plus/active_record/connection_adapters/foreign_key_definition.rb

@@ -49,9 +49,9 @@ module SchemaPlus
         def initialize(name, table_name, column_names, references_table_name, references_column_names, on_update = nil, on_delete = nil, deferrable = nil)
           @name = name
           @table_name = unquote(table_name)
-          @column_names = unquote(column_names)
+          @column_names = unquote(Array.wrap(column_names))
           @references_table_name = unquote(references_table_name)
-          @references_column_names = unquote(references_column_names)
+          @references_column_names = unquote(Array.wrap(references_column_names))
           @on_update = on_update
           @on_delete = on_delete
           @deferrable = deferrable
@@ -124,6 +124,13 @@ module SchemaPlus
           table_name.to_s.gsub(/[.]/, '_')
         end
 
+        def ==(other) # note equality test ignores :name and options
+          [:table_name,
+           :column_names,
+           :references_table_name,
+           :references_column_names
+           ].all? { |attr| self.send(attr) == other.send(attr) }
+        end
       end
     end
   end

data/lib/schema_plus/active_record/connection_adapters/mysql_adapter.rb

@@ -27,11 +27,15 @@ module SchemaPlus
           tables_without_schema_plus(name, *args) - views(name)
         end
 
-        def remove_column_with_schema_plus(table_name, column_name)
+        def remove_column_with_schema_plus(table_name, column_name, type=nil, options={})
           foreign_keys(table_name).select { |foreign_key| foreign_key.column_names.include?(column_name.to_s) }.each do |foreign_key|
             remove_foreign_key(table_name, foreign_key.name)
           end
-          remove_column_without_schema_plus(table_name, column_name)
+          if ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+            remove_column_without_schema_plus(table_name, column_name, type, options)
+          else
+            remove_column_without_schema_plus(table_name, column_name)
+          end
         end
 
         def rename_table_with_schema_plus(oldname, newname)
@@ -59,8 +63,22 @@ module SchemaPlus
           super
         end
 
-        def remove_foreign_key(table_name, foreign_key_name, options = {})
-          execute "ALTER TABLE #{quote_table_name(table_name)} DROP FOREIGN KEY #{foreign_key_name}"
+        def remove_index_sql(table_name, options)
+          return [] if options.delete(:if_exists) and not index_exists?(table_name, options)
+          super
+        end
+
+        def remove_foreign_key_sql(table_name, *args)
+          case ret = super
+          when String then ret.sub(/DROP CONSTRAINT/, 'DROP FOREIGN KEY')
+          else ret
+          end
+        end
+
+        def remove_foreign_key(table_name, *args)
+          case sql = remove_foreign_key_sql(table_name, *args)
+          when String then execute "ALTER TABLE #{quote_table_name(table_name)} #{sql}"
+          end
         end
 
         def foreign_keys(table_name, name = nil)
@@ -147,13 +165,15 @@ module SchemaPlus
           sql
         end
 
-        def default_expr_valid?(expr)
-          false # only the TIMESTAMP column accepts SQL column defaults and rails uses DATETIME
-        end
+        module AddColumnOptions
+          def default_expr_valid?(expr)
+            false # only the TIMESTAMP column accepts SQL column defaults and rails uses DATETIME
+          end
 
-        def sql_for_function(function)
-          case function
-          when :now then 'CURRENT_TIMESTAMP'
+          def sql_for_function(function)
+            case function
+            when :now then 'CURRENT_TIMESTAMP'
+            end
           end
         end