schema_associations 1.2.4 → 1.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a6ca1bc960ff609537ddbc4ffcad10ba5cf813c
-  data.tar.gz: edc393be28b2f7e1613d6287614de0d0c30b7d5c
+  metadata.gz: dc1905f1df57594ba2e456f9453099827e62df17
+  data.tar.gz: f85030cb99925c5589c9499cbde3f21d177b01fc
 SHA512:
-  metadata.gz: 96669b7a7591180b7ae45fb71fd00ea245d00010d6a70622c8a4faf0d40e21de6142f1060089ba3221585ac09e9cd4e7c1d5e0bd622b000b1dfae11664287299
-  data.tar.gz: 9822ff73c231ead9a5a9ab932566406dfe52c99c68b556c7db6516165924016fa4beb5bea54cf7b77d910adf71a21604d2ea1c3c53e6e2dce78a21fc6d1b1d2a
+  metadata.gz: d747c0d7bb98aff9f230d91ec4c67d6f78d6b6d7ab75473d6486f5a8dfca9b839c949c8b3b34f41b7e0a0c42be2809cbf9f748ff47e6c7a9028262718284e15e
+  data.tar.gz: 8335b7d788b8fdc5f35fec400892ce3850c5227038d7a9ade9faa872c8fee03dcd71c3af340d097bd75d6fc9321fc282616accfec189ed31352fb41929922a8f

data/README.md

