has-many-with-set 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 93548e8a95e04b64e08bebcf6fba55282f3ea3d7
-  data.tar.gz: 374a51505970c3b07ecf2ac7801c7a5578f69428
+SHA256:
+  metadata.gz: a6605618e3038cc34da96f01c5a8acd806516ba9f41b901385a52a0e4ce14a6d
+  data.tar.gz: 827199a3b87007de3394f4bee41432820748c93019a7a0b660ff9980b338e35e
 SHA512:
-  metadata.gz: f444c8f81e462051803fdd0fc2e326b60f876237aa34e5ebf7620f95cc916fccabc8468b76ea134d93c318a77729b3eba7fae19f9c21307d61c2f50cd831ec63
-  data.tar.gz: b448cc6bb24875e48e1ddb039ec11e286b54b1fba0d178c28af900058f16ef38f607392c4e5a7af46837eef82c6b240cd658cec8406fccab72c369e18959b23b
+  metadata.gz: 2a4e622a55e2d219bb8011409aa3417ed045cb2d1e469ecd30fe55bccb57fcc59f012e736835f384184c749e9f68b88416dca21a3d960515ccb40d8d7ba59464
+  data.tar.gz: '0294441d7ecb4b6aed65c5d347bf42a94e11a87736e6f92ecfcb87ae3bf7dc46cbde2502411a52c383a152a3f33bf5cefb321b2359925ec2b082609cd7d4ae56'

data/{README.textile → README.md}

@@ -1,16 +1,16 @@
-h1. has-many-with-set
+# has-many-with-set
 
-h3. A smarter way of doing many-to-many relationships in Ruby On Rails.
+### A smarter way of doing many-to-many relationships in Ruby On Rails.
 
-h2. Introduction
+## Introduction
 
-*Update: Now works with Rails 4*
+*Update: Now works with Rails 5*
 
 Rails has two ways to model many-to-many relationships: *_has_and_belongs_to_many_* and *_has_many :through_*, this gem introduces a third one: *_has_many_with_set_*.
 
 *_has_many_with_set_* is equivalent to *_has_and_belongs_to_many_* in functionality. It works only when you do not want information about a relationship but the relationship itself, behind the curtains though, they do not work anything alike, *_has_many_with_set_* is far more efficient in terms of data size as it reduces the redundancy that occurs in a normal many-to-many relationship when the cardinality is low, that is, the same combination occurs many times. For example, in a blog application, when many posts share the same tags.
 
-h2. How so?
+## How so?
 
 The regular way of doing many-to-many relationships is using a join table to relate two tables, both ways of doing it in Ruby On Rails use this method, the only difference is the degree of control they give you on the "intermediary" table, one hides it from you (which is nice) and the other allows you to put more data in it besides the relationship, use validations, callbacks, etc.
 
@@ -18,7 +18,8 @@ The _join_ table model is a very redundant way of storing these relationships if
 
 For example:
 
-bc.. Tag.create(:name => 'programming')
+```
+Tag.create(:name => 'programming')
 Tag.create(:name => 'open source')
 Tag.create(:name => 'startups')
 Tag.create(:name => 'ruby')
@@ -35,12 +36,13 @@ tags = Tag.all
   a.save
 end
 
-ArticlesTags = Class.new(ActiveRecord::Base)
-ArticlesTags.count # this class doesn't exist by default,
-                   # I had to create it by hand for the example.
+ArticlesTagsSetsTag = Class.new(ApplicationRecord)
+ArticlesTagsSetsTag.count # this class doesn't exist by default,
+                          # I had to create it by hand for the example.
 => 1932
+```
 
-p. So we create five tags, and we create 1000 articles with a random combination of tags, not surprisingly, our join table has plenty of rows to represent all the relationships between our articles and their tags, if this were to behave linearly, if we had 1,000,000 articles we would have 1,932,000 rows just to represent the relationship.
+So we create five tags, and we create 1000 articles with a random combination of tags, not surprisingly, our join table has plenty of rows to represent all the relationships between our articles and their tags, if this were to behave linearly, if we had 1,000,000 articles we would have 1,932,000 rows just to represent the relationship.
 
 This example  (albeit a bit unrealistic) shows how redundant this is, even though we are using the same combination of tags over and over again we get more and more rows, if we are speaking about thousands it is not a big problem but when your databases grow to the hundreds of thousands or the millions, stuff like this starts to matter.
 
