redhillonrails_core 1.0.9.1 → 1.1.0

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

@@ -0,0 +1,111 @@
+module RedhillonrailsCore
+  module ActiveRecord
+    module 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
+
+        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
+  end
+end

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

@@ -0,0 +1,31 @@
+module RedhillonrailsCore
+  module ActiveRecord
+    module 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
+  end
+end

data/lib/redhillonrails_core/active_record/schema.rb

@@ -0,0 +1,27 @@
+module RedhillonrailsCore
+  module 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
+end

data/lib/redhillonrails_core/active_record/schema_dumper.rb

@@ -0,0 +1,70 @@
+module RedhillonrailsCore
+  module 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|
+          unless index.columns.blank? 
+            stream.print "  add_index #{index.table.inspect}, #{index.columns.inspect}, :name => #{index.name.inspect}"
+            stream.print ", :unique => true" if index.unique
+            stream.print ", :kind => \"#{index.kind}\"" unless index.kind.blank?
+            stream.print ", :case_sensitive => false" unless index.case_sensitive?
+            stream.print ", :conditions => #{index.conditions.inspect}" unless index.conditions.blank?
+          else
+            stream.print "  add_index #{index.table.inspect}"
+            stream.print ", :name => #{index.name.inspect}"
+            stream.print ", :kind => \"#{index.kind}\"" unless index.kind.blank?
+            stream.print ", :expression => #{index.expression.inspect}"
+          end
+
+          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
+end

data/lib/redhillonrails_core.rb

@@ -6,32 +6,26 @@ rescue
 end
 
 # TODO: only needed adapters should be required here
-require 'red_hill_consulting/core'
-require 'red_hill_consulting/core/active_record'
-require 'red_hill_consulting/core/active_record/base'
-require 'red_hill_consulting/core/active_record/schema'
-require 'red_hill_consulting/core/active_record/schema_dumper'
-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_column'
-require 'red_hill_consulting/core/active_record/connection_adapters/schema_statements'
-require 'red_hill_consulting/core/active_record/connection_adapters/table_definition'
+require 'redhillonrails_core/active_record/base'
+require 'redhillonrails_core/active_record/schema'
+require 'redhillonrails_core/active_record/schema_dumper'
+require 'redhillonrails_core/active_record/connection_adapters/abstract_adapter'
+require 'redhillonrails_core/active_record/connection_adapters/foreign_key_definition'
+require 'redhillonrails_core/active_record/connection_adapters/column'
+require 'redhillonrails_core/active_record/connection_adapters/index_definition'
+require 'redhillonrails_core/active_record/connection_adapters/mysql_column'
+require 'redhillonrails_core/active_record/connection_adapters/table_definition'
 
-module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
-  autoload :MysqlAdapter, 'red_hill_consulting/core/active_record/connection_adapters/mysql_adapter'
-  autoload :Mysql4Adapter, 'red_hill_consulting/core/active_record/connection_adapters/mysql4_adapter'
-  autoload :Mysql5Adapter, 'red_hill_consulting/core/active_record/connection_adapters/mysql5_adapter'
-  autoload :PostgresqlAdapter, 'red_hill_consulting/core/active_record/connection_adapters/postgresql_adapter'
-  autoload :Sqlite3Adapter, 'red_hill_consulting/core/active_record/connection_adapters/sqlite3_adapter'
+module RedhillonrailsCore::ActiveRecord::ConnectionAdapters
+  autoload :MysqlAdapter, 'redhillonrails_core/active_record/connection_adapters/mysql_adapter'
+  autoload :PostgresqlAdapter, 'redhillonrails_core/active_record/connection_adapters/postgresql_adapter'
+  autoload :Sqlite3Adapter, 'redhillonrails_core/active_record/connection_adapters/sqlite3_adapter'
 end
 
-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)
+ActiveRecord::Base.send(:include, RedhillonrailsCore::ActiveRecord::Base)
+ActiveRecord::Schema.send(:include, RedhillonrailsCore::ActiveRecord::Schema)
+ActiveRecord::SchemaDumper.send(:include, RedhillonrailsCore::ActiveRecord::SchemaDumper)
+ActiveRecord::ConnectionAdapters::IndexDefinition.send(:include, RedhillonrailsCore::ActiveRecord::ConnectionAdapters::IndexDefinition)
+ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, RedhillonrailsCore::ActiveRecord::ConnectionAdapters::TableDefinition)
+ActiveRecord::ConnectionAdapters::Column.send(:include, RedhillonrailsCore::ActiveRecord::ConnectionAdapters::Column)
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, RedhillonrailsCore::ActiveRecord::ConnectionAdapters::AbstractAdapter)

