aspgems-redhillonrails_core 2.0.0.beta1

data/lib/redhillonrails_core/active_record/base.rb

@@ -0,0 +1,45 @@
+module RedhillonrailsCore::ActiveRecord
+  module Base
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        class << base
+          alias_method_chain :abstract_class?, :redhillonrails_core
+          alias_method_chain :reset_column_information, :redhillonrails_core
+        end
+      end
+
+      def base_class?
+        self == base_class
+      end
+
+      def abstract_class_with_redhillonrails_core?
+        abstract_class_without_redhillonrails_core? || !(name =~ /^Abstract/).nil?
+      end
+
+      def reset_column_information_with_redhillonrails_core
+        reset_column_information_without_redhillonrails_core
+        @indexes = @foreign_keys = nil
+      end
+
+      def pluralized_table_name(table_name)
+        ActiveRecord::Base.pluralize_table_names ? table_name.to_s.pluralize : table_name
+      end
+
+      def indexes
+        @indexes ||= connection.indexes(table_name, "#{name} Indexes")
+      end
+
+      def foreign_keys
+        @foreign_keys ||= connection.foreign_keys(table_name, "#{name} Foreign Keys")
+      end
+
+      def reverse_foreign_keys
+        connection.reverse_foreign_keys(table_name, "#{name} Reverse Foreign Keys")
+      end
+    end
+  end
+end

data/lib/redhillonrails_core/active_record/connection_adapters/abstract/column.rb

@@ -0,0 +1,14 @@
+module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
+	module Column
+
+	  def required_on
+	    if null
+	      nil
+	    elsif default.nil?
+	      :save
+	    else
+	      :update
+	    end
+	  end
+	end
+end

data/lib/redhillonrails_core/active_record/connection_adapters/abstract/foreign_key_definition.rb

