drysql 0.1.0

data/README

@@ -0,0 +1,119 @@
+====================================================================
+NOTE: Dave Thomas' book Programming Ruby (Pragmatic Programmers' Guide) was my
+			bible during the development of this plug-in so I may have inadvertently borrowed some
+			code from the book, and I most certainly borrowed ideas and coding conventions from the book.
+			Thanks for writing such a great book Dave!
+====================================================================
+
+DrySQL v.0.1.0
+==========
+
+The idea behind DrySQL is that if you have defined a schema on your database complete with keys, constraints, 
+relationships, and behaviour, then you shouldn't need to re-define any of this in your application code.
+
+DrySQL retrieves metadata from your DB's information schema, and uses this to identify keys, and generate
+associations and validations for your ActiveRecord::Base subclasses
+
+For an overview of the features and some use cases, please visit the DrySQL project website: 
+http://drysql.rubyforge.org
+
+How Do I Install It?
+============
+
+Assuming that you have installed RubyGems, on the command line type the following:
+
+gem install drysql
+
+That's it!
+
+How Does It Work?
+============
+
+1. Loading the DrySQL gem
+-------------------------------
+DrySQL simply extends ActiveRecord, so all you need to do is insert the following statement in your code
+somewhere where it will be processed before your application needs to use DrySQL's behaviour:
+
+require_gem 'drysql'
+
+Note that DrySQL depends on the ActiveRecord gem, which in turn depends on the ActiveSupport gem, so you will
+need to have these installed as well.
+
+2. Mapping classes to tables
+--------------------------------
+
+DrySQL makes the assumption that your table name and class name will be compatible with Rails naming
+conventions, or you will specify the table name explicitly using set_table_name inside your class definition.
+
+If your DB tables follow the Rails naming conventions, then you don't need to define classes for them at all. 
+The first time you reference a non-existant class, DrySQL will generate the class for you.
+
+eg. 
+The first time you reference the non-existant class Employee in your Ruby code, DrySQL will generate the class 
+ActiveRecord::Base::Employee in memory. If your DB table is called Employees, then Rails will map the Employee 
+class to the Employees table once you instantiate an Employee object.
+
+If you feel more comfortable defining your class explicitly, it can be as simple as this:
+
+class Employee < ActiveRecord::Base
+end
+
+
+If your Employee table is not called Employees, then you will need to define your class in your Ruby application,
+and call set_table_name inside your class definition:
+
+class Employee < ActiveRecord::Base
+	set_table_name "XYZ123"
+end
+
+
+3. Generating Keys, Associations, and Validations
+--------------------------------------------------------
+
+The first time you instantiate an ActiveRecord::Base subclass (we'll continue to use Employee for these examples),
+DrySQL will intercept the instantiation, query the DB's information schema for the constraints and column metadata 
+associated with your table, and use this information to identify the keys on the table, and generate associations and 
+validations for the class.
+
+Rather than assume that your primary key is called table_name_id, DrySQL queries the DB to find out exactly what your
+primary key column is called. The same is true of foreign keys. Thus, DrySQL fully supports your legacy DB tables.
+
+DrySQL can currently generate the following associations:
+belongs_to
+has_one
+has_many
+has_many :through
+
+Supposing that I find a bulletproof way to identify has_and_belongs_to_many associations from the information schema, 
+I will add functionality for auto-generating these associations.
+
+DrySQL can currently generate the following validations:
+validates_length_of
+validates_numericality_of
+validates_inclusion_of (for boolean columns only, CHECK constraints can be used to enhance this)
+validates_nullability_of
+
+validates_nullability_of is a new validation introduced in DrySQL. Common convention is to use validates_presence_of
+on any column with a NOT NULL constraint. There are 2 holes in this approach: 
+	1) For character columns this validation will throw an error if the value of the column is the empty string, even though the DB considers this a perfectly valid value
+	2) For columns that either have a default value specified or are auto-generated by the DB, we do not want to throw an error if the value is null
+	
+validates_nullability_of throws an error only if the value is nil, no default value is specified for the column, and the column value is not auto-generated by the DB
+
+DrySQL, by design, does not auto-generate validates_uniqueness_of, because I am not convinced about its usefulness.
+Validating records before querying the DB is useful because we can identify invalid data and avoid the cost of I/O by attempting to
+insert/update invalid data into the DB. validates_uniquess_of needs to query the DB in order to perform the validation, so I fail to see the advantage
+of using this application-side validation over just letting the DB perform the validation and having your app handle the duplicate key error thrown
+by the DB.
+
+
+4. A Note About the Unit Tests
+-----------------------------------
+
+I did not publish the tests with the first release of DrySQL because they are built on a clone of a corporate database, and I need to obfuscate them first.
+I will publish tests with the next release
+
+Enjoy!
+
+
+