@@ -7,7 +7,6 @@ on the database schema.
 [![Gem Version](https://badge.fury.io/rb/schema_associations.svg)](http://badge.fury.io/rb/schema_associations)
 [![Build Status](https://secure.travis-ci.org/SchemaPlus/schema_associations.svg)](http://travis-ci.org/SchemaPlus/schema_associations)
 [![Coverage Status](https://img.shields.io/coveralls/SchemaPlus/schema_associations.svg)](https://coveralls.io/r/SchemaPlus/schema_associations?branch=master)
-[![Dependency Status](https://gemnasium.com/lomba/schema_associations.svg)](https://gemnasium.com/lomba/schema_associations)
 
 
 ## Overview
@@ -22,37 +21,42 @@ defined using `belongs_to`, `has_one`, `has_many`, and
 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
+```ruby
+class Post < ActiveRecord::Base
+    has_many :comments, inverse_of: :post
+end
 
-    class Comment < ActiveReocrd::Base
-        belongs_to :post, :inverse_of => :comments
-    end
+class Comment < ActiveRecord::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:
+Enter the SchemaAssociations gem.  It extends ActiveRecord to automatically define the appropriate associations based on foreign key constraints in the database.  
 
-    create_table :posts do |t|
-    end
+SchemaAssociations works particularly well with the
+[schema_auto_foreign_keys](http://github.com/SchemaPlus/schema_auto_foreign_keys) gem which automatically
+defines foreign key constraints.  So the common case is simple -- if you have this in your migration:
 
-    create_table :comments do |t|
-      t.integer post_id
-    end
+```ruby
+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
+```ruby
+class Post < ActiveRecord::Base
+end
 
-    class Comment < ActiveRecord::Base
-    end
+class Comment < ActiveRecord::Base
+end
+```
 
 and SchemaAssociations defines the appropriate associations under the hood.
 
@@ -60,34 +64,30 @@ and SchemaAssociations defines the appropriate associations under the hood.
 
 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
+definitions. 
 
-See the [SchemaAssociations::Confg RDOC](http://rubydoc.info/gems/schema_associations/SchemaAssociations/Config) for the available options.
+You can also control the behavior with various options, via a global initializer and/or per-model.  See the [Configuration section](#configuration) 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
+```ruby
+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
+```ruby
+class Post < ActiveRecord::Base
+    schema_associations
+end
+```
 
-You can also pass options as per above.
+You can also pass options as described in [Configurtion](#configuration)
 
 ## Full Details
 
@@ -96,58 +96,70 @@ You can also pass options as per above.
 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
+```ruby
+#
+# 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
+```ruby
+#
+# 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
+```ruby
+#
+# 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
 
@@ -160,139 +172,167 @@ 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
+```ruby
+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
+```ruby
+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
+```ruby
+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
+```ruby
+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
+```ruby
+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.
+related objects.  For example, you may have widgets each of which has a color, and each widget might have one frob that has a top color and a bottom color--all from the same set of colors.
 
-    create_table :widget_colors |t|
-    end
+```ruby
+create_table :widget_colors |t|
+end
 
-    create_table :widgets do |t|
-        t.integer   :widget_color_id
-    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
+create_table :widget_frobs
+    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
+```ruby
+@widget.widget_color
+@widget.widget_frob.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
+```ruby
+@widget.color
+@widget.frob.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
+```ruby
+class WidgetColor < ActiveRecord::Base
+    has_many :widgets,         class_name: "Widget",     foreign_key: "widget_color_id"
+    has_many :frobs_as_top,    class_name: "WidgetFrob", foreign_key: "top_widget_color_id"
+    has_many :frobs_as_bottom, class_name: "WidgetFrob", foreign_key: "bottom_widget_color_id"
+end
+
+class Widget < ActiveRecord::Base
+    belongs_to :color, class_name: "WidgetColor", foreign_key: "widget_color_id"
+    has_one    :frob,  class_name: "WidgetFrob",  foreign_key: "widget_frob_id"
+end
+
+class WidgetFrob < 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)
+turn off concise names globally or per-model, see [Configuration](#configuration).
 
 ### 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.
+SchemaAssociations will specify `order: :position` for the association.
 That is,
 
-    create_table :comments do |t|
-        t.integer post_id
-        t.integer position
-    end
+```ruby
+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
+```ruby
+class Post < ActiveRecord::Base
+    has_many :comments, order: :position
+end
+```
 
-## Table names and model class names
+## Table names, model class names, and modules
 
-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.
+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 namespaced in a module.
 
 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
+```ruby
+hpy_campers
+hpy_go_lucky
+```
 
 The default model class names would be
 
-	  HpyCampers
-	  HpyGoLucky
-	
+```ruby
+HpyCampers
+HpyGoLucky
+```
+
 But if instead you wanted
 
-	  Happy::Campers
-	  Happy::GoLucky
-	
-You could set up this mapping in `config/initializers/schema_associations.rb`:
+```ruby
+Happy::Campers
+Happy::GoLucky
+```
+    
+you would define the mapping in the [configuration](#configuration):
 
-      SchemaPlus.setup do |config|
-          config.table_prefix_map["hpy_"] = "Happy::"
-      end
+```ruby
+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.
 
@@ -317,6 +357,61 @@ 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).
 
+## Configuration
+
+You can configure options globally in an initializer such as `config/initializers/schema_associations.rb`, e.g.
+
+```ruby
+SchemaAssociations.setup do |config|
+  config.concise_names = false
+end
+```
+
+and/or override the options per-model, e.g.:
+
+```ruby
+class MyModel < ActiveRecord::Base
+  schema_associations.config concise_names: false
+end
+```
+
+Here's the full list of options, with their default values:
+
+```ruby
+SchemaAssociations.setup do |config|
+
+  # Enable/disable SchemaAssociations' automatic behavior
+  config.auto_create = true
+  
+  # Whether to use concise naming (strip out common prefixes from class names)
+  config.concise_names = true
+  
+  # List of association names to exclude from automatic creation.
+  # Value is a single name, an array of names, or nil.
+  config.except = nil
+  
+  # List of association names to include in automatic creation.
+  # Value is a single name, and array of names, or nil.
+  config.only = nil
+
+  # 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.
+  config.except_type = nil
+
+  # List of association types to include in automatic creation.
+  # Value is one or an array of :belongs_to, :has_many, :has_one, and/or
+  # :has_and_belongs_to_many, or nil.
+  config.only_type = nil
+
+  # 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.
+  config.table_prefix_map = {}
+end
+```
+
+
 ## Compatibility
 
 SchemaAssociations is tested on all combinations of:
@@ -358,6 +453,10 @@ Code coverage results will be in coverage/index.html -- it should be at 100% cov
 
 ## Release notes:
 
+### 1.2.5
+
+* Use schema_monkey rather than Railties.
+
 ### 1.2.4
 
 * Bug fix: Don't fail trying to do associations for abstract classes (mysql2 only).  [#11, #12] Thanks to [@dmeranda](https://github.com/dmeranda)

data/lib/schema_associations.rb

@@ -3,7 +3,6 @@ require 'valuable'
 
 require 'schema_associations/version'
 require 'schema_associations/active_record/associations'
-require 'schema_associations/railtie' if defined?(Rails)
 
 module SchemaAssociations
 
@@ -17,7 +16,7 @@ module SchemaAssociations
   # or override them per-model, e.g.:
   #
   #     class MyModel < ActiveRecord::Base
-  #        schema_associations.config :concise_names => false
+  #        schema_associations :concise_names => false
   #     end
   #
   class Config < Valuable
@@ -74,7 +73,7 @@ module SchemaAssociations
     # names.
     has_value :table_prefix_map, :default => {}
 
-    def dup #:nodoc:
+    def dup # :nodoc:
       self.class.new(Hash[attributes.collect{ |key, val| [key, Valuable === val ?  val.class.new(val.attributes) : val] }])
     end
 
@@ -108,12 +107,6 @@ module SchemaAssociations
     yield config
   end
 
-  def self.insert #:nodoc:
-    return if @inserted
-    @inserted = true
-    ::ActiveRecord::Base.extend SchemaAssociations::ActiveRecord::Associations
-  end
-
 end
 
-SchemaAssociations.insert unless defined? Rails::Railtie
+SchemaMonkey.register SchemaAssociations

data/lib/schema_associations/active_record/associations.rb

@@ -2,261 +2,254 @@ require 'ostruct'
 
 module SchemaAssociations
   module ActiveRecord
-    module Associations #:nodoc:
 
-      module Relation #:nodoc:
-        def self.included(base)
-          base.alias_method_chain :initialize, :schema_associations
-        end
-
-        def initialize_with_schema_associations(klass, *args)
-          klass.send :_load_schema_associations_associations unless klass.nil?
-          initialize_without_schema_associations(klass, *args)
-        end
-      end
+    module Relation
 
-      def self.extended(base) #:nodoc:
-        class << base
-          alias_method_chain :reflect_on_association, :schema_associations
-          alias_method_chain :_reflect_on_association, :schema_associations if method_defined? :_reflect_on_association
-          alias_method_chain :reflect_on_all_associations, :schema_associations
-        end
-        ::ActiveRecord::Relation.send :include, Relation if defined? ::ActiveRecord::Relation
+      def initialize(klass, *args)
+        klass.send :_load_schema_associations_associations unless klass.nil?
+        super
       end
+    end
 
-      def reflect_on_association_with_schema_associations(*args) #:nodoc:
-        _load_schema_associations_associations
-        reflect_on_association_without_schema_associations(*args)
-      end
+    module Base
 
-      # introduced in rails 4.1
-      def _reflect_on_association_with_schema_associations(*args) #:nodoc:
-        _load_schema_associations_associations
-        _reflect_on_association_without_schema_associations(*args)
-      end
+      module ClassMethods
 
-      def reflect_on_all_associations_with_schema_associations(*args) #:nodoc:
-        _load_schema_associations_associations
-        reflect_on_all_associations_without_schema_associations(*args)
-      end
+        def reflect_on_association(*args)
+          _load_schema_associations_associations
+          super
+        end
 
-      def define_attribute_methods(*args) #:nodoc:
-        super
-        _load_schema_associations_associations
-      end
+        # introduced in rails 4.1
+        def _reflect_on_association(*args)
+          _load_schema_associations_associations
+          super
+        end
 
-      # Per-model override of Config options.  Use via, e.g.
-      #     class MyModel < ActiveRecord::Base
-      #         schema_associations :auto_create => false
-      #     end
-      #
-      # If <tt>:auto_create</tt> is not specified, it is implicitly
-      # specified as true.  This allows the "non-invasive" style of using
-      # SchemaAssociations in which you set the global Config to
-      # <tt>auto_create = false</tt>, then in any model that you want auto
-      # associations you simply do:
-      #
-      #     class MyModel < ActiveRecord::Base
-      #         schema_associations
-      #     end
-      #
-      #  Of course other options can be passed, such as
-      #
-      #     class MyModel < ActiveRecord::Base
-      #         schema_associations :concise_names => false, :except_type => :has_and_belongs_to_many
-      #     end
-      #
-      #
-      def schema_associations(opts={})
-        @schema_associations_config = SchemaAssociations.config.merge({:auto_create => true}.merge(opts))
-      end
+        def reflect_on_all_associations(*args)
+          _load_schema_associations_associations
+          super
+        end
 
-      def schema_associations_config # :nodoc:
-        @schema_associations_config ||= SchemaAssociations.config.dup
-      end
+        def define_attribute_methods(*args)
+          super
+          _load_schema_associations_associations
+        end
 
-      private
+        # Per-model override of Config options.  Use via, e.g.
+        #     class MyModel < ActiveRecord::Base
+        #         schema_associations :auto_create => false
+        #     end
+        #
+        # If <tt>:auto_create</tt> is not specified, it is implicitly
+        # specified as true.  This allows the "non-invasive" style of using
+        # SchemaAssociations in which you set the global Config to
+        # <tt>auto_create = false</tt>, then in any model that you want auto
+        # associations you simply do:
+        #
+        #     class MyModel < ActiveRecord::Base
+        #         schema_associations
+        #     end
+        #
+        #  Of course other options can be passed, such as
+        #
+        #     class MyModel < ActiveRecord::Base
+        #         schema_associations :concise_names => false, :except_type => :has_and_belongs_to_many
+        #     end
+        #
+        #
+        def schema_associations(opts={})
+          @schema_associations_config = SchemaAssociations.config.merge({:auto_create => true}.merge(opts))
+        end
 
-      def _load_schema_associations_associations #:nodoc:
-        return if @schema_associations_associations_loaded
-        @schema_associations_associations_loaded = true
-        return if abstract_class?
-        return unless schema_associations_config.auto_create?
+        def schema_associations_config # :nodoc:
+          @schema_associations_config ||= SchemaAssociations.config.dup
+        end
 
-        reverse_foreign_keys.each do | foreign_key |
-          if foreign_key.from_table =~ /^#{table_name}_(.*)$/ || foreign_key.from_table =~ /^(.*)_#{table_name}$/
-            other_table = $1
-            if other_table == other_table.pluralize and connection.columns(foreign_key.from_table).any?{|col| col.name == "#{other_table.singularize}_id"}
-              _define_association(:has_and_belongs_to_many, foreign_key, other_table)
+        private
+
+        def _load_schema_associations_associations
+          return if @schema_associations_associations_loaded
+          @schema_associations_associations_loaded = true
+          return if abstract_class?
+          return unless schema_associations_config.auto_create?
+
+          reverse_foreign_keys.each do | foreign_key |
+            if foreign_key.from_table =~ /^#{table_name}_(.*)$/ || foreign_key.from_table =~ /^(.*)_#{table_name}$/
+              other_table = $1
+              if other_table == other_table.pluralize and connection.columns(foreign_key.from_table).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
-          else
-            _define_association(:has_one_or_many, foreign_key)
           end
-        end
 
-        foreign_keys.each do | foreign_key |
-          _define_association(:belongs_to, foreign_key)
+          foreign_keys.each do | foreign_key |
+            _define_association(:belongs_to, foreign_key)
+          end
         end
-      end
 
-      def _define_association(macro, fk, referencing_table_name = nil) #:nodoc:
-        column_names = Array.wrap(fk.column)
-        return unless column_names.size == 1
+        def _define_association(macro, fk, referencing_table_name = nil)
+          column_names = Array.wrap(fk.column)
+          return unless column_names.size == 1
 
-        referencing_table_name ||= fk.from_table
-        column_name = column_names.first
+          referencing_table_name ||= fk.from_table
+          column_name = column_names.first
 
-        references_name = fk.to_table.singularize
-        referencing_name = referencing_table_name.singularize
+          references_name = fk.to_table.singularize
+          referencing_name = referencing_table_name.singularize
 
-        referencing_class_name = _get_class_name(referencing_name)
-        references_class_name = _get_class_name(references_name)
+          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)
+          names = _determine_association_names(column_name.sub(/_id$/, ''), referencing_name, references_name)
 
-        argstr = ""
+          argstr = ""
 
 
-        case macro
-        when :has_and_belongs_to_many
-          name = names[:has_many]
-          opts = {:class_name => referencing_class_name, :join_table => fk.from_table, :foreign_key => column_name}
-        when :belongs_to
-          name = names[:belongs_to]
-          opts = {:class_name => references_class_name, :foreign_key => column_name}
-          if connection.indexes(referencing_table_name).any?{|index| index.unique && index.columns == [column_name]}
-            opts[:inverse_of] = names[:has_one]
-          else
-            opts[:inverse_of] = names[:has_many]
-          end
-
-        when :has_one_or_many
-          opts = {:class_name => referencing_class_name, :foreign_key => column_name, :inverse_of => names[:belongs_to]}
-          # 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).any?{|index| index.unique && index.columns == [column_name]}
-            macro = :has_one
-            name = names[:has_one]
-          else
-            macro = :has_many
+          case macro
+          when :has_and_belongs_to_many
             name = names[:has_many]
-            if connection.columns(referencing_table_name).any?{ |col| col.name == 'position' }
-              scope_block = lambda { order :position }
-              argstr += "-> { order :position }, "
+            opts = {:class_name => referencing_class_name, :join_table => fk.from_table, :foreign_key => column_name}
+          when :belongs_to
+            name = names[:belongs_to]
+            opts = {:class_name => references_class_name, :foreign_key => column_name}
+            if connection.indexes(referencing_table_name).any?{|index| index.unique && index.columns == [column_name]}
+              opts[:inverse_of] = names[:has_one]
+            else
+              opts[:inverse_of] = names[:has_many]
+            end
+
+          when :has_one_or_many
+            opts = {:class_name => referencing_class_name, :foreign_key => column_name, :inverse_of => names[:belongs_to]}
+            # 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).any?{|index| index.unique && index.columns == [column_name]}
+              macro = :has_one
+              name = names[:has_one]
+            else
+              macro = :has_many
+              name = names[:has_many]
+              if connection.columns(referencing_table_name).any?{ |col| col.name == 'position' }
+                scope_block = lambda { order :position }
+                argstr += "-> { order :position }, "
+              end
             end
           end
+          argstr += opts.inspect[1...-1]
+          if (_filter_association(macro, name) && !_method_exists?(name))
+            _create_association(macro, name, argstr, scope_block, opts.dup)
+          end
         end
-        argstr += opts.inspect[1...-1]
-        if (_filter_association(macro, name) && !_method_exists?(name))
-          _create_association(macro, name, argstr, scope_block, opts.dup)
-        end
-      end
 
-      def _create_association(macro, name, argstr, *args)
-        logger.debug "[schema_associations] #{self.name || self.from_table.classify}.#{macro} #{name.inspect}, #{argstr}"
-        send macro, name, *args
-        case
-        when respond_to?(:subclasses) then subclasses
-        end.each do |subclass|
-          subclass.send :_create_association, macro, name, argstr, *args
+        def _create_association(macro, name, argstr, *args)
+          logger.debug "[schema_associations] #{self.name || self.from_table.classify}.#{macro} #{name.inspect}, #{argstr}"
+          send macro, name, *args
+          case
+          when respond_to?(:subclasses) then subclasses
+          end.each do |subclass|
+            subclass.send :_create_association, macro, name, argstr, *args
+          end
         end
-      end
 
 
-      def _determine_association_names(reference_name, referencing_name, references_name)
+        def _determine_association_names(reference_name, referencing_name, references_name)
 
-        references_concise = _concise_name(references_name, referencing_name)
-        referencing_concise = _concise_name(referencing_name, references_name)
+          references_concise = _concise_name(references_name, referencing_name)
+          referencing_concise = _concise_name(referencing_name, references_name)
 
-        if _use_concise_name?
-          references = references_concise
-          referencing = referencing_concise
-        else
-          references = references_name
-          referencing = referencing_name
-        end
+          if _use_concise_name?
+            references = references_concise
+            referencing = referencing_concise
+          else
+            references = references_name
+            referencing = referencing_name
+          end
+
+          case reference_name
+          when 'parent'
+            belongs_to         = 'parent'
+            has_one            = 'child'
+            has_many           = 'children'
+
+          when references_name
+            belongs_to         = references
+            has_one            = referencing
+            has_many           = referencing.pluralize
+
+          when /(.*)_#{references_name}$/, /(.*)_#{references_concise}$/
+            label = $1
+            belongs_to         = "#{label}_#{references}"
+            has_one            = "#{referencing}_as_#{label}"
+            has_many           = "#{referencing.pluralize}_as_#{label}"
+
+          when /^#{references_name}_(.*)$/, /^#{references_concise}_(.*)$/
+            label = $1
+            belongs_to         = "#{references}_#{label}"
+            has_one            = "#{referencing}_as_#{label}"
+            has_many           = "#{referencing.pluralize}_as_#{label}"
+
+          else
+            belongs_to         = reference_name
+            has_one            = "#{referencing}_as_#{reference_name}"
+            has_many           = "#{referencing.pluralize}_as_#{reference_name}"
+          end
 
-        case reference_name
-        when 'parent'
-          belongs_to         = 'parent'
-          has_one            = 'child'
-          has_many           = 'children'
-
-        when references_name
-          belongs_to         = references
-          has_one            = referencing
-          has_many           = referencing.pluralize
-
-        when /(.*)_#{references_name}$/, /(.*)_#{references_concise}$/
-          label = $1
-          belongs_to         = "#{label}_#{references}"
-          has_one            = "#{referencing}_as_#{label}"
-          has_many           = "#{referencing.pluralize}_as_#{label}"
-
-        when /^#{references_name}_(.*)$/, /^#{references_concise}_(.*)$/
-          label = $1
-          belongs_to         = "#{references}_#{label}"
-          has_one            = "#{referencing}_as_#{label}"
-          has_many           = "#{referencing.pluralize}_as_#{label}"
-
-        else
-          belongs_to         = reference_name
-          has_one            = "#{referencing}_as_#{reference_name}"
-          has_many           = "#{referencing.pluralize}_as_#{reference_name}"
+          { :belongs_to => belongs_to.to_sym, :has_one => has_one.to_sym, :has_many => has_many.to_sym }
         end
 
-        { :belongs_to => belongs_to.to_sym, :has_one => has_one.to_sym, :has_many => has_many.to_sym }
-      end
+        def _concise_name(string, other)
+          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 _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
+        def _common_leader(string, other)
+          leader = nil
+          other.split('_').each do |part|
+            test = "#{leader}#{part}_"
+            break unless string.start_with? test
+            leader = test
+          end
+          return leader
         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
+        def _use_concise_name?
+          schema_associations_config.concise_names?
         end
-        return leader
-      end
 
-      def _use_concise_name? #:nodoc:
-        schema_associations_config.concise_names?
-      end
+        def _filter_association(macro, name)
+          config = schema_associations_config
+          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 _filter_association(macro, name) #:nodoc:
-        config = schema_associations_config
-        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 _get_class_name(name)
+          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 _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)
+          method_defined?(name) || private_method_defined?(name) and not (name == :type && [Object, Kernel].include?(instance_method(:type).owner))
+        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

data/lib/schema_associations/version.rb

@@ -1,3 +1,3 @@
 module SchemaAssociations
-  VERSION = "1.2.4"
+  VERSION = "1.2.5"
 end

data/spec/spec_helper.rb

@@ -11,7 +11,7 @@ require 'schema_associations'
 require 'logger'
 require 'schema_dev/rspec'
 
-SchemaDev::Rspec::setup_db
+SchemaDev::Rspec::setup
 
 Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_associations
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.2.5
 platform: ruby
 authors:
 - Ronen Barzel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-15 00:00:00.000000000 Z
+date: 2016-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: schema_plus_foreign_keys
@@ -135,7 +135,6 @@ files:
 - init.rb
 - lib/schema_associations.rb
 - lib/schema_associations/active_record/associations.rb
-- lib/schema_associations/railtie.rb
 - lib/schema_associations/version.rb
 - schema_associations.gemspec
 - schema_dev.yml

data/lib/schema_associations/railtie.rb

@@ -1,9 +0,0 @@
-module SchemaAssociations
-  class Railtie < Rails::Railtie #:nodoc:
-
-    initializer 'schema_associations.insert', :after => :load_config_initializers do
-      SchemaAssociations.insert
-    end
-
-  end
-end