@@ -48,42 +50,45 @@ This is what this gem fixes, it makes sure that when you create a combination of
 
 *_has-many-with-set_* is here to help.
 
-h2. Installation
+## Installation
 
 *Rails 3.x*
 
 To use it, add it to your Gemfile:
 
-@gem 'has-many-with-set'@
+`gem 'has-many-with-set'`
 
 That's pretty much it!
 
-h2. Usage
+## Usage
 
 To to use *_has-many-with-set_* to relate two already existing models you have to create the underlying tables that are going to be used by it, this is very easily done by generating a migration for them:
 
-@rails generate has_many_with_set:migration PARENT CHILD@
+`rails generate has_many_with_set:migration PARENT CHILD`
 
 And add the relationship to your parent model:
 
-bc.. class Parent < ActiveRecord::Base
+```
+class Parent < ActiveRecord::Base
   has_many_with_set :children
 end
+```
 
-p. And that's it! You can start using it in your application. This can be done for as many models as you want, (you have to create migrations for all combinations!) you can even use multiple sets to relate different data to the same parent model (like Authors and Tags for your Articles).
+And that's it! You can start using it in your application. This can be done for as many models as you want, (you have to create migrations for all combinations!) you can even use multiple sets to relate different data to the same parent model (like Authors and Tags for your Articles).
 
-h2. Example
+## Example
 
 Using our previous example:
 
-bc. rails g model Article title:string body:text
+```
+rails g model Article title:string body:text`
 
-bc. rails g model Tag name:string
+rails g model Tag name:string
 
-bc. rails g has_many_with_set:migration Article Tag
+rails g has_many_with_set:migration Article Tag
       create  db/migrate/20121106063326_create_articles_tags_set.rb
 
-bc.. class Article < ActiveRecord::Base
+class Article < ApplicationRecord
   has_many_with_set :tags   # <--- key part!
 end
 
@@ -123,13 +128,13 @@ Tag.first.articles.size
 Tag.first.articles.first
 => #<Article id: 2, title: "Buzzword about buzzwords!", ..>
 