data/lib/associations.rb

@@ -0,0 +1,90 @@
+module ActiveRecord
+
+  class Base
+  
+    class << self
+    
+      # The @associations instvar is used as an indicator as to whether the associations have already been generated or not.
+      # The first time an instance of a DrySQL-enabled subclass of ActiveRecord::Base is created, the associations are generated
+      # for the class.    
+      def generate_associations
+        unless @associations 
+          generate_belongs_to_associations
+          generate_has_many_associations
+          generate_through_associations
+          @associations = reflections
+        end
+      end
+      
+      def is_associated_with(class_name_symbol)
+        !(reflections.detect {|key, reflection| key.to_s.singularize == class_name_symbol.to_s.singularize}).nil?
+      end
+      
+      private
+      
+        # A belongs_to association exists from class A to class B if A contains a foreign key into B
+        def generate_belongs_to_associations
+          foreign_keys = table_constraints.select {|constraint| constraint.foreign_key?}
+          foreign_keys.each do |foreign_key| 
+            belongs_to_class_name = (class_name(foreign_key.referenced_table_name.upcase)).downcaseFirstLetter
+            self.send(:belongs_to, :"#{belongs_to_class_name}", :foreign_key=>foreign_key.column_name)
+            logger.info("GENERATED ASSOCIATION: #{self.name} belongs_to :#{belongs_to_class_name}, :foreign_key=>#{foreign_key.column_name}")
+          end
+        end
+        
+        # A has_many association exists from A to B if B contains a foreign key into A.
+        # If B's foreign key into A is a unique key within B, then the association is A has_one B
+        def generate_has_many_associations
+          foreign_constraints.each do |foreign_constraint|
+            if foreign_constraint_column_is_unique?(foreign_constraint)
+              has_one_class_name = (class_name(foreign_constraint.table_name.upcase)).downcaseFirstLetter
+              self.send(:has_one, :"#{has_one_class_name}", :foreign_key=>foreign_constraint.referenced_column_name)
+              logger.info("GENERATED ASSOCIATION: #{self.name} has_one :#{has_one_class_name}, :foreign_key=>#{foreign_constraint.referenced_column_name}")
+            else
+              has_many_class_name = (class_name(foreign_constraint.table_name.upcase)).downcaseFirstLetter.pluralize
+              self.send(:has_many, :"#{has_many_class_name}", :foreign_key=>foreign_constraint.referenced_column_name)
+              logger.info("GENERATED ASSOCIATION: #{self.name} has_many :#{has_many_class_name}, :foreign_key=>#{foreign_constraint.referenced_column_name}")
+            end
+          end
+        end
+        
+        def foreign_constraint_column_is_unique?(constraint)
+          class_name = class_name(constraint.table_name.upcase)
+          klass = instance_eval(class_name)
+          constraints_on_given_column = klass.table_constraints.select {|current| current.column_name == constraint.column_name}
+          constraints_on_given_column.any? {|current| current.unique_key?}
+        end
+        
+        # Identifying has_many :through associations:
+        # 1) Collect all has_many associations for this class
+        # 
+        # 2) Collect all FKs from each has_many class that do not reference this class's table
+        # 
+        # 3) Create a has_many :through association for each class referenced by the FKs from step 2,
+        #     unless this class already has an association to the class referenced by the FK
+        #     
+        #     i.e. if this class already has a has_many association with B, don't create a has_many B :through C
+        #          because this will overwrite our direct association
+        #          
+        #     FIXME: this logic doesn't stand up when A has_many :B, :through=>C *and* A has_many :B, :through=>D
+        #               Each association will atttempt to create an accessor for B on A, the next overwriting the previous.
+        #               --> I'm not sure that there is any way to fix this programmatically
+        def generate_through_associations
+          has_many_associations.each do |association|
+            # FIXME the singularization is a hack. We should be able to figure the exact class name without relying
+            #            on naming conventions
+            foreign_class = instance_eval(association[0].to_s.camelize.singularize)
+            eligible_foreign_keys = foreign_class.table_constraints.select {|c| c.foreign_key? && c.referenced_table_name.upcase != table_name.upcase}
+            eligible_foreign_keys.select {|key| !self.is_associated_with(symbolized_class_name_from_table_name(key.referenced_table_name))}.each do |fk|
+              has_many_class_name = pluralized_symbolized_class_name_from_table_name(fk.referenced_table_name)
+              self.send(:has_many, has_many_class_name, :through=>association[0])
+              logger.info("GENERATED ASSOCIATION: #{self.name} has_many #{has_many_class_name}, :through=>#{association[0]}")             
+            end
+          end
+        end
+      
+    end  # end of class methods
+  
+  end   # end of class Base
+
+end   # end of module ActiveRecord

