schema_plus 2.0.0.pre2 → 2.0.0.pre3

data/lib/schema_plus_enums.rb

@@ -0,0 +1,6 @@
+require 'schema_monkey'
+
+require_relative 'schema_plus_enums/active_record'
+require_relative 'schema_plus_enums/middleware'
+
+SchemaMonkey.register(SchemaPlusEnums)

data/lib/{schema_pg_enums → schema_plus_enums}/active_record.rb

@@ -1,4 +1,4 @@
-module SchemaPgEnums
+module SchemaPlusEnums
   module ActiveRecord
     module ConnectionAdapters
       module PostgresqlAdapter

data/lib/schema_plus_enums/middleware.rb

@@ -0,0 +1,22 @@
+module SchemaPlusEnums
+  module Middleware
+
+    module Dumper
+      module Extensions
+
+        module Postgresql
+
+          def after(env)
+            env.connection.enums.each do |schema, name, values|
+              params = [name.inspect]
+              params << values.map(&:inspect).join(', ')
+              params << ":schema => #{schema.inspect}" if schema != 'public'
+
+              env.extensions << "create_enum #{params.join(', ')}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus_foreign_keys.rb

@@ -0,0 +1,96 @@
+require 'active_record'
+require 'valuable'
+
+require 'schema_plus_foreign_keys/version'
+require 'schema_plus_foreign_keys/active_record/base'
+require 'schema_plus_foreign_keys/active_record/connection_adapters/abstract_adapter'
+require 'schema_plus_foreign_keys/active_record/connection_adapters/table_definition'
+require 'schema_plus_foreign_keys/active_record/connection_adapters/schema_statements'
+require 'schema_plus_foreign_keys/active_record/schema'
+require 'schema_plus_foreign_keys/active_record/connection_adapters/foreign_key_definition'
+require 'schema_plus_foreign_keys/active_record/migration/command_recorder'
+require 'schema_plus_foreign_keys/middleware/dumper'
+require 'schema_plus_foreign_keys/middleware/migration'
+require 'schema_plus_foreign_keys/middleware/model'
+
+module SchemaPlusForeignKeys
+  module ActiveRecord
+    module ConnectionAdapters
+      autoload :Mysql2Adapter, 'schema_plus_foreign_keys/active_record/connection_adapters/mysql2_adapter'
+      autoload :PostgresqlAdapter, 'schema_plus_foreign_keys/active_record/connection_adapters/postgresql_adapter'
+      autoload :Sqlite3Adapter, 'schema_plus_foreign_keys/active_record/connection_adapters/sqlite3_adapter'
+    end
+  end
+
+  # This global configuation options for SchemaPlusForeignKeys.
+  # Set them in +config/initializers/schema_plus_foreign_keys.rb+ using:
+  #
+  #    SchemaPlusForeignKeys.setup do |config|
+  #       ...
+  #    end
+  #
+  class Config < Valuable
+
+    ##
+    # :attr_accessor: auto_create
+    #
+    # Whether to automatically create foreign key constraints for columns
+    # suffixed with +_id+.  Boolean, default is +true+.
+    has_value :auto_create, :klass => :boolean, :default => true
+
+    ##
+    # :attr_accessor: auto_index
+    #
+    # Whether to automatically create indexes when creating foreign key constraints for columns.
+    # Boolean, default is +true+.
+    has_value :auto_index, :klass => :boolean, :default => true
+
+    ##
+    # :attr_accessor: on_update
+    #
+    # The default value for +:on_update+ when creating foreign key
+    # constraints for columns.  Valid values are as described in
+    # ForeignKeyDefinition, or +nil+ to let the database connection use
+    # its own default.  Default is +nil+.
+    has_value :on_update
+
+    ##
+    # :attr_accessor: on_delete
+    #
+    # The default value for +:on_delete+ when creating foreign key
+    # constraints for columns.  Valid values are as described in
+    # ForeignKeyDefinition, or +nil+ to let the database connection use
+    # its own default.  Default is +nil+.
+    has_value :on_delete
+
+    def merge(opts)
+      dup.update_attributes(opts)
+    end
+  end
+
+
+  # Returns the global configuration, i.e., the singleton instance of Config
+  def self.config
+    @config ||= Config.new
+  end
+
+  # Initialization block is passed a global Config instance that can be
+  # used to configure SchemaPlusForeignKeys behavior.  E.g., if you want to disable
+  # automation creation of foreign key constraints for columns name *_id,
+  # put the following in config/initializers/schema_plus_foreign_keys.rb :
+  #
+  #    SchemaPlusForeignKeys.setup do |config|
+  #       config.auto_create = false
+  #    end
+  #
+  def self.setup # :yields: config
+    yield config
+  end
+
+  def self.insert #:nodoc:
+    SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation, SchemaPlusForeignKeys::ActiveRecord::ConnectionAdapters::AbstractAdapter::VisitTableDefinition
+  end
+
+end
+
+SchemaMonkey.register(SchemaPlusForeignKeys)

