has-many-with-set 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,142 @@
+h1. has-many-with-set
+
+h3. A smarter way of doing many-to-many relationships in Ruby On Rails.
+
+h2. Introduction
+
+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?
+
+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.
+
+The _join_ table model is a very redundant way of storing these relationships if the same combination happens more than once because you have to create the same amount rows in the join table each time you save this combination for each different _parent_.
+
+For example:
+
+bc.. Tag.new(:name => 'programming').save
+Tag.new(:name => 'open source').save
+Tag.new(:name => 'startups').save
+Tag.new(:name => 'ruby').save
+Tag.new(:name => 'development').save
+
+tags = Tag.all
+
+1000.times do
+  a = Article.new(:title => "Buzzword about buzzwords!",
+                  :body => "Lorem ipsum")
+
+  rand(tags.size + 1).times do
+    t = tags[rand(tags.size)]
+    a.tags << t
+  end
+
+  a.tags.uniq!
+  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.
+=> 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.
+
+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.
+
+This is what this gem fixes, it makes sure that when you create a combination of items it is unique and it gets used as many times as its needed when requested again, like a *set*.
+
+*_has-many-with-set_* is here to help.
+
+h2. Installation
+
+*Rails 3.x*
+
+To use it, add it to your Gemfile:
+
+@gem 'has-many-with-set'@
+
+That's pretty much it!
+
+h2. 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@
+
+And add the relationship to your parent model:
+
+bc.. 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).
+
+h2. Example
+
+Using our previous example:
+
+bc. rails g has_many_with_set:migration Article Tag
+      create  db/migrate/20121106063326_create_articles_tags_set.rb
+
+bc.. class Article < ActiveRecord::Base
+  attr_accessible :body, :title
+
+  has_many_with_set :tags   # <--- key part!
+end
+
+Tag.new(:name => 'programming').save
+Tag.new(:name => 'open source').save
+Tag.new(:name => 'startups').save
+Tag.new(:name => 'ruby').save
+Tag.new(:name => 'development').save
+
+tags = Tag.all
+
+1000.times do
+  a = Article.new(:title => "Buzzword about buzzwords!",
+                  :body => "Lorem ipsum")
+
+  rand(tags.size + 1).times do
+    t = tags[rand(tags.size)]
+    a.tags << t
+  end
+
+  a.tags.uniq!
+  a.save
+end
+
+ArticlesTagsSetsTag = Class.new(ActiveRecord::Base)
+ArticlesTagsSetsTag.count # this class doesn't exist by default,
+                          # I had to create it by hand for the example.
+=> 80
+
+Article.first.tags
+=> [#<Tag id: 1, name: "programming", ...>]
+
+Article.last.tags
+=> [#<Tag id: 1, name: "programming", ...>, #<Tag id: 5, name: "development", ...]
+
+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!!
+
+h2. Final remarks
+
+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.
+
+Please keep in mind that *_has-many-with-set_* is not without some caveats:
+
+* It can only be used when you do not need to put extra information in the relationships rows since they are shared among many parents.
+* It is only effective when there is a high natural redundancy in your data, that is, when many sets can be shared among many parents.
+* Although the retrieval queries are the same as with regular *_has_and_belongs_to_many_* and have no extra cost, it does have a tiny bit of extra cost when saving or updating since we have to find or create a suitable set before actually saving the parent record to the database. This cost is probably negligible as opposed to writing all the time, but I can't say it's free.
+
+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
+
+* Francisco Soto <ebobby@ebobby.org>
+
+Copyright © 2012 Francisco Soto (http://ebobby.org) released under the MIT license.

data/Rakefile

@@ -0,0 +1,19 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/lib/generators/has_many_with_set/migration_generator.rb

@@ -0,0 +1,32 @@
+require 'rails/generators'
+
+module HasManyWithSet
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+    source_root File.expand_path('../templates', __FILE__)
+
+    def self.next_migration_number(path)
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    end
+
+    ORM_IDENTIFIER_SIZE_LIMIT = 63
+
+    argument :parent, :type => :string, :required => true
+    argument :child, :type => :string, :required => true
+
+    attr_accessor :parent, :child
+
+    desc "This generates the migration file needed for a has_many_with_set relationship."
+    def create_migration
+      @parent_table = parent.tableize
+      @child_table = child.tableize
+      @set_table = "#{ @parent_table }_#{ @child_table }_sets"
+      @set_items_table = "#{ @set_table }_#{ @child_table }"
+      @migration_class_name = "create_#{ @set_table }".classify
+      @items_table_set_table_index = "ix_items_#{ @set_items_table }"[0,  ORM_IDENTIFIER_SIZE_LIMIT]
+      @items_table_child_table_index = "ix_#{ @child_table }_#{ @set_items_table }"[0,  ORM_IDENTIFIER_SIZE_LIMIT]
+
+      migration_template "sets.rb.erb", "db/migrate/#{ @migration_class_name.tableize.singularize }.rb"
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+class <%= @migration_class_name  %> < ActiveRecord::Migration
+  def change
+    create_table :<%= @set_table %> do |t|
+      t.timestamps
+    end
+
+    create_table :<%= @set_items_table %> do |t|
+      t.references :<%= @set_table.singularize %>, :null => false
+      t.references :<%= @child_table.singularize %>, :null => false
+    end
+
+    add_column :<%= @parent_table %>, :<%= @set_table.singularize %>_id, :integer
+
+    add_index :<%= @parent_table %>, :<%= @set_table.singularize %>_id
+    add_index :<%= @set_items_table %>, :<%= @set_table.singularize %>_id, :name => :<%= @items_table_set_table_index %>
+    add_index :<%= @set_items_table %>, :<%= @child_table.singularize %>_id, :name => :<%= @items_table_child_table_index %>
+  end
+end

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

@@ -0,0 +1,45 @@
+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
+
+      Proc.new {
+        values = []
+        values = send(set_table_name_singular).send(child_table_name).to_a unless send(set_table_id).nil?
+        values
+      }
+    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)
+          instance_variable_set(instance_var_name, values)
+        end
+
+        values
+      }
+    end
+
+    def self.build_setter_method (instance_var_name)
+      Proc.new { |elements|
+        elements = [] if elements.nil?
+
+        unless elements.is_a? Array
+          if elements.respond_to?(:is_a)
+            elements = elements.to_a
+          else
+            elements = [ elements ]
+          end
+        end
+
+        elements = elements.flatten.uniq
+
+        instance_variable_set(instance_var_name, elements)
+      }
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module HasManyWithSet
+  module Callbacks
+    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 }="
+
+      klass = Object.const_get(set_table_name.classify)
+
+      Proc.new {
+        set = nil
+        values = send(child_table_name)
+
+        if values.blank?
+          ActiveRecord::Base.transaction do
+            set = klass.find_by_sql(empty_set_query).first
+
+            if set.nil?
+              set = klass.new
+              set.save
+            end
+          end
+        else
+          values = values.flatten.uniq
+
+          values.each do |v| v.save if v.changed? end
+
+          ActiveRecord::Base.transaction do
+            set = klass.find_by_sql([ find_set_query,
+                                      values.map { |v| v.id },
+                                      values.size,
+                                      values.size ]).first
+            if set.nil?
+              set = klass.new
+              set.send(set_items_setter, values)
+              set.save
+            end
+
+            send(set_items_setter, values)
+          end
+        end
+
+        send(set_item_id_setter, set.id)
+      }
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module HasManyWithSet
+  # This is the magic entry point method that adds set relationships to a model.
+  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)
+    parent_table_name               = parent_model_name.tableize
+    child_table_name                = child_model_name.tableize
+    set_table_name                  = "#{ parent_table_name }_#{ child_table_name }_sets"
+    set_model_name                  = set_table_name.classify
+    set_items_table_name            = "#{ set_table_name }_#{ child_table_name }"
+    instance_var_name               = "@#{ child_table_name }"
+    setter_method_name              = "#{ child_table_name }="
+    loader_method_name              = "#{ set_items_table_name }_loader"
+    save_callback_method_name       = "#{ set_items_table_name }_save_callback"
+
+    Relationships.create_set_model(set_model_name)
+    Relationships.relate_child_to_set(set_model_name, child_model_name)
+    Relationships.relate_parent_to_set(set_model_name, parent_model_name)
+
+    define_method(loader_method_name,
+                  Accessors.build_loader_method(child_table_name, set_table_name))
+
+    define_method(child_table_name,
+                  Accessors.build_getter_method(instance_var_name, loader_method_name))
+
+    define_method(setter_method_name,
+                  Accessors.build_setter_method(instance_var_name))
+
+    define_method(save_callback_method_name,
+                  Callbacks.build_saver_callback(set_table_name, set_items_table_name,
+                                                 child_table_name, instance_var_name))
+
+    class_eval do
+      private loader_method_name
+      private save_callback_method_name
+
+      before_save save_callback_method_name
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module HasManyWithSet
+  module Queries
+    def self.build_find_empty_set_query(set_table_name, set_items_table_name)
+      "select #{ set_table_name }.id from #{ set_table_name }
+       where not exists (select null from #{ set_items_table_name }
+                         where #{ set_items_table_name }.#{ set_table_name.singularize }_id = #{ set_table_name }.id)"
+    end
+
+    def self.build_find_set_query(set_table_name, set_items_table_name, child_table_name)
+      "select #{ set_table_name }.id from #{ set_items_table_name }
+         join #{ set_table_name } on
+           #{ set_table_name }.id = #{ set_items_table_name }.#{ set_table_name.singularize }_id
+       where
+         #{set_items_table_name }.#{ child_table_name.singularize }_id IN (?)
+         and (select count(*) from #{ set_items_table_name } c
+              where c.#{ set_table_name.singularize }_id =
+                    #{ set_items_table_name }.#{ set_table_name.singularize }_id) = ?
+       group by #{ set_table_name }.id
+       having count(*) = ?"
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module HasManyWithSet
+  module Relationships
+    def self.create_set_model (set_model_name)
+      Object.const_set(set_model_name, Class.new(ActiveRecord::Base)) unless
+        Object.const_defined?(set_model_name) # this *should* never happen...
+    end
+
+    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
+      end
+
+      # ... and take the Set model and finish the many-to-many relationship.
+      Object.const_get(set_model_name).class_eval do
+        has_and_belongs_to_many child_model_name.tableize.to_sym
+      end
+    end
+
+    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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+module HasManyWithSet
+  VERSION = "1.0.0"
+end

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

@@ -0,0 +1,19 @@
+require "active_record"
+require "active_support"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require "has-many-with-set/has-many-with-set"
+require "has-many-with-set/relationships"
+require "has-many-with-set/queries"
+require "has-many-with-set/accessors"
+require "has-many-with-set/callbacks"
+
+module HasManyWithSet
+end
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.extend HasManyWithSet
+end
+
+$LOAD_PATH.shift

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

@@ -0,0 +1,119 @@
+require "test_helper"
+
+PARENT = "ModelOne"
+CHILD  = "ModelTwo"
+MIGRATION_PATH = "test/tmp/"
+MIGRATION_FILE = "db/migrate/create_model_ones_model_twos_set"
+
+class MigrationGeneratorTest < Rails::Generators::TestCase
+  tests HasManyWithSet::MigrationGenerator
+
+  destination MIGRATION_PATH
+  setup :prepare_destination
+
+  test "Generate migration" do
+    run_generator [ PARENT, CHILD ]
+
+    assert_migration MIGRATION_FILE
+  end
+end
+
+# 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)
+
+class HasManyWithSetTest < ActiveSupport::TestCase
+  test "parent class has the getter" do
+    assert_respond_to ModelOne.new, "model_twos"
+  end
+
+  test "parent class has the setter" do
+    assert_respond_to ModelOne.new, "model_twos="
+  end
+
+  test "getter type" do
+    assert_kind_of Array, ModelOne.new.model_twos
+  end
+
+  test "children can be saved" do
+    15.times do
+      assert ModelTwo.new.save
+    end
+
+    assert (ModelTwo.all.size == 15)
+  end
+
+  test "parent saved with empty set" do
+    assert ModelOne.new(:num => 0).save
+    assert ModelOne.last.model_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
+    assert record.save
+
+    record = ModelOne.find(record.id)
+    assert record.num == record.model_twos.size
+  end
+
+  test "parent saved with several children" do
+    ModelTwo.all.each do |m|
+      record = ModelOne.new(:num => 1)
+      record.model_twos << m
+      assert record.save
+
+      record = ModelOne.find(record.id)
+      assert record.num == record.model_twos.size
+    end
+  end
+
+  test "set reuse" do
+    items = ModelTwo.all
+
+    25.times do
+      master_record = ModelOne.new
+
+      rand(items.size + 1).times do
+        master_record.model_twos << items[rand(items.size)]
+      end
+
+      master_record.num = master_record.model_twos.size
+      master_record.save
+
+      master_items = master_record.model_twos
+
+      set_id = master_record.send("model_ones_model_twos_set_id")
+
+      100.times do
+        record = ModelOne.new(:num => master_items.size)
+        record.model_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 }")
+      end
+    end
+  end
+
+  test "do not save repeated items" do
+    items = ModelTwo.all
+    master_record = ModelOne.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.save
+
+    assert master_record.model_twos.size == items.size
+  end
+
+  test "items count match" do
+    ModelOne.all.each do |m|
+      assert m.num == m.model_twos.size
+    end
+  end
+end

data/test/support/models.rb

@@ -0,0 +1,7 @@
+class ModelTwo < ActiveRecord::Base
+end
+
+class ModelOne < ActiveRecord::Base
+  attr_accessible :num
+  has_many_with_set :model_two
+end

data/test/support/prepare_activerecord.rb

@@ -0,0 +1,39 @@
+class PrepareActiveRecord
+  class << self
+    def prepare_default_schema
+      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+
+      ActiveRecord::Schema.define do
+        self.verbose = false
+
+        create_table :model_ones do |t|
+          t.integer :num
+          t.timestamps
+        end
+
+        create_table :model_twos do |t|
+          t.timestamps
+        end
+      end
+    end
+
+    def run_migration(relative, root)
+      file = migration_file_name(relative, root)
+
+      require(file)
+
+      # I think this is horrendous but I don't want to hardcode the name of the class either.
+      loaded_klass = Module.constants.last
+
+      Object.const_get(loaded_klass).new.change
+    end
+
+    private
+
+    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
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+require "active_record"
+require "active_support"
+require "rails"
+require "rails/generators"
+require "rails/test_help"
+
+require File.expand_path("lib/has-many-with-set")
+require "generators/has_many_with_set/migration_generator"
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

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

@@ -0,0 +1,18 @@
+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

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: has-many-with-set
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Francisco Soto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+- !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'
+description: A smarter way of doing many-to-many relationships in Rails.
+email:
+- ebobby@ebobby.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/has_many_with_set/migration_generator.rb
+- lib/generators/has_many_with_set/templates/sets.rb.erb
+- lib/has-many-with-set/accessors.rb
+- lib/has-many-with-set/callbacks.rb
+- lib/has-many-with-set/has-many-with-set.rb
+- lib/has-many-with-set/queries.rb
+- lib/has-many-with-set/relationships.rb
+- lib/has-many-with-set/version.rb
+- lib/has-many-with-set.rb
+- MIT-LICENSE
+- Rakefile
+- README.textile
+- test/has-many-with-set_test.rb
+- test/support/models.rb
+- test/support/prepare_activerecord.rb
+- test/test_helper.rb
+- test/tmp/db/migrate/20121113022938_create_model_ones_model_twos_set.rb
+homepage: https://github.com/ebobby/has-many-with-set
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2377775004769566141
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2377775004769566141
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A smarter way of doing many-to-many relationships in Rails.
+test_files:
+- test/has-many-with-set_test.rb
+- test/support/models.rb
+- test/support/prepare_activerecord.rb
+- test/test_helper.rb
+- test/tmp/db/migrate/20121113022938_create_model_ones_model_twos_set.rb