data/lib/base.rb

@@ -0,0 +1,136 @@
+module ActiveRecord
+
+  class Base
+       
+    # Stores a dictionary of table_name => class_name mappings to facilitate reverse lookup
+    # with acceptable performance
+    @@class_name_hash = {}
+    
+    @@logger = Logger.new(STDERR)
+    @@logger.level = Logger::INFO
+    
+
+    # ------------------------------------------------------------------------------------------------------------------------  
+    # Class Methods  
+    # 
+    # This extension to ActiveRecord::Base creates associations and validations for data objects
+    # based on the actual constraints defined on the DB that are retrieved through extension APIs on the
+    # database adapters.
+    # 
+    # To accomplish this, it subverts the 2 methods of creating ActiveRecord objects:
+    # 
+    # *1 - ActiveRecord::Base.initialize - this is called when an ActiveRecord object is created with ActiveRecord::Base.new
+    # 
+    # *2 - ActiveRecord::Base.instantiate - this is called when an ActiveRecord object is created through one of the find methods
+    # 
+    # When an ActiveRecord object is created through these methods the class-level associations and validations
+    # are generated unless they already exist
+    class << self
+    
+      def logger
+        @@logger
+      end
+  
+      # Save table name keys as all UPPERCASE to simplify lookup
+      alias :base_set_table_name :set_table_name
+      def set_table_name(value = nil, &block)
+        base_set_table_name(value)
+        @@class_name_hash["#{table_name.upcase}"] = self.name
+      end
+      
+      
+      # Overrides primary_key in ActiveRecord::Base
+      # 
+      # This implementation will need to be adjusted should composite primary keys be supported in the future
+      # 
+      # set_primary_key generates an accessor method on the caller that returns the string value
+      # --> this generated accessor will be invoked on future calls to primary_key
+      # ---------------------------------------------------------------------------------------------------
+      def primary_key
+        primary = table_constraints.detect {|constraint| constraint.primary_key?}
+        primary_name = primary.column_name
+        set_primary_key(primary_name)
+        primary_name
+      end
+
+   
+      alias :base_class_name :class_name
+      def class_name(table_name = table_name) # :nodoc:
+        #Attempt to retrieve class name from cache before attempting to generate it         
+        name = @@class_name_hash[table_name.upcase]
+        if !name
+          return base_class_name(table_name)
+        end
+        name
+      end
+       
+      
+      alias :base_instantiate :instantiate
+      def instantiate(record)
+        generate_associations
+        generate_validations
+        base_instantiate(record)
+      end
+           
+      # table_constraints are those constraints defined on this table
+      def table_constraints
+        constraints.select {|constraint| constraint.referenced_table_name.nil? || constraint.table_name.upcase == table_name.upcase}
+      end
+      
+      # foreign_constraints are those constraints that are defined on other tables, but 
+      # reference this table (i.e. FKs into this table)
+      def foreign_constraints      
+        constraints.select {|constraint| 
+            !constraint.referenced_table_name.nil? && 
+            constraint.referenced_table_name.upcase == table_name.upcase &&
+            constraint.table_name.upcase != table_name.upcase}
+      end
+      
+      def associations
+        @associations ? @associations : {}
+      end
+     
+      
+      private
+      
+        def constraints
+          unless @constraints
+            @constraints = connection.constraints(table_name, "#{name} Constraints")
+          end
+          @constraints 
+        end
+        
+        # FIXME MacroReflection needs an instance method has_many?
+        # This logic does not belong in Base  
+        def has_many_associations
+          reflections.select {|key, reflection| reflection.macro == :has_many}
+        end
+        
+        def symbolized_class_name_from_table_name(table_name)
+          (class_name(table_name)).downcaseFirstLetter.to_sym
+        end
+      
+        def pluralized_symbolized_class_name_from_table_name(table_name)
+          (class_name(table_name)).downcaseFirstLetter.pluralize.to_sym
+        end
+      
+    end  #end class << self  (Class Methods)
+
+    # ---------------------------------------------------------------------------------------------------
+
+    public    
+      alias :base_initialize :initialize
+      def initialize(attributes = nil)
+        base_initialize
+        self.class.generate_associations
+        self.class.generate_validations
+      end
+      
+      def constraints
+        self.class.table_constraints
+      end
+      
+    
+  end   # end class Base
+  
+end   #end module ActiveRecord

