schema_plus 1.2.0 → 1.3.0

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

@@ -6,9 +6,13 @@ module SchemaPlus
         # Extracts the value from a PostgreSQL column default definition.
         def self.included(base) #:nodoc:
           base.extend ClassMethods
-          base.class_eval do
-            class << self
-              alias_method_chain :extract_value_from_default, :schema_plus
+          if defined?(JRUBY_VERSION)
+            base.alias_method_chain :default_value, :schema_plus
+          else
+            base.class_eval do
+              class << self
+                alias_method_chain :extract_value_from_default, :schema_plus
+              end
             end
           end
         end
@@ -23,16 +27,22 @@ module SchemaPlus
           super(name, default, sql_type, null)
         end
 
+        def default_value_with_schema_plus(default)
+          value = default_value_without_schema_plus(default)
+          self.class.convert_default_value(default, value)
+        end
+
         module ClassMethods
           def extract_value_from_default_with_schema_plus(default)
-
-
             value = extract_value_from_default_without_schema_plus(default)
+            convert_default_value(default, value)
+          end
 
-            # in some cases (e.g. if change_column_default(table, column,
-            # nil) is used), postgresql will return NULL::xxxxx (rather
-            # than nil) for a null default -- make sure we treat it as nil,
-            # not as a function.
+          # in some cases (e.g. if change_column_default(table, column,
+          # nil) is used), postgresql will return NULL::xxxxx (rather
+          # than nil) for a null default -- make sure we treat it as nil,
+          # not as a function.
+          def convert_default_value(default, value)
             default = nil if value.nil? && default =~ /\ANULL::(?:character varying|bpchar|text)\z/m
 
             if value.nil? && !default.nil?
@@ -49,11 +59,11 @@ module SchemaPlus
 
         def self.included(base) #:nodoc:
           base.class_eval do
-            if ::ActiveRecord::VERSION::MAJOR.to_i < 4
+            if ::ActiveRecord::VERSION::MAJOR.to_i < 4 && !defined?(JRUBY_VERSION)
               remove_method :indexes
             end
             alias_method_chain :rename_table, :schema_plus
-            alias_method_chain :exec_cache, :schema_plus
+            alias_method_chain :exec_cache, :schema_plus unless defined?(JRUBY_VERSION)
           end
           ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.send(:include, PostgreSQLColumn) unless ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.include?(PostgreSQLColumn)
         end
@@ -130,7 +140,7 @@ module SchemaPlus
           result = query(<<-SQL, name)
 
            SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
-                  m.amname, pg_get_expr(d.indpred, t.oid), pg_get_expr(d.indexprs, t.oid)
+                  m.amname, pg_get_expr(d.indpred, t.oid) as conditions, pg_get_expr(d.indexprs, t.oid) as expression
            FROM pg_class t
            INNER JOIN pg_index d ON t.oid = d.indrelid
            INNER JOIN pg_class i ON d.indexrelid = i.oid
@@ -146,29 +156,38 @@ module SchemaPlus
             unique = (is_unique == 't')
             index_keys = indkey.split(" ")
 
-            columns = Hash[query(<<-SQL, "Columns for index #{index_name} on #{table_name}")]
-            SELECT a.attnum, a.attname
-            FROM pg_attribute a
-            WHERE a.attrelid = #{oid}
-            AND a.attnum IN (#{index_keys.join(",")})
+            rows = query(<<-SQL, "Columns for index #{index_name} on #{table_name}")
+              SELECT CAST(a.attnum as VARCHAR), a.attname, t.typname
+              FROM pg_attribute a
+              INNER JOIN pg_type t ON a.atttypid = t.oid
+              WHERE a.attrelid = #{oid}
             SQL
+            columns = {}
+            types = {}
+            rows.each do |num, name, type|
+              columns[num] = name
+              types[name] = type
+            end
 
             column_names = columns.values_at(*index_keys).compact
             case_sensitive = true
 
             # extract column names from the expression, for a
-            # case-insensitive index
+            # case-insensitive index.
+            # only applies to character, character varying, and text
             if expression
               rexp_lower = %r{\blower\(\(?([^)]+)(\)::text)?\)}
               if expression.match /\A#{rexp_lower}(?:, #{rexp_lower})*\z/
-                case_insensitive_columns = expression.scan(rexp_lower).map(&:first)
-                column_names = index_keys.map do |index_key|
-                  index_key == '0' ? case_insensitive_columns.shift : columns[index_key]
+                case_insensitive_columns = expression.scan(rexp_lower).map(&:first).select{|column| %W[char varchar text].include? types[column]}
+                if case_insensitive_columns.any?
+                  case_sensitive = false
+                  column_names = index_keys.map { |index_key|
+                    index_key == '0' ? case_insensitive_columns.shift : columns[index_key]
+                  }.compact
                 end
