schema_plus 0.1.0.pre1

data/lib/schema_plus/active_record/schema.rb

@@ -0,0 +1,27 @@
+module SchemaPlus
+  module ActiveRecord
+    module Schema #:nodoc: all
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def self.extended(base)
+          class << base
+            attr_accessor :defining
+            alias :defining? :defining
+
+            alias_method_chain :define, :schema_plus
+          end
+        end
+
+        def define_with_schema_plus(info={}, &block)
+          self.defining = true
+          define_without_schema_plus(info, &block)
+        ensure
+          self.defining = false
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/active_record/schema_dumper.rb

@@ -0,0 +1,122 @@
+require 'tsort'
+
+module SchemaPlus
+  module ActiveRecord
+
+    # SchemaPlus modifies ActiveRecord's schema dumper to include foreign
+    # key constraints and views.
+    #
+    # Additionally, 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.)
+    #
+    # The tables and views are dumped in alphabetical order, subject to
+    # topological sort constraints that a table must be dumped before any
+    # view that references it or table that has a foreign key constaint to
+    # it.
+    #
+    module SchemaDumper
+
+      include TSort
+
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          private
+          alias_method_chain :table, :schema_plus
+          alias_method_chain :tables, :schema_plus
+          alias_method_chain :indexes, :schema_plus
+        end
+      end
+
+      private
+
+      def tables_with_schema_plus(stream) #:nodoc:
+        @table_dumps = {}
+        @re_view_referent = %r{(?:(?i)FROM|JOIN) \S*\b(#{(@connection.tables + @connection.views).join('|')})\b}
+        begin
+          tables_without_schema_plus(nil)
+
+          @connection.views.each do |view_name|
+            definition = @connection.view_definition(view_name)
+            @table_dumps[view_name] = "  create_view #{view_name.inspect}, #{definition.inspect}\n"
+          end
+
+          tsort().each do |table|
+            stream.print @table_dumps[table]
+          end
+
+        ensure
+          @table_dumps = nil
+        end
+      end
+
+      def tsort_each_node(&block) #:nodoc:
+        @table_dumps.keys.sort.each(&block)
+      end
+
+      def tsort_each_child(table, &block) #:nodoc:
+        references = if @connection.views.include?(table)
+                       @connection.view_definition(table).scan(@re_view_referent).flatten
+                     else
+                       @connection.foreign_keys(table).collect(&:references_table_name)
+                     end
+        references.sort.uniq.each(&block)
+      end
+
+      def table_with_schema_plus(table, ignore) #:nodoc:
+
+        stream = StringIO.new
+        table_without_schema_plus(table, stream)
+        stream.rewind
+        table_dump = stream.read
+
+        if i = (table_dump =~ /^\s*[e]nd\s*$/)
+          stream = StringIO.new
+          dump_indexes(table, stream)
+          dump_foreign_keys(table, stream)
+          stream.rewind
+          table_dump.insert i, stream.read
+        end
+
+        @table_dumps[table] = table_dump
+      end
+
+      def indexes_with_schema_plus(table, stream) #:nodoc:
+        # do nothing.  we've already taken care of indexes as part of
+        # dumping the tables
+      end
+
+      def dump_indexes(table, stream) #:nodoc:
+        indexes = @connection.indexes(table)
+        indexes.each do |index|
+          stream.print "    t.index"
+          unless index.columns.blank? 
+            stream.print " #{index.columns.inspect}, :name => #{index.name.inspect}"
+            stream.print ", :unique => true" if index.unique
+            stream.print ", :kind => \"#{index.kind}\"" unless index.kind.blank?
+            stream.print ", :case_sensitive => false" unless index.case_sensitive?
+            stream.print ", :conditions => #{index.conditions.inspect}" unless index.conditions.blank?
+            index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
+            stream.print ", :length => #{Hash[*index.columns.zip(index.lengths).flatten].inspect}" if index_lengths.present?
+          else
+            stream.print " :name => #{index.name.inspect}"
+            stream.print ", :kind => \"#{index.kind}\"" unless index.kind.blank?
+            stream.print ", :expression => #{index.expression.inspect}"
+          end
+
+          stream.puts
+        end
+      end
+
+      def dump_foreign_keys(table, stream) #:nodoc:
+        foreign_keys = @connection.foreign_keys(table)
+        foreign_keys.each do |foreign_key|
+          stream.print "  "
+          stream.puts foreign_key.to_dump
+        end
+      end
+
+    end
+  end
+end

data/lib/schema_plus/active_record/validations.rb

@@ -0,0 +1,139 @@
+module SchemaPlus
+  module ActiveRecord
+      module Validations
+
+        def inherited(klass) #:nodoc:
+          if self == ::ActiveRecord::Base
+            klass.instance_eval do
+
+              # create a callback to load the validations before validation
+              # happens.  the callback deletes itself after use (just to
+              # eliminate the callback overhead).
+              before_validation :load_schema_validations
+              private
+              define_method :load_schema_validations do
+                self.class.send :load_schema_validations
+                self.class.skip_callback :validation, :before, :load_schema_validations
+              end
+            end
+          end
+          super
+        end
+
+        # Adds schema-based validations to model.
+        # Attributes as well as associations are validated.
+        # For instance if there is column
+        #
+        #     <code>email NOT NULL</code>
+        #
+        # defined at database-level it will be translated to
+        #
+        #     <code>validates_presence_of :email</code>
+        #
+        # If there is an association named <tt>user</tt>
+        # based on <tt>user_id NOT NULL</tt> it will be translated to
+        #
+        #     <code>validates_presence_of :user</code>
+        #
+        #  Note it uses the name of association (user) not the column name (user_id).
+        #  Only <tt>belongs_to</tt> associations are validated.
+        #
+        #  This accepts following options:
+        #  * :only - auto-validate only given attributes
+        #  * :except - auto-validate all but given attributes
+        #
+        def schema_plus(*) #:nodoc:
+          super
+          load_schema_validations
+        end
+
+        private
+
+        def load_schema_validations #:nodoc:
+          # Don't bother if: it's already been loaded; the class is abstract; not a base class; or the table doesn't exist
+          return unless create_schema_validations?
+          
+          load_column_validations
+          load_association_validations
+          @schema_validations_loaded = true
+        end
+
+        def load_column_validations #:nodoc:
+          content_columns.each do |column|
+            name = column.name.to_sym
+
+            # Data-type validation
+            if column.type == :integer
+              validate_logged :validates_numericality_of, name, :allow_nil => true, :only_integer => true
+            elsif column.number?
+              validate_logged :validates_numericality_of, name, :allow_nil => true
+            elsif column.text? && column.limit
+              validate_logged :validates_length_of, name, :allow_nil => true, :maximum => column.limit
+            end
+
+            # NOT NULL constraints
+            if column.required_on
+              if column.type == :boolean
+                validate_logged :validates_inclusion_of, name, :in => [true, false], :message => :blank
+              else
+                validate_logged :validates_presence_of, name
+              end
+            end
+
+            # UNIQUE constraints
+            add_uniqueness_validation(column) if column.unique?
+          end
+        end
+
+        def load_association_validations #:nodoc:
+          reflect_on_all_associations(:belongs_to).each do |association|
+            # :primary_key_name was deprecated (noisily) in rails 3.1
+            foreign_key_method = (association.respond_to? :foreign_key) ?  :foreign_key : :primary_key_name
+            column = columns_hash[association.send(foreign_key_method).to_s]
+            next unless column
+
+            # NOT NULL constraints
+            validate_logged :validates_presence_of, association.name if column.required_on
+
+            # UNIQUE constraints
+            add_uniqueness_validation(column) if column.unique?
+          end
+        end
+
+        def add_uniqueness_validation(column) #:nodoc:
+          scope = column.unique_scope.map(&:to_sym)
+          condition = :"#{column.name}_changed?"
+          name = column.name.to_sym
+          validate_logged :validates_uniqueness_of, name, :scope => scope, :allow_nil => true, :if => condition
+        end
+
+        def create_schema_validations? #:nodoc:
+          schema_plus_config.validations.auto_create? && !(@schema_validations_loaded || abstract_class? || name.blank? || !table_exists?)
+        end
+
+        def validate_logged(method, arg, opts={}) #:nodoc:
+          if _filter_validation(method, arg) 
+            msg = "SchemaPlus validations: #{self.name}.#{method} #{arg.inspect}"
+            msg += ", #{opts.inspect[1...-1]}" if opts.any?
+            logger.info msg
+            send method, arg, opts
+          end
+        end
+
+        def _filter_validation(macro, name) #:nodoc:
+          config = schema_plus_config.validations
+          types = [macro]
+          if match = macro.to_s.match(/^validates_(.*)_of$/) 
+            types << match[1].to_sym
+          end
+          return false if config.only        and not Array.wrap(config.only).include?(name)
+          return false if config.except      and     Array.wrap(config.except).include?(name)
+          return false if config.only_type   and not (Array.wrap(config.only_type) & types).any?
+          return false if config.except_type and     (Array.wrap(config.except_type) & types).any?
+          return true
+        end
+
+      end
+
+    end
+  end

data/lib/schema_plus/railtie.rb

@@ -0,0 +1,12 @@
+module SchemaPlus 
+  class Railtie < Rails::Railtie #:nodoc:
+    config.before_initialize do
+      SchemaPlus.insert_connection_adapters
+    end
+
+    initializer 'schema_plus.insert', :after => :load_config_initializers do
+      SchemaPlus.insert
+    end
+
+  end
+end

data/lib/schema_plus/version.rb

@@ -0,0 +1,3 @@
+module SchemaPlus
+  VERSION = "0.1.0.pre1"
+end

data/lib/schema_plus.rb

@@ -0,0 +1,248 @@
+require 'valuable'
+
+require 'schema_plus/version'
+require 'schema_plus/active_record/base'
+require 'schema_plus/active_record/migration'
+require 'schema_plus/active_record/connection_adapters/table_definition'
+require 'schema_plus/active_record/connection_adapters/schema_statements'
+require 'schema_plus/active_record/schema'
+require 'schema_plus/active_record/schema_dumper'
+require 'schema_plus/active_record/connection_adapters/abstract_adapter'
+require 'schema_plus/active_record/connection_adapters/column'
+require 'schema_plus/active_record/connection_adapters/foreign_key_definition'
+require 'schema_plus/active_record/connection_adapters/index_definition'
+require 'schema_plus/active_record/associations'
+require 'schema_plus/railtie' if defined?(Rails)
+
+module SchemaPlus
+  module ActiveRecord
+
+    autoload :Validations, 'schema_plus/active_record/validations'
+
+    module ConnectionAdapters
+      autoload :MysqlAdapter, 'schema_plus/active_record/connection_adapters/mysql_adapter'
+      autoload :PostgresqlAdapter, 'schema_plus/active_record/connection_adapters/postgresql_adapter'
+      autoload :Sqlite3Adapter, 'schema_plus/active_record/connection_adapters/sqlite3_adapter'
+    end
+  end
+
+  # This global configuation options for SchmeaPlus.
+  # Set them in +config/initializers/schema_plus.rb+ using:
+  #
+  #    SchemaPlus.setup do |config|
+  #       ...
+  #    end
+  #
+  # The options are grouped into subsets based on area of functionality.
+  # See Config::ForeignKeys, Config::Associations, Config::Validations
+  #
+  class Config < Valuable
+
+    # This set of configuration options control SchemaPlus's foreign key
+    # constraint behavior.  Set them in
+    # +config/initializers/schema_plus.rb+ using:
+    #
+    #    SchemaPlus.setup do |config|
+    #       config.foreign_keys.auto_create = ...
+    #    end
+    #
+    class ForeignKeys < 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
+    end
+    has_value :foreign_keys, :klass => ForeignKeys, :default => ForeignKeys.new
+
+    # This set of configuration options control SchemaPlus's automatic
+    # association behavior.  Set them in
+    # +config/initializers/schema_plus.rb+ using:
+    #
+    #    SchemaPlus.setup do |config|
+    #       config.associations.auto_create = ...
+    #    end
+    #
+    class Associations < Valuable
+      
+      ##
+      # :attr_accessor: auto_create
+      #
+      # Whether to automatically create associations based on foreign keys.
+      # Boolean, default is +true+.
+      has_value :auto_create, :klass => :boolean, :default => true
+
+      ##
+      # :attr_accessor: concise_names
+      #
+      # Whether to use concise naming (strip out common prefixes from class names).
+      # Boolean, default is +true+.
+      has_value :concise_names, :klass => :boolean, :default => true
+
+      ##
+      # :attr_accessor: except
+      #
+      # List of association names to exclude from automatic creation.
+      # Value is a single name, an array of names, or +nil+.  Default is +nil+.
+      has_value :except, :default => nil
+
+      ##
+      # :attr_accessor: only
+      #
+      # List of association names to include in automatic creation.
+      # Value is a single name, and array of names, or +nil+.  Default is +nil+.
+      has_value :only, :default => nil
+
+      ##
+      # :attr_accessor: except_type
+      #
+      # List of association types to exclude from automatic creation.
+      # Value is one or an array of +:belongs_to+, +:has_many+, +:has_one+, and/or
+      # +:has_and_belongs_to_many+, or +nil+.  Default is +nil+.
+      has_value :except_type, :default => nil
+
+      ##
+      # :attr_accessor: only_type
+      #
+      # List of association types to include from automatic creation.
+      # Value is one or an array of +:belongs_to+, +:has_many+, +:has_one+, and/or
+      # +:has_and_belongs_to_many+, or +nil+.  Default is +nil+.
+      has_value :only_type, :default => nil
+
+    end
+    has_value :associations, :klass => Associations, :default => Associations.new
+
+    # This set of configuration options control SchemaPlus's automatic
+    # validations behavior.  Set them in
+    # +config/initializers/schema_plus.rb+ using:
+    #
+    #    SchemaPlus.setup do |config|
+    #       config.validations.auto_create = ...
+    #    end
+    #
+    class Validations < Valuable
+      ##
+      # :attr_accessor: auto_create
+      #
+      # Whether to automatically create validations based on database constraints.
+      # Boolean, default is +true+.
+      has_value :auto_create, :klass => :boolean, :default => true
+
+      ##
+      # :attr_accessor: only
+      #
+      # List of field names to include in automatic validation.
+      # Value is a single name, and array of names, or +nil+.  Default is +nil+.
+      has_value :only, :default => nil
+
+      ##
+      # :attr_accessor: except
+      #
+      # List of field names to exclude from automatic validation.
+      # Value is a single name, an array of names, or +nil+.  Default is <tt>[:created_at, :updated_at, :created_on, :updated_on]</tt>.
+      has_value :except, :default => [:created_at, :updated_at, :created_on, :updated_on]
+      
+      ##
+      # :attr_accessor: only_type
+      #
+      # List of validation types to exclude from automatic validation.
+      # Value is a single type, and array of types, or +nil+.  Default is +nil+.
+      # A type is specified as, e.g., +:validates_presence_of+ or simply +:presence+.
+      has_value :except_type, :default => nil
+
+      ##
+      # :attr_accessor: only_type
+      #
+      # List of validation types to include in automatic validation.
+      # Value is a single type, and array of types, or +nil+.  Default is +nil+.
+      # A type is specified as, e.g., +:validates_presence_of+ or simply +:presence+.
+      has_value :only_type, :default => nil
+
+    end
+    has_value :validations, :klass => Validations, :default => Validations.new
+
+
+    def dup #:nodoc:
+      self.class.new(Hash[attributes.collect{ |key, val| [key, Valuable === val ?  val.class.new(val.attributes) : val] }])
+    end
+
+    def update_attributes(opts)#:nodoc:
+      opts = opts.dup
+      opts.keys.each { |key| self.send(key).update_attributes(opts.delete(key)) if self.class.attributes.include? key and Hash === opts[key] }
+      super(opts)
+      self
+    end
+
+    def merge(opts)#:nodoc:
+      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 SchemaPlus 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.rb :
+  #
+  #    SchemaPlus.setup do |config|
+  #       config.foreign_keys.auto_create = false
+  #    end
+  #
+  def self.setup # :yields: config
+    yield config
+  end
+
+  def self.insert_connection_adapters #:nodoc:
+    return if @inserted_connection_adapters
+    @inserted_connection_adapters = true
+    ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter)
+    ::ActiveRecord::ConnectionAdapters::Column.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::Column)
+    ::ActiveRecord::ConnectionAdapters::IndexDefinition.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::IndexDefinition)
+    # (mysql2 v0.2.7 uses its own IndexDefinition, which is compatible with the monkey patches; so if that constant exists, include the patches
+    ::ActiveRecord::ConnectionAdapters::Mysql2IndexDefinition.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::IndexDefinition) if defined? ::ActiveRecord::ConnectionAdapters::Mysql2IndexDefinition
+    ::ActiveRecord::ConnectionAdapters::SchemaStatements.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::SchemaStatements)
+    ::ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::TableDefinition)
+  end
+
+  def self.insert #:nodoc:
+    return if @inserted
+    @inserted = true
+    insert_connection_adapters
+    ::ActiveRecord::Base.send(:include, SchemaPlus::ActiveRecord::Base)
+    ::ActiveRecord::Migration.send(:include, SchemaPlus::ActiveRecord::Migration)
+    ::ActiveRecord::Schema.send(:include, SchemaPlus::ActiveRecord::Schema)
+    ::ActiveRecord::SchemaDumper.send(:include, SchemaPlus::ActiveRecord::SchemaDumper)
+  end
+
+end