data/lib/connection_adapters/abstract/schema_definitions.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+  
+    class Column
+    
+      def generated?
+        raise NotImplementedError, "Column subclass did not implement this method"
+      end
+      
+      # MySQL sinks the boat on this one.
+      # If no default is specified for a non-nullable column, then MySQL assigns an implicit default value.
+      # This makes it impossible to determine whether or not a default value has been specified for any 
+      # non-nullable column without parsing the SHOW CREATE TABLE output, which is non-standard.
+      def default_specified?
+        raise NotImplementedError, "Column subclass did not implement this method"
+      end        
+    
+    end
+    
+  end
+end

data/lib/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,39 @@
+module ActiveRecord
+
+  module ConnectionAdapters
+  
+    # This is abstract class serves as the template for table constraints from all 
+    # databases compatible with the ISO SQL:2003 information schema standard
+    class AbstractTableConstraint
+      
+      def raise_subclass_responsibility_error
+        raise NotImplementedError, "AbstractTableConstraint subclass #{self.class} did not implement this method"
+      end  
+      
+      alias :primary_key? :raise_subclass_responsibility_error
+      alias :foreign_key? :raise_subclass_responsibility_error
+      alias :unique_key? :raise_subclass_responsibility_error
+      alias :component_of_unique_key? :raise_subclass_responsibility_error
+      alias :is_member_of_composite? :raise_subclass_responsibility_error
+      alias :constraint_schema :raise_subclass_responsibility_error
+      alias :constraint_name :raise_subclass_responsibility_error
+      alias :constraint_type :raise_subclass_responsibility_error
+      alias :table_schema :raise_subclass_responsibility_error
+      alias :table_name :raise_subclass_responsibility_error
+      alias :column_name :raise_subclass_responsibility_error
+      alias :referenced_table_schema :raise_subclass_responsibility_error
+      alias :referenced_table_name :raise_subclass_responsibility_error
+      alias :referenced_column_name :raise_subclass_responsibility_error
+          
+    end
+    
+    
+    class AbstractAdapter
+    
+      def constraints(table_name, name=nil)
+        raise NotImplementedError, "AbstractAdapter subclass #{self.class} did not implement this method"
+      end
+      
+    end
+  end
+end