-                case_sensitive = false
               end
             end
-            
+
             # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
             desc_order_columns = inddef.scan(/(\w+) DESC/).flatten
             orders = desc_order_columns.any? ? Hash[column_names.map {|column| [column, desc_order_columns.include?(column) ? :desc : :asc]}] : {}
@@ -184,6 +203,10 @@ module SchemaPlus
           end
         end
 
+        def query(*args)
+          select(*args).map(&:values)
+        end if defined?(JRUBY_VERSION)
+
         def rename_table_with_schema_plus(oldname, newname) #:nodoc:
           rename_table_without_schema_plus(oldname, newname)
           rename_indexes_and_foreign_keys(oldname, newname)
@@ -289,14 +312,16 @@ module SchemaPlus
           foreign_keys
         end
 
-        def default_expr_valid?(expr)
-          true # arbitrary sql is okay in PostgreSQL
-        end
+        module AddColumnOptions
+          def default_expr_valid?(expr)
+            true # arbitrary sql is okay in PostgreSQL
+          end
 
-        def sql_for_function(function)
-          case function
-            when :now
-              "NOW()"
+          def sql_for_function(function)
+            case function
+              when :now
+                "NOW()"
+            end
           end
         end
       end

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

@@ -76,6 +76,7 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
       # an error.)
       #
       def add_index_with_schema_plus(table, columns, options={})
+        options.delete(:if_exists)
         add_index_without_schema_plus(table, columns, options)
       rescue => e
         SchemaStatements.add_index_exception_handler(self, table, columns, options, e)

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

@@ -21,6 +21,7 @@ module SchemaPlus
             alias_method_chain :indexes, :schema_plus
             alias_method_chain :rename_table, :schema_plus
           end
+
           if ::ActiveRecord::VERSION::MAJOR.to_i < 4
             ::ActiveRecord::ConnectionAdapters::SQLiteColumn.send(:include, SQLiteColumn) unless ::ActiveRecord::ConnectionAdapters::SQLiteColumn.include?(SQLiteColumn)
           else
@@ -116,14 +117,16 @@ module SchemaPlus
           foreign_keys
         end
 
-        def default_expr_valid?(expr)
-          true # arbitrary sql is okay
-        end
+        module AddColumnOptions
+          def default_expr_valid?(expr)
+            true # arbitrary sql is okay
+          end
 
-        def sql_for_function(function)
-          case function
-            when :now
-              "(DATETIME('now'))"
+          def sql_for_function(function)
+            case function
+              when :now
+                "(DATETIME('now'))"
+            end
           end
         end
       end

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

@@ -171,23 +171,14 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
     def remove_foreign_key(_, *args) #:nodoc:
     end
 
-    # This is a deliberately empty stub.  In fact, verifying that it won't
-    # ever be called.  The reason for it is that ColumnOptionsHandler will
-    # remove a previous index when changing a column.  But we don't do
-    # column changes within table definitions.
-    def remove_index(_, options) raise "InternalError: remove_index called in a table definition" ; end
-
-    # Determines if an indexes is queued to be created.  Called from
-    # ColumnOptionsHandler as part of checking whether to auto-create an index
-    def index_exists?(_, column_name, options={})
-      if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-        @indexes.find{|index| index.table == self.name && index.columns == Array.wrap(column_name) && options.all?{|k, v| index.send(k) == v}}
-      else
-        @indexes.find {|index_column_name, index_options| Array.wrap(index_column_name) == Array.wrap(column_name) && options.all?{|k, v| index_options[k] == v} }
-      end
+    # This is a deliberately empty stub.  The reason for it is that
+    # ColumnOptionsHandler will remove a previous index when changing a
+    # column.  But we don't do column changes within table definitions.
+    # Presumably will be called with :if_exists true.  If not, will raise
+    # an error.
+    def remove_index(_, options)
+      raise "InternalError: remove_index called in a table definition" unless options[:if_exists]
     end
 
-
-
   end
 end

data/lib/schema_plus/active_record/migration/command_recorder.rb

