aspgems-redhillonrails_core 2.0.0.beta2 → 2.0.0.beta4

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

@@ -3,7 +3,7 @@ module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
     def self.included(base)
       base.class_eval do
         alias_method_chain :remove_column, :redhillonrails_core
-        alias_method_chain :remove_columns, :redhillonrails_core
+        alias_method_chain :structure_dump, :views
       end
     end
 
@@ -16,7 +16,7 @@ module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
     end
 
     def remove_foreign_key(table_name, foreign_key_name)
-      execute "ALTER TABLE #{table_name} DROP FOREIGN KEY #{foreign_key_name}"
+      execute "ALTER TABLE #{quote_table_name(table_name)} DROP FOREIGN KEY #{foreign_key_name}"
     end
 
     def remove_column_with_redhillonrails_core(table_name, *column_names)
@@ -28,7 +28,6 @@ module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
         remove_column_without_redhillonrails_core(table_name, column_name)
       end
     end
-    alias :remove_columns_with_redhillonrails_core :remove_column_with_redhillonrails_core
 
     def foreign_keys(table_name, name = nil)
       results = execute("SHOW CREATE TABLE #{quote_table_name(table_name)}", name)
@@ -58,64 +57,19 @@ module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
       foreign_keys
     end
 
-#    def reverse_foreign_keys(table_name, name = nil)
-#      results = execute(<<-SQL, name)
-#      SELECT constraint_name, table_name, column_name, referenced_table_name, referenced_column_name
-#        FROM information_schema.key_column_usage
-#        WHERE table_schema = SCHEMA()
-#          AND referenced_table_schema = table_schema
-#        ORDER BY constraint_name, ordinal_position;
-#      SQL
-#      current_foreign_key = nil
-#      foreign_keys = []
-#
-#      results.each do |row|
-#        next unless table_name.casecmp(row[3]) == 0
-#        if current_foreign_key != row[0]
-#          foreign_keys << ForeignKeyDefinition.new(row[0], row[1], [], row[3], [])
-#          current_foreign_key = row[0]
-#        end
-#
-#        foreign_keys.last.column_names << row[2]
-#        foreign_keys.last.references_column_names << row[4]
-#      end
-#
-#      foreign_keys
-#    end
-
     def reverse_foreign_keys(table_name, name = nil)
-#      @@schema ||= nil
-#      @@schema_version ||= 0
-#      current_version = ActiveRecord::Migrator.current_version
-#      if @@schema.nil? || @@schema_version != current_version
-#        @@schema_version = current_version
-#        ans = execute(<<-SQL, name)
-#        SELECT constraint_name, table_name, column_name, referenced_table_name, referenced_column_name
-#          FROM information_schema.key_column_usage
-#         WHERE table_schema = SCHEMA()
-#           AND referenced_table_schema = table_schema
-#         ORDER BY constraint_name, ordinal_position;
-#        SQL
-#        @@schema = []
-#        ans.each do | row |
-#          @@schema << [row[0], row[1], row[2], row[3], row[4]]
-#        end
-#      end
-#      results = @@schema
-
       results = execute(<<-SQL, name)
       SELECT constraint_name, table_name, column_name, referenced_table_name, referenced_column_name
-        FROM information_schema.key_column_usage
-        WHERE table_schema = SCHEMA()
-          AND referenced_table_schema = table_schema
-        ORDER BY constraint_name, ordinal_position;
+      FROM information_schema.key_column_usage
+      WHERE table_schema = SCHEMA()
+      AND referenced_table_schema = table_schema
+      ORDER BY constraint_name, ordinal_position;
       SQL
-
       current_foreign_key = nil
       foreign_keys = []
 
       results.each do |row|
-        next if row[3] != table_name
+        next unless table_name.to_s.casecmp(row[3].to_s) == 0
         if current_foreign_key != row[0]
           foreign_keys << ForeignKeyDefinition.new(row[0], row[1], [], row[3], [])
           current_foreign_key = row[0]
@@ -127,5 +81,25 @@ module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
 
       foreign_keys
     end
+
+    def views(name = nil)
+      views = []
+      execute("SHOW FULL TABLES WHERE TABLE_TYPE='VIEW'", name).each { |row| views << row[0] }
+      views
+    end
+
+    def view_definition(view_name, name = nil)
+      select_one("SHOW CREATE VIEW #{quote_table_name(view_name)}", name)["Create View"]
+    end
+
+    def structure_dump_with_views
+      structure = structure_dump_without_views
+
+      views.each do |view|
+        structure += view_definition(view) + ";\n\n"
+      end
+
+      structure
+    end
   end
 end

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

