schema_plus 0.1.0.pre1

data/lib/schema_plus/active_record/base.rb

@@ -0,0 +1,81 @@
+module SchemaPlus
+  module ActiveRecord
+
+    #
+    # SchemaPlus adds several methods to ActiveRecord::Base
+    #
+    module Base
+      def self.included(base) #:nodoc:
+        base.extend(ClassMethods)
+        base.extend(SchemaPlus::ActiveRecord::Associations)
+        base.extend(SchemaPlus::ActiveRecord::Validations)
+      end
+
+      module ClassMethods #:nodoc:
+        def self.extended(base) #:nodoc:
+          class << base
+            alias_method_chain :columns, :schema_plus
+            alias_method_chain :abstract_class?, :schema_plus
+            alias_method_chain :reset_column_information, :schema_plus
+          end
+        end
+
+        public
+
+        # Per-model override of Config options.  Use via, e.g.
+        #     class MyModel < ActiveRecord::Base
+        #         schema_plus :associations => { :auto_create => false }
+        #     end
+        def schema_plus(opts)
+          @schema_plus_config = SchemaPlus.config.merge(opts)
+        end
+
+        def abstract_class_with_schema_plus? #:nodoc:
+          abstract_class_without_schema_plus? || !(name =~ /^Abstract/).nil?
+        end
+
+        def columns_with_schema_plus #:nodoc:
+          unless @schema_plus_extended_columns
+            @schema_plus_extended_columns = true
+            cols = columns_hash
+            indexes.each do |index|
+              index.columns.each do |name|
+                cols[name].indexes << index
+              end
+            end
+          end
+          columns_without_schema_plus
+        end
+
+        def reset_column_information_with_schema_plus #:nodoc:
+          reset_column_information_without_schema_plus
+          @indexes = @foreign_keys = @schema_plus_extended_columns = nil
+        end
+
+        # Returns a list of IndexDefinition objects, for each index
+        # defind on this model's table.
+        def indexes
+          @indexes ||= connection.indexes(table_name, "#{name} Indexes")
+        end
+
+        # Returns a list of ForeignKeyDefinition objects, for each foreign
+        # key constraint defined in this model's table
+        def foreign_keys
+          @foreign_keys ||= connection.foreign_keys(table_name, "#{name} Foreign Keys")
+        end
+
+        # Returns a list of ForeignKeyDefinition objects, for each foreign
+        # key constraint of other tables that refer to this model's table
+        def reverse_foreign_keys
+          connection.reverse_foreign_keys(table_name, "#{name} Reverse Foreign Keys")
+        end
+
+        private
+
+        def schema_plus_config # :nodoc:
+          @schema_plus_config ||= SchemaPlus.config.dup
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+module SchemaPlus
+  module ActiveRecord
+    # SchemaPlus adds several methods to the connection adapter (as returned by ActiveRecordBase#connection).  See AbstractAdapter for details.
+    module ConnectionAdapters
+
+      #
+      # SchemaPlus 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
+      # things are called by ActiveRecord::Base.
+      #
+      module AbstractAdapter
+        def self.included(base) #:nodoc:
+          base.alias_method_chain :initialize, :schema_plus
+          base.alias_method_chain :drop_table, :schema_plus
+        end
+
+        def initialize_with_schema_plus(*args) #:nodoc:
+          initialize_without_schema_plus(*args)
+          adapter = nil
+          case adapter_name
+            # name of MySQL adapter depends on mysql gem
+            # * with mysql gem adapter is named MySQL
+            # * with mysql2 gem adapter is named Mysql2
+            # Here we handle this and hopefully futher adapter names
+          when /^MySQL/i 
+            adapter = 'MysqlAdapter'
+          when 'PostgreSQL' 
+            adapter = 'PostgresqlAdapter'
+          when 'SQLite' 
+            adapter = 'Sqlite3Adapter'
+          end
+          if adapter 
+            adapter_module = SchemaPlus::ActiveRecord::ConnectionAdapters.const_get(adapter)
+            self.class.send(:include, adapter_module) unless self.class.include?(adapter_module)
+            self.post_initialize if self.respond_to? :post_initialize
+          end
+        end
+
+        # Create a view given the SQL definition
+        def create_view(view_name, definition)
+          execute "CREATE VIEW #{quote_table_name(view_name)} AS #{definition}"
+        end
+
+        # Drop the named view
+        def drop_view(view_name)
+          execute "DROP VIEW #{quote_table_name(view_name)}"
+        end
+
+        #--
+        # these are all expected to be defined by subclasses, listing them
+        # here only as templates.
+        #++
+        # Returns a list of all views (abstract)
+        def views(name = nil) [] end
+        # Returns the SQL definition of a given view (abstract)
+        def view_definition(view_name, name = nil) end
+        # Return the ForeignKeyDefinition objects for foreign key
+        # constraints defined on this table (abstract)
+        def foreign_keys(table_name, name = nil) [] end
+        # Return the ForeignKeyDefinition objects for foreign key
+        # constraints defined on other tables that reference this table
+        # (abstract)
+        def reverse_foreign_keys(table_name, name = nil) [] end
+
+        # Define a foreign key constraint.  Valid options are :on_update,
+        # :on_delete, and :deferrable, with values as described at
+        # ForeignKeyDefinition
+        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 #{quote_table_name(table_name)} ADD #{foreign_key.to_sql}"
+        end
+
+        # Remove a foreign key constraint
+        def remove_foreign_key(table_name, foreign_key_name)
+          execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{foreign_key_name}"
+        end
+
+        def drop_table_with_schema_plus(name, options = {}) #:nodoc:
+          unless ::ActiveRecord::Base.connection.class.include?(SchemaPlus::ActiveRecord::ConnectionAdapters::Sqlite3Adapter)
+            reverse_foreign_keys(name).each { |foreign_key| remove_foreign_key(foreign_key.table_name, foreign_key.name) }
+          end
+          drop_table_without_schema_plus(name, options)
+        end
+
+        # Returns true if the database supports parital indexes (abstract; only
+        # Postgresql returns true)
+        def supports_partial_indexes?
+          false
+        end
+
+      end
+    end
+  end
+end