data/redhillonrails_core.gemspec

@@ -5,75 +5,69 @@
 
 Gem::Specification.new do |s|
   s.name = %q{redhillonrails_core}
-  s.version = "1.0.9.1"
+  s.version = "1.1.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-12-13}
-  s.description = %q{RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins. It creates and drops views and foreign-keys or obtains indexes directly from a model class.}
+  s.date = %q{2011-01-09}
+  s.description = %q{Adds support in ActiveRecord for foreign_keys, complex indexes and other database-related stuff. Easily create foreign_keys, complex indexes and views.}
   s.email = %q{michal.lomnicki@gmail.com}
   s.extra_rdoc_files = [
     "README.rdoc"
   ]
   s.files = [
-    ".document",
-     ".gitignore",
-     ".rvmrc",
-     "CHANGELOG",
-     "Gemfile",
-     "Gemfile.lock",
+    "CHANGELOG",
      "MIT-LICENSE",
      "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "examples/example_helper.rb",
-     "examples/postgresql_index_parser_example.rb",
      "init.rb",
-     "lib/red_hill_consulting/core.rb",
-     "lib/red_hill_consulting/core/active_record.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"
+     "lib/redhillonrails_core/active_record/base.rb",
+     "lib/redhillonrails_core/active_record/connection_adapters/abstract_adapter.rb",
+     "lib/redhillonrails_core/active_record/connection_adapters/column.rb",
+     "lib/redhillonrails_core/active_record/connection_adapters/foreign_key_definition.rb",
+     "lib/redhillonrails_core/active_record/connection_adapters/index_definition.rb",
+     "lib/redhillonrails_core/active_record/connection_adapters/mysql_adapter.rb",
+     "lib/redhillonrails_core/active_record/connection_adapters/mysql_column.rb",
+     "lib/redhillonrails_core/active_record/connection_adapters/postgresql_adapter.rb",
+     "lib/redhillonrails_core/active_record/connection_adapters/sqlite3_adapter.rb",
+     "lib/redhillonrails_core/active_record/connection_adapters/table_definition.rb",
+     "lib/redhillonrails_core/active_record/schema.rb",
+     "lib/redhillonrails_core/active_record/schema_dumper.rb",
+     "redhillonrails_core.gemspec"
   ]
   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.7}
-  s.summary = %q{RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Adds support in ActiveRecord for foreign_keys, complex indexes and other database-related stuff}
   s.test_files = [
-    "examples/example_helper.rb",
-     "examples/postgresql_index_parser_example.rb"
+    "spec/schema/schema.rb",
+     "spec/foreign_key_spec.rb",
+     "spec/schema_dumper_spec.rb",
+     "spec/connections/mysql2/connection.rb",
+     "spec/connections/postgresql/connection.rb",
+     "spec/connections/sqlite3/connection.rb",
+     "spec/connections/mysql/connection.rb",
+     "spec/support/reference.rb",
+     "spec/index_definition_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/index_spec.rb",
+     "spec/models/user.rb",
+     "spec/models/post.rb",
+     "spec/models/comment.rb"
   ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activerecord>, [">= 0"])
-      s.add_development_dependency(%q<micronaut>, [">= 0"])
     else
       s.add_dependency(%q<activerecord>, [">= 0"])
-      s.add_dependency(%q<micronaut>, [">= 0"])
     end
   else
     s.add_dependency(%q<activerecord>, [">= 0"])
-    s.add_dependency(%q<micronaut>, [">= 0"])
   end
 end
 

data/spec/connections/mysql/connection.rb