@@ -0,0 +1,63 @@
+module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
+  class ForeignKeyDefinition < Struct.new(:name, :table_name, :column_names, :references_table_name, :references_column_names, :on_update, :on_delete, :deferrable)
+    ACTIONS = {:cascade => "CASCADE", :restrict => "RESTRICT", :set_null => "SET NULL", :set_default => "SET DEFAULT", :no_action => "NO ACTION"}.freeze
+
+    def initialize(name, table_name, column_names, references_table_name, references_column_names, on_update = nil, on_delete = nil, deferrable = nil)
+      super(name, unquote(table_name), unquote(column_names), unquote(references_table_name), unquote(references_column_names), on_update, on_delete, deferrable)
+    end
+
+    def to_dump
+      dump = "add_foreign_key"
+      dump << " #{table_name.inspect}, [#{Array(column_names).collect { |name| name.inspect }.join(', ')}]"
+      dump << ", #{references_table_name.inspect}, [#{Array(references_column_names).collect { |name| name.inspect }.join(', ')}]"
+      dump << ", :on_update => :#{on_update}" if on_update
+      dump << ", :on_delete => :#{on_delete}" if on_delete
+      dump << ", :deferrable => #{deferrable}" if deferrable
+      dump << ", :name => #{name.inspect}" if name
+      dump
+    end
+
+    def to_sql
+      sql = name ? "CONSTRAINT #{name} " : ""
+      sql << "FOREIGN KEY (#{Array(quoted_column_names).join(", ")}) REFERENCES #{quoted_references_table_name} (#{Array(quoted_references_column_names).join(", ")})"
+      sql << " ON UPDATE #{ACTIONS[on_update]}" if on_update
+      sql << " ON DELETE #{ACTIONS[on_delete]}" if on_delete
+      sql << " DEFERRABLE" if deferrable
+      sql
+    end
+
+    alias :to_s :to_sql
+
+    def quoted_column_names
+      Array(column_names).collect { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
+    end
+
+    def quoted_references_column_names
+      Array(references_column_names).collect { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
+    end
+
+#    def quoted_table_name
+#      ::ActiveRecord::Base.connection.quote_table_name(table_name)
+#    end
+#
+    def quoted_references_table_name
+      ::ActiveRecord::Base.connection.quote_table_name(references_table_name)
+    end
+
+    def quote(name)
+      ::ActiveRecord::Base.connection.quote(name)
+    end
+
+    def unquote(names)
+      if names.is_a?(Array)
+        names.collect { |name| __unqoute(name) }
+      else
+        __unqoute(names)
+      end
+    end
+
+    def __unqoute(value)
+      value.to_s.sub(/^["`](.*)["`]$/, '\1')
+    end
+  end
+end

data/lib/redhillonrails_core/active_record/connection_adapters/abstract/index_definition.rb

@@ -0,0 +1,11 @@
+module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
+	module IndexDefinition
+		def case_sensitive?
+			@case_sensitive.nil? ? true : @case_sensitive
+		end
+
+		def case_sensitive=(case_sensitive)
+			@case_sensitive = case_sensitive
+		end
+	end
+end

data/lib/redhillonrails_core/active_record/connection_adapters/abstract/schema_statements.rb

@@ -0,0 +1,23 @@
+module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
+	module SchemaStatements
+		def self.included(base)
+			base.module_eval do
+				alias_method_chain :create_table, :redhillonrails_core
+			end
+		end
+
+		def create_table_with_redhillonrails_core(name, options = {})
+			if options.include?(:comment)
+				options = options.dup
+				comment = options.delete(:comment)
+			end
+
+			create_table_without_redhillonrails_core(name, options) do |table_defintion|
+				table_defintion.name = name
+				yield table_defintion if block_given?
+			end
+
+			set_table_comment(name, comment) if comment
+		end
+	end
+end

data/lib/redhillonrails_core/active_record/connection_adapters/abstract/table_definition.rb

@@ -0,0 +1,27 @@
+module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
+  module TableDefinition
+    def self.included(base)
+      base.class_eval do
+        attr_accessor :name
+        alias_method_chain :initialize, :redhillonrails_core
+        alias_method_chain :to_sql, :redhillonrails_core
+      end
+    end
+
+    def initialize_with_redhillonrails_core(*args)
+      initialize_without_redhillonrails_core(*args)
+      @foreign_keys = []
+    end
+
+    def foreign_key(column_names, references_table_name, references_column_names, options = {})
+      @foreign_keys << ForeignKeyDefinition.new(options[:name], nil, column_names, ActiveRecord::Migrator.proper_table_name(references_table_name), references_column_names, options[:on_update], options[:on_delete], options[:deferrable])
+      self
+    end
+
+    def to_sql_with_redhillonrails_core
+      sql = to_sql_without_redhillonrails_core
+      sql << ', ' << @foreign_keys * ', ' unless @foreign_keys.empty? || ActiveRecord::Schema.defining?
+      sql
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
+  module AbstractAdapter
+    def self.included(base)
+      base.module_eval do
+        alias_method_chain :initialize, :redhillonrails_core
+        alias_method_chain :drop_table, :redhillonrails_core
+      end
+    end
+
+    def initialize_with_redhillonrails_core(*args)
+      initialize_without_redhillonrails_core(*args)
+      adapter = nil
+      case adapter_name
+        # name of MySQL adapter depends on mysql gem
+        # * with mysql gem adapter is named MySQL
+        # * with mysql2 gem adapter is named Mysql2
+        # Here we handle this and hopefully futher adapter names
+        when /^MySQL/i
+          adapter = 'MysqlAdapter'
+        when 'PostgreSQL'
+          adapter = 'PostgresqlAdapter'
+        when 'SQLite'
+          adapter = 'Sqlite3Adapter'
+      end
+      if adapter
+        adapter_module = RedhillonrailsCore::ActiveRecord::ConnectionAdapters.const_get(adapter)
+        self.class.send(:include, adapter_module) unless self.class.include?(adapter_module)
+      end
+      # Needed from mysql2 >= 0.2.7
+      if adapter_name =~ /^Mysql2/i && defined?(ActiveRecord::ConnectionAdapters::Mysql2IndexDefinition)
+        index_definition_module = RedhillonrailsCore::ActiveRecord::ConnectionAdapters::IndexDefinition
+        ActiveRecord::ConnectionAdapters::Mysql2IndexDefinition.send(:include, index_definition_module) unless ActiveRecord::ConnectionAdapters::Mysql2IndexDefinition.include?(index_definition_module)
+      end
+    end
+    
+    def create_view(view_name, definition)
+      execute "CREATE VIEW #{view_name} AS #{definition}"
+    end
+    
+    def drop_view(view_name)
+      execute "DROP VIEW #{view_name}"
+    end
+    
+    def views(name = nil)
+      []
+    end
+    
+    def view_definition(view_name, name = nil)
+    end
+
+    def foreign_keys(table_name, name = nil)
+      []
+    end
+
+    def reverse_foreign_keys(table_name, name = nil)
+      []
+    end
+
+    def add_foreign_key(table_name, column_names, references_table_name, references_column_names, options = {})
+      foreign_key = ForeignKeyDefinition.new(options[:name], 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 #{table_name} ADD #{foreign_key}"
+    end
+
+    def remove_foreign_key(table_name, foreign_key_name)
+      execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{foreign_key_name}"
+    end
+
+    def drop_table_with_redhillonrails_core(name, options = {})
+      reverse_foreign_keys(name).each do |foreign_key|
+        begin
+          remove_foreign_key(foreign_key.table_name, foreign_key.name)
+        rescue Exception => e
+          # TODO spec this
+          #there is a problem when using rollback if two tables have 
+          #similar names. In that case, the plugin will try to remove a
+          #non-existing column and raise an exception. I rescue the
+          #exception so the migration can proceed
+          nil
+        end  
+      end
+      drop_table_without_redhillonrails_core(name, options)
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
+  module MysqlAdapter
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :remove_column, :redhillonrails_core
+        alias_method_chain :remove_columns, :redhillonrails_core
+      end
+    end
+
+    def set_table_comment(table_name, comment)
+      execute "ALTER TABLE #{table_name} COMMENT='#{quote_string(comment)}'"
+    end
+    
+    def clear_table_comment(table_name)
+      execute "ALTER TABLE #{table_name} COMMENT=''"
+    end
+
+    def remove_foreign_key(table_name, foreign_key_name)
+      execute "ALTER TABLE #{table_name} DROP FOREIGN KEY #{foreign_key_name}"
+    end
+
+    def remove_column_with_redhillonrails_core(table_name, *column_names)
+      raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
+      column_names.flatten.each do |column_name|
+        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_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)
+
+      foreign_keys = []
+
+      results.each do |row|
+        row[1].each_line do |line|
+          if line =~ /^  CONSTRAINT [`"](.+?)[`"] FOREIGN KEY \([`"](.+?)[`"]\) REFERENCES [`"](.+?)[`"] \((.+?)\)( ON DELETE (.+?))?( ON UPDATE (.+?))?,?$/
+            name = $1
+            column_names = $2
+            references_table_name = $3
+            references_column_names = $4
+            on_update = $8
+            on_delete = $6
+            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,
+                                                     table_name, column_names.gsub('`', '').split(', '),
+                                                     references_table_name, references_column_names.gsub('`', '').split(', '),
+                                                     on_update, on_delete)
+          end
+        end
+      end
+
+      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;
+      SQL
+
+      current_foreign_key = nil
+      foreign_keys = []
+
+      results.each do |row|
+        next if row[3] != table_name
+        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
+  end
+end

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

@@ -0,0 +1,8 @@
+module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
+  module MysqlColumn
+    def initialize(name, default, sql_type = nil, null = true)
+      default = nil if !null && default.blank?
+      super
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
+  module PostgresqlAdapter
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :indexes, :redhillonrails_core
+      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_names = Array(column_name)
+      index_name   = index_name(table_name, :column => column_names)
+
+      if Hash === options # legacy support, since this param was a string
+        index_type = options[:unique] ? "UNIQUE" : ""
+        index_name = options[:name] || index_name
+      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) }
+
+      execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{table_name} (#{quoted_column_names.join(", ")})"
+    end
+
+    def indexes_with_redhillonrails_core(table_name, name = nil)
+      indexes = indexes_without_redhillonrails_core(table_name, name)
+      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
+      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
+        end
+      end
+
+      indexes
+    end
+
+    def foreign_keys(table_name, name = nil)
+      load_foreign_keys(<<-SQL, name)
+        SELECT f.conname, pg_get_constraintdef(f.oid), t.relname
+          FROM pg_class t, pg_constraint f
+         WHERE f.conrelid = t.oid
+           AND f.contype = 'f'
+           AND t.relname = '#{table_name}'
+      SQL
+    end
+
+    def reverse_foreign_keys(table_name, name = nil)
+      load_foreign_keys(<<-SQL, name)
+        SELECT f.conname, pg_get_constraintdef(f.oid), t2.relname
+          FROM pg_class t, pg_class t2, pg_constraint f
+         WHERE f.confrelid = t.oid
+           AND f.conrelid = t2.oid
+           AND f.contype = 'f'
+           AND t.relname = '#{table_name}'
+      SQL
+    end
+
+    def views(name = nil)
+      schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
+      query(<<-SQL, name).map { |row| row[0] }
+        SELECT viewname
+          FROM pg_views
+         WHERE schemaname IN (#{schemas})
+      SQL
+    end
+    
+    def view_definition(view_name, name = nil)
+      result = query(<<-SQL, name)
+        SELECT pg_get_viewdef(oid)
+          FROM pg_class
+         WHERE relkind = 'v'
+           AND relname = '#{view_name}'
+      SQL
+      row = result.first
+      row.first unless row.nil?
+    end
+
+    private
+
+    def load_foreign_keys(sql, name = nil)
+      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
+      end
+
+      foreign_keys
+    end
+  end
+end