data/lib/schema_plus/active_record/connection_adapters/column.rb

@@ -0,0 +1,55 @@
+module SchemaPlus
+  module ActiveRecord
+    module ConnectionAdapters
+
+      #
+      # SchemaPlus adds several methods to Column
+      #
+      module Column
+
+        # Returns the list of IndexDefinition instances for each index that
+        # refers to this column.  Returns an empty list if there are no
+        # such indexes.
+        def indexes
+          # list get filled by SchemaPlus::ActiveRecord::Base::columns_with_schema_plus
+          @indexes ||= []
+        end
+
+        # If the column is in a unique index, returns a list of names of other columns in
+        # the index.  Returns an empty list if it's a single-column index.
+        # Returns nil if the column is not in a unique index.
+        def unique_scope
+          if index = indexes.select{|i| i.unique}.sort_by{|i| i.columns.size}.first
+            index.columns.reject{|name| name == self.name}
+          end
+        end
+
+        # Returns true if the column is in a unique index.  See also
+        # unique_scope
+        def unique?
+          indexes.any?{|i| i.unique}
+        end
+
+        # Returns true if the column is in one or more indexes that are
+        # case sensitive
+        def case_sensitive?
+          indexes.any?{|i| i.case_sensitive?}
+        end
+
+        # Returns the circumstance in which the column must have a value:
+        #   nil     if the column may be null
+        #   :save   if the column has no default value
+        #   :update otherwise
+        def required_on
+          if null
+            nil
+          elsif default.nil?
+            :save
+          else
+            :update
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/active_record/connection_adapters/foreign_key_definition.rb