data/lib/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,139 @@
+module ActiveRecord
+
+  module ConnectionAdapters
+  
+    class MysqlColumn < Column #:nodoc:
+      attr_reader :extra
+      
+      @@auto_increment = "auto_increment"
+      
+      # Capture the value of the "EXTRA" column in the column metadata table.
+      # This can be used to generate validations
+      alias :base_initialize :initialize
+      def initialize(name, default, sql_type = nil, null = true, extra = nil)
+        base_initialize(name, default, sql_type, null)
+        @extra = extra
+      end
+      
+      def generated?
+        @extra == @@auto_increment
+      end
+      
+      # Until MySQL properly handles default values, I assume that a default value of NULL or empty
+      # string means that a default value has not been specified for the column.
+      # 
+      # We really only care about this when the column is NOT NULL, in which case it should be safe
+      # to assume that no one would define the column as NOT NULL and then explicitly set the empty string
+      # as the default value. ...Right? 
+      def default_specified?
+        !(default.nil? || default.blank?)
+      end
+      
+    end
+  
+    
+    # A representation of a referential constraint or key in MySQL
+    # Specifically: Primary, Foreign, Unique Key definitions
+    class MysqlConstraint < AbstractTableConstraint
+      @@PRIMARY_KEY_TYPE='PRIMARY KEY'
+      @@FOREIGN_KEY_TYPE='FOREIGN KEY'
+      @@UNIQUE_KEY_TYPE='UNIQUE'
+        
+      attr_reader :constraint_schema, :constraint_name, :constraint_type, :table_schema, :table_name, :column_name,
+        :referenced_table_schema, :referenced_table_name, :referenced_column_name
+        
+      attr_writer :member_of_composite
+          
+      def initialize(constraint_catalog, constraint_schema, constraint_name, table_schema, table_name, constraint_type,
+        column_name, referenced_table_schema, referenced_table_name, referenced_column_name)
+        @constraint_catalog = constraint_catalog
+        @constraint_schema = constraint_schema
+        @constraint_name = constraint_name
+        @table_schema = table_schema
+        @table_name = table_name
+        @constraint_type = constraint_type
+        @column_name = column_name
+        @referenced_table_schema = referenced_table_schema
+        @referenced_table_name = referenced_table_name
+        @referenced_column_name = referenced_column_name
+      end
+        
+      def primary_key?
+        constraint_type == @@PRIMARY_KEY_TYPE
+      end
+        
+      def foreign_key?
+        constraint_type == @@FOREIGN_KEY_TYPE
+      end
+        
+      def component_of_unique_key?
+        constraint_type == @@UNIQUE_KEY_TYPE
+      end
+      
+      def unique_key?
+        component_of_unique_key? and !is_member_of_composite?
+      end
+      
+      def is_member_of_composite?
+        @member_of_composite ? @member_of_composite : false
+      end
+      
+ 
+    end
+    
+    # The purpose of this extension to MysqlAdapter is to exploit the referential constraints offered in MySQL >=5.0, and
+    # to make the table and column metadata stored in MySQL available to ActiveRecord objects
+    # 
+    # Currently, CHECK constraints are not supported in MySQL 5.x. Although the syntax for creating CHECK constraints is
+    # supported, they are ignored by MySQL
+    class MysqlAdapter < AbstractAdapter
+      
+      # FIXME filter SQL queries on information_schema by schema name in case a table
+      #           with the same name exists in > 1 schema (i.e. test vs. dev schema)
+      def schema
+        @connection_options[3]
+      end
+      
+      # The "EXTRA" column is discarded in the standard Rails implementation of MysqlAdapter.columns.
+      # ActiveRecord can use this column to generate validations
+      def columns(table_name, name = nil)#:nodoc:
+        sql = "SHOW FIELDS FROM #{table_name}"
+        columns = []
+        execute(sql, name).each { |field| columns << MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES", field[5])}
+        columns
+      end
+    
+      # Retrieve each DB constraint from the information_schema database that is either a constraint on
+      # table_name or references table_name (eg. FK into table_name) 
+      # 
+      # Save a boolean value on each constraint indicating whether it is part of a composite constraint or not.
+      # This allows us to encapsulate is_composite? logic on the constraint object itself, rather than 
+      # depending on access to the complete set of constraints for the table at a later time
+      def constraints(table_name, name = nil)#:nodoc:
+        constraints = []
+        
+        sql = "select t2.*, t1.column_name, t1.referenced_table_schema, t1.referenced_table_name, t1.referenced_column_name \
+        from information_schema.key_column_usage as t1 inner join information_schema.table_constraints as t2 \
+        using (constraint_name, table_schema, table_name) where table_name='#{table_name}' or t1.referenced_table_name='#{table_name}'"
+        results = execute(sql, name)
+        constraint_name_hash = {}
+        results.each do |row| 
+          constraints << MysqlConstraint.new(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9])
+          comparable_constraint_name = row[2].upcase
+          constraint_name_count = constraint_name_hash[comparable_constraint_name]
+          constraint_name_count ? 
+            constraint_name_hash[comparable_constraint_name] = constraint_name_count + 1 :
+            constraint_name_hash[comparable_constraint_name] = 1
+        end
+        
+        constraints.each do | constraint|
+          constraint.member_of_composite=(constraint_name_hash[constraint.constraint_name.upcase] > 1)
+        end
+        constraints
+      end
+       
+    end
+       
+  end
+
+end