@@ -0,0 +1,88 @@
+module SchemaPlus
+  module ActiveRecord
+    module Migration
+      module CommandRecorder
+        include SchemaPlus::ActiveRecord::ColumnOptionsHandler
+
+        attr_accessor :schema_plus_config #:nodoc:
+
+        def self.included(base) #:nodoc:
+          base.class_eval do
+            alias_method_chain :add_column, :schema_plus
+            alias_method_chain :add_reference, :schema_plus unless ::ActiveRecord::VERSION::MAJOR.to_i < 4
+            alias_method_chain :invert_add_index, :schema_plus
+          end
+        end
+
+        def add_column_with_schema_plus(table_name, name, type, options = {}) #:nodoc:
+          add_column_without_schema_plus(table_name, name, type, options)
+          revertable_schema_plus_handle_column_options(table_name, name, options, :config => schema_plus_config)
+          self
+        end
+
+        # seems like this is fixing a rails bug:
+        #   change_table foo, :bulk => true { |t| t.references :bar } 
+        # results in an 'unknown method :add_reference_sql' (with mysql2)
+        #
+        # should track it down separately and submit a patch/fix to rails
+        #
+        def add_reference_with_schema_plus(table_name, ref_name, options = {}) #:nodoc:
+          # which is the worse hack...?
+          if RUBY_VERSION >= "2.0.0"
+            # .. rebinding a method from a different module?  (can't do this in ruby 1.9.3)
+            ::ActiveRecord::ConnectionAdapters::SchemaStatements.instance_method(:add_reference).bind(self).call(table_name, ref_name, options)
+          else
+            # .. or copying and pasting the code?
+            polymorphic = options.delete(:polymorphic)
+            index_options = options.delete(:index)
+            add_column(table_name, "#{ref_name}_id", :integer, options)
+            add_column(table_name, "#{ref_name}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : options) if polymorphic
+            add_index(table_name, polymorphic ? %w[id type].map{ |t| "#{ref_name}_#{t}" } : "#{ref_name}_id", index_options.is_a?(Hash) ? index_options : nil) if index_options
+          end
+
+          self
+        end
+
+        if ::ActiveRecord::VERSION::MAJOR >= 4
+          def revertable_schema_plus_handle_column_options(table_name, name, options, config)
+            length = commands.length
+            schema_plus_handle_column_options(table_name, name, options, config)
+            if reverting
+              rev = []
+              while commands.length > length
+                cmd = commands.pop
+                rev.unshift cmd unless cmd[0].to_s =~ /^add_/
+              end
+              commands.concat rev
+            end
+          end
+        else
+          alias :revertable_schema_plus_handle_column_options :schema_plus_handle_column_options
+        end
+
+        def add_foreign_key(*args)
+          record(:add_foreign_key, args)
+        end
+        
+        def invert_add_foreign_key(args)
+          table_name, column_names, references_table_name, references_column_names, options = args
+          [:remove_foreign_key, [table_name, column_names, references_table_name, references_column_names, (options||{}).merge(if_exists: true)]]
+        end
+
+        def invert_add_index_with_schema_plus(args)
+          table, columns, options = *args
+          [:remove_index, [table, (options||{}).merge(column: columns, if_exists: true)]]
+        end
+
+        def remove_foreign_key(*args)
+          record(:remove_foreign_key, args)
+        end
+
+        def invert_remove_foreign_key(args)
+          [:add_foreign_key, args]
+        end
+
+      end
+    end
+  end
+end

data/lib/schema_plus/active_record/schema_dumper.rb

@@ -126,7 +126,7 @@ module SchemaPlus
             dump << ", :conditions => #{index.conditions.inspect}" unless index.conditions.blank?
             index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
             dump << ", :length => #{Hash[*index.columns.zip(index.lengths).flatten].inspect}" if index_lengths.present?
-            dump << ", :order => {" + index.columns.map{|column| column.inspect + " => " + (index.orders[column] || :asc).inspect}.join(", ") + "}" if index.orders
+            dump << ", :order => {" + index.orders.map{|column, val| "#{column.inspect} => #{val.inspect}"}.join(", ") + "}" unless index.orders.blank?
           else
             dump << " :name => #{index.name.inspect}"
             dump << ", :kind => \"#{index.kind}\"" unless index.kind.blank?

data/lib/schema_plus/version.rb

@@ -1,3 +1,3 @@
 module SchemaPlus
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/lib/schema_plus.rb

@@ -13,6 +13,7 @@ require 'schema_plus/active_record/connection_adapters/abstract_adapter'
 require 'schema_plus/active_record/connection_adapters/column'
 require 'schema_plus/active_record/connection_adapters/foreign_key_definition'
 require 'schema_plus/active_record/connection_adapters/index_definition'
+require 'schema_plus/active_record/migration/command_recorder'
 require 'schema_plus/railtie' if defined?(Rails::Railtie)
 
 module SchemaPlus
@@ -124,10 +125,18 @@ module SchemaPlus
     ::ActiveRecord::ConnectionAdapters::IndexDefinition.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::IndexDefinition)
     ::ActiveRecord::ConnectionAdapters::SchemaStatements.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::SchemaStatements)
     ::ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::TableDefinition)
