foreign_keys 1.2.0

data/.gitignore

@@ -0,0 +1,3 @@
+pkg
+rdoc
+.idea

data/README.markdown

@@ -0,0 +1,73 @@
+Foreign Keys Plugin
+===================
+
+This plugin adds basic support for foreign keys, by providing some additional
+schema statements as well as integration into the standard schema dumper.
+
+Currently, mysql and postgresql connection adapters are supported.
+
+Installation
+------------
+
+Via standard git clone:
+
+    git clone git://github.com/dwalters/foreign_keys.git vendor/plugins/foreign_keys
+
+Via rails plugin (requires 2.1):
+
+    script/plugin install git://github.com/dwalters/foreign_keys.git
+
+Adding Foreign Keys
+-------------------
+
+Just place the appropriate statements in your migrations.  The simplest example is:
+
+    add_foreign_key :orders, :user_id
+
+The usual rails conventions are used to deduce that this should result in a
+foreign key from the `orders.user_id` column to the `users.id` column
+
+Of course, you may specify these values explicitly too, and will need to when
+the conventions don't match exactly:
+
+    add_foreign_key :articles, :author_id, :references => :users
+
+Some other options of note:
+
+* `references`: the name of the referenced table
+* `keys`: the corresponding column name(s) in the referenced table
+* `on_delete` / `on_update`: one of `:restrict`, `:set_null`, `:cascade`
+* `name`: the name to assign to the foreign key constraint
+
+Note that recent mysql versions will create an index on the referenced
+column(s) if one does not already exist.
+
+You may wish to check the documentation for further options.
+
+Removing Foreign Keys
+---------------------
+
+You can remove foreign keys by name:
+
+    remove_foreign_key :orders, :name => "index_orders_on_user_id"
+
+Or the name can be deduced if you used standard conventions when you created it:
+
+    remove_foreign_key :orders, :user_id
+
+This will not automatically remove any indexes.
+
+Schema Dump
+-----------
+
+The usual rake targets for `db:schema:dump`, `db:schema:load`, and `db:reset`
+should all work as desired.
+
+Author
+------
+
+Dan Walters
+
+<http://github.com/dwalters/foreign_keys>
+
+Max Lapshin -- PostgreSQL support

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |jewel|
+    jewel.name = 'foreign_keys'
+    jewel.summary = 'Foreign key sypport for Rails (MySQL, PostgreSQL)'
+    jewel.homepage = 'http://github.com/dwalters/foreign_keys/tree/master'
+    jewel.description = 'Foreign key support plugin for Rails and MySQL, with schema dumper integration'
+    jewel.authors = ["Dan Walters"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc 'Default: run unit tests.'
+task :default => :rdoc
+
+desc 'Generate documentation for the smurf plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Foreign keys'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.markdown')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 1
+:minor: 2
+:patch: 0

data/foreign_keys.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{foreign_keys}
+  s.version = "1.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Dan Walters"]
+  s.date = %q{2009-05-26}
+  s.description = %q{Foreign key support plugin for Rails and MySQL, with schema dumper integration}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.markdown",
+     "Rakefile",
+     "VERSION.yml",
+     "foreign_keys.gemspec",
+     "init.rb",
+     "lib/foreign_keys.rb",
+     "lib/foreign_keys/mysql_adapter.rb",
+     "lib/foreign_keys/postgresql_adapter.rb",
+     "lib/foreign_keys/schema_dumper.rb",
+     "lib/foreign_keys/schema_statements.rb"
+  ]
+  s.homepage = %q{http://github.com/dwalters/foreign_keys/tree/master}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Foreign key sypport for Rails (MySQL, PostgreSQL)}
+
+  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/init.rb

@@ -0,0 +1 @@
+require 'lib/foreign_keys'

data/lib/foreign_keys/mysql_adapter.rb

@@ -0,0 +1,22 @@
+ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+  def foreign_keys(table_name)#:nodoc:
+    sql = execute("SHOW CREATE TABLE #{quote_table_name(table_name)}").fetch_hash["Create Table"]
+
+    foreign_keys = []
+    sql.scan(/CONSTRAINT `(\w+)` FOREIGN KEY \((.*?)\) REFERENCES `(\w+)` \((.*?)\)(?:\s+ON DELETE\s+(.*?))?(?:\s+ON UPDATE\s+(.*?))?[,\)\n]/) do |name, column_list, references, key_list, on_delete, on_update|
+      columns = []; column_list.scan(/`(\w+)`/) { |match| columns << match.first }
+      keys = []; key_list.scan(/`(\w+)`/) { |match| keys << match.first }
+
+      foreign_keys << {
+        :name => name,
+        :columns => columns,
+        :references => references,
+        :keys => keys,
+        :on_update => on_update,
+        :on_delete => on_delete
+      }
+    end
+
+    foreign_keys
+  end
+end