@@ -0,0 +1,18 @@
+print "Using MySQL\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.configurations = {
+  'redhillonrails' => {
+    :adapter => 'mysql',
+    :database => 'redhillonrails_core_test',
+    :username => 'redhillonrails',
+    :encoding => 'utf8',
+    :socket => '/var/run/mysqld/mysqld.sock',
+    :min_messages => 'warning'
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'redhillonrails'

data/spec/connections/mysql2/connection.rb

@@ -0,0 +1,18 @@
+print "Using MySQL2\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.configurations = {
+  'redhillonrails' => {
+    :adapter => 'mysql2',
+    :database => 'redhillonrails_core_test',
+    :username => 'redhillonrails',
+    :encoding => 'utf8',
+    :socket => '/var/run/mysqld/mysqld.sock',
+    :min_messages => 'warning'
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'redhillonrails'

data/spec/connections/postgresql/connection.rb

@@ -0,0 +1,15 @@
+print "Using PostgreSQL\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.configurations = {
+  'redhillonrails' => {
+    :adapter => 'postgresql',
+    :database => 'redhillonrails_core_test',
+    :min_messages => 'warning'
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'redhillonrails'

data/spec/connections/sqlite3/connection.rb

@@ -0,0 +1,14 @@
+print "Using SQLite3\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.configurations = {
+  'redhillonrails' => {
+    :adapter => 'sqlite3',
+    :database => File.expand_path(File.dirname(__FILE__) + 'redhillonrails_core.db')
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'redhillonrails'

data/spec/foreign_key_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'models/user'
+require 'models/post'
+require 'models/comment'
+
+describe "Foreign Key" do
+
+  let(:migration) { ::ActiveRecord::Migration }
+
+  context "when is added", "posts(author_id)" do
+
+    before(:each) do 
+      add_foreign_key(:posts, :author_id, :users, :id, :on_update => :cascade, :on_delete => :restrict)
+    end
+
+    after(:each) do
+      fk = Post.foreign_keys.detect { |fk| fk.column_names == %w[author_id] }
+      remove_foreign_key(:posts, fk.name)
+    end
+
+    it "references users(id)" do
+      Post.should reference(:users, :id).on(:author_id)
+    end
+
+    it "cascades on update" do
+      Post.should reference(:users).on_update(:cascade)
+    end
+
+    it "restricts on delete" do
+      Post.should reference(:users).on_delete(:restrict)
+    end
+
+    it "is available in Post.foreign_keys" do
+      Post.foreign_keys.collect(&:column_names).should include(%w[author_id])
+    end
+
+    it "is available in User.reverse_foreign_keys" do
+      User.reverse_foreign_keys.collect(&:column_names).should include(%w[author_id])
+    end
+
+  end
+
+  context "when is dropped", "comments(post_id)" do
+
+    let(:foreign_key_name) { Comment.foreign_keys.detect { |definition| definition.column_names == %w[post_id] }.name }
+
+    before(:each) do
+      remove_foreign_key(:comments, foreign_key_name)
+    end
+
+    after(:each) do
+      add_foreign_key(:comments, :post_id, :posts, :id)
+    end
+
+    it "doesn't reference posts(id)" do
+      Comment.should_not reference(:posts).on(:post_id)
+    end
+
+    it "is no longer available in Post.foreign_keys" do
+      Comment.foreign_keys.collect(&:column_names).should_not include(%w[post_id])
+    end
+    
+    it "is no longer available in User.reverse_foreign_keys" do
+      Post.reverse_foreign_keys.collect(&:column_names).should_not include(%w[post_id])
+    end
+
+  end
+
+  context "when referencing column and column is removed" do
+
+    let(:foreign_key_name) { Comment.foreign_keys.detect { |definition| definition.column_names == %w[post_id] }.name }
+
+    it "should remove foreign keys" do
+      remove_foreign_key(:comments, foreign_key_name)
+      Post.reverse_foreign_keys.collect { |fk| fk.column_names == %w[post_id] && fk.table_name == "comments" }.should be_empty
+    end
+
+  end
+
+  protected
+  def add_foreign_key(*args)
+    migration.suppress_messages do
+      migration.add_foreign_key(*args)
+    end
+    User.reset_column_information
+    Post.reset_column_information
+    Comment.reset_column_information
+  end
+
+  def remove_foreign_key(*args)
+    migration.suppress_messages do
+      migration.remove_foreign_key(*args)
+    end
+    User.reset_column_information
+    Post.reset_column_information
+    Comment.reset_column_information
+  end
+
+end