+    ::ActiveRecord::Migration::CommandRecorder.send(:include, SchemaPlus::ActiveRecord::Migration::CommandRecorder)
+
+    if "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}".to_r >= "4.1".to_r
+      ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter::AddColumnOptions)
+    else
+      ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter::AddColumnOptions)
+    end
 
     if ::ActiveRecord::VERSION::MAJOR.to_i >= 4
-      ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation)
+      ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter::VisitTableDefinition)
     end
+
   end
 
   def self.insert #:nodoc:

data/runspecs

@@ -5,8 +5,8 @@ require 'ostruct'
 require 'shellwords'
 require 'tempfile'
 
-RUBY_VERSIONS = %W[1.9.3 2.0.0]
-RAILS_VERSIONS = %W[3.2 4.0]
+RUBY_VERSIONS = %W[jruby 1.9.3 2.0.0]
+RAILS_VERSIONS = %W[3.2 edge 4.0]
 DB_ADAPTERS = %W[postgresql mysql mysql2 sqlite3]
 
 o = OpenStruct.new
@@ -66,14 +66,33 @@ combos = o.ruby_versions.product(o.rails_versions, o.db_adapters).map{|product|
     case
     when combo.rails >= "3.2" && combo.ruby <= "1.8.7" then false  # no longer happens, just keeping it as an example
     when combo.rails >= "4" && combo.db_adapter == "mysql" then false
+    when combo.ruby == "jruby"
+      case
+      when combo.rails == "3.2" && combo.db_adapter == "postgresql" then true
+      else false
+      end
     else true
     end
 }
 
-def ruby_version_selector(ruby)
-    if @use_rvm ||= system("which -s rvm")
+if system("which -s rvm")
+    # using rvm
+    def ruby_version_selector(ruby)
         "rvm #{ruby} do"
-    else
+    end
+else
+    # using rbenv.
+    #
+    # because we're running within a ruby program that was launched by
+    # rbenv, we already have various environment variables set up.  need
+    # strip those out so that the forked shell can run a diifferent ruby
+    # version than the one we're in now.
+    ENV['PATH'] = ENV['PATH'].split(':').reject{|dir| dir =~ %r{/rbenv/(?!shims)}}.join(':')
+    ENV['GEM_PATH'] = ENV['GEM_PATH'].split(':').reject{|dir| dir =~ %r{/rbenv}}.join(':')
+    ENV['RBENV_DIR'] = nil
+    ENV['RBENV_HOOK_PATH'] = nil
+
+    def ruby_version_selector(ruby)
         @versions ||= `rbenv versions --bare`.split
         version = @versions.select{|v| v.start_with? ruby}.last || abort("no ruby version '#{ruby}' installed in rbenv")
         "RBENV_VERSION=#{version}"

data/spec/column_definition_spec.rb

@@ -23,7 +23,13 @@ describe "Column definition" do
     end
   end
 
-  let(:connection) { ActiveRecord::Base.connection }
+  def call_add_column_options!(*params, &block)
+    if ::ActiveRecord::VERSION::MAJOR >= 4
+      ActiveRecord::Base.connection.schema_creation.send(:add_column_options!, *params, &block)
+    else
+      ActiveRecord::Base.connection.add_column_options!(*params, &block)
+    end
+  end
 
   context "text columns" do
     before(:each) do
@@ -32,7 +38,7 @@ describe "Column definition" do
 
     context "just default passed" do
       before(:each) do
-        connection.add_column_options!(@sql, { :default => "2011-12-11 00:00:00" })
+        call_add_column_options!(@sql, { :default => "2011-12-11 00:00:00" })
       end
 
       subject { @sql}
@@ -44,7 +50,7 @@ describe "Column definition" do
 
     context "just default passed in hash" do
       before(:each) do
-        connection.add_column_options!(@sql, { :default => { :value => "2011-12-11 00:00:00" } })
+        call_add_column_options!(@sql, { :default => { :value => "2011-12-11 00:00:00" } })
       end
 
       subject { @sql}
@@ -54,10 +60,34 @@ describe "Column definition" do
       end
     end
 