data/lib/foreign_keys/postgresql_adapter.rb

@@ -0,0 +1,45 @@
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+  def foreign_keys(table_name)#:nodoc:
+    data = select_all(<<-EOF)
+    select t.constraint_name as name,
+            k.table_name as from_table,
+    	k.column_name as from_column,
+    	c.table_name as to_table,
+    	c.column_name as to_column,
+    	r.update_rule as update_rule,
+    	r.delete_rule as delete_rule
+    from information_schema.table_constraints t,
+         information_schema.constraint_column_usage c,
+         information_schema.key_column_usage k,
+         information_schema.referential_constraints r
+    where t.constraint_name = c.constraint_name and
+          k.constraint_name = c.constraint_name and
+          r.constraint_name = c.constraint_name and
+          t.constraint_type = 'FOREIGN KEY' and
+          t.table_name = '#{table_name}'
+    EOF
+
+    foreign_keys = data.inject({}) do |list, row|
+      if !list[row["name"]]
+        list[row["name"]] = {
+          :name => row["name"],
+          :columns => [row["from_column"]],
+          :references => row["to_table"],
+          :keys => [row["to_column"]],
+          :on_update => row["update_rule"],
+          :on_delete => row["delete_rule"]
+        }
+      else
+        list[row["name"]][:columns] << row["from_column"]
+        list[row["name"]][:keys] << row["to_column"]
+      end
+      list
+    end.map do |key, ref|
+      ref[:columns] = Array(ref[:columns]).uniq.compact.join(", ")
+      ref[:keys] = Array(ref[:keys]).uniq.compact.join(", ")
+      ref.delete(:on_update) if ref[:on_update] == "NO ACTION"
+      ref.delete(:on_delete) if ref[:on_delete] == "NO ACTION"
+      ref
+    end
+  end
+end

data/lib/foreign_keys/schema_dumper.rb

@@ -0,0 +1,33 @@
+ActiveRecord::SchemaDumper.class_eval do
+  private
+
+  def tables(stream)
+    table_names = @connection.tables.sort.reject do |tbl|
+      ['schema_migrations', 'schema_info', ignore_tables].flatten.any? do |ignored|
+        case ignored
+        when String; tbl == ignored
+        when Regexp; tbl =~ ignored
+        else
+          raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+        end
+      end
+    end
+
+    table_names.each { |tbl| table(tbl, stream) }
+    table_names.each { |tbl| foreign_keys(tbl, stream) } if @connection.respond_to?(:foreign_keys)
+  end
+
+  def foreign_keys(table, stream)
+    foreign_keys = @connection.foreign_keys(table).sort { |a, b| a[:columns] <=> b[:columns] }
+    foreign_keys.each do |foreign_key|
+      stream.print "  add_foreign_key #{table.inspect}, #{foreign_key[:columns].inspect}"
+      stream.print ", :references => #{foreign_key[:references].inspect}" if foreign_key[:references] && foreign_key[:references] != foreign_key[:columns].first.gsub(/_id$/, '').tableize
+      stream.print ", :keys => #{foreign_key[:keys].inspect}" if foreign_key[:keys] && foreign_key[:keys] != ["id"]
+      stream.print ", :name => #{foreign_key[:name].inspect}" if foreign_key[:name]
+      stream.print ", :on_delete => #{foreign_key[:on_delete].downcase.gsub(/ /, '_').to_sym.inspect}" if foreign_key[:on_delete]
+      stream.print ", :on_update => #{foreign_key[:on_update].downcase.gsub(/ /, '_').to_sym.inspect}" if foreign_key[:on_update]
+      stream.puts
+    end
+    stream.puts unless foreign_keys.empty?
+  end
+end

data/lib/foreign_keys/schema_statements.rb