-p. Same example as before, just now using *_has_many_with_set_*. We get the impressive number of 80 rows to represent the same information that we had before with thousands of rows (roughly the same, since we use random combinations is not _exactly_ the same article/tag layout).
+```
 
-The funny thing in this particular example, is that since we have only five tags, there are only 32 possible ways to combine five tags together, these 32 combinations amount to 80 rows in our relationship table.... that is, even if we had a million articles we would still have the same 80 rows to represent our relationships, we don't need to create any more rows!!
+Same example as before, just now using *_has_many_with_set_*. We get the impressive number of 80 rows to represent the same information that we had before with thousands of rows (roughly the same, since we use random combinations is not _exactly_ the same article/tag layout).
 
-h2. Final remarks
+The funny thing in this particular example, is that since we have only five tags, there are only 32 possible ways to combine five tags together, these 32 combinations amount to 80 rows in our relationship table.... that is, even if we had a million articles we would still have the same 80 rows to represent our relationships, we don't need to create any more rows!!
 
-If you want to read a detailed post about how this works and what this gem does with some useful diagrams and sample queries, you can check out this blog post : "Using sets for many-to-many-relationships":http://ebobby.org/2012/11/11/Using-Sets-For-Many-To-Many-Relationships.html.
+## Final remarks
 
 Please keep in mind that *_has-many-with-set_* is not without some caveats:
 
@@ -139,7 +144,7 @@ Please keep in mind that *_has-many-with-set_* is not without some caveats:
 
 This is one humble attempt to help make Ruby On Rails a bit more useful with large data sets and applications, I hope you enjoy it and is useful to you, please email me with comments or suggestions (or even code!).
 
-h2. Author
+## Author
 
 * Francisco Soto <ebobby@ebobby.org>
 

data/lib/generators/has_many_with_set/templates/sets.rb.erb

@@ -1,4 +1,4 @@
-class <%= @migration_class_name  %> < ActiveRecord::Migration
+class <%= @migration_class_name  %> < ActiveRecord::Migration[5.0]
   def change
     create_table :<%= @set_table %> do |t|
       t.timestamps

data/lib/has-many-with-set/accessors.rb

@@ -1,31 +1,32 @@
 module HasManyWithSet
   module Accessors
-    def self.build_loader_method (child_table_name, set_table_name)
-      set_table_id = "#{ set_table_name.singularize }_id"
-      set_table_name_singular = set_table_name.singularize
+    def self.build_loader_method(child_table_name, set_table_name)
+      set_table_id = "#{ set_table_name.singularize }_id".to_sym
+      set_table_name_singular = set_table_name.singularize.to_sym
 
-      Proc.new {
+      Proc.new do
         values = []
-        values = send(set_table_name_singular).send(child_table_name).to_a unless send(set_table_id).nil?
+
+        values = send(set_table_name_singular).send(child_table_name).to_a unless
+          send(set_table_id).nil?
+
         values
-      }
+      end
     end
 
-    def self.build_getter_method (instance_var_name, loader_method_name)
-      Proc.new {
-        values = instance_variable_get(instance_var_name)
-
-        unless values
-          values = send(loader_method_name)
+    def self.build_getter_method(instance_var_name, loader_method_name)
+      Proc.new do
+        unless instance_variable_defined?(instance_var_name)
+          values = send(loader_method_name.to_sym)
           instance_variable_set(instance_var_name, values)
         end
 
-        values
-      }
+        instance_variable_get(instance_var_name)
+      end
     end
 
-    def self.build_setter_method (instance_var_name)
-      Proc.new { |elements|
+    def self.build_setter_method(instance_var_name)
+      Proc.new do |elements|
         elements = [] if elements.nil?
 
         unless elements.is_a? Array
@@ -39,10 +40,10 @@ module HasManyWithSet
         elements = elements.flatten.uniq
 
         instance_variable_set(instance_var_name, elements)
-      }
+      end
     end
 
-    def self.build_parent_loader_method (parent_table_name, child_table_name, set_table_name, set_items_table_name)
+    def self.build_parent_loader_method(parent_table_name, child_table_name, set_table_name, set_items_table_name)
       find_query = Queries.build_find_parents_query(parent_table_name, child_table_name, set_table_name, set_items_table_name)
 
       parent_klass = Object.const_get(parent_table_name.classify)

data/lib/has-many-with-set/callbacks.rb

@@ -1,16 +1,16 @@
 module HasManyWithSet
   module Callbacks
-    def self.build_saver_callback (set_table_name, set_items_table_name,
-                                   child_table_name, instance_var_name)
+    def self.build_saver_callback(set_table_name, set_items_table_name,
+                                  child_table_name, instance_var_name)
       empty_set_query = Queries.build_find_empty_set_query(set_table_name, set_items_table_name)
       find_set_query = Queries.build_find_set_query(set_table_name, set_items_table_name, child_table_name)
 
-      set_item_id_setter = "#{ set_table_name.singularize }_id="
-      set_items_setter   = "#{ child_table_name }="
+      set_item_id_setter = "#{ set_table_name.singularize }_id=".to_sym
+      set_items_setter   = "#{ child_table_name }=".to_sym
 
       klass = Object.const_get(set_table_name.classify)
 
-      Proc.new {
+      Proc.new do
         set = nil
         values = send(child_table_name)
 
@@ -44,7 +44,7 @@ module HasManyWithSet
         end
 
         send(set_item_id_setter, set.id)
-      }
+      end
     end
   end
 end

data/lib/has-many-with-set/has-many-with-set.rb

@@ -1,12 +1,12 @@
 module HasManyWithSet
   # This is the magic entry point method that adds set relationships to a model.
-  def has_many_with_set (child)
+  def has_many_with_set(child)
     build_set_relationship self.to_s, child.to_s.classify
   end
 
   private
 
-  def build_set_relationship (parent_model_name, child_model_name)
+  def build_set_relationship(parent_model_name, child_model_name)
     parent_table_name               = parent_model_name.tableize
     child_table_name                = child_model_name.tableize
     set_table_name                  = "#{ parent_table_name }_#{ child_table_name }_sets"
@@ -52,7 +52,7 @@ module HasManyWithSet
       private loader_method_name
       private save_callback_method_name
 
-      before_save save_callback_method_name
+      before_save save_callback_method_name.to_sym
     end
   end
 end

data/lib/has-many-with-set/queries.rb

@@ -19,7 +19,7 @@ module HasManyWithSet
        having count(*) = ?;"
     end
 
-    def self.build_find_parents_query (parent_table_name, child_table_name, set_table_name, set_items_table_name)
+    def self.build_find_parents_query(parent_table_name, child_table_name, set_table_name, set_items_table_name)
      "select #{ parent_table_name }.* from #{ child_table_name }
         join #{ set_items_table_name } on #{ child_table_name }.id = #{ set_items_table_name }.#{ child_table_name.singularize }_id
         join #{ parent_table_name } on #{ parent_table_name }.#{ set_table_name.singularize }_id =

data/lib/has-many-with-set/relationships.rb

@@ -1,11 +1,11 @@
 module HasManyWithSet
   module Relationships
-    def self.create_set_model (set_model_name)
-      Object.const_set(set_model_name, Class.new(ActiveRecord::Base)) unless
+    def self.create_set_model(set_model_name)
+      Object.const_set(set_model_name, Class.new(ApplicationRecord)) unless
         Object.const_defined?(set_model_name) # this *should* never happen...
     end
 
-    def self.relate_child_to_set (set_model_name, child_model_name)
+    def self.relate_child_to_set(set_model_name, child_model_name)
       # Take the child model and add a regular many-to-many relationship to the Set model...
       Object.const_get(child_model_name).class_eval do
         has_and_belongs_to_many set_model_name.tableize.to_sym, :join_table => "#{ set_model_name.tableize }_#{ child_model_name.tableize }"
@@ -17,10 +17,10 @@ module HasManyWithSet
       end
     end
 
-    def self.relate_parent_to_set (set_model_name, parent_model_name)
+    def self.relate_parent_to_set(set_model_name, parent_model_name)
       # The parent object has a FK to the Set table, so it belongs_to it.
       Object.const_get(parent_model_name).class_eval do
-        belongs_to set_model_name.tableize.singularize.to_sym
+        belongs_to set_model_name.tableize.singularize.to_sym, optional: true
       end
     end
   end

data/lib/has-many-with-set/version.rb

@@ -1,3 +1,3 @@
 module HasManyWithSet
-  VERSION = "1.3.0"
+  VERSION = "2.0.0"
 end

data/test/has-many-with-set_test.rb

@@ -1,9 +1,9 @@
 require "test_helper"
 
-PARENT = "ModelOne"
-CHILD  = "ModelTwo"
+PARENT = "One"
+CHILD  = "Two"
 MIGRATION_PATH = "test/tmp/"
-MIGRATION_FILE = "db/migrate/create_model_ones_model_twos_set"
+MIGRATION_FILE = "db/migrate/create_ones_twos_set"
 
 PrepareActiveRecord.prepare_default_schema
 
@@ -20,127 +20,120 @@ class MigrationGeneratorTest < Rails::Generators::TestCase
   end
 end
 
-PrepareActiveRecord.run_migration(MIGRATION_FILE, MIGRATION_PATH)
-
 class HasManyWithSetTest < ActiveSupport::TestCase
   def setup
-    unless @initialized
-      # Migration test has to run first, I do not like that but is the only way to actually
-      # test the whole thing.
-      PrepareActiveRecord.prepare_default_schema
-      PrepareActiveRecord.run_migration(MIGRATION_FILE, MIGRATION_PATH)
-      @initialized = true
-    end
+    PrepareActiveRecord.prepare_default_schema
+    PrepareActiveRecord.run_migration(PARENT, CHILD)
   end
 
   test "parent class has the getter" do
-    assert_respond_to ModelOne.new, "model_twos"
+    assert_respond_to One.new, "twos"
   end
 
   test "parent class has the setter" do
-    assert_respond_to ModelOne.new, "model_twos="
+    assert_respond_to One.new, "twos="
   end
 
   test "child class has the getter" do
-    assert_respond_to ModelTwo.new, "model_ones"
+    assert_respond_to Two.new, "ones"
   end
 
   test "getter type" do
-    assert_kind_of Array, ModelOne.new.model_twos
+    assert_kind_of Array, One.new.twos
   end
 
   test "children can be saved" do
     15.times do
-      assert ModelTwo.new.save
+      assert Two.new.save
     end
 
-    assert (ModelTwo.all.size == 15)
+    assert (Two.all.size == 15)
   end
 
   test "parent saved with empty set" do
-    assert ModelOne.new(:num => 0).save
-    assert ModelOne.last.model_twos.size == 0
+    assert One.new(:num => 0).save
+    assert One.last.twos.size == 0
   end
 
   test "parent saved with non-empty set" do
-    record = ModelOne.new
-    record.model_twos = ModelTwo.all
-    record.num = record.model_twos.size
+    record = One.new
+    record.twos = Two.all
+    record.num = record.twos.size
     assert record.save
 
-    record = ModelOne.find(record.id)
-    assert record.num == record.model_twos.size
+    record = One.find(record.id)
+    assert record.num == record.twos.size
   end
 
   test "parent saved with several children" do
-    ModelTwo.all.each do |m|
-      record = ModelOne.new(:num => 1)
-      record.model_twos << m
+    Two.all.each do |m|
+      record = One.new(:num => 1)
+      record.twos << m
       assert record.save
 
-      record = ModelOne.find(record.id)
-      assert record.num == record.model_twos.size
+      record = One.find(record.id)
+      assert record.num == record.twos.size
     end
   end
 
   test "set reuse" do
-    items = ModelTwo.all
+    items = Two.all
 
     25.times do
-      master_record = ModelOne.new
+      master_record = One.new
 
       rand(items.size + 1).times do
-        master_record.model_twos << items[rand(items.size)]
+        master_record.twos << items[rand(items.size)]
       end
 
-      master_record.num = master_record.model_twos.size
+      master_record.num = master_record.twos.size
       master_record.save
 
-      master_items = master_record.model_twos
+      master_items = master_record.twos
 
-      set_id = master_record.send("model_ones_model_twos_set_id")
+      set_id = master_record.send(:ones_twos_set_id)
 
       100.times do
-        record = ModelOne.new(:num => master_items.size)
-        record.model_twos = master_items
+        record = One.new(:num => master_items.size)
+        record.twos = master_items
         record.save
 
-        assert(record.send("model_ones_model_twos_set_id") == set_id,
-               "Set ids do not match #{ record.send('model_ones_model_twos_set_id') } == #{ set_id }")
+        assert(record.send(:ones_twos_set_id) == set_id,
+               "Set ids do not match #{ record.send(:ones_twos_set_id) } == #{ set_id }")
       end
     end
   end
 
   test "do not save repeated items" do
-    items = ModelTwo.all
-    master_record = ModelOne.new(:num => items.size)
+    items = Two.all
+    master_record = One.new(:num => items.size)
 
-    master_record.model_twos = ModelTwo.all
-    master_record.model_twos << items
-    master_record.model_twos << items
-    master_record.model_twos << items
+    master_record.twos = Two.all
+    master_record.twos << items
+    master_record.twos << items
+    master_record.twos << items
     master_record.save
 
-    assert master_record.model_twos.size == items.size
+    assert master_record.twos.size == items.size
   end
 
   test "children can see parents" do
-    item = ModelTwo.create
+    item = Two.create
 
     how_many = rand(50)
 
     how_many.times do
-      record = ModelOne.new(:num => 1)
-      record.model_twos << item
+      record = One.new(:num => 1)
+      record.twos << item
       record.save
     end
 
-    assert item.model_ones.size == how_many, "#{ item.model_ones.size } != #{ how_many }"
+    assert item.ones.size == how_many, "#{ item.ones.size } != #{ how_many }"
   end
 
   test "items count match" do
-    ModelOne.all.each do |m|
-      assert m.num == m.model_twos.size
+    One.all.each do |m|
+      assert m.num == m.twos.size
     end
   end
 end

data/test/support/models.rb

@@ -1,6 +1,10 @@
-class ModelTwo < ActiveRecord::Base
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
 end
 
-class ModelOne < ActiveRecord::Base
-  has_many_with_set :model_two
+class Two < ApplicationRecord
+end
+
+class One < ApplicationRecord
+  has_many_with_set :two
 end

data/test/support/prepare_activerecord.rb

@@ -6,29 +6,29 @@ class PrepareActiveRecord
       ActiveRecord::Schema.define do
         self.verbose = false
 
-        create_table :model_ones do |t|
+        create_table :ones do |t|
           t.integer :num
           t.timestamps
         end
 
-        create_table :model_twos do |t|
+        create_table :twos do |t|
           t.timestamps
         end
       end
     end
 
-    def run_migration(relative, root)
-      require(migration_file_name(relative, root))
+    def run_migration(parent, child)
+      generator = HasManyWithSet::MigrationGenerator.new([parent, child])
+      generator.destination_root = Dir.tmpdir
 
-      CreateModelOnesModelTwosSet.new.change
-    end
+      migration_path = generator.create_migration_file
+      migration_file = File.join(Dir.tmpdir, migration_path)
+
+      require(migration_file)
 
-    private
+      CreateOnesTwosSet.new.change
 
-    def migration_file_name(relative, root)
-      absolute = File.expand_path(relative, root)
-      dirname, file_name = File.dirname(absolute), File.basename(absolute).sub(/\.rb$/, '')
-      Dir.glob("#{dirname}/[0-9]*_*.rb").grep(/\d+_#{file_name}.rb$/).first
+      File.delete(migration_file)
     end
   end
 end

data/test/tmp/db/migrate/20180923002305_create_ones_twos_set.rb

@@ -0,0 +1,18 @@
+class CreateOnesTwosSet < ActiveRecord::Migration[5.0]
+  def change
+    create_table :ones_twos_sets do |t|
+      t.timestamps
+    end
+
+    create_table :ones_twos_sets_twos do |t|
+      t.references :ones_twos_set, :null => false
+      t.references :two, :null => false
+    end
+
+    add_column :ones, :ones_twos_set_id, :integer
+
+    add_index :ones, :ones_twos_set_id
+    add_index :ones_twos_sets_twos, :ones_twos_set_id, :name => :ix_items_ones_twos_sets_twos
+    add_index :ones_twos_sets_twos, :two_id, :name => :ix_twos_ones_twos_sets_twos
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: has-many-with-set
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Francisco Soto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-13 00:00:00.000000000 Z
+date: 2018-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -47,7 +47,7 @@ extra_rdoc_files: []
 files:
 - CHANGELOG
 - MIT-LICENSE
-- README.textile
+- README.md
 - Rakefile
 - lib/generators/has_many_with_set/migration_generator.rb
 - lib/generators/has_many_with_set/templates/sets.rb.erb
@@ -62,7 +62,7 @@ files:
 - test/support/models.rb
 - test/support/prepare_activerecord.rb
 - test/test_helper.rb
-- test/tmp/db/migrate/20141013205312_create_model_ones_model_twos_set.rb
+- test/tmp/db/migrate/20180923002305_create_ones_twos_set.rb
 homepage: https://github.com/ebobby/has-many-with-set
 licenses: []
 metadata: {}
@@ -82,13 +82,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A smarter way of doing many-to-many relationships in Rails.
 test_files:
+- test/tmp/db/migrate/20180923002305_create_ones_twos_set.rb
 - test/has-many-with-set_test.rb
-- test/support/models.rb
 - test/support/prepare_activerecord.rb
+- test/support/models.rb
 - test/test_helper.rb
-- test/tmp/db/migrate/20141013205312_create_model_ones_model_twos_set.rb

data/test/tmp/db/migrate/20141013205312_create_model_ones_model_twos_set.rb

@@ -1,18 +0,0 @@
-class CreateModelOnesModelTwosSet < ActiveRecord::Migration
-  def change
-    create_table :model_ones_model_twos_sets do |t|
-      t.timestamps
-    end
-
-    create_table :model_ones_model_twos_sets_model_twos do |t|
-      t.references :model_ones_model_twos_set, :null => false
-      t.references :model_two, :null => false
-    end
-
-    add_column :model_ones, :model_ones_model_twos_set_id, :integer
-
-    add_index :model_ones, :model_ones_model_twos_set_id
-    add_index :model_ones_model_twos_sets_model_twos, :model_ones_model_twos_set_id, :name => :ix_items_model_ones_model_twos_sets_model_twos
-    add_index :model_ones_model_twos_sets_model_twos, :model_two_id, :name => :ix_model_twos_model_ones_model_twos_sets_model_twos
-  end
-end