data/lib/{schema_plus → schema_plus_foreign_keys}/active_record/base.rb

@@ -1,8 +1,8 @@
-module SchemaPlus
+module SchemaPlusForeignKeys
   module ActiveRecord
 
     #
-    # SchemaPlus adds several methods to ActiveRecord::Base
+    # SchemaPlusForeignKeys adds several methods to ActiveRecord::Base
     #
     module Base
       def self.included(base) #:nodoc:

data/lib/{schema_plus → schema_plus_foreign_keys}/active_record/connection_adapters/abstract_adapter.rb

@@ -1,10 +1,10 @@
-module SchemaPlus
+module SchemaPlusForeignKeys
   module ActiveRecord
-    # SchemaPlus adds several methods to the connection adapter (as returned by ActiveRecordBase#connection).  See AbstractAdapter for details.
+    # SchemaPlusForeignKeys adds several methods to the connection adapter (as returned by ActiveRecordBase#connection).  See AbstractAdapter for details.
     module ConnectionAdapters
 
       #
-      # SchemaPlus adds several methods to
+      # SchemaPlusForeignKeys adds several methods to
       # ActiveRecord::ConnectionAdapters::AbstractAdapter.  In most cases
       # you don't call these directly, but rather the methods that define
       # things are called by schema statements, and methods that query
@@ -113,7 +113,7 @@ module SchemaPlus
           if fk = fks.detect { |fk| fk.match(test_fk) }
             fk.name
           else
-            raise "SchemaPlus: no foreign key constraint found on #{from_table.inspect} matching #{[to_table, options].inspect}" unless options[:if_exists]
+            raise "SchemaPlusForeignKeys: no foreign key constraint found on #{from_table.inspect} matching #{[to_table, options].inspect}" unless options[:if_exists]
             nil
           end
         end
@@ -149,11 +149,11 @@ module SchemaPlus
 
         module VisitTableDefinition
           def self.included(base) #:nodoc:
-            base.alias_method_chain :visit_TableDefinition, :schema_plus
+            base.alias_method_chain :visit_TableDefinition, :schema_plus_foreign_keys
           end
 
-          def visit_TableDefinition_with_schema_plus(o) #:nodoc:
-            create_sql = visit_TableDefinition_without_schema_plus(o)
+          def visit_TableDefinition_with_schema_plus_foreign_keys(o) #:nodoc:
+            create_sql = visit_TableDefinition_without_schema_plus_foreign_keys(o)
             last_chunk = ") #{o.options}"
 
             unless create_sql.end_with?(last_chunk)

data/lib/{schema_plus → schema_plus_foreign_keys}/active_record/connection_adapters/foreign_key_definition.rb

@@ -1,6 +1,6 @@
 require 'active_record/connection_adapters/abstract/schema_definitions'
 
-module SchemaPlus
+module SchemaPlusForeignKeys
   module ActiveRecord
     module ConnectionAdapters
       # Instances of this class are returned by the queries ActiveRecord::Base#foreign_keys and ActiveRecord::Base#reverse_foreign_keys (via AbstractAdapter#foreign_keys and AbstractAdapter#reverse_foreign_keys)
@@ -19,7 +19,7 @@ module SchemaPlus
 
         def self.included(base)
           base.class_eval do
-            alias_method_chain :initialize, :schema_plus
+            alias_method_chain :initialize, :schema_plus_foreign_keys
           end
         end
 
@@ -46,7 +46,7 @@ module SchemaPlus
         ACTIONS = { :cascade => "CASCADE", :restrict => "RESTRICT", :nullify => "SET NULL", :set_default => "SET DEFAULT", :no_action => "NO ACTION" }.freeze
         ACTION_LOOKUP = ACTIONS.invert.freeze
 
-        def initialize_with_schema_plus(from_table, to_table, options={})
+        def initialize_with_schema_plus_foreign_keys(from_table, to_table, options={})
           [:on_update, :on_delete].each do |key|
             if options[key] == :set_null
               require 'byebug' ; byebug
@@ -55,7 +55,7 @@ module SchemaPlus
             end
           end
 
-          initialize_without_schema_plus(from_table, to_table, options)
+          initialize_without_schema_plus_foreign_keys(from_table, to_table, options)
           if column.is_a?(Array) and column.length == 1
             options[:column] = column[0]
           end

data/lib/{schema_plus → schema_plus_foreign_keys}/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,7 +1,7 @@
-module SchemaPlus
+module SchemaPlusForeignKeys
   module ActiveRecord
     module ConnectionAdapters
-      # SchemaPlus includes a MySQL implementation of the AbstractAdapter
+      # SchemaPlusForeignKeys includes a MySQL implementation of the AbstractAdapter
       # extensions.
       module Mysql2Adapter
 
@@ -9,21 +9,21 @@ module SchemaPlus
 
         def self.included(base)
           base.class_eval do
-            alias_method_chain :remove_column, :schema_plus
-            alias_method_chain :rename_table, :schema_plus
+            alias_method_chain :remove_column, :schema_plus_foreign_keys
+            alias_method_chain :rename_table, :schema_plus_foreign_keys
           end
-          ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::SchemaCreation.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter::VisitTableDefinition)
+          ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::SchemaCreation.send(:include, SchemaPlusForeignKeys::ActiveRecord::ConnectionAdapters::AbstractAdapter::VisitTableDefinition)
         end
 
-        def remove_column_with_schema_plus(table_name, column_name, type=nil, options={})
+        def remove_column_with_schema_plus_foreign_keys(table_name, column_name, type=nil, options={})
           foreign_keys(table_name).select { |foreign_key| Array.wrap(foreign_key.column).include?(column_name.to_s) }.each do |foreign_key|
             remove_foreign_key(table_name, name: foreign_key.name)
           end
-          remove_column_without_schema_plus(table_name, column_name, type, options)
+          remove_column_without_schema_plus_foreign_keys(table_name, column_name, type, options)
         end
 
-        def rename_table_with_schema_plus(oldname, newname)
-          rename_table_without_schema_plus(oldname, newname)
+        def rename_table_with_schema_plus_foreign_keys(oldname, newname)
+          rename_table_without_schema_plus_foreign_keys(oldname, newname)
           rename_foreign_keys(oldname, newname)
         end
 

data/lib/{schema_plus → schema_plus_foreign_keys}/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,19 +1,19 @@
-module SchemaPlus
+module SchemaPlusForeignKeys
   module ActiveRecord
     module ConnectionAdapters
 
-      # The Postgresql adapter implements the SchemaPlus extensions and
+      # The Postgresql adapter implements the SchemaPlusForeignKeys extensions and
       # enhancements
       module PostgresqlAdapter
 
         def self.included(base) #:nodoc:
           base.class_eval do
-            alias_method_chain :rename_table, :schema_plus
+            alias_method_chain :rename_table, :schema_plus_foreign_keys
           end
         end
 
-        def rename_table_with_schema_plus(oldname, newname) #:nodoc:
-          rename_table_without_schema_plus(oldname, newname)
+        def rename_table_with_schema_plus_foreign_keys(oldname, newname) #:nodoc:
+          rename_table_without_schema_plus_foreign_keys(oldname, newname)
           rename_foreign_keys(oldname, newname)
         end
 

data/lib/schema_plus_foreign_keys/active_record/connection_adapters/schema_statements.rb

@@ -0,0 +1,33 @@
+module SchemaPlusForeignKeys::ActiveRecord::ConnectionAdapters
+  module SchemaStatements
+
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        alias_method_chain :create_table, :schema_plus_foreign_keys
+      end
+    end
+
+    ##
+    # :method: create_table
+    #
+    # SchemaPlusForeignKeys extends SchemaStatements::create_table to allow you to specify configuration options per table.  Pass them in as a hash keyed by configuration set (see SchemaPlusForeignKeys::Config),
+    # for example:
+    #
+    #     create_table :widgets, :foreign_keys => {:auto_create => true, :on_delete => :cascade} do |t|
+    #        ...
+    #     end
+    def create_table_with_schema_plus_foreign_keys(table, options = {})
+      options = options.dup
+      config_options = options.delete(:foreign_keys) || {}
+
+      # override rails' :force to cascade
+      drop_table(table, if_exists: true, cascade: true) if options.delete(:force)
+
+      create_table_without_schema_plus_foreign_keys(table, options) do |table_definition|
+        table_definition.schema_plus_config = SchemaPlusForeignKeys.config.merge(config_options)
+        yield table_definition if block_given?
+      end
+    end
+  end
+
+end

data/lib/{schema_plus → schema_plus_foreign_keys}/active_record/connection_adapters/sqlite3_adapter.rb

@@ -1,8 +1,8 @@
-module SchemaPlus
+module SchemaPlusForeignKeys
   module ActiveRecord
     module ConnectionAdapters
 
-      # SchemaPlus includes an Sqlite3 implementation of the AbstractAdapter
+      # SchemaPlusForeignKeys includes an Sqlite3 implementation of the AbstractAdapter
       # extensions.
       module Sqlite3Adapter
 
@@ -10,7 +10,7 @@ module SchemaPlus
 
         def self.included(base)
           base.class_eval do
-            alias_method_chain :rename_table, :schema_plus
+            alias_method_chain :rename_table, :schema_plus_foreign_keys
           end
         end
 
@@ -19,8 +19,8 @@ module SchemaPlus
           execute('PRAGMA FOREIGN_KEYS = ON')
         end
 
-        def rename_table_with_schema_plus(oldname, newname) #:nodoc:
-          rename_table_without_schema_plus(oldname, newname)
+        def rename_table_with_schema_plus_foreign_keys(oldname, newname) #:nodoc:
+          rename_table_without_schema_plus_foreign_keys(oldname, newname)
           rename_foreign_keys(oldname, newname)
         end
 

data/lib/{schema_plus → schema_plus_foreign_keys}/active_record/connection_adapters/table_definition.rb

@@ -1,19 +1,19 @@
-module SchemaPlus::ActiveRecord::ConnectionAdapters
+module SchemaPlusForeignKeys::ActiveRecord::ConnectionAdapters
 
   #
-  # SchemaPlus adds several methods to TableDefinition, allowing indexes
+  # SchemaPlusForeignKeys adds several methods to TableDefinition, allowing indexes
   # and foreign key constraints to be defined within a
   # <tt>create_table</tt> block of a migration, allowing for better
   # encapsulation and more DRY definitions.
   #
-  # For example, without SchemaPlus you might define a table like this:
+  # For example, without SchemaPlusForeignKeys you might define a table like this:
   #
   #    create_table :widgets do |t|
   #       t.string :name
   #    end
   #    add_index :widgets, :name
   #
-  # But with SchemaPlus, the index can be defined within the create_table
+  # But with SchemaPlusForeignKeys, the index can be defined within the create_table
   # block, so you don't need to repeat the table name:
   #
   #    create_table :widgets do |t|
@@ -31,7 +31,7 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
   # For details about the :index option (including unique and multi-column indexes), see the
   # documentation for Migration::ClassMethods#add_column
   #
-  # SchemaPlus also supports creation of foreign key constraints analogously, using Migration::ClassMethods#add_foreign_key or TableDefinition#foreign_key or as part of the column definition, for example:
+  # SchemaPlusForeignKeys also supports creation of foreign key constraints analogously, using Migration::ClassMethods#add_foreign_key or TableDefinition#foreign_key or as part of the column definition, for example:
   #
   #    create_table :posts do |t|  # not DRY
   #       t.integer :author_id
@@ -47,13 +47,13 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
   #       t.integer :author_id, :foreign_key => true
   #    end
   #
-  # <b>NOTE:</b> In the standard configuration, SchemaPlus automatically
+  # <b>NOTE:</b> In the standard configuration, SchemaPlusForeignKeys automatically
   # creates foreign key constraints for columns whose names end in
   # <tt>_id</tt>.  So the above examples are redundant, unless automatic
   # creation was disabled at initialization in the global Config.
   #
-  # SchemaPlus likewise by default automatically creates foreign key constraints for
-  # columns defined via <tt>t.references</tt>.   However, SchemaPlus does not create
+  # SchemaPlusForeignKeys likewise by default automatically creates foreign key constraints for
+  # columns defined via <tt>t.references</tt>.   However, SchemaPlusForeignKeys does not create
   # foreign key constraints if the <tt>:polymorphic</tt> option is true
   #
   # Finally, the configuration for foreign keys can be overriden on a per-table

data/lib/{schema_plus → schema_plus_foreign_keys}/active_record/migration/command_recorder.rb

@@ -1,4 +1,4 @@
-module SchemaPlus
+module SchemaPlusForeignKeys
   module ActiveRecord
     module Migration
       module CommandRecorder
@@ -7,8 +7,8 @@ module SchemaPlus
 
         def self.included(base) #:nodoc:
           base.class_eval do
-            alias_method_chain :add_reference, :schema_plus
-            alias_method_chain :invert_add_index, :schema_plus
+            alias_method_chain :add_reference, :schema_plus_foreign_keys
+            alias_method_chain :invert_add_index, :schema_plus_foreign_keys
           end
         end
 
@@ -18,7 +18,7 @@ module SchemaPlus
         #
         # should track it down separately and submit a patch/fix to rails
         #
-        def add_reference_with_schema_plus(table_name, ref_name, options = {}) #:nodoc:
+        def add_reference_with_schema_plus_foreign_keys(table_name, ref_name, options = {}) #:nodoc:
           polymorphic = options.delete(:polymorphic)
           options[:references] = nil if polymorphic
           # ugh.  copying and pasting code from ::ActiveRecord::ConnectionAdapters::SchemaStatements#add_reference
@@ -30,7 +30,7 @@ module SchemaPlus
           self
         end
 
-        def invert_add_index_with_schema_plus(args)
+        def invert_add_index_with_schema_plus_foreign_keys(args)
           table, columns, options = *args
           [:remove_index, [table, (options||{}).merge(column: columns, if_exists: true)]]
         end

data/lib/{schema_plus → schema_plus_foreign_keys}/active_record/schema.rb

@@ -1,4 +1,4 @@
-module SchemaPlus
+module SchemaPlusForeignKeys
   module ActiveRecord
     module Schema #:nodoc: all
       def self.included(base)
@@ -8,18 +8,18 @@ module SchemaPlus
       module ClassMethods
         def self.extended(base)
           class << base
-            alias_method_chain :define, :schema_plus
+            alias_method_chain :define, :schema_plus_foreign_keys
           end
         end
 
-        def define_with_schema_plus(info={}, &block)
+        def define_with_schema_plus_foreign_keys(info={}, &block)
           fk_override = { :auto_create => false, :auto_index => false }
-          save = Hash[fk_override.keys.collect{|key| [key, SchemaPlus.config.foreign_keys.send(key)]}]
+          save = Hash[fk_override.keys.collect{|key| [key, SchemaPlusForeignKeys.config.send(key)]}]
           begin
-            SchemaPlus.config.foreign_keys.update_attributes(fk_override)
-            define_without_schema_plus(info, &block)
+            SchemaPlusForeignKeys.config.update_attributes(fk_override)
+            define_without_schema_plus_foreign_keys(info, &block)
           ensure
-            SchemaPlus.config.foreign_keys.update_attributes(save)
+            SchemaPlusForeignKeys.config.update_attributes(save)
           end
         end
       end