@@ -0,0 +1,70 @@
+ActiveRecord::ConnectionAdapters::SchemaStatements.module_eval do
+  # Adds a new foreign key to a table.  +columns+ can be a single Symbol, or an
+  # array of Symbols, on which the key will be added.
+  #
+  # The referenced table name and columns are deduced using the usual conventions
+  # unless explicitly specified via +:references+ and/or +:keys+ options.
+  #
+  # The foreign key will be named using the same rules as #add_index, unless you
+  # pass +:name+ as an option.
+  #
+  # Options for +:on_delete+ and +:on_update+ may be specified.  Acceptable
+  # values are +:restrict+, +:set_null+, and +:cascade+.
+  #
+  # Note that some databases will automatically create an index on the constrained
+  # columns.
+  #
+  # ===== Examples
+  # ====== Creating a simple foreign key
+  #  add_foreign_key :orders, :user_id
+  # generates
+  #  ALTER TABLE orders ADD CONSTRAINT index_orders_on_user_id FOREIGN KEY (user_id) REFERENCES users (id)
+  # ====== Specifying the target table
+  #  add_foreign_key :articles, :author_id, :references => :users
+  # generates
+  #  ALTER TABLE articles ADD CONSTRAINT index_articles_on_author_id FOREIGN KEY (author_id) REFERENCES users (id)
+  # ====== Cascading deletes
+  #  add_foreign_key :comments, :post_id, :on_delete => :cascade
+  # generates
+  #  ALTER TABLE comments ADD CONSTRAINT index_comments_on_post_id FOREIGN KEY (post_id) REFERENCES posts (id) ON DELETE CASCADE
+  def add_foreign_key(table_name, columns, options = {})
+    columns = Array(columns)
+    name = options[:name] || index_name(table_name, :column => columns)
+    column_list = columns.collect { |column| quote_column_name(column) }.join(", ")
+    keys = Array(options[:keys] || :id)
+    key_list = keys.collect { |key| quote_column_name(key) }.join(", ")
+    references = if options[:references]
+      options[:references]
+    else
+      columns.first.to_s.gsub(/_id$/, '').tableize
+    end
+
+    sql = "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(name)} FOREIGN KEY (#{column_list}) REFERENCES #{quote_table_name(references)} (#{key_list})"
+    sql << " ON DELETE #{options[:on_delete].to_s.gsub(/_/,' ')}" if options[:on_delete]
+    sql << " ON UPDATE #{options[:on_update].to_s.gsub(/_/,' ')}" if options[:on_update]
+    execute sql
+  end
+
+  # Remove the given foreign key from the table.  If +:name+ is specified, it will be used
+  # directly as the name of the key to delete.  Otherwise, the same conventions used
+  # when by #add_foreign_key may be provided.
+  #
+  # Any underlying indexes will not be automatically dropped.
+  #
+  # ===== Examples
+  # ====== Removing a foreign key by name
+  #  remove_foreign_key :orders, :name => "index_orders_on_user_id"
+  # ====== Removing a foreign key by column
+  #  remove_foreign_key :orders, :user_id
+  def remove_foreign_key(table_name, *args)
+    options = args.extract_options!
+    name = if options[:name]
+      options[:name]
+    else
+      columns = args.first
+      index_name(table_name, :column => Array(columns))
+    end
+
+    execute "ALTER TABLE #{quote_table_name(table_name)} DROP FOREIGN KEY #{quote_column_name(name)}"
+  end
+end

data/lib/foreign_keys.rb

@@ -0,0 +1,4 @@
+require 'foreign_keys/mysql_adapter' if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
+require 'foreign_keys/postgresql_adapter' if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+require 'foreign_keys/schema_dumper'
+require 'foreign_keys/schema_statements'

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: foreign_keys
+version: !ruby/object:Gem::Version 
+  version: 1.2.0
+platform: ruby
+authors: 
+- Dan Walters
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-26 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: Foreign key support plugin for Rails and MySQL, with schema dumper integration
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- README.markdown
+- Rakefile
+- VERSION.yml
+- foreign_keys.gemspec
+- init.rb
+- lib/foreign_keys.rb
+- lib/foreign_keys/mysql_adapter.rb
+- lib/foreign_keys/postgresql_adapter.rb
+- lib/foreign_keys/schema_dumper.rb
+- lib/foreign_keys/schema_statements.rb
+has_rdoc: true
+homepage: http://github.com/dwalters/foreign_keys/tree/master
+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: Foreign key sypport for Rails (MySQL, PostgreSQL)
+test_files: []
+