@@ -0,0 +1,115 @@
+module SchemaPlus
+  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)
+      #
+      # The on_update and on_delete attributes can take on the following values:
+      #   :cascade
+      #   :restrict
+      #   :set_null
+      #   :set_default
+      #   :no_action
+      class ForeignKeyDefinition
+
+        # The name of the foreign key constraint
+        attr_reader :name
+
+        # The name of the table the constraint is defined on
+        attr_reader :table_name
+
+        # The list of column names that are constrained (as strings).
+        attr_reader :column_names
+
+        # The foreign table that is referenced by the constraint
+        attr_reader :references_table_name
+
+        # The list of column names (as strings) of the foreign table that are referenced
+        # by the constraint
+        attr_reader :references_column_names
+
+        # The ON_UPDATE behavior for the constraint.  See above for the
+        # possible values.
+        attr_reader :on_update
+
+        # The ON_UPDATE behavior for the constraint.  See above for the
+        # possible values.
+        attr_reader :on_delete
+
+        # True if the constraint is deferrable
+        attr_reader :deferrable
+
+        # :enddoc:
+        
+        ACTIONS = { :cascade => "CASCADE", :restrict => "RESTRICT", :set_null => "SET NULL", :set_default => "SET DEFAULT", :no_action => "NO ACTION" }.freeze
+
+        def initialize(name, table_name, column_names, references_table_name, references_column_names, on_update = nil, on_delete = nil, deferrable = nil)
+          @name = name
+          @table_name = unquote(table_name)
+          @column_names = unquote(column_names)
+          @references_table_name = unquote(references_table_name)
+          @references_column_names = unquote(references_column_names)
+          @on_update = on_update
+          @on_delete = on_delete
+          @deferrable = deferrable
+
+          ACTIONS.has_key?(on_update) or raise(ArgumentError, "invalid :on_update action: #{on_update.inspect}") if on_update
+          ACTIONS.has_key?(on_delete) or raise(ArgumentError, "invalid :on_delete action: #{on_delete.inspect}") if on_delete
+          if ::ActiveRecord::Base.connection.adapter_name =~ /^mysql/i
+            raise(NotImplementedError, "MySQL does not support ON UPDATE SET DEFAULT") if on_update == :set_default
+            raise(NotImplementedError, "MySQL does not support ON DELETE SET DEFAULT") if on_delete == :set_default
+          end
+        end
+
+        # Dumps a definition of foreign key.
+        # Must be invoked inside create_table block.
+        #
+        # It was introduced to satisfy sqlite which requires foreign key definitions
+        # to be declared when creating a table. That approach is fine for MySQL and
+        # PostgreSQL too.
+        def to_dump
+          dump = "  t.foreign_key"
+          dump << " [#{Array(column_names).collect{ |name| name.inspect }.join(', ')}]"
+          dump << ", #{references_table_name.inspect}, [#{Array(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 (#{quoted_column_names.join(", ")}) REFERENCES #{quoted_references_table_name} (#{quoted_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
+
+        def quoted_column_names
+          Array(column_names).collect { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
+        end
+
+        def quoted_references_column_names
+          Array(references_column_names).collect { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
+        end
+
+        def quoted_references_table_name
+          ::ActiveRecord::Base.connection.quote_table_name(references_table_name)
+        end
+
+        def unquote(names)
+          if names.is_a?(Array)
+            names.collect { |name| __unquote(name) }
+          else
+            __unquote(names)
+          end
+        end
+
+        def __unquote(value)
+          value.to_s.sub(/^["`](.*)["`]$/, '\1')
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/active_record/connection_adapters/index_definition.rb

@@ -0,0 +1,51 @@
+module SchemaPlus
+  module ActiveRecord
+    module ConnectionAdapters
+      # 
+      # SchemaPlus extends the IndexDefinition object to return information
+      # about partial indexes and case sensitivity (i.e. Postgresql
+      # support).
+      module IndexDefinition
+        def self.included(base)  #:nodoc:
+          base.alias_method_chain :initialize, :schema_plus
+        end
+        
+        attr_reader :conditions
+        attr_reader :expression
+        attr_reader :kind
+
+        def case_sensitive?
+          @case_sensitive
+        end
+
+        def initialize_with_schema_plus(*args) #:nodoc:
+          # same args as add_index(table_name, column_names, options={})
+          if args.length == 2 or (args.length == 3 && Hash === args.last)
+            table_name, column_names, options = args + [{}]
+            initialize_without_schema_plus(table_name, options[:name], options[:unique], column_names, options[:lengths])
+            @conditions = options[:conditions]
+            @expression = options[:expression]
+            @kind = options[:kind]
+            @case_sensitive = options.include?(:case_sensitive) ? options[:case_sensitive] : true
+          else # backwards compatibility
+            initialize_without_schema_plus(*args)
+            @case_sensitive = true
+          end
+        end
+
+        # returns the options as a hash suitable for add_index
+        def opts #:nodoc:
+          opts = {}
+          opts[:name]           = name unless name.nil?
+          opts[:unique]         = unique unless unique.nil?
+          opts[:lengths]        = lengths unless lengths.nil?
+          opts[:conditions]     = conditions unless conditions.nil?
+          opts[:expression]     = expression unless expression.nil?
+          opts[:kind]           = kind unless kind.nil?
+          opts[:case_sensitive] = case_sensitive? unless @case_sensitive.nil?
+          opts
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+module SchemaPlus
+  module ActiveRecord
+    module ConnectionAdapters
+      # SchemaPlus includes a MySQL implementation of the AbstractAdapater
+      # extensions.  (This works with both the <tt>mysql</t> and
+      # <tt>mysql2</tt> gems.)
+      module MysqlAdapter
+
+        #:enddoc:
+        
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :tables, :schema_plus
+            alias_method_chain :remove_column, :schema_plus
+          end
+        end
+
+        def tables_with_schema_plus(name=nil, *args)
+          tables_without_schema_plus(name, *args) - views(name)
+        end
+
+        def remove_column_with_schema_plus(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_schema_plus(table_name, column_name)
+        end
+
+        def remove_foreign_key(table_name, foreign_key_name, options = {})
+          execute "ALTER TABLE #{quote_table_name(table_name)} DROP FOREIGN KEY #{foreign_key_name}"
+        end
+
+
+        def foreign_keys(table_name, name = nil)
+          results = execute("SHOW CREATE TABLE #{quote_table_name(table_name)}", name)
+
+          foreign_keys = []
+
+          results.each do |row|
+            row[1].lines.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 ? on_update.downcase.gsub(' ', '_').to_sym : :restrict
+                on_delete = on_delete ? on_delete.downcase.gsub(' ', '_').to_sym : :restrict
+
+                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
+         ORDER BY constraint_name, ordinal_position;
+          SQL
+          current_foreign_key = nil
+          foreign_keys = []
+
+          results.each do |row|
+            next unless table_name.casecmp(row[3]) == 0
+            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
+
+        def views(name = nil)
+          views = []
+          execute("SELECT table_name FROM information_schema.views WHERE table_schema = SCHEMA()", name).each do |row|
+            views << row[0]
+          end
+          views
+        end
+
+        def view_definition(view_name, name = nil)
+          result = execute("SELECT view_definition, check_option FROM information_schema.views WHERE table_schema = SCHEMA() AND table_name = #{quote(view_name)}", name)
+          return nil unless (result.respond_to?(:num_rows) ? result.num_rows : result.to_a.size) > 0 # mysql vs mysql2
+          row = result.respond_to?(:fetch_row) ? result.fetch_row : result.first
+          sql = row[0]
+          sql.gsub!(%r{#{quote_table_name(current_database)}[.]}, '')
+          case row[1]
+          when "CASCADED" then sql += " WITH CASCADED CHECK OPTION"
+          when "LOCAL" then sql += " WITH LOCAL CHECK OPTION"
+          end
+          sql
+        end
+
+      end
+    end
+  end
+end