data/lib/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,116 @@
+module ActiveRecord
+
+  module ConnectionAdapters
+  
+    class PostgreSQLColumn < Column #:nodoc:
+      attr_accessor :generated
+      
+      alias :generated? :generated
+      
+      def default_specified?
+        !default.nil?
+      end
+    
+    end
+    
+    
+    class PostgreSQLConstraint < AbstractTableConstraint
+      @@PRIMARY_KEY_TYPE = "PRIMARY KEY"
+      @@FOREIGN_KEY_TYPE = "FOREIGN KEY"
+      @@UNIQUE_KEY_TYPE = "UNIQUE"
+      @@CHECK_CONSTRAINT_TYPE = "CHECK"
+        
+      attr_reader :constraint_catalog, :constraint_schema, :constraint_name, :constraint_type, 
+        :table_catalog, :table_schema, :table_name, :column_name,
+        :referenced_table_catalog, :referenced_table_schema, :referenced_table_name, :referenced_column_name
+        
+      attr_writer :member_of_composite
+      
+      def initialize(table_catalog, table_schema, table_name, column_name, constraint_catalog, constraint_schema, 
+        constraint_name, referenced_table_catalog, referenced_table_schema, referenced_table_name, constraint_type,
+        referenced_column_name)
+        @table_catalog = table_catalog
+        @table_schema = table_schema
+        @table_name = table_name
+        @column_name = column_name
+        @constraint_catalog = constraint_catalog
+        @constraint_schema = constraint_schema
+        @constraint_name = constraint_name
+        @constraint_type = constraint_type
+        @referenced_table_catalog = referenced_table_catalog
+        @referenced_table_schema = referenced_table_schema
+        @referenced_table_name = referenced_table_name
+        @referenced_column_name = referenced_column_name
+      end
+      
+      def primary_key?
+        constraint_type == @@PRIMARY_KEY_TYPE
+      end
+        
+      def foreign_key?
+        constraint_type == @@FOREIGN_KEY_TYPE
+      end
+      
+      def check_constraint?
+        constraint_type == @@CHECK_CONSTRAINT_TYPE
+      end
+        
+      def component_of_unique_key?
+        constraint_type == @@UNIQUE_KEY_TYPE
+      end
+      
+      def unique_key?
+        component_of_unique_key? and !is_member_of_composite?
+      end
+      
+      def is_member_of_composite?
+        @member_of_composite ? @member_of_composite : false
+      end
+      
+    end
+    
+    
+    class PostgreSQLAdapter < AbstractAdapter
+    
+      def columns(table_name, name = nil) #:nodoc:
+        columns = []
+        column_definitions(table_name).each do |name, type, default, notnull, typmod|
+          # typmod now unused as limit, precision, scale all handled by superclass
+          current = PostgreSQLColumn.new(name, default_value(default), translate_field_type(type), notnull == "f")
+          current.generated= (!default.nil? && default.index('nextval') == 0)
+          columns << current
+        end
+        columns
+      end
+      
+    
+      def constraints(table_name, name = nil)#:nodoc:
+        constraints = []       
+        sql = "select t3.* , t4.* from information_schema.constraint_column_usage as t3 right join \
+          (select t2.*, t1.column_name from information_schema.key_column_usage as t1 inner join \
+            information_schema.table_constraints as t2 using (constraint_name, table_catalog, table_schema, table_name)) \
+            as t4 using (constraint_catalog, constraint_schema, constraint_name) \
+            where t4.table_name='#{table_name.downcase}' or t3.table_name='#{table_name.downcase}'"
+        results = query(sql, name)
+        constraint_name_hash = {}
+        results.each do |row| 
+          constraints << PostgreSQLConstraint.new(row[10], row[11], row[12], row[16], row[4], row[5], row[6], row[0], row[1], row[2], row[13], row[3])
+          comparable_constraint_name = row[6].upcase
+          constraint_name_count = constraint_name_hash[comparable_constraint_name]
+          constraint_name_count ? 
+            constraint_name_hash[comparable_constraint_name] = constraint_name_count + 1 :
+            constraint_name_hash[comparable_constraint_name] = 1
+        end
+        
+        constraints.each do |constraint|
+          constraint.member_of_composite=(constraint_name_hash[constraint.constraint_name.upcase] > 1)
+        end
+        constraints
+      end
+       
+    end
+    
+    
+  end
+  
+end

