acts_as_muschable 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+spec/*.log
+.DS_Store
+pkg

data/Rakefile

@@ -0,0 +1,22 @@
+require 'spec/rake/spectask'
+
+desc 'Default: run specs'
+task :default => :spec
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList["spec/**/*_spec.rb"]
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "acts_as_muschable"
+    gemspec.summary = "Easy peasy model sharding"
+    gemspec.description = "Do not use me unless you are not you but somebody else."
+    gemspec.email = "jannis@moviepilot.de"
+    gemspec.homepage = "http://github.com/moviepilot/acts_as_muschable"
+    gemspec.authors = ["Moviepilot"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/acts_as_muschable.gemspec

@@ -0,0 +1,50 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{acts_as_muschable}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Moviepilot"]
+  s.date = %q{2010-03-04}
+  s.description = %q{Do not use me unless you are not you but somebody else.}
+  s.email = %q{jannis@moviepilot.de}
+  s.files = [
+    ".gitignore",
+     "Rakefile",
+     "VERSION",
+     "acts_as_muschable.gemspec",
+     "init.rb",
+     "lib/acts_as_muschable.rb",
+     "rails/init.rb",
+     "spec/acts_as_muschable/acts_as_muschable_spec.rb",
+     "spec/acts_as_muschable/integration_spec.rb",
+     "spec/schema.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/moviepilot/acts_as_muschable}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Easy peasy model sharding}
+  s.test_files = [
+    "spec/acts_as_muschable/acts_as_muschable_spec.rb",
+     "spec/acts_as_muschable/integration_spec.rb",
+     "spec/schema.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init"

data/lib/acts_as_muschable.rb

@@ -0,0 +1,178 @@
+#
+#  acts_as_muschable adds support for sharding data over multiple tables by
+#  messing with the #table_name method. If you want to shard your data over 
+#  multiple databases, use the DataFabric gem, which does the sharding at
+#  connection level.
+#
+module ActiveRecord
+  
+  # originally table_name and quoted_table_name are cached both in the model 
+  # and in the reflection object. disabling the cache in the reflection object
+  # doesn't mean the table name is recalculated on every access, it only gets
+  # delegated to (the cached) ReflectedModel.table_name every time, meaning
+  # one more method call.
+  module Reflection
+    class AssociationReflection
+      def table_name
+        klass.table_name
+      end
+  
+      def quoted_table_name
+        klass.quoted_table_name
+      end
+    end
+  end
+  
+  module Acts
+    module Muschable
+      def self.included(base)
+        raise StandardError, "acts_as_muschable is only tested against ActiveRecord -v=2.3.5" if defined?(::Rails) and ::Rails.version>'2.3.5'
+        base.extend(ActsAsMuschableLoader)
+      end
+
+      module ActsAsMuschableLoader
+        def acts_as_muschable(*args)
+          raise RuntimeError, "You called acts_as_muschable twice" unless @class_musched.nil?
+          @class_musched = true
+          extend ClassMethods
+          class_eval do
+            class << self; alias_method_chain :table_name, :shard; end
+            self.shard_amount = args.last[:shard_amount] || 0
+          end
+        end
+        private :acts_as_muschable
+      end
+
+      module ClassMethods
+        
+        def initialize_shards
+          0.upto(@shard_amount-1) do |i|
+            connection.execute("CREATE TABLE #{table_name_for_shard(i)} LIKE #{table_name_without_shard}")
+          end
+        end
+
+        @shard_amount = nil
+        attr_reader :shard_amount
+        def shard_amount=(amount)
+          ensure_positive_int('shard_amount', amount)
+          @shard_amount = amount
+        end
+
+        def activate_shard(shard)
+          ensure_positive_int('shard identifier', shard)
+          raise ArgumentError, "Can't activate shard, out of range. Adjust #{self.name}.shard_amount=" unless shard<@shard_amount
+
+          ensure_setup
+          Thread.current[:shards][self.name.to_sym] = shard.to_s
+        end
+        
+        def activate_base_shard
+          ensure_setup
+          Thread.current[:shards][self.name.to_sym] = -1
+        end
+
+        def detect_corrupt_shards
+          base_schema = extract_relevant_part_from_schema_definition(table_schema(table_name_without_shard))
+          returning Array.new do |corrupt_shards|
+            0.upto(shard_amount-1) do |shard|
+              shard_schema = extract_relevant_part_from_schema_definition(table_schema(table_name_for_shard(shard)))
+              corrupt_shards << shard if shard_schema!=base_schema or base_schema.blank?
+            end
+          end
+        end
+
+        def drop_shards(amount = nil)
+          amount ||= detect_shard_amount_in_database
+          ensure_positive_int('parameter for #drop_shards', amount)
+          0.upto(amount-1) do |i|
+            connection.execute("DROP TABLE #{table_name_for_shard(i)}")
+          end
+        end
+
+        def table_name_with_shard
+          ensure_setup
+          shard = Thread.current[:shards][self.name.to_sym]
+
+          return table_name_without_shard if @shard_amount==0 or shard == -1
+          raise ArgumentError, 'No shard has been activated' unless shard
+          table_name_for_shard(shard)
+        end
+
+        def detect_shard_amount_in_database
+          result = connection.execute "SHOW TABLES LIKE '#{table_name_without_shard}%'"
+          tables = []
+          result.each do |row|
+            tables << row[0].gsub(table_name_without_shard, '').to_i
+          end
+          result.free
+          return 0 if tables.size<=1
+          tables.sort.last.to_i + 1
+        end
+
+        def shard_levels
+          return [] unless shard_amount > 0
+          levels = []
+          (0...shard_amount).each do |i|
+            result = connection.execute "SELECT COUNT(*) FROM #{table_name_for_shard(i)}"
+            result.each do |row|
+              levels[i] = row[0].to_i
+            end
+          end
+          levels
+        end
+
+        def ensure_setup
+          raise ArgumentError, "You have to set #{self.name}.shard_amount" if @shard_amount.nil?
+          Thread.current[:shards] ||= Hash.new
+        end
+
+        def table_name_for_shard(shard)
+          "#{table_name_without_shard}#{shard}"
+        end
+
+        def ensure_positive_int(name, i)
+          raise ArgumentError, "Only positive integers are allowed as #{name}" unless i.is_a?(Integer) and i>=0
+        end
+
+        def table_schema(table_name)
+          result = connection.execute "SHOW CREATE TABLE #{table_name}"
+          schema = ""
+          result.each do |row|
+            schema << row[1]
+          end
+          schema
+        rescue ActiveRecord::StatementInvalid
+          ""
+        ensure
+          result.free if result
+        end
+        
+        def extract_relevant_part_from_schema_definition(definition)
+          definition.gsub!(/ AUTO_INCREMENT=[\d]+/, '')
+          match = definition.match(/[^\(]+(.*)$/m)
+          return match[1] if match
+          ""
+        end
+        
+        #
+        #  This is here because ActiveRecord::Base's table_name method
+        #  does something funky. If you call ActiveRecord::Base#table_name
+        #  for the first time, it goes through the class hierarchy and
+        #  puts together a table name.
+        #
+        #  Then it redefines the table_name method to instantly return that
+        #  name from the first run without going through the class hierarchy
+        #  again.
+        #
+        #  So this method overwrites :table_name_without_shard instead of
+        #  the actual #table_name method, so that the name of the shard is
+        #  returned.
+        #
+        def set_table_name(value = nil, &block)
+          define_attr_method :table_name_without_shard, value, &block
+        end
+
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,5 @@
+require 'acts_as_muschable'
+
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Muschable
+
+RAILS_DEFAULT_LOGGER.info "** acts_as_muschable: initialized properly."

data/spec/acts_as_muschable/acts_as_muschable_spec.rb

@@ -0,0 +1,215 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Acts as Muschable" do
+  
+  before(:all) do
+    Thread.current[:shards] = nil
+  end
+  
+  describe "changing active shards" do
+    it "should throw an exception when MuschableModel.table_name is called before MuschableModel.set_shard" do
+      lambda{ 
+        MuschableModel.table_name
+      }.should raise_error(ArgumentError, 'No shard has been activated')
+    end
+    
+    it "should not affect UnMuschableModels" do
+      UnmuschableModel.table_name.should == "unmuschable_models"
+    end
+    
+    it "should be able to MuschableModel.activate_shard" do
+      MuschableModel.should respond_to(:activate_shard)
+    end
+    
+    it "should be able to MuschableModel.activate_base_shard" do
+      MuschableModel.should respond_to(:activate_base_shard)
+    end
+    
+    it "should return the correct MuschableModel.table_name according to shard" do
+      MuschableModel.activate_shard(0)
+      MuschableModel.table_name.should == "muschable_models0"
+      MuschableModel.activate_shard(1)
+      MuschableModel.table_name.should == "muschable_models1"
+      MuschableModel.activate_base_shard
+      MuschableModel.table_name.should == "muschable_models"
+    end
+    
+    it "should only accept positive numeric shard identifiers" do
+      lambda{
+        MuschableModel.activate_shard("0")
+      }.should raise_error(ArgumentError, 'Only positive integers are allowed as shard identifier')
+      lambda{
+        MuschableModel.activate_shard(-1)
+      }.should raise_error(ArgumentError, 'Only positive integers are allowed as shard identifier')
+    end
+    
+    it "should be somewhat thread safe" do
+      MuschableModel.shard_amount = 1_000_000
+      threads = []
+      300.times do
+        threads << Thread.new do
+          shard = rand(1_000_000)
+          MuschableModel.activate_shard(shard)
+          sleep(rand(10))
+          MuschableModel.table_name.should == "muschable_models#{shard}"
+          MuschableModel.activate_base_shard
+          sleep(rand(5))
+          MuschableModel.table_name.should == "muschable_models"
+        end
+      end
+      threads.each { |thread| thread.join }
+    end
+  end
+  
+  describe "managing the amount of shards" do
+    it "should have a method to set MuschableModel.shard_amount=" do
+      MuschableModel.shard_amount = 1
+      MuschableModel.shard_amount.should == 1
+      MuschableModel.shard_amount = 15
+      MuschableModel.shard_amount.should == 15
+    end
+    
+    it "should do no sharding when MuschableModel.shard_amount is set to 0 (useful for test environments and such)" do
+      MuschableModel.shard_amount = 0
+      MuschableModel.table_name.should == "muschable_models"
+    end
+    
+    it "should not accept non-integers as MuschableModel.shard_amount=" do
+      lambda{
+        MuschableModel.shard_amount = "15"
+      }.should raise_error(ArgumentError, 'Only positive integers are allowed as shard_amount')
+      lambda{
+        MuschableModel.shard_amount = -1
+      }.should raise_error(ArgumentError, 'Only positive integers are allowed as shard_amount')
+    end
+    
+    it "should not accept a shard identifier larger MuschableModel.shard_amount" do
+      MuschableModel.shard_amount = 16
+      lambda{
+        MuschableModel.activate_shard(16)
+      }.should raise_error(ArgumentError, "Can't activate shard, out of range. Adjust MuschableModel.shard_amount=")
+    end
+    
+    it "should have a method MuschableModel.initialize_shards to create MuschableModel.shard_amount new shards" do
+      MuschableModel.activate_shard(0)
+      connection = mock("Connection")
+      connection.stub!(:table_exists?).with(any_args).and_return true
+      MuschableModel.should_receive(:connection).exactly(16).and_return connection
+      
+      0.upto(15) do |i|
+        query = "CREATE TABLE muschable_models#{i} LIKE muschable_models"
+        connection.should_receive(:execute).with(query).once.and_return(mock("execute #{i}", :null_object => true))
+      end
+      
+      MuschableModel.initialize_shards
+    end
+    
+    it "should have a method MuschableModel.drop_shards(12) to drop shards 0...12" do
+      MuschableModel.activate_shard(0)
+      connection = mock("Connection")
+      connection.stub!(:table_exists?).with(any_args).and_return true
+      MuschableModel.should_receive(:connection).exactly(12).and_return connection
+      
+      0.upto(11) do |i|
+        query = "DROP TABLE muschable_models#{i}"
+        connection.should_receive(:execute).with(query).once.and_return(mock("execute #{i}", :null_object => true))
+      end
+      
+      MuschableModel.drop_shards(12)
+    end
+    
+    [-1, "1", "a"].each do |i|
+      it "should not allow #drop_shards(#{i})" do
+        lambda{
+          MuschableModel.drop_shards(i)
+        }.should raise_error(ArgumentError, 'Only positive integers are allowed as parameter for #drop_shards')
+      end
+    end
+    
+    it "should have a method MuschableModel.assure_shards_health that goes through all shards and makes sure their structure equals that of the base table" do
+      MuschableModel.should respond_to(:detect_corrupt_shards)
+    end
+  end
+
+  describe "utility methods" do
+    
+    it "should have a method :shard_level to deliver statistics about how many rows each shard has" do
+      MuschableModel.should respond_to(:shard_levels)
+    end
+    
+    it "should extract the relevant parts from a schema definition in order to compare definitions" do
+      base_table_definition =<<-SQL
+        CREATE TABLE `movies_users` (
+          `user_id` int(11) DEFAULT NULL,
+          `movie_id` int(11) DEFAULT NULL,
+          `rating_date` datetime DEFAULT NULL,
+          `rating` int(3) DEFAULT NULL,
+          `top` tinyint(1) NOT NULL DEFAULT '0',
+          `flop` tinyint(1) NOT NULL DEFAULT '0',
+          `id` int(11) NOT NULL AUTO_INCREMENT,
+          `watchlist` tinyint(1) NOT NULL DEFAULT '0',
+          `blacklist` tinyint(1) NOT NULL DEFAULT '0',
+          `watchlist_date` datetime DEFAULT NULL,
+          `blacklist_date` datetime DEFAULT NULL,
+          `forecast` float DEFAULT NULL,
+          `forecast_relevance` float DEFAULT NULL,
+          `forecast_neighbour_count` int(4) DEFAULT NULL,
+          `forecast_or_rating` int(3) DEFAULT NULL,
+          PRIMARY KEY (`id`),
+          UNIQUE KEY `index_movies_users_on_user_id_and_movie_id` (`user_id`,`movie_id`),
+          KEY `user_ratings` (`movie_id`,`user_id`,`rating`),
+          KEY `index_movies_users_on_updated_at_and_id` (`rating_date`,`id`),
+          KEY `movie_id_and_rating_date` (`movie_id`,`rating_date`),
+          KEY `movie_id_and_user_id_and_forecast_or_rating` (`movie_id`,`user_id`,`forecast_or_rating`),
+          KEY `rating_date` (`rating_date`),
+          KEY `top` (`top`),
+          KEY `flop` (`flop`),
+          KEY `index_movies_users_on_user_id_and_blacklist_and_movie_id` (`user_id`,`blacklist`,`movie_id`),
+          KEY `movies_users_on_user_id_and_rating_and_movie_id` (`user_id`,`rating`,`movie_id`),
+          KEY `movies_users_on_movie_id_and_rating` (`movie_id`,`rating`),
+          KEY `movies_users_on_rating_and_user_id_and_movie_id` (`rating`,`user_id`,`movie_id`),
+          KEY `user_id_and_movie_id_and_forecast_or_rating_on_movies_users` (`user_id`,`movie_id`,`forecast_or_rating`)
+        ) ENGINE=MyISAM AUTO_INCREMENT=241855247 DEFAULT CHARSET=utf8
+      SQL
+
+      shard_table_definition =<<-SQL
+        CREATE TABLE `movies_users0` (
+          `user_id` int(11) DEFAULT NULL,
+          `movie_id` int(11) DEFAULT NULL,
+          `rating_date` datetime DEFAULT NULL,
+          `rating` int(3) DEFAULT NULL,
+          `top` tinyint(1) NOT NULL DEFAULT '0',
+          `flop` tinyint(1) NOT NULL DEFAULT '0',
+          `id` int(11) NOT NULL AUTO_INCREMENT,
+          `watchlist` tinyint(1) NOT NULL DEFAULT '0',
+          `blacklist` tinyint(1) NOT NULL DEFAULT '0',
+          `watchlist_date` datetime DEFAULT NULL,
+          `blacklist_date` datetime DEFAULT NULL,
+          `forecast` float DEFAULT NULL,
+          `forecast_relevance` float DEFAULT NULL,
+          `forecast_neighbour_count` int(4) DEFAULT NULL,
+          `forecast_or_rating` int(3) DEFAULT NULL,
+          PRIMARY KEY (`id`),
+          UNIQUE KEY `index_movies_users_on_user_id_and_movie_id` (`user_id`,`movie_id`),
+          KEY `user_ratings` (`movie_id`,`user_id`,`rating`),
+          KEY `index_movies_users_on_updated_at_and_id` (`rating_date`,`id`),
+          KEY `movie_id_and_rating_date` (`movie_id`,`rating_date`),
+          KEY `movie_id_and_user_id_and_forecast_or_rating` (`movie_id`,`user_id`,`forecast_or_rating`),
+          KEY `rating_date` (`rating_date`),
+          KEY `top` (`top`),
+          KEY `flop` (`flop`),
+          KEY `index_movies_users_on_user_id_and_blacklist_and_movie_id` (`user_id`,`blacklist`,`movie_id`),
+          KEY `movies_users_on_user_id_and_rating_and_movie_id` (`user_id`,`rating`,`movie_id`),
+          KEY `movies_users_on_movie_id_and_rating` (`movie_id`,`rating`),
+          KEY `movies_users_on_rating_and_user_id_and_movie_id` (`rating`,`user_id`,`movie_id`),
+          KEY `user_id_and_movie_id_and_forecast_or_rating_on_movies_users` (`user_id`,`movie_id`,`forecast_or_rating`)
+        ) ENGINE=MyISAM DEFAULT CHARSET=utf8
+      SQL
+
+      base_definition  = MuschableModel.extract_relevant_part_from_schema_definition(base_table_definition)
+      shard_definition = MuschableModel.extract_relevant_part_from_schema_definition(shard_table_definition)
+      
+      shard_definition.should == base_definition
+    end
+  end
+end

data/spec/acts_as_muschable/integration_spec.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Integration tests with database access" do
+  
+  unless ENV['RUN_MUSCH_INTEGRATION_TESTS']=="true"
+    print <<-HELP
+<pre>==================== INTEGRATION TESTS ===========================
+ If you want to run functional tests on your DB, set
+ ENV['RUN_MUSCH_INTEGRATION_TESTS'] to 'true' and call rake spec again.
+
+ Then make sure the mysql user rails:rails@localhost has all mysql
+ privileges for database 'test' (should work out of the box if you 
+ have a rails user in mysql)
+=================================================================</pre>
+    HELP
+    break 
+  end
+  
+  describe "shard management" do
+
+    before(:all) do
+      Thread.current[:shards] = nil
+      puts "\nRunning integration tests"
+      @conn = MuschableModel.connection
+    end
+    
+    it "should detect how many must be deleted with #detect_shard_amount_in_database when there are shards" do
+      MuschableModel.detect_shard_amount_in_database.should == 4
+    end
+    
+    it "should detect how many must be deleted with #detect_shard_amount_in_database when there are no shards" do
+      OtherMuschableModel.detect_shard_amount_in_database.should == 0
+    end
+    
+    it "should detect corrupt shards during #detect_corrupt_shards" do
+      MuschableModel.shard_amount = 4
+      MuschableModel.detect_corrupt_shards.should == [1,2,3] 
+    end
+    
+    it "should not detect corrupt shards when database is healthy" do
+      MuschableModel.shard_amount = 1
+      MuschableModel.detect_corrupt_shards.should be_blank
+    end
+    
+    it "should drop all shards during #drop_shards(3)" do
+      class YetAnotherMuschableModel < ActiveRecord::Base
+        acts_as_muschable :shard_amount => 5
+      end
+      create_base_table_and_shards "yet_another_muschable_models", 10
+      YetAnotherMuschableModel.detect_shard_amount_in_database.should == 10
+      YetAnotherMuschableModel.drop_shards(10)
+      YetAnotherMuschableModel.detect_shard_amount_in_database.should == 0
+    end
+    
+    it "should drop all shards during #drop_shards (automatically guessing how many shards exist)" do
+      class YetYetAnotherMuschableModel < ActiveRecord::Base
+        acts_as_muschable :shard_amount => 5
+      end
+      create_base_table_and_shards "yet_yet_another_muschable_models", 15
+      YetYetAnotherMuschableModel.activate_shard 0
+      YetYetAnotherMuschableModel.detect_shard_amount_in_database.should == 15
+      YetYetAnotherMuschableModel.drop_shards
+      YetYetAnotherMuschableModel.detect_shard_amount_in_database.should == 0
+    end
+    
+    it "should create all shards during #initialize_shards" do
+      OtherMuschableModel.detect_shard_amount_in_database.should == 0
+      OtherMuschableModel.shard_amount = 3
+      OtherMuschableModel.initialize_shards
+      
+      OtherMuschableModel.detect_shard_amount_in_database.should == 3
+      OtherMuschableModel.detect_corrupt_shards.should be_blank
+    end
+
+  end
+
+  describe "objects living in different shards" do
+    
+    before(:all) do
+      class MyMuschableModel < ActiveRecord::Base
+        acts_as_muschable :shard_amount => 2
+      end
+      create_base_table_and_shards "my_muschable_models", 0
+      MyMuschableModel.initialize_shards
+      @conn = MuschableModel.connection
+    end
+    
+    it "should create different models in different shards" do
+      MyMuschableModel.activate_shard 0
+      model1_in_shard0 = MyMuschableModel.create :name => "model1_in_shard0"
+      model2_in_shard0 = MyMuschableModel.create :name => "model2_in_shard0"
+      MyMuschableModel.count.should == 2
+      MyMuschableModel.find(model2_in_shard0.id).should == model2_in_shard0
+      
+      MyMuschableModel.activate_shard 1
+      model1_in_shard1 = MyMuschableModel.create :name => "model1_in_shard1"
+      MyMuschableModel.count.should == 1
+      MyMuschableModel.destroy_all
+      MyMuschableModel.count.should == 0
+
+      MyMuschableModel.activate_shard 0
+      MyMuschableModel.count.should == 2
+    end
+
+  end
+
+  #
+  #  Drop all tables created during this test (i.e. have muschable in their name)
+  after(:all) do
+    @conn.execute "DROP TABLE schema_migrations"
+    result = @conn.execute "SHOW TABLES LIKE '%muschable%'"
+    result.each do |row|
+      @conn.execute("DROP TABLE #{row[0]}")
+    end
+    result.free
+  end
+end
+
+
+#
+#  Santa's little helper
+#
+def create_base_table_and_shards(table_name, shard_amount)
+  ActiveRecord::Schema.define :version => 0 do
+    create_table table_name, :force => true do |t|
+      t.integer  "id",        :limit => 11
+      t.string   "name"
+    end
+    add_index table_name, ["id"], :name => "index_on_id"
+    
+    0.upto(shard_amount-1) do |i|
+      create_table "#{table_name}#{i}", :force => true do |t|
+        t.integer  "id",                :limit => 11
+        t.string   "name"
+      end
+      add_index "#{table_name}#{i}", ["id"], :name => "index_on_id"
+    end
+  end
+end

data/spec/schema.rb

@@ -0,0 +1,52 @@
+RAILS_DEFAULT_LOGGER.silence do
+  ActiveRecord::Schema.define :version => 0 do
+
+    #
+    #  Base table
+    #
+    create_table "muschable_models", :force => true do |t|
+      t.integer  "id",        :limit => 11
+      t.string   "name"
+    end
+    add_index "muschable_models", ["id"], :name => "index_on_id"
+
+    #
+    #  First shard, healthy
+    #
+    create_table "muschable_models0", :force => true do |t|
+      t.integer  "id",        :limit => 11
+      t.string   "name"
+    end
+    add_index "muschable_models0", ["id"], :name => "index_on_id"
+
+    #
+    #  Second shard, wrong column
+    #
+    create_table "muschable_models1", :force => true do |t|
+      t.integer  "id",        :limit => 11
+      t.string   "nume"
+    end
+    add_index "muschable_models1", ["id"], :name => "index_on_id"
+
+    #
+    #  Third shard, missing in action
+    #
+
+    #
+    #  Fourth shard, missing index
+    #
+    create_table "muschable_models3", :force => true do |t|
+      t.integer  "id",        :limit => 11
+      t.string   "name"
+    end
+
+    #
+    # Another base shard
+    #
+    create_table "other_muschable_models", :force => true do |t|
+      t.integer  "id",        :limit => 11
+      t.string   "name"
+    end
+    add_index "other_muschable_models", ["id"], :name => "index_on_id"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format specdoc
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+ENV["RAILS_ENV"] = "test"
+
+require 'rubygems'
+require 'active_support'
+require 'active_record'
+require 'spec'
+
+RAILS_DEFAULT_LOGGER = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require File.join(File.dirname(__FILE__), '..', 'init')
+
+if ENV['RUN_MUSCH_INTEGRATION_TESTS']=="true"
+  ActiveRecord::Base.establish_connection(
+    "adapter"  => "mysql",
+    "database" => "test",
+    "host"     => "localhost",
+    "socket"   => "/tmp/mysql.sock",
+    "port"     => 3306,
+    "username" => "rails",
+    "password" => "rails"
+  )
+
+  load(File.dirname(__FILE__) + '/schema.rb')
+end
+
+class MuschableModel < ActiveRecord::Base
+  acts_as_muschable :shard_amount => 16
+end
+
+class OtherMuschableModel < ActiveRecord::Base
+  acts_as_muschable :shard_amount => 16
+end
+
+class UnmuschableModel < ActiveRecord::Base
+end
+
+# This is here so the schema definitions don't produce too much output
+BEGIN {
+  class<<Object
+    def puts_with_crap_cleansing(msg)
+      puts_without_crap_cleansing(msg) if ['-- ', '   ->'].reject{|⎮| msg.starts_with?(⎮)}.count == 2
+    end
+    alias_method :puts_without_crap_cleansing, :puts
+    alias_method :puts, :puts_with_crap_cleansing
+  end
+}

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_muschable
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Moviepilot
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-04 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Do not use me unless you are not you but somebody else.
+email: jannis@moviepilot.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Rakefile
+- VERSION
+- acts_as_muschable.gemspec
+- init.rb
+- lib/acts_as_muschable.rb
+- rails/init.rb
+- spec/acts_as_muschable/acts_as_muschable_spec.rb
+- spec/acts_as_muschable/integration_spec.rb
+- spec/schema.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/moviepilot/acts_as_muschable
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Easy peasy model sharding
+test_files: 
+- spec/acts_as_muschable/acts_as_muschable_spec.rb
+- spec/acts_as_muschable/integration_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb