schema_plus 1.8.9 → 2.0.0.pre1

data/lib/schema_plus/middleware/dumper.rb

@@ -0,0 +1,94 @@
+module SchemaPlus
+  module Middleware
+    module Dumper
+
+      def self.insert
+        SchemaMonkey::Middleware::Dumper::Tables.prepend FkDependencies
+        SchemaMonkey::Middleware::Dumper::Tables.append IgnoreActiveRecordFkDumps
+        SchemaMonkey::Middleware::Dumper::Table.append ForeignKeys
+      end
+
+      # index and foreign key constraint definitions are dumped
+      # inline in the create_table block.  (This is done for elegance, but
+      # also because Sqlite3 does not allow foreign key constraints to be
+      # added to a table after it has been defined.)
+
+      #
+      # Middleware for the collection of tables
+      #
+
+      class FkDependencies < SchemaMonkey::Middleware::Base
+
+        def call(env)
+          @inline_fks = Hash.new{ |h, k| h[k] = [] }
+          @backref_fks = Hash.new{ |h, k| h[k] = [] }
+
+          env.connection.tables.each do |table|
+            @inline_fks[table] = env.connection.foreign_keys(table)
+            env.dump.depends(table, @inline_fks[table].collect(&:to_table))
+          end
+
+          # Normally we dump foreign key constraints inline in the table
+          # definitions, both for visual cleanliness and because sqlite3
+          # doesn't allow foreign key constraints to be added afterwards.
+          # But in case there's a cycle in the constraint references, some
+          # constraints will need to be broken out then added later.  (Adding
+          # constraints later won't work with sqlite3, but that means sqlite3
+          # won't let you create cycles in the first place.)
+          break_fk_cycles(env) while env.dump.strongly_connected_components.any?{|component| component.size > 1}
+
+          env.dump.data.inline_fks = @inline_fks
+          env.dump.data.backref_fks = @backref_fks
+
+          continue env
+        end
+
+        def break_fk_cycles(env) #:nodoc:
+          env.dump.strongly_connected_components.select{|component| component.size > 1}.each do |tables|
+            table = tables.sort.first
+            backref_fks = @inline_fks[table].select{|fk| tables.include?(fk.to_table)}
+            @inline_fks[table] -= backref_fks
+            env.dump.dependencies[table] -= backref_fks.collect(&:to_table)
+            backref_fks.each do |fk|
+              @backref_fks[fk.to_table] << fk
+            end
+          end
+        end
+      end
+
+      class IgnoreActiveRecordFkDumps < SchemaMonkey::Middleware::Base
+        # Ignore the foreign key dumps at the end of the schema; we'll put them in/near their tables
+        def call(env)
+          continue env
+          env.dump.foreign_keys = []
+        end
+      end
+
+      #
+      # Middleware for individual tables
+      #
+      class ForeignKeys < SchemaMonkey::Middleware::Base
+        def call(env)
+          continue env
+          dumped = {}
+          env.table.columns.each do |column|
+            if (foreign_key = env.dump.data.inline_fks[env.table.name].find(&its.column.to_s == column.name))
+              column.add_option foreign_key.to_dump(column: true)
+              dumped[foreign_key] = true
+            end
+            if (foreign_key = env.dump.data.backref_fks.values.flatten.find{|fk| fk.from_table.to_s == env.table.name && fk.column.to_s == column.name})
+              column.add_comment "foreign key references #{foreign_key.to_table.inspect} (below)"
+            end
+          end
+          env.table.statements += env.dump.data.inline_fks[env.table.name].map { |foreign_key|
+            foreign_key.to_dump(inline: true) unless dumped[foreign_key]
+          }.compact.sort
+          env.table.trailer += env.dump.data.backref_fks[env.table.name].map { |foreign_key|
+            foreign_key.to_dump
+          }.sort
+        end
+      end
+    end
+
+  end
+end

data/lib/schema_plus/middleware/migration.rb

@@ -0,0 +1,167 @@
+module SchemaPlus
+  module Middleware
+    module Migration
+
+      def self.insert
+        SchemaMonkey::Middleware::Migration::Column.prepend Shortcuts
+        SchemaMonkey::Middleware::Migration::Column.append AddForeignKeys
+      end
+
+      class Shortcuts < SchemaMonkey::Middleware::Base
+        def call(env)
+          fk_options = env.options[:foreign_key]
+
+          case fk_options
+          when false then ;
+          when true then fk_options = {}
+          end
+
+          if fk_options != false # may be nil
+            [:references, :on_update, :on_delete, :deferrable].each do |key|
+              (fk_options||={}).reverse_merge!(key => env.options[key]) if env.options.has_key? key
+            end
+          end
+
+          if fk_options and fk_options.has_key?(:references)
+            case fk_options[:references]
+            when nil, false
+              fk_options = false
+            when Array then
+              table, primary_key = fk_options[:references]
+              fk_options[:references] = table
+              fk_options[:primary_key] ||= primary_key
+            end
+          end
+
+
+          fk_options = false if fk_options and fk_options.has_key?(:references) and not fk_options[:references]
+
+          env.options[:foreign_key] = fk_options
+
+          continue env
+
+        end
+      end
+
+      class AddForeignKeys < SchemaMonkey::Middleware::Base
+        def call(env)
+          options = env.options
+          original_options = options.dup
+
+          is_reference = (env.type == :reference)
+          is_polymorphic = is_reference && options[:polymorphic]
+
+          # usurp index creation from AR.  That's necessary to make
+          # auto_index work properly
+          index = options.delete(:index) unless is_polymorphic
+          options[:foreign_key] = false if is_reference
+
+          continue env
+
+          return if is_polymorphic
+
+          env.options = original_options
+
+          add_foreign_keys_and_auto_index(env)
+
+        end
+
+        def add_foreign_keys_and_auto_index(env)
+
+          if (reverting = env.caller.is_a?(::ActiveRecord::Migration::CommandRecorder) && env.caller.reverting)
+            commands_length = env.caller.commands.length
+          end
+
+          config = (env.caller.try(:schema_plus_config) || SchemaPlus.config).foreign_keys
+          fk_args = get_fk_args(env, config)
+
+          # remove existing fk and auto-generated index in case of change of fk on existing column
+          if env.operation == :change and fk_args # includes :none for explicitly off
+            remove_foreign_key_if_exists(env)
+            remove_auto_index_if_exists(env)
+          end
+
+          fk_args = nil if fk_args == :none
+
+          create_index(env, fk_args, config)
+          create_fk(env, fk_args) if fk_args
+
+          if reverting
+            rev = []
+            while env.caller.commands.length > commands_length
+              cmd = env.caller.commands.pop
+              rev.unshift cmd unless cmd[0].to_s =~ /^add_/
+            end
+            env.caller.commands.concat rev
+          end
+
+        end
+
+        def auto_index_name(env)
+          ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.auto_index_name(env.table_name, env.column_name)
+        end
+
+        def create_index(env, fk_args, config)
+          # create index if requested explicity or implicitly due to auto_index
+          index = env.options[:index]
+          index = { :name => auto_index_name(env) } if index.nil? and fk_args && config.auto_index?
+          return unless index
+          case env.caller
+          when ::ActiveRecord::ConnectionAdapters::TableDefinition
+            env.caller.index(env.column_name, index)
+          else
+            env.caller.add_index(env.table_name, env.column_name, index)
+          end
+        end
+
+        def create_fk(env, fk_args)
+          references = fk_args.delete(:references)
+          case env.caller
+          when ::ActiveRecord::ConnectionAdapters::TableDefinition
+            env.caller.foreign_key(env.column_name, references, fk_args)
+          else
+            env.caller.add_foreign_key(env.table_name, references, fk_args.merge(:column => env.column_name))
+          end
+        end
+
+
+        def get_fk_args(env, config)
+          args = nil
+          column_name = env.column_name.to_s
+          options = env.options
+
+          return :none if options[:foreign_key] == false
+
+          args = options[:foreign_key]
+          args ||= {} if config.auto_create? and column_name =~ /_id$/
+
+          return nil if args.nil?
+
+          args[:references] ||= env.table_name if column_name == 'parent_id'
+
+          args[:references] ||= begin
+                                  table_name = column_name.sub(/_id$/, '')
+                                  table_name = table_name.pluralize if ::ActiveRecord::Base.pluralize_table_names
+                                  table_name
+                                end
+
+          args[:on_update] ||= config.on_update
+          args[:on_delete] ||= config.on_delete
+
+          args
+        end
+
+        def remove_foreign_key_if_exists(env)
+          env.caller.remove_foreign_key(env.table_name.to_s, column: env.column_name.to_s, :if_exists => true)
+        end
+
+        def remove_auto_index_if_exists(env)
+          env.caller.remove_index(env.table_name, :name => auto_index_name(env), :column => env.column_name, :if_exists => true)
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/schema_plus/middleware/model.rb

@@ -0,0 +1,17 @@
+module SchemaPlus
+  module Middleware
+    module Model
+
+      def self.insert
+        SchemaMonkey::Middleware::Model::ResetColumnInformation.append ResetColumnInformation
+      end
+
+      class ResetColumnInformation < SchemaMonkey::Middleware::Base
+        def call(env)
+          continue env
+          env.model.reset_foreign_key_information
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/version.rb

@@ -1,3 +1,3 @@
 module SchemaPlus
-  VERSION = "1.8.9"
+  VERSION = "2.0.0.pre1"
 end

data/lib/schema_plus_tables.rb

@@ -0,0 +1,15 @@
+require 'schema_monkey'
+
+require_relative 'schema_plus_tables/active_record/connection_adapters/abstract_adapter'
+
+module SchemaPlusTables
+  module ActiveRecord
+    module ConnectionAdapters
+      autoload :MysqlAdapter, 'schema_plus_tables/active_record/connection_adapters/mysql_adapter'
+      autoload :PostgresqlAdapter, 'schema_plus_tables/active_record/connection_adapters/postgresql_adapter'
+      autoload :Sqlite3Adapter, 'schema_plus_tables/active_record/connection_adapters/sqlite3_adapter'
+    end
+  end
+end
+
+SchemaMonkey.register(SchemaPlusTables)

data/lib/schema_plus_tables/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,20 @@
+module SchemaPlusTables
+  module ActiveRecord
+    module ConnectionAdapters
+      module AbstractAdapter
+        
+        # Extends rails' drop_table to include these options:
+        #   :cascade
+        #   :if_exists
+        #
+        def drop_table(name, options = {})
+          sql = "DROP TABLE"
+          sql += " IF EXISTS" if options[:if_exists]
+          sql += " #{quote_table_name(name)}"
+          sql += " CASCADE" if options[:cascade]
+          execute sql
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus_tables/active_record/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,25 @@
+module SchemaPlusTables
+  module ActiveRecord
+    module ConnectionAdapters
+      module MysqlAdapter
+        
+        # implement cascade by removing foreign keys
+        def drop_table(name, options={})
+          if options[:cascade]
+            reverse_foreign_keys(name).each do |foreign_key|
+              remove_foreign_key(foreign_key.from_table, name: foreign_key.name)
+            end
+          end
+
+          sql = 'DROP'
+          sql += ' TEMPORARY' if options[:temporary]
+          sql += ' TABLE'
+          sql += ' IF EXISTS' if options[:if_exists]
+          sql += " #{quote_table_name(name)}"
+
+          execute sql
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus_tables/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,13 @@
+module SchemaPlusTables
+  module ActiveRecord
+    module ConnectionAdapters
+      module PostgresqlAdapter
+        # pg gem defines a drop_table with fewer options than our Abstract
+        # one, so use the abstract one instead
+        def drop_table(name, options={})
+          SchemaPlusTables::ActiveRecord::ConnectionAdapters::AbstractAdapter.instance_method(:drop_table).bind(self).call(name, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module SchemaPlusTables
+  module ActiveRecord
+    module ConnectionAdapters
+      module Sqlite3Adapter
+
+        def drop_table(name, options={})
+          super(name, options.except(:cascade))
+        end
+      end
+    end
+  end
+end

data/lib/schema_views.rb

@@ -0,0 +1,16 @@
+require 'schema_monkey'
+
+require_relative 'schema_views/active_record/connection_adapters/abstract_adapter'
+require_relative 'schema_views/middleware'
+
+module SchemaViews
+  module ActiveRecord
+    module ConnectionAdapters
+      autoload :MysqlAdapter, 'schema_views/active_record/connection_adapters/mysql_adapter'
+      autoload :PostgresqlAdapter, 'schema_views/active_record/connection_adapters/postgresql_adapter'
+      autoload :Sqlite3Adapter, 'schema_views/active_record/connection_adapters/sqlite3_adapter'
+    end
+  end
+end
+
+SchemaMonkey.register(SchemaViews)

data/lib/schema_views/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,41 @@
+module SchemaViews
+  module ActiveRecord
+    module ConnectionAdapters
+      module AbstractAdapter
+        # Create a view given the SQL definition.  Specify :force => true
+        # to first drop the view if it already exists.
+        def create_view(view_name, definition, options={})
+          definition = definition.to_sql if definition.respond_to? :to_sql
+          if options[:force]
+            drop_view(view_name, if_exists: true)
+          end
+          execute "CREATE VIEW #{quote_table_name(view_name)} AS #{definition}"
+        end
+
+        # Drop the named view.  Specify :if_exists => true
+        # to fail silently if the view doesn't exist.
+        def drop_view(view_name, options = {})
+          sql = "DROP VIEW"
+          sql += " IF EXISTS" if options[:if_exists]
+          sql += " #{quote_table_name(view_name)}"
+          execute sql
+        end
+
+        #####################################################################
+        #
+        # The functions below here are abstract; each subclass should
+        # define them all. Defining them here only for reference.
+        #
+
+        # (abstract) Returns the names of all views, as an array of strings
+        def views(name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
+
+        # (abstract) Returns the SQL definition of a given view.  This is
+        # the literal SQL would come after 'CREATVE VIEW viewname AS ' in
+        # the SQL statement to create a view.
+        def view_definition(view_name, name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; end
+      end
+    end
+  end
+end
+

data/lib/schema_views/active_record/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,30 @@
+module SchemaViews
+  module ActiveRecord
+    module ConnectionAdapters
+      module MysqlAdapter
+
+        def views(name = nil)
+          views = []
+          select_all("SELECT table_name FROM information_schema.views WHERE table_schema = SCHEMA()", name).each do |row|
+            views << row["table_name"]
+          end
+          views
+        end
+
+        def view_definition(view_name, name = nil)
+          results = select_all("SELECT view_definition, check_option FROM information_schema.views WHERE table_schema = SCHEMA() AND table_name = #{quote(view_name)}", name)
+          return nil unless results.any?
+          row = results.first
+          sql = row["view_definition"]
+          sql.gsub!(%r{#{quote_table_name(current_database)}[.]}, '')
+          case row["check_option"]
+          when "CASCADED" then sql += " WITH CASCADED CHECK OPTION"
+          when "LOCAL" then sql += " WITH LOCAL CHECK OPTION"
+          end
+          sql
+        end
+
+      end
+    end
+  end
+end