data/lib/dependencies.rb

@@ -0,0 +1,24 @@
+class Module #:nodoc:
+
+  alias :base_const_missing :const_missing
+  
+  # If a non-existant class is specified, define it as a subclass of ActiveRecord::Base here
+  # 
+  # This idea was inspired by the Magic Models project: http://magicmodels.rubyforge.org/
+  # 
+  # I believe the on-demand generation and simple ActiveRecord::Base subclassing 
+  # to be a better implementation for my needs
+  def const_missing(class_id)
+    begin
+      base_const_missing(class_id)
+    rescue NameError
+      class_def = <<-end_class_def
+        class #{class_id} < ActiveRecord::Base          
+        end
+      end_class_def
+      eval(class_def, TOPLEVEL_BINDING)                     
+    end
+    const_get(class_id)
+  end
+  
+end

data/lib/drysql.rb

@@ -0,0 +1,14 @@
+unless defined?(ActiveRecord)
+    require 'rubygems'
+    require_gem 'activerecord'
+end
+
+require 'connection_adapters/abstract_adapter'
+require 'connection_adapters/mysql_adapter'
+require 'connection_adapters/postgresql_adapter'
+require 'connection_adapters/abstract/schema_definitions'
+require 'associations'
+require 'validations'
+require 'helpers/string'
+require 'base'
+require 'dependencies'

data/lib/helpers/string.rb

@@ -0,0 +1,9 @@
+class String
+
+  def downcaseFirstLetter
+    duplicate = self.dup
+    duplicate[0, 1] = duplicate[0, 1].downcase
+    duplicate
+  end
+  
+end

data/lib/validations.rb

