schema_plus 0.1.0.pre1

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+.*.sw?
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+.rvmrc
+*.log
+*.sqlite3
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2006 RedHill Consulting, Pty. Ltd.
+Copyright (c) 2009 Michal Lomnicki & Ronen Barzel 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+Except as contained in this notice, the name(s) of the above copyright
+holders shall not be used in advertising or otherwise to promote the sale,
+use or other dealings in this Software without prior written authorization.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,147 @@
+= SchemaPlus
+
+== Overview
+
+SchemaPlus is an ActiveRecord extension that provides enhanced capabilities for schema definition and querying, including: enhanced and more DRY index capabilities, support and automation for foreign key constraints, and support for views.
+
+For added rails DRYness see also the gems {+schema_associations+}[http://rubygems.org/gems/schema_associations] and {+schema_validations+}[http://rubygems.org/gems/schema_associations]  <b>IMPORTANT PRERELEASE NOTE: <i>Those are not yet separate gems, they are currently bundled in here.  They're not documented yet though.</i></b>
+
+== Compatibility
+
+SchemaPlus supports all combinations of:
+* rails 3.0 or 3.1
+* MRI ruby 1.8.7 or 1.9.2
+* Postgres, MySQL (using mysql or mysql2 gem), or Sqlite3
+
+== Installation
+
+Install from http://rubygems.org via
+
+        $ gem install "schema_plus"
+
+or in a Gemfile
+
+        gem "schema_plus"
+
+== Features
+
+Here some examples that show off the high points.  For full details see the RDoc documentation.
+
+=== Indexes
+
+With standard rails migrations, you specify indexes separately from the table definition:
+
+    # Standard Rails approach...
+    create_table :parts do |t|
+      t.string :name
+      t.string :product_code
+    end
+
+    add_index :parts, :name     # index repeats table and column names and is defined separately
+    add_index :parts, :product_code, :unique => true
+
+But with SchemaPlus rather than specify your outside your table definition you can specify your indexes when you define each column:
+
+    # More DRY way...
+    create_table :parts do |t|
+      t.string :name,           :index => true
+      t.string :product_code,   :index => :unique
+    end
+
+Options can be provided index using a hash, for example:
+
+    t.string :product_code,     :index => { :unique => true, :name => "my_index_name" }
+
+You can also create multi-column indexes, for example:
+
+    t.string :first_name
+    t.string :last_name,        :index => { :with => :first_name }
+
+    t.string :country_code
+    t.string :area_code
+    t.string :local_number      :index => { :width => [:country_code, :area_code], :unique => true }
+
+If you're using Postgresql, SchemaPlus provides support for conditions, expressions, index methods, and case-insensitive indexes; see doc at SchemaPlus::ActiveRecord::ConnectionAdapters::PostgresqlAdapter and SchemaPlus::ActiveRecord::ConnectionAdapters::IndexDefinition
+
+And when you query column information using ActiveRecord::Base#columns, SchemaPlus analogously provides index information relevant to each column: which indexes reference the column, whether the column must be unique, etc.  See doc at SchemaPlus::ActiveRecord::ConnectionAdapters::Column
+
+=== Foreign Key Constraints
+
+SchemaPlus adds support for foreign key constraints. In fact, for the
+common convention that you name a column with suffix +_id+ to indicate that
+it's a foreign key, SchemaPlus automatically defines the appropriate
+constraint.
+
+You can explicitly specify foreign key constraints, or override the
+automatic ones, using the +:references+ option to specify the table
+name (and optionally that table's key column name, if it's not +id+).
+
+Here are some examples:
+
+    t.integer :author_id                                 # automatically references table 'authors', key id
+    t.integer :parent_id                                 # special name parent_id automatically references its own table (for tree nodes)
+    t.integer :author, :references => :authors           # non-conventional column name needs :references for a constraint
+    t.integer :author_id, :refences => :authors          # same as automatic behavior
+    t.integer :author_id, :refences => [:authors, :id]   # same as automatic behavior
+    t.integer :author_id, :references => :people         # override table name
+    t.integer :author_id, :references => [:people, :ssn] # override table name and key
+    t.integer :author_id, :referencs => nil              # don't create a constraint
+
+
+You can also modify the behavior using +:on_delete+, +:on_update+, and +:deferrable+
+
+    t.integer :author_id, :on_delete => :cascade
+
+The foreign key behavior can be configured globally (see Config) or per-table (see create_table).
+
+To examine your foreign key constraints, connection.foreign_keys returns a
+list of foreign key constraints defined for a given table, and
+connection.reverse_foreign_keys returns a list of foreign key constraints
+that reference a given table.  See SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.
+
+=== Views
+
+SchemaPlus provides support for creating and dropping views.  For example:
+
+  create_view :uncommented_posts, "SELECT * FROM posts LEFT OUTER JOIN comments ON comments.post_id = posts.id WHERE comments.id IS NULL"
+  drop_view :uncommented_posts
+
+ActiveRecord works with views the same as with ordinary tables.  That is, for the above view you can define
+
+  class UncommentedPosts < ActiveRecord::Base
+  end
+
+
+== History
+
+* SchemaPlus is derived from several "Red Hill On Rails" plugins
+  originally created by harukizaemon (https://github.com/harukizaemon)
+  with later contributions from 
+  * Michał Łomnicki (https://github.com/mlomnicki)
+  * François Beausoleil (https://github.com/francois)
+  * Greg Barnett (https://github.com/greg-barnett)
+  * Ronen Barzel (https://github.com/ronen)
+
+* SchemaPlus was created in 2011 by Michal Lomnicki and Ronen Barzel
+
+
+
+== Testing
+
+SchemaPlus is tested using rspec.  To run the tests, after you've forked & cloned: Make sure you have Postgresql and MySQL running.  Create database user "schema_plus" with permissions for database "schema_plus_unittest".  Then:
+
+  $ cd schema_plus
+  $ bundle install
+  $ rake postgresql:build_databases
+  $ rake mysql:build_databases
+  $ rake postgresql:spec # to run postgresql tests only
+  $ rake mysql:spec # to run mysql tests only
+  $ rake mysql2:spec # to run mysql2 tests only
+  $ rake sqlite3:spec # to run sqlite3 tests only
+  $ rake spec # run all tests
+
+If you're running ruby 1.9.2, code coverage results will be in coverage/index.html -- it should be at 100% coverage.
+
+== License
+
+This plugin is released under the MIT license.

data/Rakefile

@@ -0,0 +1,70 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+%w[postgresql mysql mysql2 sqlite3].each do |adapter|
+  namespace adapter do
+    RSpec::Core::RakeTask.new(:spec) do |spec|
+      spec.rspec_opts = "-Ispec/connections/#{adapter}"
+      spec.fail_on_error = false
+    end
+  end
+end
+
+desc 'Run postgresql, mysql2 and sqlite3 tests'
+task :spec do 
+  %w[postgresql mysql mysql2 sqlite3].each do |adapter|
+    Rake::Task["#{adapter}:spec"].invoke
+  end
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "schema_plus #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+namespace :postgresql do
+  desc 'Build the PostgreSQL test databases'
+  task :build_databases do
+    %x( createdb -E UTF8 schema_plus_unittest )
+  end
+
+  desc 'Drop the PostgreSQL test databases'
+  task :drop_databases do
+    %x( dropdb schema_plus_unittest )
+  end
+
+  desc 'Rebuild the PostgreSQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
+end
+
+task :build_postgresql_databases => 'postgresql:build_databases'
+task :drop_postgresql_databases => 'postgresql:drop_databases'
+task :rebuild_postgresql_databases => 'postgresql:rebuild_databases'
+
+MYSQL_DB_USER = 'schema_plus'
+namespace :mysql do
+  desc 'Build the MySQL test databases'
+  task :build_databases do
+    %x( echo "create DATABASE schema_plus_unittest DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci " | mysql --user=#{MYSQL_DB_USER})
+  end
+
+  desc 'Drop the MySQL test databases' 
+  task :drop_databases do
+    %x( mysqladmin --user=#{MYSQL_DB_USER} -f drop schema_plus_unittest )
+  end
+
+  desc 'Rebuild the MySQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
+end
+
+task :build_mysql_databases => 'mysql:build_databases'
+task :drop_mysql_databases => 'mysql:drop_databases'
+task :rebuild_mysql_databases => 'mysql:rebuild_databases'

data/init.rb

@@ -0,0 +1 @@
+require 'schema_plus' unless defined?(SchemaPlus)

data/lib/schema_plus/active_record/associations.rb

@@ -0,0 +1,211 @@
+require 'ostruct'
+
+module SchemaPlus
+  module ActiveRecord
+    module Associations
+
+      module Relation #:nodoc:
+        def self.included(base)
+          base.alias_method_chain :initialize, :schema_plus
+        end
+
+        def initialize_with_schema_plus(klass, *args)
+          klass.send :_load_schema_plus_associations
+          initialize_without_schema_plus(klass, *args)
+        end
+      end
+
+      def self.extended(base) #:nodoc:
+        class << base
+          alias_method_chain :reflect_on_association, :schema_plus
+          alias_method_chain :reflect_on_all_associations, :schema_plus
+        end
+        ::ActiveRecord::Relation.send :include, Relation
+      end
+
+      def reflect_on_association_with_schema_plus(*args) #:nodoc:
+        _load_schema_plus_associations
+        reflect_on_association_without_schema_plus(*args)
+      end
+
+      def reflect_on_all_associations_with_schema_plus(*args) #:nodoc:
+        _load_schema_plus_associations
+        reflect_on_all_associations_without_schema_plus(*args)
+      end
+
+      def define_attribute_methods(*args) #:nodoc:
+        super
+        _load_schema_plus_associations
+      end
+
+      private
+
+      def _load_schema_plus_associations #:nodoc:
+        return if @schema_plus_associations_loaded
+        @schema_plus_associations_loaded = true
+        return unless schema_plus_config.associations.auto_create?
+
+        reverse_foreign_keys.each do | foreign_key |
+          if foreign_key.table_name =~ /^#{table_name}_(.*)$/ || foreign_key.table_name =~ /^(.*)_#{table_name}$/
+            other_table = $1
+            if other_table == other_table.pluralize and connection.columns(foreign_key.table_name).any?{|col| col.name == "#{other_table.singularize}_id"}
+              _define_association(:has_and_belongs_to_many, foreign_key, other_table)
+            else
+              _define_association(:has_one_or_many, foreign_key)
+            end
+          else
+            _define_association(:has_one_or_many, foreign_key)
+          end
+        end
+
+        foreign_keys.each do | foreign_key |
+          _define_association(:belongs_to, foreign_key)
+        end
+      end
+
+      def _define_association(macro, fk, referencing_table_name = nil) #:nodoc:
+        return unless fk.column_names.size == 1
+
+        referencing_table_name ||= fk.table_name
+
+        column_name = fk.column_names.first
+        reference_name = column_name.sub(/_id$/, '')
+        references_name = fk.references_table_name.singularize
+        referencing_name = referencing_table_name.singularize
+
+        references_class_name = references_name.classify
+        referencing_class_name = referencing_name.classify
+
+        references_concise = _concise_name(references_name, referencing_name)
+        referencing_concise = _concise_name(referencing_name, references_name)
+
+        case reference_name
+        when 'parent'
+          belongs_to         = 'parent'
+          belongs_to_concise = 'parent'
+
+          has_one            = 'child'
+          has_one_concise    = 'child'
+
+          has_many           = 'children'
+          has_many_concise   = 'children'
+
+        when references_name
+          belongs_to         = references_name
+          belongs_to_concise = references_concise
+
+          has_one            = referencing_name
+          has_one_concise    = referencing_concise
+
+          has_many           = referencing_name.pluralize
+          has_many_concise   = referencing_concise.pluralize
+
+        when /(.*)_#{references_name}$/, /(.*)_#{references_concise}$/
+          label = $1
+          belongs_to         = "#{label}_#{references_name}"
+          belongs_to_concise = "#{label}_#{references_concise}"
+
+          has_one            = "#{referencing_name}_as_#{label}"
+          has_one_concise    = "#{referencing_concise}_as_#{label}"
+
+          has_many           = "#{referencing_name.pluralize}_as_#{label}"
+          has_many_concise   = "#{referencing_concise.pluralize}_as_#{label}"
+
+        when /^#{references_name}_(.*)$/, /^#{references_concise}_(.*)$/
+          label = $1
+          belongs_to            = "#{references_name}_#{label}"
+          belongs_to_concise    = "#{references_concise}_#{label}"
+
+          has_one               = "#{referencing_name}_as_#{label}"
+          has_one_concise       = "#{referencing_concise}_as_#{label}"
+
+          has_many              = "#{referencing_name.pluralize}_as_#{label}"
+          has_many_concise      = "#{referencing_concise.pluralize}_as_#{label}"
+
+        else
+          belongs_to            = reference_name
+          belongs_to_concise    = reference_name
+
+          has_one               = "#{referencing_name}_as_#{reference_name}"
+          has_one_concise       = "#{referencing_concise}_as_#{reference_name}"
+
+          has_many              = "#{referencing_name.pluralize}_as_#{reference_name}"
+          has_many_concise      = "#{referencing_concise.pluralize}_as_#{reference_name}"
+        end
+
+        case macro
+        when :has_and_belongs_to_many
+          name = has_many
+          name_concise = has_many_concise
+          opts = {:class_name => referencing_class_name, :join_table => fk.table_name, :foreign_key => column_name}
+        when :belongs_to
+          name = belongs_to
+          name_concise = belongs_to_concise
+          opts = {:class_name => references_class_name, :foreign_key => column_name}
+        when :has_one_or_many
+          opts = {:class_name => referencing_class_name, :foreign_key => column_name}
+          # use connection.indexes and connection.colums rather than class
+          # methods of the referencing class because using the class
+          # methods would require getting the class -- which might trigger
+          # an autoload which could start some recursion making things much
+          # harder to debug.
+          if connection.indexes(referencing_table_name, "#{referencing_table_name} Indexes").any?{|index| index.unique && index.columns == [column_name]}
+            macro = :has_one
+            name = has_one
+            name_concise = has_one_concise
+          else
+            macro = :has_many
+            name = has_many
+            name_concise = has_many_concise
+            if connection.columns(referencing_table_name, "#{referencing_table_name} Columns").any?{ |col| col.name == 'position' }
+              opts[:order] = :position
+            end
+          end
+        end
+        name = name_concise if _use_concise_name?
+        name = name.to_sym
+        if (_filter_association(macro, name) && !_method_exists?(name))
+          logger.info "SchemaPlus associations: #{self.name || self.table_name.classify}.#{macro} #{name.inspect}, #{opts.inspect[1...-1]}"
+          send macro, name, opts.dup
+        end
+      end
+
+      def _concise_name(string, other) #:nodoc:
+        case
+        when string =~ /^#{other}_(.*)$/           then $1
+        when string =~ /(.*)_#{other}$/            then $1
+        when leader = _common_leader(string,other) then string[leader.length, string.length-leader.length]
+        else                                            string
+        end
+      end
+
+      def _common_leader(string, other) #:nodoc:
+        leader = nil
+        other.split('_').each do |part|
+          test = "#{leader}#{part}_"
+          break unless string.start_with? test
+          leader = test
+        end
+        return leader
+      end
+
+      def _use_concise_name? #:nodoc:
+        schema_plus_config.associations.concise_names?
+      end
+
+      def _filter_association(macro, name) #:nodoc:
+        config = schema_plus_config.associations
+        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).include?(macro)
+        return false if config.except_type and     Array.wrap(config.except_type).include?(macro)
+        return true
+      end
+
+      def _method_exists?(name) #:nodoc:
+        method_defined?(name) || private_method_defined?(name) and not (name == :type && [Object, Kernel].include?(instance_method(:type).owner))
+      end
+
+    end
+  end
+end