@@ -2,61 +2,75 @@ module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
   module PostgresqlAdapter
     def self.included(base)
       base.class_eval do
-        alias_method_chain :indexes, :redhillonrails_core
+        remove_method :indexes
       end
     end
 
-    def set_table_comment(table_name, comment)
-      execute "COMMENT ON TABLE #{table_name} IS '#{quote_string(comment)}'"
-    end
-
-    def clear_table_comment(table_name)
-      execute "COMMENT ON TABLE #{table_name} IS NULL"
-    end
-
     def add_index(table_name, column_name, options = {})
+      column_name, options = [], column_name if column_name.is_a?(Hash)
       column_names = Array(column_name)
-      index_name   = index_name(table_name, :column => column_names)
+      if column_names.empty?
+        raise ArgumentError, "No columns and :expression missing from options - cannot create index" if options[:expression].blank?
+        raise ArgumentError, "Index name not given. Pass :name option" if options[:name].blank?
+      end
 
-      if Hash === options # legacy support, since this param was a string
-        index_type = options[:unique] ? "UNIQUE" : ""
-        index_name = options[:name] || index_name
+      index_type = options[:unique] ? "UNIQUE" : ""
+      index_name = options[:name] || index_name(table_name, column_names)
+      conditions = options[:conditions]
+
+      if column_names.empty? then
+        sql = "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} #{options[:expression]}"
       else
-        index_type = options
-      end
+        quoted_column_names = column_names.map { |e| options[:case_sensitive] == false && e.to_s !~ /_id$/ ? "LOWER(#{quote_column_name(e)})" : quote_column_name(e) }
 
-      quoted_column_names = column_names.map { |e| options[:case_sensitive] == false && e.to_s !~ /_id$/ ? "LOWER(#{quote_column_name(e)})" : quote_column_name(e) }
+        sql = "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names.join(", ")})"
+        sql += " WHERE (#{ ::ActiveRecord::Base.send(:sanitize_sql, conditions, quote_table_name(table_name)) })" if conditions
+      end
+      execute sql
+    end
 
-      execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{table_name} (#{quoted_column_names.join(", ")})"
+    def supports_partial_indexes?
+      true
     end
 
-    def indexes_with_redhillonrails_core(table_name, name = nil)
-      indexes = indexes_without_redhillonrails_core(table_name, name)
+    def indexes(table_name, name = nil)
+      schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
       result = query(<<-SQL, name)
-        SELECT c2.relname, i.indisunique, pg_catalog.pg_get_indexdef(i.indexrelid, 0, true)
-          FROM pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_index i
-         WHERE c.relname = '#{table_name}'
-           AND c.oid = i.indrelid AND i.indexrelid = c2.oid
-           AND i.indisprimary = 'f'
-           AND i.indexprs IS NOT NULL
-         ORDER BY 1
+           SELECT distinct i.relname, d.indisunique, d.indkey, m.amname, t.oid, 
+                    pg_get_expr(d.indpred, t.oid), pg_get_expr(d.indexprs, t.oid)
+             FROM pg_class t, pg_class i, pg_index d, pg_am m
+           WHERE i.relkind = 'i'
+             AND i.relam = m.oid
+             AND d.indexrelid = i.oid
+             AND d.indisprimary = 'f'
+             AND t.oid = d.indrelid
+             AND t.relname = '#{table_name}'
+             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname IN (#{schemas}) )
+          ORDER BY i.relname
       SQL
 
-      result.each do |row|
-        if row[2]=~ /\((.*LOWER\([^:]+(::text)?\).*)\)$/i
-          indexes.delete_if { |index| index.name == row[0] }
-          column_names = $1.split(", ").map do |name|
-            name = $1 if name =~ /^LOWER\(([^:]+)(::text)?\)$/i
-            name = $1 if name =~ /^"(.*)"$/
-            name
-          end
-          index = ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, row[0], row[1] == "t", column_names)
-          index.case_sensitive = false
-          indexes << index
+      result.map do |(index_name, is_unique, indkey, kind, oid, conditions, expression)|
+        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(",")})
+        SQL
+
+        column_names = columns.values_at(*index_keys).compact
+        if md = expression.try(:match, /^lower\(\(?([^)]+)\)?(::text)?\)$/i)
+          column_names << md[1]
         end
+        index = ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, index_name, unique, column_names)
+        index.conditions = conditions
+        index.case_sensitive = !(expression =~ /lower/i)
+        index.kind = kind unless kind.downcase == "btree"
+        index.expression = expression
+        index
       end
