backlog 0.36.2 → 0.37.1

data/vendor/plugins/redhillonrails_core/README

@@ -1,124 +0,0 @@
-= RedHill on Rails Core
-
-RedHill on Rails Core is a plugin that adds the following features:
-
-* Generic support for foreign-keys;
-* Mechanism for obtaining indexes directly from a model class; and
-* A mechanism for determining when <code>Schema.define()</code> is running.
-
-=== 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.
-
-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/vendor/plugins/redhillonrails_core/init.rb

@@ -1,19 +0,0 @@
-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)
-end
-if defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter) then
-  ActiveRecord::ConnectionAdapters::SQLite3Adapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::Sqlite3Adapter)
-end

data/vendor/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/base.rb

@@ -1,54 +0,0 @@
-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 unless method_defined?(:columns_without_redhillonrails_core)
-          alias_method_chain :abstract_class?, :redhillonrails_core unless method_defined?(:abstract_class_without_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 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)
-      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/vendor/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/connection_adapters/abstract_adapter.rb

@@ -1,31 +0,0 @@
-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 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)
-      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) }
-      drop_table_without_redhillonrails_core(name, options)
-    end
-  end
-end

data/vendor/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/connection_adapters/column.rb

@@ -1,21 +0,0 @@
-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/vendor/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/connection_adapters/foreign_key_definition.rb

@@ -1,26 +0,0 @@
-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}, [#{column_names.collect{ |name| name.inspect }.join(', ')}]"
-      dump << ", #{references_table_name.inspect}, [#{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/vendor/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/connection_adapters/index_definition.rb

@@ -1,11 +0,0 @@
-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/vendor/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/connection_adapters/mysql_adapter.rb

@@ -1,74 +0,0 @@
-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 remove_foreign_key(table_name, foreign_key_name)
-      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)
-      results = execute(<<-SQL, name)
-        SELECT constraint_name, table_name, column_name, referenced_table_name, referenced_column_name
-          FROM information_schema.key_column_usage
-         WHERE table_schema = SCHEMA()
-           AND referenced_table_schema = table_schema
-           AND referenced_table_name = '#{table_name}'
-         ORDER BY constraint_name, ordinal_position;
-      SQL
-
-      current_foreign_key = nil
-      foreign_keys = []
-
-      results.each do |row|
-        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/vendor/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/connection_adapters/mysql_column.rb

@@ -1,8 +0,0 @@
-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/vendor/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,99 +0,0 @@
-module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
-  module PostgresqlAdapter
-    def self.included(base)
-      base.class_eval do
-        alias_method_chain :indexes, :redhillonrails_core
-      end
-    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 { |name| name =~ /^LOWER\((.*)::text\)$/i ? $1 : name }
-          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
-
-    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