advertnet 1.0.0

data/vendor/plugins/foreign_key_migrations/about.yml

@@ -0,0 +1,5 @@
+author: simon@redhillconsulting.com.au
+summary: Automatically generates foreign-key constraints when creating tables.
+homepage: http://www.redhillonrails.org
+license: MIT
+rails_version: EDGE

data/vendor/plugins/foreign_key_migrations/init.rb

@@ -0,0 +1,3 @@
+ActiveRecord::Base.send(:include, RedHillConsulting::ForeignKeyMigrations::ActiveRecord::Base)
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, RedHillConsulting::ForeignKeyMigrations::ActiveRecord::ConnectionAdapters::AbstractAdapter)
+ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, RedHillConsulting::ForeignKeyMigrations::ActiveRecord::ConnectionAdapters::TableDefinition)

data/vendor/plugins/foreign_key_migrations/install.rb

@@ -0,0 +1 @@
+puts "WARNING: You also need to install redhillonrails_core" unless File.exists?(File.join(File.dirname(__FILE__), "..", "redhillonrails_core"))

data/vendor/plugins/foreign_key_migrations/lib/red_hill_consulting/foreign_key_migrations/active_record/base.rb

@@ -0,0 +1,22 @@
+module RedHillConsulting::ForeignKeyMigrations::ActiveRecord
+  module Base
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def references(table_name, column_name, options)
+        column_name = column_name.to_s
+        if options.has_key?(:references)
+          references = options[:references]
+          references = [references, :id] unless references.nil? || references.is_a?(Array)
+          references
+        elsif column_name == 'parent_id'
+          [table_name, :id]
+        elsif column_name =~ /^(.*)_id$/
+          [pluralized_table_name($1), :id]
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/foreign_key_migrations/lib/red_hill_consulting/foreign_key_migrations/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,22 @@
+module RedHillConsulting::ForeignKeyMigrations::ActiveRecord::ConnectionAdapters
+  module AbstractAdapter
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :initialize, :foreign_key_migrations unless method_defined?(:initialize_without_foreign_key_migrations)
+      end
+    end
+
+    def initialize_with_foreign_key_migrations(*args)
+      initialize_without_foreign_key_migrations(*args)
+      self.class.class_eval do
+        alias_method_chain :add_column, :foreign_key_migrations unless method_defined?(:add_column_without_foreign_key_migrations)
+      end
+    end
+
+    def add_column_with_foreign_key_migrations(table_name, column_name, type, options = {})
+      add_column_without_foreign_key_migrations(table_name, column_name, type, options)
+      references = ActiveRecord::Base.references(table_name, column_name, options)
+      add_foreign_key(table_name, column_name, references.first, references.last, options) if references
+    end
+  end
+end

data/vendor/plugins/foreign_key_migrations/lib/red_hill_consulting/foreign_key_migrations/active_record/connection_adapters/table_definition.rb

@@ -0,0 +1,28 @@
+module RedHillConsulting::ForeignKeyMigrations::ActiveRecord::ConnectionAdapters
+  module TableDefinition
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :column, :foreign_key_migrations
+        alias_method_chain :primary_key, :foreign_key_migrations
+      end
+    end
+
+    def primary_key_with_foreign_key_migrations(name, options = {})
+      column(name, :primary_key, options)
+    end
+
+    def column_with_foreign_key_migrations(name, type, options = {})
+      column_without_foreign_key_migrations(name, type, options)
+      references = ActiveRecord::Base.references(self.name, name, options)
+      foreign_key(name, references.first, references.last, options) if references
+      self
+    end
+
+    # Some people liked this; personally I've decided against using it but I'll keep it nonetheless
+    def belongs_to(table, options = {})
+      options = options.merge(:references => table)
+      options[:on_delete] = options.delete(:dependent) if options.has_key?(:dependent)
+      column("#{table.to_s.singularize}_id".to_sym, :integer, options)
+    end
+  end
+end

data/vendor/plugins/redhillonrails_core/CHANGELOG