-
-      indexes
     end
 
     def foreign_keys(table_name, name = nil)
@@ -88,7 +102,7 @@ module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
          WHERE schemaname IN (#{schemas})
       SQL
     end
-    
+
     def view_definition(view_name, name = nil)
       result = query(<<-SQL, name)
         SELECT pg_get_viewdef(oid)
@@ -106,26 +120,37 @@ module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
       foreign_keys = []
 
       query(sql, name).each do |row|
-          if row[1] =~ /^FOREIGN KEY \((.+?)\) REFERENCES (.+?)\((.+?)\)( ON UPDATE (.+?))?( ON DELETE (.+?))?( (DEFERRABLE|NOT DEFERRABLE))?$/
-              name = row[0]
-              from_table_name = row[2]
-              column_names = $1
-              references_table_name = $2
-              references_column_names = $3
-              on_update = $5
-              on_delete = $7
-              deferrable = $9 == "DEFERRABLE"
-              on_update = on_update.downcase.gsub(' ', '_').to_sym if on_update
-              on_delete = on_delete.downcase.gsub(' ', '_').to_sym if on_delete
-
-              foreign_keys << ForeignKeyDefinition.new(name,
-                                             from_table_name, column_names.split(', '),
-                                             references_table_name.sub(/^"(.*)"$/, '\1'), references_column_names.split(', '),
-                                             on_update, on_delete, deferrable)
-          end
+        if row[1] =~ /^FOREIGN KEY \((.+?)\) REFERENCES (.+?)\((.+?)\)( ON UPDATE (.+?))?( ON DELETE (.+?))?( (DEFERRABLE|NOT DEFERRABLE))?$/
+          name = row[0]
+          from_table_name = row[2]
+          column_names = $1
+          references_table_name = $2
+          references_column_names = $3
+          on_update = $5
+          on_delete = $7
+          deferrable = $9 == "DEFERRABLE"
+          on_update = on_update.downcase.gsub(' ', '_').to_sym if on_update
+          on_delete = on_delete.downcase.gsub(' ', '_').to_sym if on_delete
+
+          foreign_keys << ForeignKeyDefinition.new(name,
+                                                   from_table_name, column_names.split(', '),
+                                                   references_table_name.sub(/^"(.*)"$/, '\1'), references_column_names.split(', '),
+                                                   on_update, on_delete, deferrable)
+        end
       end
 
       foreign_keys
     end
+
+    # Converts form like: column1, LOWER(column2)
+    # to: column1, column2
+    def determine_index_column_names(column_definitions)
+      column_definitions.split(", ").map do |name|
+        name = $1 if name =~ /^LOWER\(([^:]+)(::text)?\)$/i
+        name = $1 if name =~ /^"(.*)"$/
+        name
+      end
+    end
+
   end
 end

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

@@ -0,0 +1,30 @@
+module RedhillonrailsCore
+  module ActiveRecord
+    module Migration
+      module CommandRecorder
+        def add_foreign_key(*args)
+          record(:add_foreign_key, args)
+        end
+
+        def remove_foreign_key(*args)
+          record(:remove_foreign_key, args)
+        end
+
+        def invert_add_foreign_key(args)
+          from_table, to_table, add_options = *args
+          add_options ||= {}
+
+          if add_options[:name]
+            options = {:name => add_options[:name]}
+          elsif add_options[:column]
+            options = {:column => add_options[:column]}
+          else
+            options = to_table
+          end
+
+          [:remove_foreign_key, [from_table, options]]
+        end
+      end
+    end
+  end
+end

data/lib/redhillonrails_core/active_record/schema_dumper.rb

@@ -25,12 +25,24 @@ module RedhillonrailsCore::ActiveRecord
     def indexes_with_redhillonrails_core(table, stream)
       if (indexes = @connection.indexes(table)).any?
         add_index_statements = indexes.map do |index|
-          statement_parts = [('add_index ' + index.table.inspect)]
-          statement_parts << index.columns.inspect
-          statement_parts << (':name => ' + index.name.inspect)
-          statement_parts << ':unique => true' if index.unique
-          # This only used in postgresql
-          statement_parts << ':case_sensitive => false' unless index.case_sensitive?
+
+          if index.columns.any?
+            statement_parts = [('add_index ' + index.table.inspect)]
+            statement_parts << index.columns.inspect
+            statement_parts << (':name => ' + index.name.inspect)
+            statement_parts << ':unique => true' if index.unique
+            # This only used in postgresql - :case_sensitive, :conditions, :kind, :expression
+            statement_parts << ':case_sensitive => false' unless index.case_sensitive?
+            statement_parts << ':conditions => ' + index.conditions.inspect unless index.conditions.blank?
+            statement_parts << ':kind => ' + index.kind.inspect unless index.kind.blank?
+            statement_parts << ':expression => ' + index.expression.inspect unless index.expression.blank?
+          else
+            # This only used in postgresql - :case_sensitive, :conditions, :kind, :expression
+            statement_parts = [('add_index ' + index.table.inspect)]
+            statement_parts << (':name => ' + index.name.inspect)
+            statement_parts << ':kind => ' + index.kind.inspect unless index.kind.blank?
+            statement_parts << ':expression => ' + index.expression.inspect unless index.expression.blank?
+          end
 
           if index.respond_to?(:lengths)
             index_lengths = index.lengths.compact if index.lengths.is_a?(Array)

data/lib/redhillonrails_core/version.rb

@@ -1,3 +1,3 @@
 module RedhillonrailsCore
-  VERSION = "2.0.0.beta2"
+  VERSION = "2.0.0.beta4"
 end

data/redhillonrails_core.gemspec

@@ -20,7 +20,8 @@ Gem::Specification.new do |s|
   s.add_dependency("activerecord", ">= 2")
   s.add_dependency("activesupport", ">= 2")
 
-  s.add_development_dependency("rspec", "~> 2.5.0")
+  # Development dependencies through thorfile
+  s.add_development_dependency("rspec", "~> 2.6.0")
   s.add_development_dependency("pg")
   s.add_development_dependency("mysql")
   s.add_development_dependency("mysql2")

data/spec/command_recorder_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Command Recorder' do
+  if defined?(ActiveRecord::Migration::CommandRecorder)
+    before do
+      @recorder = ActiveRecord::Migration::CommandRecorder.new
+    end
+
+    it 'invert_add_foreign_key' do
+      @recorder.add_foreign_key(:employees, :companies)
+      remove = @recorder.inverse.first
+      remove.should == [:remove_foreign_key, [:employees, :companies]]
+    end
+
+    it 'invert_add_foreign_key with column' do
+      @recorder.add_foreign_key(:employees, :companies, :column => :place_id)
+      remove = @recorder.inverse.first
+      remove.should == [:remove_foreign_key, [:employees, {:column => :place_id}]]
+    end
+
+    it 'invert_add_foreign_key with name' do
+      @recorder.add_foreign_key(:employees, :companies, :name => 'the_best_fk', :column => :place_id)
+      remove = @recorder.inverse.first
+      remove.should == [:remove_foreign_key, [:employees, {:name => 'the_best_fk'}]]
+
+      @recorder.record :rename_table, [:old, :new]
+      rename = @recorder.inverse.first
+      rename.should == [:rename_table, [:new, :old]]
+    end
+
+    it 'remove_foreign_key is irreversible' do
+      @recorder.remove_foreign_key(:employees, :companies)
+      expect {
+        @recorder.inverse
+      }.to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+
+end

data/spec/connections/mysql/connection.rb

@@ -4,15 +4,13 @@ require 'logger'
 ActiveRecord::Base.logger = Logger.new("debug.log")
 
 ActiveRecord::Base.configurations = {
-  'redhillonrails' => {
+  'mysql' => {
     :adapter => 'mysql',
-    :database => 'rh_core_unittest',
-    :username => 'rh_core',
+    :database => 'redhillonrails_core',
+    :username => (ENV["TRAVIS"] ? '' : 'redhillonrails'),
     :encoding => 'utf8',
-    :socket => '/var/run/mysqld/mysqld.sock',
-    :min_messages => 'warning'
   }
 
 }
 
-ActiveRecord::Base.establish_connection 'redhillonrails'
+ActiveRecord::Base.establish_connection 'mysql'

data/spec/connections/mysql2/connection.rb

@@ -4,15 +4,13 @@ require 'logger'
 ActiveRecord::Base.logger = Logger.new("debug.log")
 
 ActiveRecord::Base.configurations = {
-  'redhillonrails' => {
+  'mysql2' => {
     :adapter => 'mysql2',
-    :database => 'rh_core_unittest',
-    :username => 'rh_core',
+    :database => 'redhillonrails_core',
+    :username => (ENV["TRAVIS"] ? '' : 'redhillonrails'),
     :encoding => 'utf8',
-    :socket => '/var/run/mysqld/mysqld.sock',
-    :min_messages => 'warning'
   }
 
 }
 
-ActiveRecord::Base.establish_connection 'redhillonrails'
+ActiveRecord::Base.establish_connection 'mysql2'