redhillonrails_core 1.0.9.1 → 1.1.0

data/CHANGELOG

@@ -1,3 +1,10 @@
+1.1.0
+    * standard gem layout (no more RedHillConsulting module)
+    * got rid of table comments support
+    * dropped Mysql4 compatibility
+    * added specs regarding foreign_keys
+    * added specs regarding indexes
+    * fixed included module for sqlite3
 1.0.9.1
     * get rid of ActiveRecord < 3.0.0 dependency
 1.0.9

data/README.rdoc

@@ -1,19 +1,19 @@
-= Credits
+= Disclaimer
 
-This plugin was created by harukizaemon(http://github.com/harukizaemon) but is not supported currently by him.
-I've forked it to make it edge-rails compatible and to introduce new features.
+redhillonrails_core was originally created by http://github.com/harukizaemon but it was retired and is no longer supported.
+
+That fork is intended to make redhillonrails_core compatible with edge rails and introduce some new features.
 
 = RedHill on Rails Core
 
-RedHill on Rails Core provides bunch of useful database features:
+Goal of redhillonrails_core is to provided missing ActiveRecord support for
+database specific features:
 
-* Creating and dropping views;
-* Creating and removing foreign-keys;
-* Creating partial indexes (postgresql only)
-* Obtaining indexes directly from a model class; and
-* Determining when <code>Schema.define()</code> is running.
+* foreign_keys
+* case-insensitive and partial indexes (pgsql only)
+* views
 
-=== Installation
+== Installation
 
 As a gem
     
@@ -23,13 +23,11 @@ As a gem
 
   script/plugin install http://github.com/mlomnicki/redhillonrails_core.git
 
-=== View Support
+== Compatibility 
 
-The plugin provides a mechanism for creating and dropping views as well as
-preserving views when performing a schema dump:
-
-  create_view :normal_customers, "SELECT * FROM customers WHERE status = 'normal'"
-  drop_view :normal_customers
+* Ruby - 1.8, 1.9
+* ActiveRecord - 2.X, 3.X
+* Databases - PostgreSQL, MySQL, SQLite3 (most features should also run on others)
 
 === Foreign Key Support
 
@@ -96,31 +94,14 @@ each test, you should list your fixtures in order of parent->child. For example:
 
 Rails will then set-up and tear-down the fixtures in the correct sequence.
 
-Some databases (PostgreSQL and MySQL for example) allow you to set a comment for a
-table. You can do this for existing tables by using:
-
-  set_table_comment :orders, "All pending and processed orders"
-
-or even at the time of creation:
-
-  create_table :orders, :comment => "All pending and processed orders" do |t|
-    ...
-  end
-
-You can clear table comments using:
-
-  clear_table_comment :orders
-
-There is also a rake tasks to show all database tables and their comments:
+=== View Support
 
-  rake db:comments
+The plugin provides a mechanism for creating and dropping views as well as
+preserving views when performing a schema dump:
 
-The plugin fully supports and understands the following active-record
-configuration properties:
+  create_view :normal_customers, "SELECT * FROM customers WHERE status = 'normal'"
+  drop_view :normal_customers
 
-* <code>config.active_record.pluralize_table_names</code>
-* <code>config.active_record.table_name_prefix</code>
-* <code>config.active_record.table_name_suffix</code>
 
 === Model Indexes
 
@@ -166,23 +147,26 @@ Note also that this ties in well with Rails built-in support for case-insensitiv
 
   validates_uniqueness_of :name, :case_sensitive => false
 
-=== Schema Defining
-
-The plugin also adds a method--<code>defining?()</code>--to
-<code>ActiveRecord::Schema</code> to indicate when <code>define()</code> is running. This is necessary
-as some migration plugins must change their behaviour accordingly.
+=== Tests
 
-=== Examples
+redhillonrails_core is tested using similar approach to ActiveRecord tests.
+However we use rspec in favor of Test::Unit
 
-redhillonrails_core uses Micronaut for specing. The examples are split per-database adapter. Run using Bundler:
+First you have to fetch sources from github as specs are not inculded in a gem.
 
+  $ git clone https://mlomnicki@github.com/mlomnicki/redhillonrails_core.git
+  $ cd redhillonrails_core
   $ bundle install
-  $ bundle exec rake postgresql:examples
+  $ rake postgresql:build_database # create redhillonrails user first
+  $ rake mysql:build_database  # create user as above
+  $ bundle exec rake spec
 
-Running examples only will fail since the environment won't be setup properly.
+  # to run postgresql specs only
+  $ bundle exec rake spec postgresql:spec 
 
 === Contributors
 
+* Michał Łomnicki
 * François Beausoleil - http://github.com/francois
 * Greg Barnett
 

data/lib/redhillonrails_core/active_record/base.rb

@@ -0,0 +1,63 @@
+module RedhillonrailsCore
+  module ActiveRecord
+    module Base
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def self.extended(base)
+          class << base
+            alias_method_chain :columns, :redhillonrails_core
+            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 columns_with_redhillonrails_core
+          unless @columns
+            columns_without_redhillonrails_core
+            cols = columns_hash
+            indexes.each do |index|
+              next if index.columns.blank?
+              column_name = index.columns.reverse.detect { |name| name !~ /_id$/ } || index.columns.last
+              column = cols[column_name]
+              column.case_sensitive = index.case_sensitive?
+              column.unique_scope = index.columns.reject { |name| name == column_name } if index.unique
+            end
+          end
+          @columns
+        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
+end

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

@@ -0,0 +1,75 @@
+module RedhillonrailsCore
+  module ActiveRecord
+    module ConnectionAdapters
+      module AbstractAdapter
+        def self.included(base)
+          base.alias_method_chain :initialize, :redhillonrails_core
+          base.alias_method_chain :drop_table, :redhillonrails_core
+        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
+        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, options = {})
+          execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{foreign_key_name}"
+        end
+
+        def drop_table_with_redhillonrails_core(name, options = {})
+          reverse_foreign_keys(name).each { |foreign_key| remove_foreign_key(foreign_key.table_name, foreign_key.name, options) }
+          drop_table_without_redhillonrails_core(name, options)
+        end
+
+        def supports_partial_indexes?
+          false
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module RedhillonrailsCore
+  module ActiveRecord
+    module ConnectionAdapters
+      module Column
+        attr_accessor :unique_scope
+        attr_accessor :case_sensitive
+        alias case_sensitive? case_sensitive
+
+        def unique?
+          !unique_scope.nil?
+        end
+
+        def required_on
+          if null
+            nil
+          elsif default.nil?
+            :save
+          else
+            :update
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module RedhillonrailsCore
+  module ActiveRecord
+    module 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 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(column_names).join(", ")}) REFERENCES #{references_table_name} (#{Array(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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module RedhillonrailsCore
+  module ActiveRecord
+    module ConnectionAdapters
+      module IndexDefinition
+        attr_accessor :conditions, :expression, :kind
+
+        def case_sensitive?
+          @case_sensitive.nil? ? true : @case_sensitive
+        end
+
+        def case_sensitive=(case_sensitive)
+          @case_sensitive = case_sensitive
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module RedhillonrailsCore
+  module ActiveRecord
+    module ConnectionAdapters
+      module MysqlAdapter
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :remove_column, :redhillonrails_core
+          end
+        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}"
+        end
+
+        def remove_column_with_redhillonrails_core(table_name, 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
+
+        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].lines.each 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
+
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,160 @@
+module RedhillonrailsCore
+  module ActiveRecord
+    module ConnectionAdapters
+      module PostgresqlAdapter
+        def self.included(base)
+          base.class_eval do
+            remove_method :indexes
+          end
+        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)
+          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
+
+          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
+            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
+
+        def supports_partial_indexes?
+          true
+        end
+
+        def indexes(table_name, name = nil)
+          schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
+          result = query(<<-SQL, name)
+           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.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
+        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
+
+        # 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
+  end
+end