ar-octopus 0.0.19 → 0.0.20

data/.gitignore

@@ -1,2 +1,3 @@
 pkg/*.*
 tmp/*
+*.sqlite3

data/README.mkdn

@@ -1,9 +1,9 @@
 <h1> Octopus  - Easy Database Sharding for ActiveRecord</h1>
 
-<p> Octopus is a better way to do Database Sharding in ActiveRecord. Sharding allows multiple databases in the same rails application. While there are several projects that implement Sharding (e.g. DbCharmer, DataFabric), each project has its own limitations. The main goal of octopus project is to provide a nice and clean way of doing Database Sharding.</p>
+<p> Octopus is a better way to do Database Sharding in ActiveRecord. Sharding allows multiple databases in the same rails application. While there are several projects that implement Sharding (e.g. DbCharmer, DataFabric, MultiDb), each project has its own limitations. The main goal of octopus project is to provide a nice and clean way of doing Database Sharding.</p>
 
 <h2>Feature list: </h2>
-<p> The design of the api is made to be simple as possible. Octopus is focusing in the end user, giving the power of multiple databases, but with reliable code and flexibility. Octopus is focused on Rails 3,  but will be soon compatible with Rails 2.x.</p>
+<p> The design of the api is made to be simple as possible. Octopus is focusing in the end user, giving the power of multiple databases, but with reliable code and flexibility. Octopus is focused on Rails 3, is compatible with Rails 2.x.</p>
 
 <p> Octopus supports: </p>
 

data/Rakefile

@@ -29,7 +29,7 @@ begin
     gem.authors = ["Thiago Pradi", "Mike Perham", "Amit Agarwal"]
     gem.add_development_dependency "rspec", ">= 1.2.9"
     gem.add_dependency('activerecord', '>= 3.0.0beta')
-    gem.version = "0.0.19"
+    gem.version = "0.0.20"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -90,7 +90,7 @@ namespace :db do
     Dir.chdir(File.expand_path(File.dirname(__FILE__) + "/spec"))
     require "database_connection"
     require "octopus"
-    [:master, :brazil, :canada, :russia, :alone_shard, :postgresql_shard].each do |shard_symbol|
+    [:master, :brazil, :canada, :russia, :alone_shard, :postgresql_shard, :sqlite_shard].each do |shard_symbol|
       ActiveRecord::Base.using(shard_symbol).connection.initialize_schema_migrations_table()
       
       ActiveRecord::Base.using(shard_symbol).connection.create_table(:users) do |u|

data/ar-octopus.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ar-octopus}
-  s.version = "0.0.19"
+  s.version = "0.0.20"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Thiago Pradi", "Mike Perham", "Amit Agarwal"]
-  s.date = %q{2010-07-05}
+  s.date = %q{2010-07-07}
   s.description = %q{This gem allows you to use sharded databases with ActiveRecord. this also provides a interface for replication and for running migrations with multiples shards.}
   s.email = %q{tchandy@gmail.com}
   s.extra_rdoc_files = [
@@ -25,6 +25,7 @@ Gem::Specification.new do |s|
      "doc/features.textile",
      "doc/libraries.textile",
      "doc/shards.yml",
+     "init.rb",
      "lib/octopus.rb",
      "lib/octopus/association.rb",
      "lib/octopus/association_collection.rb",
@@ -32,8 +33,11 @@ Gem::Specification.new do |s|
      "lib/octopus/has_and_belongs_to_many_association.rb",
      "lib/octopus/migration.rb",
      "lib/octopus/model.rb",
-     "lib/octopus/persistence.rb",
      "lib/octopus/proxy.rb",
+     "lib/octopus/rails2/association.rb",
+     "lib/octopus/rails2/persistence.rb",
+     "lib/octopus/rails3/association.rb",
+     "lib/octopus/rails3/persistence.rb",
      "lib/octopus/scope_proxy.rb",
      "rails/init.rb",
      "spec/config/shards.yml",

data/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'rails', 'init')

data/lib/octopus.rb

@@ -35,14 +35,28 @@ module Octopus
   def self.excluded_enviroments
     @excluded_enviroments || ['development',"cucumber", "test"]
   end
+  
+  def self.rails3?
+    ActiveRecord::VERSION::MAJOR == 3
+  end
 end
 
-require "octopus/proxy"
-require "octopus/migration"
+
 require "octopus/model"
-require "octopus/persistence"
-require "octopus/controller"
-require "octopus/association"
+require "octopus/migration"
 require "octopus/association_collection"
+require "octopus/has_and_belongs_to_many_association"
+require "octopus/association"
+
+if Octopus.rails3?
+  require "octopus/rails3/association"
+  require "octopus/rails3/persistence"
+else
+  require "octopus/rails2/association"
+  require "octopus/rails2/persistence"
+end
+
+require "octopus/proxy"
 require "octopus/scope_proxy"
-require "octopus/has_and_belongs_to_many_association"
+require "octopus/controller"
+

data/lib/octopus/association.rb

@@ -22,111 +22,6 @@ module Octopus::Association
       options[:before_remove] = :set_connection
     end
   end
-  
-  def collection_reader_method(reflection, association_proxy_class)
-    define_method(reflection.name) do |*params|
-      force_reload = params.first unless params.empty?
-      reload_connection() 
-
-      association = association_instance_get(reflection.name)
-
-      unless association
-        association  = association_proxy_class.new(self, reflection)
-        association_instance_set(reflection.name, association)
-      end
-
-      reflection.klass.uncached { association.reload } if force_reload
-
-      association
-    end
-
-    define_method("#{reflection.name.to_s.singularize}_ids") do
-      reload_connection()        
-      if send(reflection.name).loaded? || reflection.options[:finder_sql]
-        send(reflection.name).map(&:id)
-      else
-        if reflection.through_reflection && reflection.source_reflection.belongs_to?
-          through = reflection.through_reflection
-          primary_key = reflection.source_reflection.primary_key_name
-          send(through.name).select("DISTINCT #{through.quoted_table_name}.#{primary_key}").map!(&:"#{primary_key}")
-        else
-          send(reflection.name).select("#{reflection.quoted_table_name}.#{reflection.klass.primary_key}").except(:includes).map!(&:id)
-        end
-      end
-    end
-  end
-
-  def association_constructor_method(constructor, reflection, association_proxy_class)
-    define_method("#{constructor}_#{reflection.name}") do |*params|
-      reload_connection() 
-      attributees      = params.first unless params.empty?
-      replace_existing = params[1].nil? ? true : params[1]
-      association      = association_instance_get(reflection.name)
-
-      unless association
-        association = association_proxy_class.new(self, reflection)
-        association_instance_set(reflection.name, association)
-      end
-
-      if association_proxy_class == ActiveRecord::Associations::HasOneAssociation
-        return_val = association.send(constructor, attributees, replace_existing)
-      else
-        return_val = association.send(constructor, attributees)
-      end
-
-      if should_set_current_shard?
-        return_val.current_shard = self.current_shard
-      end
-
-      return_val
-    end
-  end
-
-  def association_accessor_methods(reflection, association_proxy_class)
-    define_method(reflection.name) do |*params|
-      reload_connection()
-      force_reload = params.first unless params.empty?
-      association = association_instance_get(reflection.name)
-
-      if association.nil? || force_reload
-        association = association_proxy_class.new(self, reflection)
-        retval = force_reload ? reflection.klass.uncached { association.reload } : association.reload
-        if retval.nil? and association_proxy_class == ActiveRecord::Associations::BelongsToAssociation
-          association_instance_set(reflection.name, nil)
-          return nil
-        end
-        association_instance_set(reflection.name, association)
-      end
-
-      association.target.nil? ? nil : association
-    end
-
-    define_method("loaded_#{reflection.name}?") do
-      reload_connection() 
-      association = association_instance_get(reflection.name)
-      association && association.loaded?
-    end
-
-    define_method("#{reflection.name}=") do |new_value|
-      reload_connection() 
-      association = association_instance_get(reflection.name)
-
-      if association.nil? || association.target != new_value
-        association = association_proxy_class.new(self, reflection)
-      end
-
-      association.replace(new_value)
-      association_instance_set(reflection.name, new_value.nil? ? nil : association)
-    end
-
-    define_method("set_#{reflection.name}_target") do |target|
-      return if target.nil? and association_proxy_class == ActiveRecord::Associations::BelongsToAssociation
-      reload_connection() 
-      association = association_proxy_class.new(self, reflection)
-      association.target = target
-      association_instance_set(reflection.name, association)
-    end
-  end
 end
 
-ActiveRecord::Base.extend(Octopus::Association)
+ActiveRecord::Base.extend(Octopus::Association)

data/lib/octopus/association_collection.rb

@@ -1,40 +1,15 @@
-class ActiveRecord::Associations::AssociationCollection
+module Octopus::AssociationCollection   
   def should_wrap_the_connection?
     @owner.respond_to?(:current_shard) && @owner.current_shard != nil
   end
 
-  def count(column_name = nil, options = {})
-    if @reflection.options[:counter_sql]
-      if should_wrap_the_connection?
-        @owner.using(@owner.current_shard) { @reflection.klass.count_by_sql(@counter_sql) } 
-      else        
-        @reflection.klass.count_by_sql(@counter_sql)
-      end
-    else
-      column_name, options = nil, column_name if column_name.is_a?(Hash)
-
-      if @reflection.options[:uniq]
-        # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
-        column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" unless column_name
-        options.merge!(:distinct => true)
-      end
-
-      value = @reflection.klass.send(:with_scope, construct_scope) do 
-        if should_wrap_the_connection?
-          @owner.using(@owner.current_shard) { @reflection.klass.count(column_name, options) } 
-        else        
-          @reflection.klass.count(column_name, options) 
-        end
-      end
-
-      limit  = @reflection.options[:limit]
-      offset = @reflection.options[:offset]
-
-      if limit || offset
-        [ [value - offset.to_i, 0].max, limit.to_i ].min
-      else
-        value
-      end
+  def count(*args)
+    if should_wrap_the_connection?
+      @owner.using(@owner.current_shard) { super } 
+    else        
+      super
     end
   end
-end
+end
+
+ActiveRecord::Associations::AssociationCollection.send(:include, Octopus::AssociationCollection)

data/lib/octopus/has_and_belongs_to_many_association.rb

@@ -1,43 +1,21 @@
-class ActiveRecord::Associations::HasAndBelongsToManyAssociation
+module Octopus::HasAndBelongsToManyAssociation
+  def self.included(base)
+    base.instance_eval do
+      alias_method_chain :insert_record, :octopus
+    end
+  end
+
   def should_wrap_the_connection?
     @owner.respond_to?(:current_shard) && @owner.current_shard != nil
   end
-  
-  def insert_record(record, force = true, validate = true)
-    if record.new_record?
-      if force
-        record.save!
-      else
-        return false unless record.save(:validate => validate)
-      end
-    end
 
-    if @reflection.options[:insert_sql]
-      @owner.connection.insert(interpolate_sql(@reflection.options[:insert_sql], record))
-    else
-      relation = Arel::Table.new(@reflection.options[:join_table])
-      attributes = columns.inject({}) do |attrs, column|
-        case column.name.to_s
-        when @reflection.primary_key_name.to_s
-          attrs[relation[column.name]] = owner_quoted_id
-        when @reflection.association_foreign_key.to_s
-          attrs[relation[column.name]] = record.quoted_id
-        else
-          if record.has_attribute?(column.name)
-            value = @owner.send(:quote_value, record[column.name], column)
-            attrs[relation[column.name]] = value unless value.nil?
-          end
-        end
-        attrs
-      end
-      
-      if should_wrap_the_connection?
-        @owner.using(@owner.current_shard) { relation.insert(attributes) } 
-      else
-        relation.insert(attributes)
-      end
+  def insert_record_with_octopus(record, force = true, validate = true)
+    if should_wrap_the_connection?
+      @owner.using(@owner.current_shard) { insert_record_without_octopus(record, force, validate) } 
+    else 
+      insert_record_without_octopus(record, force, validate) 
     end
-
-    return true
   end
-end
+end
+
+ActiveRecord::Associations::HasAndBelongsToManyAssociation.send(:include, Octopus::HasAndBelongsToManyAssociation)

data/lib/octopus/migration.rb

@@ -1,4 +1,10 @@
 module Octopus::Migration  
+  def self.extended(base)
+    class << base
+      alias_method_chain :migrate, :octopus
+    end
+  end
+  
   def using(*args, &block)
     Octopus.config()
 
@@ -15,6 +21,7 @@ module Octopus::Migration
       self.connection().current_shard = args        
     end
 
+
     yield if block_given?
 
     return self
@@ -42,7 +49,17 @@ module Octopus::Migration
 
     return self
   end
-end
+  
+  def migrate_with_octopus(direction)
+    ret = migrate_without_octopus(direction)
+    # This Cleans the proxy
+    # TODO - REFACTOR!
+    ActiveRecord::Base.connection.instance_variable_set(:@current_shard, :master)
+    ActiveRecord::Base.connection.instance_variable_set(:@current_group, nil)
+    ActiveRecord::Base.connection().block = false
 
+    return ret
+  end
+end
 
-ActiveRecord::Migration.extend(Octopus::Migration)
+ActiveRecord::Migration.extend(Octopus::Migration)

data/lib/octopus/model.rb

@@ -37,7 +37,13 @@ module Octopus::Model
         else
           self.current_shard = self.class.connection_proxy.last_current_shard  
         end
-      end    
+      end
+      
+      if !Octopus.rails3?
+        def after_initialize
+          set_current_shard()
+        end
+      end
     end
 
     def hijack_connection()
@@ -69,6 +75,10 @@ module Octopus::Model
     def should_set_current_shard?
       self.respond_to?(:current_shard) && self.current_shard != nil
     end
+    
+    def reload_connection()
+      set_connection() if should_set_current_shard?
+    end
   end
 
   module ClassMethods

data/lib/octopus/rails2/association.rb

@@ -0,0 +1,133 @@
+module Octopus
+  module Rails2
+    module Association
+      def association_accessor_methods(reflection, association_proxy_class)
+        define_method(reflection.name) do |*params|
+          force_reload = params.first unless params.empty?
+          reload_connection()
+          association = association_instance_get(reflection.name)
+
+          if association.nil? || force_reload
+            association = association_proxy_class.new(self, reflection)
+            retval = force_reload ? reflection.klass.uncached { association.reload } : association.reload
+            if retval.nil? and association_proxy_class == ActiveRecord::Associations::BelongsToAssociation
+              association_instance_set(reflection.name, nil)
+              return nil
+            end
+            association_instance_set(reflection.name, association)
+          end
+
+          association.target.nil? ? nil : association
+        end
+
+        define_method("loaded_#{reflection.name}?") do
+          reload_connection()
+          association = association_instance_get(reflection.name)
+          association && association.loaded?
+        end
+
+        define_method("#{reflection.name}=") do |new_value|
+          association = association_instance_get(reflection.name)
+          reload_connection()
+          if association.nil? || association.target != new_value
+            association = association_proxy_class.new(self, reflection)
+          end
+
+          if association_proxy_class == ActiveRecord::Associations::HasOneThroughAssociation
+            association.create_through_record(new_value)
+            if new_record?
+              association_instance_set(reflection.name, new_value.nil? ? nil : association)
+            else
+              self.send(reflection.name, new_value)
+            end
+          else
+            association.replace(new_value)
+            association_instance_set(reflection.name, new_value.nil? ? nil : association)
+          end
+        end
+
+        define_method("set_#{reflection.name}_target") do |target|
+          reload_connection()
+          return if target.nil? and association_proxy_class == ActiveRecord::Associations::BelongsToAssociation
+          association = association_proxy_class.new(self, reflection)
+          association.target = target
+          association_instance_set(reflection.name, association)
+        end
+      end
+
+      def collection_reader_method(reflection, association_proxy_class)
+        define_method(reflection.name) do |*params|
+          force_reload = params.first unless params.empty?
+          reload_connection() 
+          association = association_instance_get(reflection.name)
+
+          unless association
+            association = association_proxy_class.new(self, reflection)
+            association_instance_set(reflection.name, association)
+          end
+
+          reflection.klass.uncached { association.reload } if force_reload
+
+          association
+        end
+
+        define_method("#{reflection.name.to_s.singularize}_ids") do
+          reload_connection() 
+          if send(reflection.name).loaded? || reflection.options[:finder_sql]
+            send(reflection.name).map(&:id)
+          else
+            send(reflection.name).all(:select => "#{reflection.quoted_table_name}.#{reflection.klass.primary_key}").map(&:id)
+          end
+        end
+      end
+
+      def collection_accessor_methods(reflection, association_proxy_class, writer = true)
+        collection_reader_method(reflection, association_proxy_class)
+
+        if writer
+          define_method("#{reflection.name}=") do |new_value|
+            reload_connection()
+            # Loads proxy class instance (defined in collection_reader_method) if not already loaded
+            association = send(reflection.name)
+            association.replace(new_value)
+            association
+          end
+
+          define_method("#{reflection.name.to_s.singularize}_ids=") do |new_value|
+            reload_connection()
+            ids = (new_value || []).reject { |nid| nid.blank? }.map(&:to_i)
+            send("#{reflection.name}=", reflection.klass.find(ids).index_by(&:id).values_at(*ids))
+          end
+        end
+      end
+
+      def association_constructor_method(constructor, reflection, association_proxy_class)
+        define_method("#{constructor}_#{reflection.name}") do |*params|
+          reload_connection() 
+          attributees      = params.first unless params.empty?
+          replace_existing = params[1].nil? ? true : params[1]
+          association      = association_instance_get(reflection.name)
+
+          unless association
+            association = association_proxy_class.new(self, reflection)
+            association_instance_set(reflection.name, association)
+          end
+
+          if association_proxy_class == ActiveRecord::Associations::HasOneAssociation
+            ret_val = association.send(constructor, attributees, replace_existing)
+          else
+            ret_val = association.send(constructor, attributees)
+          end
+
+          if should_set_current_shard?
+            ret_val.current_shard = self.current_shard
+          end
+
+          return ret_val
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend(Octopus::Rails2::Association)

data/lib/octopus/rails2/persistence.rb

@@ -0,0 +1,45 @@
+module Octopus
+  module Rails2
+    module Persistence
+      def self.included(base)
+        base.instance_eval do 
+          alias_method_chain :destroy, :octopus
+          alias_method_chain :delete, :octopus
+          alias_method_chain :reload, :octopus
+        end
+      end
+
+      def delete_with_octopus()
+        if should_set_current_shard?
+          self.using(self.current_shard) do
+            delete_without_octopus()
+          end
+        else
+          delete_without_octopus()
+        end
+      end
+
+      def destroy_with_octopus()
+        if should_set_current_shard?
+          self.using(self.current_shard) do
+            destroy_without_octopus()
+          end
+        else
+          destroy_without_octopus()
+        end
+      end
+
+      def reload_with_octopus(options = nil)
+        if should_set_current_shard?
+          self.using(self.current_shard) do
+            reload_without_octopus(options)
+          end
+        else
+          reload_without_octopus(options)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Octopus::Rails2::Persistence)

data/lib/octopus/rails3/association.rb

@@ -0,0 +1,112 @@
+module Octopus
+  module Rails3
+    module Association
+      def collection_reader_method(reflection, association_proxy_class)
+        define_method(reflection.name) do |*params|
+          force_reload = params.first unless params.empty?
+          reload_connection() 
+
+          association = association_instance_get(reflection.name)
+
+          unless association
+            association  = association_proxy_class.new(self, reflection)
+            association_instance_set(reflection.name, association)
+          end
+
+          reflection.klass.uncached { association.reload } if force_reload
+
+          association
+        end
+
+        define_method("#{reflection.name.to_s.singularize}_ids") do
+          reload_connection()        
+          if send(reflection.name).loaded? || reflection.options[:finder_sql]
+            send(reflection.name).map(&:id)
+          else
+            if reflection.through_reflection && reflection.source_reflection.belongs_to?
+              through = reflection.through_reflection
+              primary_key = reflection.source_reflection.primary_key_name
+              send(through.name).select("DISTINCT #{through.quoted_table_name}.#{primary_key}").map!(&:"#{primary_key}")
+            else
+              send(reflection.name).select("#{reflection.quoted_table_name}.#{reflection.klass.primary_key}").except(:includes).map!(&:id)
+            end
+          end
+        end
+      end
+
+      def association_constructor_method(constructor, reflection, association_proxy_class)
+        define_method("#{constructor}_#{reflection.name}") do |*params|
+          reload_connection() 
+          attributees      = params.first unless params.empty?
+          replace_existing = params[1].nil? ? true : params[1]
+          association      = association_instance_get(reflection.name)
+
+          unless association
+            association = association_proxy_class.new(self, reflection)
+            association_instance_set(reflection.name, association)
+          end
+
+          if association_proxy_class == ActiveRecord::Associations::HasOneAssociation
+            return_val = association.send(constructor, attributees, replace_existing)
+          else
+            return_val = association.send(constructor, attributees)
+          end
+
+          if should_set_current_shard?
+            return_val.current_shard = self.current_shard
+          end
+
+          return_val
+        end
+      end
+
+      def association_accessor_methods(reflection, association_proxy_class)
+        define_method(reflection.name) do |*params|
+          reload_connection()
+          force_reload = params.first unless params.empty?
+          association = association_instance_get(reflection.name)
+
+          if association.nil? || force_reload
+            association = association_proxy_class.new(self, reflection)
+            retval = force_reload ? reflection.klass.uncached { association.reload } : association.reload
+            if retval.nil? and association_proxy_class == ActiveRecord::Associations::BelongsToAssociation
+              association_instance_set(reflection.name, nil)
+              return nil
+            end
+            association_instance_set(reflection.name, association)
+          end
+
+          association.target.nil? ? nil : association
+        end
+
+        define_method("loaded_#{reflection.name}?") do
+          reload_connection() 
+          association = association_instance_get(reflection.name)
+          association && association.loaded?
+        end
+
+        define_method("#{reflection.name}=") do |new_value|
+          reload_connection() 
+          association = association_instance_get(reflection.name)
+
+          if association.nil? || association.target != new_value
+            association = association_proxy_class.new(self, reflection)
+          end
+
+          association.replace(new_value)
+          association_instance_set(reflection.name, new_value.nil? ? nil : association)
+        end
+
+        define_method("set_#{reflection.name}_target") do |target|
+          return if target.nil? and association_proxy_class == ActiveRecord::Associations::BelongsToAssociation
+          reload_connection() 
+          association = association_proxy_class.new(self, reflection)
+          association.target = target
+          association_instance_set(reflection.name, association)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend(Octopus::Rails3::Association)

data/lib/octopus/rails3/persistence.rb

@@ -0,0 +1,41 @@
+module Octopus
+  module Rails3
+    module Persistence
+      def reload_connection()
+        set_connection() if should_set_current_shard?
+      end
+
+      def update_attribute(name, value)
+        reload_connection()
+        super(name, value)
+      end
+
+      def update_attributes(attributes)
+        reload_connection()
+        super(attributes)
+      end
+
+      def update_attributes!(attributes)
+        reload_connection()
+        super(attributes)
+      end
+
+      def reload
+        reload_connection()
+        super
+      end
+
+      def delete
+        reload_connection()
+        super
+      end
+
+      def destroy
+        reload_connection()
+        super
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Octopus::Rails3::Persistence)

data/spec/config/shards.yml

@@ -16,6 +16,11 @@ octopus:
       database: octopus_shard1
       encoding: unicode
     
+    #TODO - FIX THIS
+    sqlite_shard:
+      adapter: sqlite3
+      database: /Users/tchandy/Projetos/octopus/spec/database.sqlite3
+    
     history_shards:
       aug2009:
         adapter: mysql

data/spec/octopus/controller_spec.rb

@@ -26,12 +26,16 @@ describe Octopus::Controller do
     end
     
     UsersControllers.action_methods.include?("create").should be_true
-    a = UsersControllers.new
-    a.stub!(:request).and_return(mock({:fullpath => "", :filtered_parameters => {}, :formats => ["xml"], :method => "GET"}))
-    a.instance_variable_set(:@_response, mock(:content_type => "xml", :body= => "", :status => 401))
-    a.process(:create)
-    
-    User.using(:brazil).find_by_name("ActionController").should_not be_nil
-    User.using(:master).find_by_name("ActionController").should be_nil
+
+    if Octopus.rails3?
+      a = UsersControllers.new
+      a.stub!(:request).and_return(mock({:fullpath => "", :filtered_parameters => {}, :formats => ["xml"], :method => "GET"}))
+      a.instance_variable_set(:@_response, mock(:content_type => "xml", :body= => "", :status => 401))
+      a.process(:create)
+      User.using(:brazil).find_by_name("ActionController").should_not be_nil
+      User.using(:master).find_by_name("ActionController").should be_nil
+    else
+      pending()
+    end
   end
 end

data/spec/octopus/migration_spec.rb

@@ -32,18 +32,18 @@ describe Octopus::Migration do
 
   it "should run on multiples groups" do
     migrating_to_version 5 do 
-      User.using(:canada).where(:name => "MultipleGroup").all.size.should == 2
-      User.using(:brazil).where(:name => "MultipleGroup").all.size.should == 2
-      User.using(:russia).where(:name => "MultipleGroup").all.size.should == 2
+      User.using(:canada).find(:all, {:conditions => {:name => "MultipleGroup"}}).size.should == 2
+      User.using(:brazil).find(:all, {:conditions => {:name => "MultipleGroup"}}).size.should == 2
+      User.using(:russia).find(:all, {:conditions => {:name => "MultipleGroup"}}).size.should == 2
     end
   end
 
   it "should create users inside block" do
     migrating_to_version 12 do 
-      User.using(:brazil).where(:name => "UsingBlock1").all.size.should == 1
-      User.using(:brazil).where(:name => "UsingBlock2").all.size.should == 1
-      User.using(:canada).where(:name => "UsingCanada").all.size.should == 1
-      User.using(:canada).where(:name => "UsingCanada2").all.size.should == 1
+      User.using(:brazil).find(:all, :conditions => {:name => "UsingBlock1"}).size.should == 1
+      User.using(:brazil).find(:all, :conditions => {:name => "UsingBlock2"}).size.should == 1
+      User.using(:canada).find(:all, :conditions => {:name => "UsingCanada"}).size.should == 1
+      User.using(:canada).find(:all, :conditions => {:name => "UsingCanada2"}).size.should == 1
     end
   end
 
@@ -69,8 +69,8 @@ describe Octopus::Migration do
     it "should run writes on master when you use replication" do
       using_enviroment :production_replicated do 
         migrating_to_version 10 do 
-          Cat.using(:master).where(:name => "Replication").first.should_not be_nil
-          Cat.where(:name => "Replication").first.should be_nil
+          Cat.using(:master).find_by_name("Replication").should_not be_nil
+          Cat.find_by_name("Replication").should be_nil
         end
       end
     end

data/spec/octopus/model_spec.rb

@@ -37,6 +37,11 @@ describe Octopus::Model do
       User.count.should == 1
     end
     
+    it "should work when you have a SQLite3 shard" do
+      u = User.using(:sqlite_shard).create!(:name => "Sqlite3")
+      User.using(:sqlite_shard).find_by_name("Sqlite3").should == u
+    end
+    
     it "should clean #current_shard from proxy when using execute" do
       ActiveRecord::Base.using(:canada).connection().execute("select * from users limit 1;")
       ActiveRecord::Base.connection.current_shard.should == :master
@@ -55,7 +60,7 @@ describe Octopus::Model do
         User.first.should == @user
       end
       
-      User.using(:brazil).where(:name => "Thiago").first.should == @user
+      User.using(:brazil).find_by_name("Thiago").should == @user
     end
 
     it "should clean the current_shard after executing the current query" do
@@ -82,6 +87,7 @@ describe Octopus::Model do
 
       it "should store the attribute when you find multiple instances" do
         5.times { User.using(:alone_shard).create!(:name => "Alone") }
+
         User.using(:alone_shard).all.each do |u|
           u.current_shard.should == :alone_shard
         end
@@ -98,7 +104,7 @@ describe Octopus::Model do
 
       it "should work for the reload method" do
         User.using(:alone_shard).create!(:name => "Alone")
-        u = User.using(:alone_shard).where(:name => "Alone").first
+        u = User.using(:alone_shard).find_by_name("Alone")
         u.reload
         u.name.should == "Alone"
       end
@@ -132,13 +138,15 @@ describe Octopus::Model do
 
   describe "using a postgresql shard" do
     it "should update the Arel Engine" do
-      User.using(:postgresql_shard).arel_engine.connection.adapter_name.should == "PostgreSQL"
-      User.using(:alone_shard).arel_engine.connection.adapter_name.should == "MySQL"
+      if ActiveRecord::VERSION::STRING > '2.4.0'
+        User.using(:postgresql_shard).arel_engine.connection.adapter_name.should == "PostgreSQL"
+        User.using(:alone_shard).arel_engine.connection.adapter_name.should == "MySQL"
+      end
     end
 
     it "should works with writes and reads" do
       u = User.using(:postgresql_shard).create!(:name => "PostgreSQL User")      
-      User.using(:postgresql_shard).all.should == [u]      
+      User.using(:postgresql_shard).find(:all).should == [u]      
       User.using(:alone_shard).find(:all).should == []
     end
   end
@@ -178,14 +186,14 @@ describe Octopus::Model do
       u = User.using(:brazil).create!(:name => "User1")
       u2 = User.using(:brazil).create!(:name => "User2")
       u3 = User.using(:brazil).create!(:name => "User3")
-      User.using(:brazil).where(:name => "User2").count.should == 1
+      User.using(:brazil).find(:all, :conditions => {:name => "User2"}).count.should == 1
     end
 
     it "update_attributes" do
       @user = User.using(:brazil).create!(:name => "User1")
       @user2 = User.using(:brazil).find(@user.id)
       @user2.update_attributes(:name => "Joaquim")  
-      User.using(:brazil).where(:name => "Joaquim").first.should_not be_nil    
+      User.using(:brazil).find_by_name("Joaquim").should_not be_nil    
     end
     
     it "using update_attributes inside a block" do
@@ -195,15 +203,15 @@ describe Octopus::Model do
         @user2.update_attributes(:name => "Joaquim")  
       end
       
-      User.where(:name => "Joaquim").first.should be_nil      
-      User.using(:brazil).where(:name => "Joaquim").first.should_not be_nil
+      User.find_by_name("Joaquim").should be_nil
+      User.using(:brazil).find_by_name("Joaquim").should_not be_nil
     end
 
     it "update_attribute" do
       @user = User.using(:brazil).create!(:name => "User1")
       @user2 = User.using(:brazil).find(@user.id)
       @user2.update_attributes(:name => "Joaquim")  
-      User.using(:brazil).where(:name => "Joaquim").first.should_not be_nil
+      User.using(:brazil).find_by_name("Joaquim").should_not be_nil
     end
     
     it "transaction" do
@@ -213,7 +221,7 @@ describe Octopus::Model do
       User.using(:master).count.should == 1
       
       User.using(:brazil).transaction do
-        User.where(:name => "Thiago").first.should be_nil
+        User.find_by_name("Thiago").should be_nil
         User.create!(:name => "Brazil")
       end
       

data/spec/octopus/proxy_spec.rb

@@ -5,7 +5,7 @@ describe Octopus::Proxy do
   
   describe "creating a new instance" do    
     it "should initialize all shards and groups" do
-      proxy.instance_variable_get(:@shards).keys.to_set.should == [:postgresql_shard, :alone_shard, :aug2011, :canada, :brazil, :aug2009, :russia, :aug2010, :master].to_set
+      proxy.instance_variable_get(:@shards).keys.to_set.should == [:postgresql_shard, :alone_shard, :aug2011, :canada, :brazil, :aug2009, :russia, :aug2010, :master, :sqlite_shard].to_set
       proxy.instance_variable_get(:@groups).should == {:country_shards=>[:canada, :brazil, :russia], :history_shards=>[:aug2009, :aug2010, :aug2011]}
     end
 

data/spec/octopus/scope_proxy_spec.rb

@@ -2,12 +2,14 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Octopus::ScopeProxy do
   it "should allow nested queries" do
-    @user1 = User.using(:brazil).create!(:name => "Thiago P", :number => 3)
-    @user2 = User.using(:brazil).create!(:name => "Thiago", :number => 1)
-    @user3 = User.using(:brazil).create!(:name => "Thiago", :number => 2)
+    if Octopus.rails3?
+      @user1 = User.using(:brazil).create!(:name => "Thiago P", :number => 3)
+      @user2 = User.using(:brazil).create!(:name => "Thiago", :number => 1)
+      @user3 = User.using(:brazil).create!(:name => "Thiago", :number => 2)
     
-    User.using(:brazil).where(:name => "Thiago").where(:number => 4).order(:number).all.should == []
-    User.using(:brazil).where(:name => "Thiago").using(:canada).where(:number => 2).using(:brazil).order(:number).all.should == [@user3]
-    User.using(:brazil).where(:name => "Thiago").using(:canada).where(:number => 4).using(:brazil).order(:number).all.should == []
+      User.using(:brazil).where(:name => "Thiago").where(:number => 4).order(:number).all.should == []
+      User.using(:brazil).where(:name => "Thiago").using(:canada).where(:number => 2).using(:brazil).order(:number).all.should == [@user3]
+      User.using(:brazil).where(:name => "Thiago").using(:canada).where(:number => 4).using(:brazil).order(:number).all.should == []
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,12 @@
+require "rubygems"
 MIGRATIONS_ROOT = File.expand_path(File.join(File.dirname(__FILE__),  'migrations'))
+
+if ENV["VERSION"]
+  gem 'activerecord', ENV["VERSION"]
+  gem 'activesupport', ENV["VERSION"]
+  gem 'actionpack', ENV["VERSION"]
+end
+
 require 'spec'
 require 'spec/autorun'
 require "spec/database_connection"
@@ -6,6 +14,7 @@ require "action_controller"
 require 'octopus'
 require "octopus_helper"
 
+
 Spec::Runner.configure do |config|  
   config.before(:each) do
     Octopus.stub!(:directory).and_return(File.dirname(__FILE__))

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ar-octopus
 version: !ruby/object:Gem::Version 
-  hash: 57
+  hash: 55
   prerelease: false
   segments: 
   - 0
   - 0
-  - 19
-  version: 0.0.19
+  - 20
+  version: 0.0.20
 platform: ruby
 authors: 
 - Thiago Pradi
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-05 00:00:00 -03:00
+date: 2010-07-07 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -70,6 +70,7 @@ files:
 - doc/features.textile
 - doc/libraries.textile
 - doc/shards.yml
+- init.rb
 - lib/octopus.rb
 - lib/octopus/association.rb
 - lib/octopus/association_collection.rb
@@ -77,8 +78,11 @@ files:
 - lib/octopus/has_and_belongs_to_many_association.rb
 - lib/octopus/migration.rb
 - lib/octopus/model.rb
-- lib/octopus/persistence.rb
 - lib/octopus/proxy.rb
+- lib/octopus/rails2/association.rb
+- lib/octopus/rails2/persistence.rb
+- lib/octopus/rails3/association.rb
+- lib/octopus/rails3/persistence.rb
 - lib/octopus/scope_proxy.rb
 - rails/init.rb
 - spec/config/shards.yml

data/lib/octopus/persistence.rb

@@ -1,37 +0,0 @@
-module Octopus::Persistence
-  def reload_connection()
-    set_connection() if should_set_current_shard?
-  end
-
-  def update_attribute(name, value)
-    reload_connection()
-    super(name, value)
-  end
-
-  def update_attributes(attributes)
-    reload_connection()
-    super(attributes)
-  end
-
-  def update_attributes!(attributes)
-    reload_connection()
-    super(attributes)
-  end
-
-  def reload
-    reload_connection()
-    super
-  end
-  
-  def delete
-    reload_connection()
-    super
-  end
-  
-  def destroy
-    reload_connection()
-    super
-  end
-end
-
-ActiveRecord::Base.send(:include, Octopus::Persistence)