@@ -0,0 +1,154 @@
+[REVISION 20071013]
+
+[NEW] New migration script methods: set_table_comment and clear_table_comment. Implemented for MySQL and PostgreSQL. Currently not written to schema.rb.
+
+[REVISION 20070905]
+
+[NEW] Explicitly ignore add_foreign_key() and remove_foreign_key() when running under SQLite. This solves issues when migrating schema from other databases.
+
+[REVISION 20070707]
+
+[NEW] Make the table name in table definition accessible.
+
+[REVISION 20070529]
+
+[FIXED] Undefined constant errors when patching connection adapters. Rails now only loads the connection adapter for the specified database (it used to load them all).
+
+[REVISION 20070503]
+
+[NEW] Support for SQL92 [NOT] DEFERRABLE on foreign keys.
+[CHANGED] Foreign key names are now assigned by the database unless an explicit name is given (using :name).
+
+[REVISION 20070221]
+
+[NEW] Where possible, determine if a column is case sensitive (or not) based on the presence of case-insensitive indexes.
+
+[REVISION 20070220]
+
+[CHANGED] :ignore_case => true option when creating indexes change to :case_sensitive => false in keeping with the new Rails 1.2 option of the same name on validates_uniqueness_of. You may need to re-create your schema.rb (by using rake db:schema:dump) to pickup the new syntax.
+
+[FIXED] Multi-column, case-insensitive indexes only selecting one of the columns!
+
+[REVISION 20070219]
+
+[FIXED] Can't drop table referenced in a foreign-key. All reverse foreign keys are now dropped before dropping the table.
+
+[CHANGED] Upgrade to Rails 1.2.2.
+
+[REVISION 20070217]
+
+[NEW] Support reverse_foreign_keys for MySQL using the (typically bastardised) MySQL flavour of information_schema.
+
+[CHANGED] Merged ForiegnKey and ForeignKeyDefinition as they were practically the same.
+
+[REVISION 20070214]
+
+[NEW] :name option when creating foreign keys.
+
+[FIXED] Foreign key names are preserved in schema dumps. This means they will be copied from one database to another rather than leaving it up to the target database to make one up.
+
+[NEW] Foreign keys are automatically assigned a name (fkey_<tablename>_col1_and_col2_and_col3) if none is specified.
+
+[REVISION 20061206]
+
+[NEW] Added :ignore_case option to add_index in PostgreSQL to support case-insensitive indexes. The generated indexes are actually expression indexes of the form: lower(column_name).
+
+[REVISION 20061206]
+
+[NEW] reverse_foreign_keys methods.
+
+[REVISION 20061202]
+
+[CHANGED] Use Rails 1.2 alias_method_chain.
+
+[CHANGED] Separate modules into individual files.
+
+[REVISION 20061129]
+
+[FIXED] Foreign-key ON DELETE and ON UPDATE flipped in schema dump.
+
+[REVISION 20061121]
+
+[FIXED] MySQL doesn't support SQL92 'DROP CONSTRAINT SYNTAX'; use 'DROP FOREIGN KEY' instead.
+
+[REVISION 20061116]
+
+[FIXED] 'DROP FOREIGN KEY' should be 'DROP CONSTRAINT'.
+
+[REVISION 20061114]
+
+[CHANGED] Removed Column.required as it didn't handle updates correctly. Instead we now have Column.required_on which returns an appropriate event (nil, :save, :update).
+
+[REVISION 20061110]
+
+[FIXED] MySQL driver uses single AND double quotes around identifiers.
+
+[REVISION 20061028]
+
+[FIXED] Syntax error when generating schema under MySQL when a foreign key specifies both ON UPDATE and ON DELETE.
+
+[REVISION 20061024]
+
+[FIXED] Foreign key associations for key-word table-names are quoted in postgresql.
+
+[REVISION 20061011]
+
+[NEW] ActiveRecord::Base.base_class? returns true if the class is a base class; false otherwise.
+
+[REVISION 20061009]
+
+[NEW] ActiveRecord::Base.abstract_class? returns true if class name starts with 'Abstract'; false otherwise.
+
+[REVISION 20061001]
+
+[NEW] remove_foreign_key for completeness.
+
+[FIXED] MySQL barfs when attempting to drop a column that participates in a foreign key constraint.
+
+[REVISION 20060921]
+
+[FIXED] add_foreign_key doesn't support on_delete or on_update--It doesn't do anything with the options hash.
+
+[REVISION 20060919]
+
+[CHANGED] Column.unique is now derived based on the presence of Column.unique_scope (which is an empty array for single column unique indexes).
+
+[REVISION 20060915]
+
+[NEW] Unique columns contain scoping meta-data for multi-column unique indexes. The column to be marked as unique is either the last column not ending in '_id' or simply the last column. This follows the typical composite unique index column ordering where the scoping is specified first but will attempt to find the last non-foreign-key column just-in-case. Eg, both add_index :states, [:country_id, :name] and add_index :states, [:name, :country_id] would result in the name column marked as unique with a scope of [:country_id].
+
+[REVISION 20060913]
+
+[NEW] Column.required: returns true if a column is marked as not allowing null and has no default.
+
+[REVISION 20060911]
+
+[NEW] Patch rails MysqlColumn so that empty string defaults are treated as nil when a column is marked as NOT NULL. This primarily affects schema dumps incorrectly assigning a default of 0 to numbers and '' to strings when none was originally specified.
+
+[REVISION 20060909]
+
+[CHANGED] Renamed from Foreign Key Support.
+
+[NEW] ActiveRecord::Base.indexes.
+
+[REVISION 20060906]
+
+[FIXED] :on_update with :on_delete producing invalid SQL.
+
+[REVISION 20060905]
+
+[NEW] Schema dumper outputs foreign keys when available.
+
+[NEW] Foreign-key meta-data for: PostgreSQL; and MySQL. (Still needs a bit of DRY-ing up but it works which is the first step.)
+
+[REVISION 20060901]
+
+[FIXED] Incorrect generation of ON UPDATE/ON DELETE clauses.
+
+[NEW] Support :restrict in ON UPDATE/ON DELETE clauses.
+
+[NEW] Preliminary support for querying foreign-keys in PostgreSQL.
+
+[REVISION 20060831]
+
+[NEW] Initial version.

data/vendor/plugins/redhillonrails_core/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/vendor/plugins/redhillonrails_core/README

@@ -0,0 +1,139 @@
+= 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.
+
+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 also clear table comments:
+
+  clear_table_comment :orders
+
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,54 @@
+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, "#{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