aspgems-redhillonrails_core 2.0.0.beta1

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

@@ -0,0 +1,115 @@
+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)
+          if sqlite3_foreign_key_table_exists?
+            rows = select_all(<<-SQL, name)
+        SELECT *
+          FROM #{sqlite3_foreign_key_table}
+         WHERE #{quote_column_name(discriminating_column)} = #{quote(table_name.to_s)}
+        SQL
+          else
+            rows = []
+          end
+
+         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/schema.rb

@@ -0,0 +1,25 @@
+module RedhillonrailsCore::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/redhillonrails_core/active_record/schema_dumper.rb

@@ -0,0 +1,75 @@
+module RedhillonrailsCore::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)
+      if (indexes = @connection.indexes(table)).any?
+        add_index_statements = indexes.map do |index|
+          statement_parts = [('add_index ' + index.table.inspect)]
+          statement_parts << index.columns.inspect
+          statement_parts << (':name => ' + index.name.inspect)
+          statement_parts << ':unique => true' if index.unique
+          # This only used in postgresql
+          statement_parts << ':case_sensitive => false' unless index.case_sensitive?
+
+          if index.respond_to?(:lengths)
+            index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
+            statement_parts << (':length => ' + Hash[*index.columns.zip(index.lengths).flatten].inspect) if index_lengths.present?
+          end
+
+          '  ' + statement_parts.join(', ')
+        end
+
+        stream.puts add_index_statements.sort.join("\n")
+        stream.puts
+      end
+
+      foreign_keys(table, @foreign_keys)
+    end
+
+    def foreign_keys(table, stream)
+      foreign_keys = @connection.foreign_keys(table)
+
+      foreign_keys.sort! do |a, b|
+        a.column_names.sort <=> b.column_names.sort
+      end
+
+      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/version.rb

@@ -0,0 +1,3 @@
+module RedhillonrailsCore
+  VERSION = "2.0.0.beta1"
+end

data/lib/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

data/redhillonrails_core.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "redhillonrails_core/version"
+
+Gem::Specification.new do |s|
+  s.name        = "aspgems-redhillonrails_core"
+  s.version     = RedhillonrailsCore::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Michał Łomnicki", "Paco Guzmán"]
+  s.email       = ["michal.lomnicki@gmail.com", "fjguzman@aspgems.com"]
+  s.homepage    = "https://github.com/aspgems/redhillonrails_core"
+  s.summary     = "Adds support in ActiveRecord for foreign_keys, complex indexes and other database-related stuff"
+  s.description = "Adds support in ActiveRecord for foreign_keys, complex indexes and other database-related stuff. Easily create foreign_keys, complex indexes and views."
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("activerecord", ">= 2")
+
+  s.add_development_dependency("rspec", "~> 2.5.0")
+  s.add_development_dependency("pg")
+  s.add_development_dependency("mysql")
+  s.add_development_dependency("mysql2")
+  s.add_development_dependency("sqlite3-ruby", "~> 1.3.1")
+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 => 'rh_core_unittest',
+    :username => 'rh_core',
+    :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 => 'rh_core_unittest',
+    :username => 'rh_core',
+    :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_definition_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'models/user'
+
+describe "Foreign Key definition" do
+
+  let(:definition) { RedhillonrailsCore::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new("posts_user_fkey", :posts, :user, :users, :id) }
+
+  it "it is dumped to sql with quoted values" do
+    definition.to_sql.should == %Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')})}
+  end
+
+  def quote_table_name(table)
+    ActiveRecord::Base.connection.quote_table_name(table)
+  end
+
+  def quote_column_name(column)
+    ActiveRecord::Base.connection.quote_column_name(column)
+  end
+
+end

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