@@ -0,0 +1,107 @@
+module ActiveRecord
+
+  class Errors
+  
+    @@default_error_messages[:null] = "can't be null"
+    
+    # Add an error message to each of the attributes in +attributes+ that is null
+    def add_on_null(attributes, msg = @@default_error_messages[:null])
+      for attr in [attributes].flatten
+        value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
+        add(attr, msg) if value.nil? 
+      end
+    end
+    
+  end
+  
+  
+  module Validations
+    module ClassMethods
+       
+       # NOTE: template for this method borrowed from validates_presence_of method in Rails  
+      def validates_nullability_of(*attr_names)
+        configuration = { :message => ActiveRecord::Errors.default_error_messages[:null], :on => :save }
+        configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
+
+        # can't use validates_each here, because it cannot cope with nonexistent attributes,
+        # while errors.add_on_empty can
+        attr_names.each do |attr_name|
+          send(validation_method(configuration[:on])) do |record|
+            unless configuration[:if] and not evaluate_condition(configuration[:if], record)
+              record.errors.add_on_null(attr_name,configuration[:message])
+            end
+          end
+        end
+      end
+      
+    end
+  end
+  
+
+  class Base
+  
+    class << self
+    
+      # The @validations instvar is used as an indicator as to whether the validations have already been generated or not.
+      # The first time an instance of a DrySQL-enabled subclass of ActiveRecord::Base is created, the validations are generated
+      # for the class. 
+      # 
+      # **NOTE: Some of this code and/or the ideas behind some of this code was borrowed from Simon Harris
+      #               and Red Hill Consulting's Schema Validations plug-in. Thanks Simon!
+      #               See     http://www.redhillconsulting.com.au/rails_plugins.html#schema_validations 
+      #               for info about this plug-in
+      #               
+      # Additional features added to Schema_Validations:
+      # 1) proper error message generated for boolean inclusion failure (:inclusion)
+      # 
+      # 2) all validations are generated with allow_nil=>true because...
+      # 
+      # 3) all validations are superceded with the _new_ validates_nullability_of, 
+      #     which generates an error for any field whose associated column has a NOT NULL constraint upon it,
+      #     for whom no default value is specified, and for whom the value is not generated by the DB
+      #     
+      # 4) do not generate validates_uniqueness_of by default for unique fields. This is a performance hit, and
+      #     in my opinion completely defeats the purpose of an application-side data validation because it
+      #     requires a query of the DB. Why not just let the DB do the work and handle the duplicate key exception?
+      #     
+      # 5) Do not generate validates_presence_of for non-nullable fields. This will throw an exception for fields that
+      #     contain an empty string, even though that may in fact be a valid value according to the table constraints.
+      #     This approach also fails to consider that a default value might be specified for a non-nullable field in which case
+      #     we do not need to block the null field from being saved to the DB
+      #     
+      # 6) Perform validation auto-generation on all columns rather than just those returned by Base.content_columns
+      #     I believe there is value in validating our PK, FK, and counter columns
+      def generate_validations
+        unless @validations 
+            columns.each do |column|
+            
+            if !(column.null || column.default_specified? || column.generated?)
+              self.validates_nullability_of column.name
+              logger.info("GENERATED VALIDATION: #{self.name} validates_nullability_of #{column.name}")
+            end
+            
+            if column.type == :integer   
+              self.validates_numericality_of column.name, :allow_nil => true, :only_integer => true
+              logger.info("GENERATED VALIDATION: #{self.name} validates_numericality_of #{column.name}, :allow_nil=>true, :only_integer=>true")
+            elsif column.number?
+              self.validates_numericality_of column.name, :allow_nil => true
+              logger.info("GENERATED VALIDATION: #{self.name} validates_numericality_of #{column.name}, :allow_nil=>true")
+            elsif column.text? && column.limit
+              self.validates_length_of column.name, :allow_nil => true, :maximum => column.limit
+              logger.info("GENERATED VALIDATION: #{self.name} validates_length_of #{column.name}, :allow_nil=>true, :maximum=>#{column.limit}")
+            elsif column.type == :boolean
+              self.validates_inclusion_of column.name, :in => [true, false], :allow_nil =>true, :message => ActiveRecord::Errors.default_error_messages[:inclusion]
+              logger.info("GENERATED VALIDATION: #{self.name} validates_inclusion_of #{column.name}, :in=>[true, false], \
+                :allow_nil=>true, :message=>ActiveRecord::Errors.default_error_messages[:inclusion]")
+            end
+          end         
+        end
+        @validations=true
+      end
+      
+        
+    end    # end of class methods
+    
+  end   # end of class Base
+  
+end   # end of module ActiveRecord

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: drysql
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-10-30 00:00:00 -05:00
+summary: Extends ActiveRecord to provide automatic identification of keys, and automatic generation of associations and validations
+require_paths: 
+- lib
+email: bsevans@rubyforge.org
+homepage: http://drysql.rubyforge.org
+rubyforge_project: drysql
+description: DrySQL uses your DB's information schema to identify keys, and generate associations and validations for ActiveRecord objects. You defined the schema on your DB, don't re-define it in your application code. Legacy DB Tables/Column Names, Ruby Desktop apps, Rails apps...DrySQL's got all your (data)bases covered
+autorequire: drysql
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Bryan Evans
+files: 
+- lib/validations.rb
+- lib/dependencies.rb
+- lib/associations.rb
+- lib/drysql.rb
+- lib/base.rb
+- lib/helpers/string.rb
+- lib/connection_adapters/postgresql_adapter.rb
+- lib/connection_adapters/mysql_adapter.rb
+- lib/connection_adapters/abstract_adapter.rb
+- lib/connection_adapters/abstract/schema_definitions.rb
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.14.4
+    version: