schema_associations 1.0.1 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 757e462b9762015289cb5f2fe1bbbf6bb1c566a4
+  data.tar.gz: 344a36f0f484b1c929e84f38a4c2c1daa9dbacbf
+SHA512:
+  metadata.gz: 67b28e20707ccac8c97fb0713face550b9c44adbca8102de6149c2fe8caf5326c389a5d9030df1f6ad23e0b3d43c3e1faf9db8d98c47ccd3d1adea67f142d118
+  data.tar.gz: 5d19049e8483c2751f48bb39bf2f09989185a80bfa8dc1d6536e79be60d1ceaab26f3dd5b8f91812d31f1f3cc3b6759a7a98f2896fd91f51c0a2014bbc3b5148

data/.travis.yml

@@ -1,6 +1,7 @@
 rvm:
   - 1.9.2
   - 1.9.3
+  - 2.0.0
 gemfile:
   - gemfiles/Gemfile.rails-3.2
 notifications:

data/README.md

@@ -0,0 +1,385 @@
+# SchemaAssociations
+
+SchemaAssiciations is an ActiveRecord extension that keeps your model class
+definitions simpler and more DRY, by automatically defining associations based
+on the database schema.
+
+[![Gem Version](https://badge.fury.io/rb/schema_associations.png)](http://badge.fury.io/rb/schema_associations)
+[![Build Status](https://secure.travis-ci.org/lomba/schema_associations.png)](http://travis-ci.org/lomba/schema_associations)
+[![Dependency Status](https://gemnasium.com/lomba/schema_associations.png)](https://gemnasium.com/lomba/schema_associations)
+
+## Overview
+
+One of the great things about Rails (ActiveRecord, in particular) is that it
+inspects the database and automatically defines accessors for all your
+columns, keeping your model class definitions simple and DRY.  That's great
+for simple data columns, but where it falls down is when your table contains
+references to other tables: then the "accessors" you need are the associations
+defined using `belongs_to`, `has_one`, `has_many`, and
+`has_and_belongs_to_many` -- and you need to put them into your model class
+definitions by hand.  In fact, for every relation, you need to define two
+associations each listing its inverse, such as
+
+    class Post < ActiveRecord::Base
+        has_many :comments, :inverse_of => :post
+    end
+
+    class Comment < ActiveReocrd::Base
+        belongs_to :post, :inverse_of => :comments
+    end
+
+....which isn't so DRY.
+
+Enter the SchemaAssociations gem.  It extends ActiveRecord to automatically
+define the appropriate associations based on foreign key constraints in the
+database.  SchemaAssociations builds on the
+[schema_plus](http://rubygems.org/gems/schema_plus) gem that automatically
+defines foreign key constraints.  So the common case is simple -- if you have
+this in your migration:
+
+    create_table :posts do |t|
+    end
+
+    create_table :comments do |t|
+      t.integer post_id
+    end
+
+Then all you need for your models is:
+
+    class Post < ActiveRecord::Base
+    end
+
+    class Comment < ActiveRecord::Base
+    end
+
+and SchemaAssociations defines the appropriate associations under the hood.
+
+### What if I want something special?
+
+You're always free to define associations yourself, if for example you want to
+pass special options.  SchemaAssociations won't clobber any existing
+definitions.
+
+You can also control the behavior with various options, globally via
+SchemaAssociations::setup or per-model via
+SchemaAssociations::ActiveRecord#schema_associations, such as:
+
+    class Post < ActiveRecord::Base
+        schema_associations :concise_names => false
+    end
+
+See the[SchemaAssociations::Confg](http://rubydoc.info/gems/schema_associations/SchemaAssociations/Config) for the available options.
+
+### This seems cool, but I'm worried about too much automagic
+
+You can globally turn off automatic creation in
+`config/initializers/schema_associations.rb`:
+
+    SchemaAssociations.setup do |config|
+      config.auto_create = false
+    end
+
+Then in any model where you want automatic associations, just do
+
+    class Post < ActiveRecord::Base
+      schema_associations
+    end
+
+You can also pass options as per above.
+
+## Full Details
+
+### The basics
+
+The common cases work entirely as you'd expect.  For a one-to-many
+relationship using standard naming conventions:
+
+    # migration:
+
+    create_table :comments do |t|
+        t.integer post_id
+    end
+
+    # schema_associations defines:
+
+    class Post < ActiveRecord::Base
+        has_many :comments
+    end
+
+    class Comment < ActiveReocrd::Base
+        belongs_to :post
+    end
+
+For a one-to-one relationship:
+
+    # migration:
+
+    create_table :comments do |t|
+        t.integer post_id, :index => :unique    # (using the :index option provided by schema_plus )
+    end
+
+    # schema_associations defines:
+
+    class Post < ActiveRecord::Base
+        has_one :comment
+    end
+
+    class Comment < ActiveReocrd::Base
+        belongs_to :post
+    end
+
+And for many-to-many relationships:
+
+    # migration:
+
+    create_table :groups_members do |t|
+        integer :group_id
+        integer :member_id
+    end
+
+    # schema_associations defines:
+
+    class Group < ActiveReocrd::Base
+        has_and_belongs_to_many :members
+    end
+
+    class Member < ActiveRecord::Base
+        has_and_belongs_to_many :groups
+    end
+
+### Unusual names, multiple references
+
+Sometimes you want or need to deviate from the simple naming conventions.  In
+this case, the `belongs_to` relationship name is taken from the name of the
+foreign key column, and the `has_many` or `has_one` is named by the
+referencing table, suffixed with "as" the relationship name.  An example
+should make this clear...
+
+Suppose your company hires interns, and each intern is assigned a manager and
+a mentor, who are regular employees. 
+
+    create_table :interns do |t|
+        t.integer :manager_id,      :references => :employees
+        t.integer :mentor_id,       :references => :employees
+    end
+
+SchemaAssociations defines a `belongs_to` association for each reference,
+named according to the column:
+
+    class Intern < ActiveRecord::Base
+        belongs_to  :manager, :class_name => "Employee", :foreign_key => "manager_id"
+        belongs_to  :mentor,  :class_name => "Employee", :foreign_key => "mentor_id"
+    end
+
+And the corresponding `has_many` association each gets a suffix to indicate
+which one relation it refers to:
+
+    class Employee < ActiveRecord::Base
+        has_many :interns_as_manager, :class_name => "Intern", :foreign_key => "manager_id"
+        has_many :interns_as_mentor,  :class_name => "Intern", :foreign_key => "mentor_id"
+    end
+
+### Special case for trees
+
+If your forward relation is named "parent", SchemaAssociations names the
+reverse relation "child" or "children".  That is, if you have:
+
+    create_table :nodes
+       t.integer :parent_id         # schema_plus assumes it's a reference to this table
+    end
+
+Then SchemaAssociations will define
+
+    class Node < ActiveRecord::Base
+        belongs_to :parent, :class_name => "Node", :foreign_key => "parent_id"
+        has_many :children, :class_name => "Node", :foreign_key => "parent_id"
+    end
+
+### Concise names
+
+For modularity in your tables and classes, you might  use a common prefix for
+related objects.  For example, you may have widgets each of which has a color,
+and might have one base that has a top color and a bottom color, from the same
+set of colors.
+
+    create_table :widget_colors |t|
+    end
+
+    create_table :widgets do |t|
+        t.integer   :widget_color_id
+    end
+
+    create_table :widget_base
+        t.integer :widget_id, :index => :unique
+        t.integer :top_widget_color_id,    :references => :widget_colors
+        t.integer :bottom_widget_color_id, :references => :widget_colors
+    end
+
+Using the full name for the associations would make your code verbose and not
+quite DRY:
+
+    @widget.widget_color
+    @widget.widget_base.top_widget_color
+
+Instead, by default, SchemaAssociations uses concise names: shared leading
+words are removed from the association name.  So instead of the above, your
+code looks like:
+
+    @widget.color
+    @widget.base.top_color
+
+i.e. these associations would be defined:
+
+    class WidgetColor < ActiveRecord::Base
+        has_many :widgets,         :class_name => "Widget",     :foreign_key => "widget_color_id"
+        has_many :bases_as_top,    :class_name => "WidgetBase", :foreign_key => "top_widget_color_id"
+        has_many :bases_as_bottom, :class_name => "WidgetBase", :foreign_key => "bottom_widget_color_id"
+    end
+
+    class Widget < ActiveRecord::Base
+        belongs_to :color, :class_name => "WidgetColor", :foreign_key => "widget_color_id"
+        has_one    :base,  :class_name => "WidgetBase",  :foreign_key => "widget_base_id"
+    end
+
+    class WidgetBase < ActiveRecord::Base
+        belongs_to :top_color,    :class_name => "WidgetColor", :foreign_key => "top_widget_color_id"
+        belongs_to :bottom_color, :class_name => "WidgetColor", :foreign_key => "bottom_widget_color_id"
+        belongs_to :widget,       :class_name => "Widget",      :foreign_key => "widget_id"
+    end
+
+If you like the formality of using full names for the asociations, you can
+turn off concise names globally or per-model, see [SchemaAssociations::Config](http://rubydoc.info/gems/schema_associations/SchemaAssociations/Config)
+
+### Ordering `has_many` using `position`
+
+If the target of a `has_many` association has a column named `position`,
+SchemaAssociations will specify `:order => :position` for the association. 
+That is,
+
+    create_table :comments do |t|
+        t.integer post_id
+        t.integer position
+    end
+
+leads to
+
+    class Post < ActiveRecord::Base
+      has_many :comments, :order => :position
+    end
+    
+## Table names and model class names
+
+SchemaAssociations determins the mode class name from the table name using the same convention (and helpers) that ActiveRecord uses.  But sometimes you might be doing things differently.  For example, in an engine you might have a prefix that goes in front of all table names, and the models might all be in a namespace.  
+
+To that end, SchemaAssociations lets you configure mappings from a table name prefix to a model class name prefix to use instead.  For example, suppose your database had tables:
+      
+      hpy_campers
+      hpy_go_lucky
+
+The default model class names would be
+
+	  HpyCampers
+	  HpyGoLucky
+	 
+But if instead you wanted
+
+	  Happy::Campers
+	  Happy::GoLucky
+	  
+You could set up this mapping in `config/initializers/schema_associations.rb`:
+
+      SchemaPlus.setup do |config|
+          config.table_prefix_map["hpy_"] = "Happy::"
+      end
+
+Tables names that don't start with `hpy_` will continue to use the default determination.
+
+You can set up multiple mappings.  E.g. if you're using several engines they can each set up the mapping for their own moduels.  
+
+You can set up a mapping from or to the empty string, in order to unconditionally add or remove prefixes from all model class names.
+
+
+## How do I know what it did?
+
+If you're curious (or dubious) about what associations SchemaAssociations
+defines, you can check the log file.  For every assocation that
+SchemaAssociations defines, it generates an info entry such as
+
+    [schema_associations] Post.has_many :comments, :class_name "Comment", :foreign_key "comment_id"
+
+which shows the exact method definition call.
+
+
+SchemaAssociations defines the associations lazily, only creating them when
+they're first needed.  So you may need to search through the log file to find
+them all (and some may not be defined at all if they were never needed for the
+use cases that you logged).
+
+## Compatibility
+
+SchemaAssociations supports all combinations of:
+*   rails 3.2
+*   MRI ruby 1.9.2 or 1.9.3
+
+
+Note: As of version 1.0.0, ruby 1.8.7 and rails < 3.2 are no longer supported.
+ The last version to support them is 0.1.2
+
+## Installation
+
+Install from http://rubygems.org via
+
+    $ gem install "schema_associations"
+
+or in a Gemfile
+
+    gem "schema_associations"
+
+## Testing
+
+SchemaAssociations is tested using rspec, sqlite3, and rvm, with some hackery
+to test against multiple versions of rails and ruby.  To run the full combo of
+tests, after you've forked & cloned: 
+
+    $ cd schema_associations
+    $ ./runspecs --install  # do this once to install gem dependencies for all versions (slow)
+    $ ./runspecs # as many times as you like
+
+See `./runspecs --help` for more options.  In particular, to run rspec on a
+specific file or example (rather than running the full suite) you can do, e.g.
+
+    $ ./runspecs [other options] --rspec -- spec/association_spec.rb -e 'base'
+
+If you're running ruby 1.9, code coverage results will be in
+coverage/index.html -- it should be at 100% coverage.
+
+## Release notes:
+
+### 1.1.0
+
+* New feature: `config.table_prefix_map`
+
+### 1.0.1
+
+*   Bug fix: use singular :inverse_of for :belongs_to of a :has_one 
+
+
+### 1.0.0
+
+*   Use :inverse_of in generated associations
+
+*   Drop support for ruby 1.8.7 and rails < 3.2
+
+
+## History
+
+*   SchemaAssociations is derived from the "Red Hill On Rails" plugin
+    foreign_key_associations originally created by harukizaemon
+    (https://github.com/harukizaemon)
+
+*   SchemaAssociations was created in 2011 by Michal Lomnicki and Ronen Barzel
+
+
+## License
+
+This gem is released under the MIT license.

data/lib/schema_associations.rb

@@ -66,13 +66,20 @@ module SchemaAssociations
     # +:has_and_belongs_to_many+, or +nil+.  Default is +nil+.
     has_value :only_type, :default => nil
 
+    ##
+    # :attr_accessor: table_prefix_map
+    #
+    # Hash whose keys are possible matches at the start of table names, and
+    # whose corresponding values are the prefix to use in front of class
+    # names.
+    has_value :table_prefix_map, :default => {}
+
     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

data/lib/schema_associations/active_record/associations.rb

@@ -102,8 +102,8 @@ module SchemaAssociations
         references_name = fk.references_table_name.singularize
         referencing_name = referencing_table_name.singularize
 
-        referencing_class_name = referencing_name.classify
-        references_class_name = references_name.classify
+        referencing_class_name = _get_class_name(referencing_name)
+        references_class_name = _get_class_name(references_name)
 
         names = _determine_association_names(column_name.sub(/_id$/, ''), referencing_name, references_name)
 
@@ -221,6 +221,16 @@ module SchemaAssociations
         return true
       end
 
+      def _get_class_name(name) #:nodoc:
+        name = name.dup
+        found = schema_associations_config.table_prefix_map.find { |table_prefix, class_prefix|
+          name.sub! %r[\A#{table_prefix}], ''
+        }
+        name = name.classify
+        name = found.last + name if found
+        name
+      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

data/lib/schema_associations/version.rb

@@ -1,3 +1,3 @@
 module SchemaAssociations
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/runspecs

@@ -5,7 +5,7 @@ require 'ostruct'
 require 'shellwords'
 require 'tempfile'
 
-RUBY_VERSIONS = %W[1.9.2 1.9.3]
+RUBY_VERSIONS = %W[1.9.3 2.0.0]
 RAILS_VERSIONS = %W[3.2]
 
 o = OpenStruct.new

data/spec/association_spec.rb

@@ -321,6 +321,19 @@ describe ActiveRecord::Base do
     end
   end
 
+  it "maps table prefix" do
+    with_associations_config(:table_prefix_map => { "wooga_" => "Happy"} ) do
+      create_tables(
+        "wooga_posts", {}, {},
+        "wooga_comments", {}, { :wooga_post_id => { :references => :wooga_posts} }
+      )
+      class HappyPost < ActiveRecord::Base ; self.table_name = 'wooga_posts' ; end
+      class HappyComment < ActiveRecord::Base ; self.table_name = 'wooga_comments' ; end
+      Kernel.warn HappyPost.reflect_on_all_associations.inspect
+      HappyComment.reflect_on_association(:post).class_name.should == "HappyPost"
+      HappyPost.reflect_on_association(:comments).class_name.should == "HappyComment"
+    end
+  end
 
   context "with position" do
     before(:each) do

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_associations
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 1.1.0
 platform: ruby
 authors:
 - Ronen Barzel
@@ -10,118 +9,104 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-21 00:00:00.000000000 Z
+date: 2013-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: schema_plus
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov-gem-adapter
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: SchemaAssociations extends ActiveRecord to automatically create associations
@@ -139,7 +124,7 @@ files:
 - .gitignore
 - .travis.yml
 - MIT-LICENSE
-- README.rdoc
+- README.md
 - Rakefile
 - gemfiles/Gemfile.rails-3.2
 - gemfiles/Gemfile.rails-3.2.lock
@@ -155,27 +140,26 @@ files:
 - spec/spec_helper.rb
 homepage: https://github.com/lomba/schema_associations
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: schema_associations
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: ActiveRecord extension that automatically (DRY) creates associations based
   on the schema
 test_files:

data/README.rdoc

@@ -1,330 +0,0 @@
-= SchemaAssociations
-
-SchemaAssiciations is an ActiveRecord extension that keeps your model class
-definitions simpler and more DRY, by automatically defining associations
-based on the database schema.
-
-{<img src="https://secure.travis-ci.org/lomba/schema_associations.png"/>}[http://travis-ci.org/lomba/schema_associations]
-{<img src="https://gemnasium.com/lomba/schema_associations.png" alt="Dependency Status" />}[https://gemnasium.com/lomba/schema_associations]
-
-== Overview
-
-One of the great things about Rails (ActiveRecord, in particular) is that
-it inspects the database and automatically defines accessors for all your
-columns, keeping your model class definitions simple and DRY.  That's great
-for simple data columns, but where it falls down is when your table
-contains references to other tables: then the "accessors" you need are the
-associations defined using +belongs_to+, +has_one+, +has_many+, and
-+has_and_belongs_to_many+ -- and you need to put them into your model class
-definitions by hand.  In fact, for every relation, you need to define two
-associations each listing its inverse, such as
-
-    class Post < ActiveRecord::Base
-        has_many :comments, :inverse_of => :post
-    end
-
-    class Comment < ActiveReocrd::Base
-        belongs_to :post, :inverse_of => :comments
-    end
-
-....which isn't so DRY.
-
-Enter the SchemaAssociations gem.  It extends ActiveRecord to automatically
-define the appropriate associations based on foreign key constraints in the
-database.  SchemaAssociations builds on the
-{+schema_plus+}[http://rubygems.org/gems/schema_plus] gem that
-automatically defines foreign key constraints.  So the common case is simple -- if you have this in your migration:
-
-    create_table :posts do |t|
-    end
-
-    create_table :comments do |t|
-      t.integer post_id
-    end
-
-Then all you need for your models is:
-
-    class Post < ActiveRecord::Base
-    end
-
-    class Comment < ActiveRecord::Base
-    end
-
-and SchemaAssociations defines the appropriate associations under the hood.
-
-=== What if I want something special?
-
-You're always free to define associations yourself, if for example you want
-to pass special options.  SchemaAssociations won't clobber any existing
-definitions.
-
-You can also control the behavior with various options, globally via
-SchemaAssociations::setup or per-model via SchemaAssociations::ActiveRecord#schema_associations, such as:
-
-    class Post < ActiveRecord::Base
-        schema_associations :concise_names => false
-    end
-
-See SchemaAssociations::Config for the available options.
-
-=== This seems cool, but I'm worried about too much automagic
-
-You can globally turn off automatic creation in <tt>config/initializers/schema_associations.rb</tt>:
-
-  SchemaAssociations.setup do |config|
-    config.auto_create = false
-  end
-
-Then in any model where you want automatic associations, just do
-
-  class Post < ActiveRecord::Base
-    schema_associations
-  end
-
-You can also pass options as per above.
-
-== Full Details
-
-=== The basics
-
-The common cases work entirely as you'd expect.  For a one-to-many
-relationship using standard naming conventions:
-
-    # migration:
-    
-    create_table :comments do |t|
-        t.integer post_id
-    end
-
-    # schema_associations defines:
-
-    class Post < ActiveRecord::Base
-        has_many :comments
-    end
-
-    class Comment < ActiveReocrd::Base
-        belongs_to :post
-    end
-
-For a one-to-one relationship:
-
-    # migration:
-    
-    create_table :comments do |t|
-        t.integer post_id, :index => :unique    # (using the :index option provided by schema_plus )
-    end
-
-    # schema_associations defines:
-
-    class Post < ActiveRecord::Base
-        has_one :comment
-    end
-
-    class Comment < ActiveReocrd::Base
-        belongs_to :post
-    end
-
-And for many-to-many relationships:
-
-    # migration:
-    
-    create_table :groups_members do |t|
-        integer :group_id
-        integer :member_id
-    end
-
-    # schema_associations defines:
-
-    class Group < ActiveReocrd::Base
-        has_and_belongs_to_many :members
-    end
-
-    class Member < ActiveRecord::Base
-        has_and_belongs_to_many :groups
-    end
-
-=== Unusual names, multiple references
-
-Sometimes you want or need to deviate from the simple naming conventions.  In
-this case, the +belongs_to+ relationship name is taken from the name of the
-foreign key column, and the +has_many+ or +has_one+ is named by the referencing
-table, suffixed with "as" the relationship name.  An example should make this clear...
-
-Suppose your company hires interns, and each intern is assigned a manager and a
-mentor, who are regular employees. 
-
-        create_table :interns do |t|
-            t.integer :manager_id,      :references => :employees
-            t.integer :mentor_id,       :references => :employees
-        end
-
-SchemaAssociations defines a +belongs_to+ association for each reference, named according to
-the column:
-
-        class Intern < ActiveRecord::Base
-            belongs_to  :manager, :class_name => "Employee", :foreign_key => "manager_id"
-            belongs_to  :mentor,  :class_name => "Employee", :foreign_key => "mentor_id"
-        end
-
-And the corresponding +has_many+ association each gets a suffix to indicate which one relation it refers to:
-
-        class Employee < ActiveRecord::Base
-            has_many :interns_as_manager, :class_name => "Intern", :foreign_key => "manager_id"
-            has_many :interns_as_mentor,  :class_name => "Intern", :foreign_key => "mentor_id"
-        end
-
-=== Special case for trees
-
-If your forward relation is named "parent", SchemaAssociations names the reverse
-relation "child" or "children".  That is, if you have:
-
-        create_table :nodes
-           t.integer :parent_id         # schema_plus assumes it's a reference to this table
-        end
-
-Then SchemaAssociations will define
-
-        class Node < ActiveRecord::Base
-            belongs_to :parent, :class_name => "Node", :foreign_key => "parent_id"
-            has_many :children, :class_name => "Node", :foreign_key => "parent_id"
-        end
-
-=== Concise names
-
-For modularity in your tables and classes, you might  use a common prefix for
-related objects.  For example, you may have widgets each of which has a color,
-and might have one base that has a top color and a bottom color, from the same
-set of colors.
-
-        create_table :widget_colors |t|
-        end
-
-        create_table :widgets do |t|
-            t.integer   :widget_color_id
-        end
-
-        create_table :widget_base
-            t.integer :widget_id, :index => :unique
-            t.integer :top_widget_color_id,    :references => :widget_colors
-            t.integer :bottom_widget_color_id, :references => :widget_colors
-        end
-
-Using the full name for the associations would make your code verbose and not quite DRY:
-
-        @widget.widget_color
-        @widget.widget_base.top_widget_color
-
-Instead, by default, SchemaAssociations uses concise names: shared leading
-words are removed from the association name.  So instead of the above, your
-code looks like:
-
-        @widget.color
-        @widget.base.top_color
-
-i.e. these associations would be defined:
-
-        class WidgetColor < ActiveRecord::Base
-            has_many :widgets,         :class_name => "Widget",     :foreign_key => "widget_color_id"
-            has_many :bases_as_top,    :class_name => "WidgetBase", :foreign_key => "top_widget_color_id"
-            has_many :bases_as_bottom, :class_name => "WidgetBase", :foreign_key => "bottom_widget_color_id"
-        end
-
-        class Widget < ActiveRecord::Base
-            belongs_to :color, :class_name => "WidgetColor", :foreign_key => "widget_color_id"
-            has_one    :base,  :class_name => "WidgetBase",  :foreign_key => "widget_base_id"
-        end
-
-        class WidgetBase < ActiveRecord::Base
-            belongs_to :top_color,    :class_name => "WidgetColor", :foreign_key => "top_widget_color_id"
-            belongs_to :bottom_color, :class_name => "WidgetColor", :foreign_key => "bottom_widget_color_id"
-            belongs_to :widget,       :class_name => "Widget",      :foreign_key => "widget_id"
-        end
-
-If you like the formality of using full names for the asociations, you can turn off concise names globally or per-model, see SchemaAssociations::Config
-
-=== Ordering +has_many+ using +position+
-
-If the target of a +has_many+ association has a column named +position+, SchemaAssociation will specify <tt>:order => :position</tt> for the association.  That is,
-
-    create_table :comments do |t|
-        t.integer post_id
-        t.integer position
-    end
-
-leads to
-
-    class Post < ActiveRecord::Base
-      has_many :comments, :order => :position
-    end
-
-
-== How do I know what it did?
-
-If you're curious (or dubious) about what associations SchemaAssociations defines, you can check the log file.  For every assocation that SchemaAssociations defines, it generates an info entry such as
-
-        [schema_associations] Post.has_many :comments, :class_name "Comment", :foreign_key "comment_id"
-
-which shows the exact method definition call.  
-
-SchemaAssociations defines the associations lazily, only creating them when
-they're first needed.  So you may need to search through the log file to find
-them all (and some may not be defined at all if they were never needed for the
-use cases that you logged).
-
-== Compatibility
-
-SchemaAssociations supports all combinations of:
-* rails 3.2
-* MRI ruby 1.9.2 or 1.9.3
-
-Note: As of version 1.0.0, ruby 1.8.7 and rails < 3.2 are no longer supported.  The last version to support them is 0.1.2
-
-== Installation
-
-Install from http://rubygems.org via
-
-        $ gem install "schema_associations"
-
-or in a Gemfile
-
-        gem "schema_associations"
-
-== Testing
-
-SchemaAssociations is tested using rspec, sqlite3, and rvm, with some
-hackery to test against multiple versions of rails and ruby.  To run the
-full combo of tests, after you've forked & cloned: 
-
-  $ cd schema_associations
-  $ ./runspecs --install  # do this once to install gem dependencies for all versions (slow)
-  $ ./runspecs # as many times as you like
-
-See <tt>./runspecs --help</tt> for more options.  In particular, to run
-rspec on a specific file or example (rather than running the full suite)
-you can do, e.g.
-
-  $ ./runspecs [other options] --rspec -- spec/association_spec.rb -e 'base'
-
-If you're running ruby 1.9, code coverage results will be in coverage/index.html -- it should be at 100% coverage.
-
-== Release notes:
-
-=== 1.0.1
-
-* Bug fix: use singular :inverse_of for :belongs_to of a :has_one 
-
-=== 1.0.0
-
-* Use :inverse_of in generated associations
-
-* Drop support for ruby 1.8.7 and rails < 3.2
-
-== History
-
-* SchemaAssociations is derived from the "Red Hill On Rails" plugin foreign_key_associations originally created by harukizaemon (https://github.com/harukizaemon)
-
-* SchemaAssociations was created in 2011 by Michal Lomnicki and Ronen Barzel
-
-== License
-
-This gem is released under the MIT license.