redhillonrails_core 1.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+MIT-LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/CHANGELOG

@@ -0,0 +1,2 @@
+1.0.0
+    * added gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 RedHill Consulting, Pty. Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,154 @@
+NOTE: This plugin was created by harukizaemon(http://github.com/harukizaemon) but is not supported currently by him.
+
+= RedHill on Rails Core
+
+RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins.  Those features include:
+
+* Creating and dropping views;
+* Creating and removing foreign-keys;
+* Obtaining indexes directly from a model class; and
+* Determining when <code>Schema.define()</code> is running.
+
+=== View Support
+
+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
+
+=== Foreign Key Support
+
+The plugin provides two mechanisms for adding foreign keys as well as
+preserving foreign keys when performing a schema dump. (Using SQL-92 syntax and
+as such should be compatible with most databases that support foreign-key
+constraints.)
+
+The first mechanism for creating foreign-keys allows you to add a foreign key
+when defining a table. For example:
+
+  create_table :orders do |t|
+    ...
+    t.foreign_key :customer_id, :customers, :id
+  end
+
+You also have the option of specifying what to do on delete/update using
+<code>:on_delete</code>/<code>:on_update</code>, respectively to one of: <code>:cascade</code>; <code>:restrict</code>; and <code>:set_null</code>:
+
+  create_table :orders do |t|
+    ...
+    t.foreign_key :customer_id, :customers, :id, :on_delete => :set_null, :on_update => :cascade
+  end
+
+The second method allows you to create arbitrary foreign-keys at any time:
+
+  add_foreign_key(:orders, :customer_id, :customers, :id, :on_delete => :set_null, :on_update => :cascade)
+
+In either case, if your database supports deferred foreign keys (for example PostgreSQL) you can specify this as well:
+
+  t.foreign_key :customer_id, :customers, :id, :deferrable => true
+  add_foreign_key(:orders, :customer_id, :customers, :id, :deferrable => true)
+
+By default, the foreign key will be assigned a name by the underlying database. However, if this doesn't suit
+your needs, you can override the default assignment using the <code>:name</code> option:
+
+  add_foreign_key(:orders, :customer_id, :customers, :id, :on_delete => :set_null, :on_update => :cascade, <strong>:name => :orders_customer_id_foreign_key<strong>)
+
+You can also query the foreign keys for a model yourself by calling <code>foreign_keys()</code>:
+
+  Order.foreign_keys
+
+Or for an arbitrary table by calling <code>foreign_keys(table_name)</code> on a database adapter.
+
+Either method returns an array of the following meta-data:
+
+* +name+ - The name of the foreign key constraint;
+* +table_name+ - The table for which the foreign-key was generated;
+* +column_names+ - The column names in the table;
+* +references_table_name+ - The table referenced by the foreign-key; and
+* +references_column_names+ - The columns names in the referenced table.
+
+If you need to drop a foreign-key, use:
+
+  remove_foreign_key :orders, :orders_ordered_by_id_fkey
+
+The plugin also ensures that all foreign keys are output when performing a
+schema dump. This happens automatically when running <code>rake migrate</code> or
+<code>rake db:schema:dump</code>. This has particular implications when running
+unit tests that contain fixtures. To ensure the test data is correctly reset after
+each test, you should list your fixtures in order of parent->child. For example:
+
+  fixtures :customers, :products, :orders, :order_lines
+
+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:
+
+  rake db:comments
+
+The plugin fully supports and understands the following active-record
+configuration properties:
+
+* <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
+
+ActiveRecord::Base already provides a method on connection for obtaining the
+indexes for a given table. This plugin now makes it possible to obtain the
+indexes for a given model--<code>ActiveRecord::Base</code>--class. For example:
+
+  Invoice.indexes
+
+Would return all the indexes for the +invoices+ table.
+
+=== 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.
+
+=== Case-insensitive Indexes
+
+For PostgreSQL, you can add an option <code>:case_sensitive => false</code> to <code>add_index</code>
+which will generate an expression index of the form:
+
+  LOWER(column_name)
+
+This means finder queries of the form:
+
+  WHERE LOWER(column_name) = LOWER(?)
+
+are able to use the indexes rather require, in the worst case, full-table scans.
+
+Note also that this ties in well with Rails built-in support for case-insensitive searching:
+
+  validates_uniqueness_of :name, :case_sensitive => false
+
+=== See Also
+
+* Foreign Key Associations (foreign_key_associations)
+* Foreign Key Migrations (foreign_key_migrations)
+* Row Version Migrations (row_version_migrations)
+* Schema Validations (schema_validations)
+
+=== License
+
+This plugin is copyright 2006 by RedHill Consulting, Pty. Ltd. and is released
+under the MIT license.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "redhillonrails_core"
+    gem.summary = %Q{RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins}
+    gem.description = %Q{
+RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins.  Those features include:
+
+* Creating and dropping views;
+* Creating and removing foreign-keys;
+* Obtaining indexes directly from a model class; and
+* Determining when <code>Schema.define()</code> is running.
+}
+    gem.email = "michal.lomnicki@gmail.com"
+    gem.homepage = "http://github.com/mlomnicki/redhillonrails_core"
+    gem.authors = ["Michał Łomnicki"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "redhillonrails_core #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/init.rb

@@ -0,0 +1 @@
+require 'redhillonrails_core' unless defined?(RedHillConsulting::Core)

data/lib/red_hill_consulting/core/active_record/base.rb

@@ -0,0 +1,60 @@
+module RedHillConsulting::Core::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|
+            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

data/lib/red_hill_consulting/core/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,46 @@
+module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
+  module AbstractAdapter
+    def self.included(base)
+      base.module_eval do
+        alias_method_chain :drop_table, :redhillonrails_core
+      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
+  end
+end

data/lib/red_hill_consulting/core/active_record/connection_adapters/column.rb

@@ -0,0 +1,21 @@
+module RedHillConsulting::Core::ActiveRecord::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

data/lib/red_hill_consulting/core/active_record/connection_adapters/foreign_key_definition.rb

@@ -0,0 +1,26 @@
+module RedHillConsulting::Core::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 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

data/lib/red_hill_consulting/core/active_record/connection_adapters/index_definition.rb

@@ -0,0 +1,11 @@
+module RedHillConsulting::Core::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/red_hill_consulting/core/active_record/connection_adapters/mysql4_adapter.rb

@@ -0,0 +1,37 @@
+module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
+  # MySQL4-specific behaviors
+  module Mysql4Adapter
+    def reverse_foreign_keys(table_name, name = nil)
+      tables = execute("SHOW TABLES")
+
+      foreign_keys = []
+      
+      tables.each do |table|
+        results = execute("SHOW CREATE TABLE #{table}")
+        results.each do |row|
+          row[1].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
+
+              if references_table_name == table_name
+                foreign_keys << ForeignKeyDefinition.new(name,
+                                               table, column_names.gsub('`', '').split(', '),
+                                               references_table_name, references_column_names.gsub('`', '').split(', '),
+                                               on_update, on_delete)
+              end
+            end
+          end
+        end
+      end
+
+      foreign_keys
+    end
+  end
+end

data/lib/red_hill_consulting/core/active_record/connection_adapters/mysql5_adapter.rb

@@ -0,0 +1,40 @@
+module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
+  # MySQL5-specific behaviors
+  module Mysql5Adapter
+    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
+      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

data/lib/red_hill_consulting/core/active_record/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,92 @@
+module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
+  module MysqlAdapter
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :remove_column, :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, options = {})
+      execute "ALTER TABLE #{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 `#{table_name}`", name)
+
+      foreign_keys = []
+
+      results.each do |row|
+        row[1].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)
+      @@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
+      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/red_hill_consulting/core/active_record/connection_adapters/mysql_column.rb

@@ -0,0 +1,8 @@
+module RedHillConsulting::Core::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/red_hill_consulting/core/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,131 @@
+module RedHillConsulting::Core::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

data/lib/red_hill_consulting/core/active_record/connection_adapters/schema_statements.rb

@@ -0,0 +1,23 @@
+module RedHillConsulting::Core::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/red_hill_consulting/core/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,109 @@
+module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
+  module Sqlite3Adapter
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :tables, :redhillonrails_core
+      end
+    end
+
+    def move_table(from, to, options = {}, &block) #:nodoc:
+      copy_table(from, to, options, &block)
+      drop_table(from, options)
+    end
+    
+    def add_foreign_key(from_table_name, from_column_names, to_table_name, to_column_names, options = {})
+      initialize_sqlite3_foreign_key_table
+      from_column_names = Array(from_column_names)
+      to_column_names = Array(to_column_names)
+      fk_name = options[:name] || ["fk", from_table_name, *to_column_names].join("_")
+
+      columns = %w(name from_table_name from_column_names to_table_name to_column_names)
+      values = [fk_name, from_table_name, from_column_names.join(","), to_table_name, to_column_names.join(",")]
+
+      quoted_values = values.map { |x| quote(x.to_s) }.join(",")
+
+      # TODO: support options
+
+      insert <<-SQL
+        INSERT INTO #{sqlite3_foreign_key_table}(#{quoted_columns(columns)})
+        VALUES (#{quoted_values})
+      SQL
+    end
+
+    def remove_foreign_key(table_name, foreign_key_name, options = {})
+      return if options[:temporary] == true
+      initialize_sqlite3_foreign_key_table
+
+      rows_deleted = delete <<-SQL
+        DELETE FROM #{sqlite3_foreign_key_table}
+         WHERE #{quote_column_name("name")} = #{quote(foreign_key_name.to_s)}
+           AND #{quote_column_name("from_table_name")} = #{quote(table_name.to_s)}
+      SQL
+      
+      if rows_deleted != 1
+        raise ActiveRecord::ActiveRecordError, "Foreign-key '#{foreign_key_name}' on table '#{table_name}' not found"
+      end
+    end
+
+    def tables_with_redhillonrails_core(name=nil)
+      tables_without_redhillonrails_core.reject{ |name| name == sqlite3_foreign_key_table }
+    end
+
+    def foreign_keys(table_name, name = nil)
+      load_foreign_keys("from_table_name", table_name, name)
+    end
+
+    def reverse_foreign_keys(table_name, name = nil)
+      load_foreign_keys("to_table_name", table_name, name)
+    end
+
+    # TODO: tests!
+    
+    private
+
+    def quoted_columns(columns)
+      columns.map { |x| quote_column_name(x) }.join(",")
+    end
+
+    def sqlite3_foreign_key_table
+      "sqlite3_foreign_keys"
+    end
+
+    def initialize_sqlite3_foreign_key_table
+      unless sqlite3_foreign_key_table_exists?
+        create_table(sqlite3_foreign_key_table, :id => false) do |t|
+          t.string "name",              :null => false
+          t.string "from_table_name",   :null => false
+          t.string "from_column_names", :null => false
+          t.string "to_table_name",     :null => false
+          t.string "to_column_names",   :null => false
+        end
+        add_index(sqlite3_foreign_key_table, "name",            :unique => true)
+        add_index(sqlite3_foreign_key_table, "from_table_name", :unique => false)
+        add_index(sqlite3_foreign_key_table, "to_table_name",   :unique => false)
+      end
+    end
+    
+    def sqlite3_foreign_key_table_exists?
+      tables_without_redhillonrails_core.detect { |name| name == sqlite3_foreign_key_table }
+    end
+
+    def load_foreign_keys(discriminating_column, table_name, name = nil)
+      rows = select_all(<<-SQL, name)
+        SELECT *
+          FROM #{sqlite3_foreign_key_table}
+         WHERE #{quote_column_name(discriminating_column)} = #{quote(table_name.to_s)}
+      SQL
+
+      rows.map do |row|
+        ForeignKeyDefinition.new(
+          row["name"],
+          row["from_table_name"], row["from_column_names"].split(","),
+          row["to_table_name"], row["to_column_names"].split(",")
+        )
+      end
+    end
+
+  end
+
+end

data/lib/red_hill_consulting/core/active_record/connection_adapters/table_definition.rb

@@ -0,0 +1,27 @@
+module RedHillConsulting::Core::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/red_hill_consulting/core/active_record/schema.rb

@@ -0,0 +1,25 @@
+module RedHillConsulting::Core::ActiveRecord
+  module Schema
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        class << base
+          attr_accessor :defining
+          alias :defining? :defining
+
+          alias_method_chain :define, :redhillonrails_core
+        end
+      end
+
+      def define_with_redhillonrails_core(info={}, &block)
+        self.defining = true
+        define_without_redhillonrails_core(info, &block)
+      ensure
+        self.defining = false
+      end
+    end
+  end
+end

data/lib/red_hill_consulting/core/active_record/schema_dumper.rb

@@ -0,0 +1,58 @@
+module RedHillConsulting::Core::ActiveRecord
+  module SchemaDumper
+    def self.included(base)
+      base.class_eval do
+        private
+        alias_method_chain :tables, :redhillonrails_core
+        alias_method_chain :indexes, :redhillonrails_core
+      end
+    end
+
+    private
+
+    def tables_with_redhillonrails_core(stream)
+      @foreign_keys = StringIO.new
+      begin
+        tables_without_redhillonrails_core(stream)
+        @foreign_keys.rewind
+        stream.print @foreign_keys.read
+        views(stream)
+      ensure
+        @foreign_keys = nil
+      end
+    end
+
+    def indexes_with_redhillonrails_core(table, stream)
+      indexes = @connection.indexes(table)
+      indexes.each do |index|
+        stream.print "  add_index #{index.table.inspect}, #{index.columns.inspect}, :name => #{index.name.inspect}"
+        stream.print ", :unique => true" if index.unique
+        stream.print ", :case_sensitive => false" unless index.case_sensitive?
+        stream.puts
+      end
+      stream.puts unless indexes.empty?
+
+      foreign_keys(table, @foreign_keys)
+    end
+
+    def foreign_keys(table, stream)
+      foreign_keys = @connection.foreign_keys(table)
+      foreign_keys.each do |foreign_key|
+        stream.print "  "
+        stream.print foreign_key.to_dump
+        stream.puts
+      end
+      stream.puts unless foreign_keys.empty?
+    end
+    
+    def views(stream)
+      views = @connection.views
+      views.each do |view_name|
+        definition = @connection.view_definition(view_name)
+        stream.print "  create_view #{view_name.inspect}, #{definition.inspect}"
+        stream.puts
+      end
+      stream.puts unless views.empty?
+    end
+  end
+end

data/lib/redhillonrails_core.rb

@@ -0,0 +1,39 @@
+require 'red_hill_consulting/core/active_record/base'
+require 'red_hill_consulting/core/active_record/connection_adapters/abstract_adapter'
+require 'red_hill_consulting/core/active_record/connection_adapters/foreign_key_definition'
+require 'red_hill_consulting/core/active_record/connection_adapters/column'
+require 'red_hill_consulting/core/active_record/connection_adapters/index_definition'
+require 'red_hill_consulting/core/active_record/connection_adapters/mysql_adapter'
+require 'red_hill_consulting/core/active_record/connection_adapters/mysql_column'
+require 'red_hill_consulting/core/active_record/connection_adapters/postgresql_adapter'
+require 'red_hill_consulting/core/active_record/connection_adapters/schema_statements'
+require 'red_hill_consulting/core/active_record/connection_adapters/sqlite3_adapter'
+require 'red_hill_consulting/core/active_record/connection_adapters/table_definition'
+
+ActiveRecord::Base.send(:include, RedHillConsulting::Core::ActiveRecord::Base)
+ActiveRecord::Schema.send(:include, RedHillConsulting::Core::ActiveRecord::Schema)
+ActiveRecord::SchemaDumper.send(:include, RedHillConsulting::Core::ActiveRecord::SchemaDumper)
+ActiveRecord::ConnectionAdapters::IndexDefinition.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::IndexDefinition)
+ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::TableDefinition)
+ActiveRecord::ConnectionAdapters::Column.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::Column)
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::AbstractAdapter)
+ActiveRecord::ConnectionAdapters::SchemaStatements.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::SchemaStatements)
+
+if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) then
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::PostgresqlAdapter)
+end
+if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter) then
+  ActiveRecord::ConnectionAdapters::MysqlColumn.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::MysqlColumn)
+  ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::MysqlAdapter)
+  if ActiveRecord::Base.connection.send(:version)[0] < 5
+    #include MySql4Adapter
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::Mysql4Adapter)
+  else
+    #include MySql5Adapter
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::Mysql5Adapter)
+  end
+    
+end
+if defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter) then
+  ActiveRecord::ConnectionAdapters::SQLite3Adapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::Sqlite3Adapter)
+end

data/redhillonrails_core.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{redhillonrails_core}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Micha\305\202 \305\201omnicki"]
+  s.date = %q{2010-03-13}
+  s.description = %q{
+RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins.  Those features include:
+
+* Creating and dropping views;
+* Creating and removing foreign-keys;
+* Obtaining indexes directly from a model class; and
+* Determining when <code>Schema.define()</code> is running.
+}
+  s.email = %q{michal.lomnicki@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "CHANGELOG",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/red_hill_consulting/core/active_record/base.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/abstract_adapter.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/column.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/foreign_key_definition.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/index_definition.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/mysql4_adapter.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/mysql5_adapter.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/mysql_adapter.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/mysql_column.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/postgresql_adapter.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/schema_statements.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/sqlite3_adapter.rb",
+     "lib/red_hill_consulting/core/active_record/connection_adapters/table_definition.rb",
+     "lib/red_hill_consulting/core/active_record/schema.rb",
+     "lib/red_hill_consulting/core/active_record/schema_dumper.rb",
+     "lib/redhillonrails_core.rb",
+     "redhillonrails_core.gemspec",
+     "tasks/db/comments.rake"
+  ]
+  s.homepage = %q{http://github.com/mlomnicki/redhillonrails_core}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/tasks/db/comments.rake

@@ -0,0 +1,9 @@
+namespace :db do
+  desc "Describe all the tables in the database by reading the table comments"
+  task :comments => :environment do
+    ActiveRecord::Base.connection.tables.sort.each do |table_name|
+      comment = ActiveRecord::Base.connection.table_comment(table_name)
+      puts "#{table_name} - #{comment}"
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: redhillonrails_core
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- "Micha\xC5\x82 \xC5\x81omnicki"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-13 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: |
+  
+  RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins.  Those features include:
+  
+  * Creating and dropping views;
+  * Creating and removing foreign-keys;
+  * Obtaining indexes directly from a model class; and
+  * Determining when <code>Schema.define()</code> is running.
+
+email: michal.lomnicki@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- CHANGELOG
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- lib/red_hill_consulting/core/active_record/base.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/abstract_adapter.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/column.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/foreign_key_definition.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/index_definition.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/mysql4_adapter.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/mysql5_adapter.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/mysql_adapter.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/mysql_column.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/postgresql_adapter.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/schema_statements.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/sqlite3_adapter.rb
+- lib/red_hill_consulting/core/active_record/connection_adapters/table_definition.rb
+- lib/red_hill_consulting/core/active_record/schema.rb
+- lib/red_hill_consulting/core/active_record/schema_dumper.rb
+- lib/redhillonrails_core.rb
+- redhillonrails_core.gemspec
+- tasks/db/comments.rake
+has_rdoc: true
+homepage: http://github.com/mlomnicki/redhillonrails_core
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins
+test_files: []
+