+    context "default passed with no nulls" do
+      before(:each) do
+        call_add_column_options!(@sql, { :default => "2011-12-11 00:00:00", null: false })
+      end
+
+      subject { @sql}
+
+      it "should use the normal default" do
+        should == "time_taken text DEFAULT '2011-12-11 00:00:00' NOT NULL"
+      end
+    end
+
+    context "default passed in hash with no nulls" do
+      before(:each) do
+        call_add_column_options!(@sql, { :default => { :value => "2011-12-11 00:00:00" }, null: false })
+      end
+
+      subject { @sql}
+
+      it "should use the normal default" do
+        should == "time_taken text DEFAULT '2011-12-11 00:00:00' NOT NULL"
+      end
+    end
+
     context "default function passed as now" do
       before(:each) do
         begin
-          connection.add_column_options!(@sql, { :default => :now })
+          call_add_column_options!(@sql, { :default => :now })
         rescue ArgumentError => e
           @raised_argument_error = e
         end
@@ -84,8 +114,38 @@ describe "Column definition" do
       end
     end
 
+    context "default function passed as now with no nulls" do
+      before(:each) do
+        begin
+          call_add_column_options!(@sql, { :default => :now, null: false })
+        rescue ArgumentError => e
+          @raised_argument_error = e
+        end
+      end
+
+      subject { @sql }
+
+      if SchemaPlusHelpers.postgresql?
+        it "should use NOW() as the default" do
+          should == "time_taken text DEFAULT NOW() NOT NULL"
+        end
+      end
+
+      if SchemaPlusHelpers.sqlite3?
+        it "should use NOW() as the default" do
+          should == "time_taken text DEFAULT (DATETIME('now')) NOT NULL"
+        end
+      end
+
+      if SchemaPlusHelpers.mysql?
+        it "should raise an error" do
+          @raised_argument_error.should be_a ArgumentError
+        end
+      end
+    end
+
     context "valid expr passed as default" do
-      subject { connection.add_column_options!(@sql, { :default => { :expr => 'NOW()' } }); @sql }
+      subject { call_add_column_options!(@sql, { :default => { :expr => 'NOW()' } }); @sql }
 
       if SchemaPlusHelpers.postgresql?
         it "should use NOW() as the default" do
@@ -109,11 +169,11 @@ describe "Column definition" do
     context "invalid expr passed as default" do
       if SchemaPlusHelpers.mysql?
         it "should raise an error" do
-          lambda {connection.add_column_options!(@sql, { :default => { :expr => "ARBITRARY_EXPR" } })}.should raise_error ArgumentError
+          lambda {call_add_column_options!(@sql, { :default => { :expr => "ARBITRARY_EXPR" } })}.should raise_error ArgumentError
         end
       else
         it "should just accept the SQL" do
-          connection.add_column_options!(@sql, { :default => { :expr => "ARBITRARY_EXPR" } })
+          call_add_column_options!(@sql, { :default => { :expr => "ARBITRARY_EXPR" } })
           @sql.should == "time_taken text DEFAULT ARBITRARY_EXPR"
         end
       end
@@ -127,7 +187,7 @@ describe "Column definition" do
 
     context "passed as boolean false" do
       before(:each) do
-        connection.add_column_options!(@sql, { :default => false })
+        call_add_column_options!(@sql, { :default => false })
       end
 
       subject { @sql}
@@ -139,7 +199,7 @@ describe "Column definition" do
 
     context "passed as boolean true" do
       before(:each) do
-        connection.add_column_options!(@sql, { :default => true })
+        call_add_column_options!(@sql, { :default => true })
       end
 
       subject { @sql}

data/spec/index_definition_spec.rb

@@ -180,6 +180,31 @@ describe "Index definition" do
 
     end
 
+    context "when index has a non-btree type" do
+      before(:each) do
+        migration.execute "CREATE INDEX users_login_index ON users USING hash(login)"
+        User.reset_column_information
+        @index = User.indexes.detect { |i| i.name == "users_login_index" }
+      end
+
+      it "exists" do
+        @index.should_not be_nil
+      end
+
+      it "defines kind" do
+        @index.kind.should == "hash"
+      end
+
+      it "does not define expression" do
+        @index.expression.should be_nil
+      end
+
+      it "does not define order" do
+        @index.orders.should be_blank
+      end
+    end
+
+
   end # of postgresql specific examples
 
   protected

data/spec/index_spec.rb

@@ -103,7 +103,7 @@ describe "add_index" do
 
     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.expression.present? }
+      @index = User.indexes.detect { |i| i.name == 'users_login_index' }
       @index.expression.should == "upper((login)::text)"
     end