rocking_chair 0.2.5 → 0.3.0

data/lib/rocking_chair/view.rb

@@ -59,6 +59,8 @@ module RockingChair
         find_by_attribute(match[1])
       elsif match = view_name.match(/\Aassociation_#{design_document_name}_belongs_to_(\w+)\Z/)
         find_belongs_to(match[1])
+      elsif match = view_name.match(/\Aassociation_#{design_document_name}_has_and_belongs_to_many_(\w+)\Z/)
+        find_has_and_belongs_to_many(match[1])
       else
         raise "Unknown View implementation for view #{view_name.inspect} in design document _design/#{design_document_name}"
       end
@@ -126,6 +128,17 @@ module RockingChair
       filter_deleted_items if options['without_deleted'].to_s == 'true'
       sort_by_attribute('created_at')
     end
+
+    def find_has_and_belongs_to_many(belongs_to)
+      if foreign_keys_are_stored_on_my_class?(belongs_to)
+        filter_items_by_key_in_attribute_group(foreign_key_array_id(belongs_to))
+        filter_items_without_correct_ruby_class
+      else
+        filter_items_by_query_document_attributes(belongs_to)
+      end
+      filter_deleted_items if options['without_deleted'].to_s == 'true'
+      sort_by_attribute('created_at')
+    end
     
     def find_by_attribute(attribute_string)
       attributes = attribute_string.split("_and_")
@@ -148,7 +161,12 @@ module RockingChair
       end
       @view_name = view_name.gsub(/_withoutdeleted\Z/, '').gsub(/_without_deleted\Z/, '').gsub(/_withdeleted\Z/, '').gsub(/_with_deleted\Z/, '')
     end
-    
+
+    def foreign_keys_are_stored_on_my_class?(belongs_to)
+      reduce_function = @view_document['reduce']
+      reduce_function == "_sum"
+    end
+
     def initialize_ruby_store
       @ruby_store = database.storage.dup
       @ruby_store.each{|doc_id, json_document| ruby_store[doc_id] = JSON.parse(json_document, :create_additions => false) }
@@ -188,6 +206,22 @@ module RockingChair
       end
     end
     
+    def filter_items_by_key_in_attribute_group(attribute)
+      filter_key = (options['key'] || options['startkey']).to_s
+      @keys = keys.select do |key|
+        document = ruby_store[key]
+        document_attribute = RockingChair::Helper.access(attribute, document)
+        document_attribute && document_attribute.is_a?(Array) && document_attribute.include?(filter_key)
+      end
+    end
+
+    def filter_items_by_query_document_attributes(belongs_to)
+      filter_key = options['key'] || options['startkey']
+      filtering_document = ruby_store[filter_key.to_s]
+      reverse_foreign_key = foreign_key_array_id(design_document_name)
+      @keys = RockingChair::Helper.access(reverse_foreign_key, filtering_document) || []
+    end
+
     def filter_deleted_items
       @keys = keys.delete_if do |key| 
         document = ruby_store[key]
@@ -258,6 +292,10 @@ module RockingChair
     def foreign_key_id(name)
       name.underscore.gsub('/','__').gsub('::','__') + "_id"
     end
+
+    def foreign_key_array_id(name)
+      name.underscore.singularize.gsub('/','__').gsub('::','__') + "_ids"
+    end
     
     def key_description
       description = {'key' => options['key']}

data/test/fixtures/simply_stored_fixtures.rb

@@ -6,6 +6,7 @@ class User
   property :firstname
   property :lastname
   belongs_to :project
+  has_and_belongs_to_many :groups, :storing_keys => true
   
   enable_soft_delete
   
@@ -33,4 +34,27 @@ class CustomViewUser
   
   property :tags
   view :by_tags, :type => SimplyStored::Couch::Views::ArrayPropertyViewSpec, :key => :tags
+end
+
+class Group
+  include SimplyStored::Couch
+
+  property :name
+  has_and_belongs_to_many :users, :storing_keys => false
+end
+
+class Server
+  include SimplyStored::Couch
+
+  property :hostname
+
+  has_and_belongs_to_many :networks, :storing_keys => true
+end
+
+class Network
+  include SimplyStored::Couch
+
+  property :klass
+
+  has_and_belongs_to_many :servers, :storing_keys => false
 end

data/test/simply_stored_test.rb

@@ -279,6 +279,113 @@ class SimplyStoredTest < Test::Unit::TestCase
       end
     end
     
+    context "when handling n:m relations using has_and_belongs_to_many" do
+      should "work relations from both sides" do
+        network_a = Network.create(:klass => "A")
+        network_b = Network.create(:klass => "B")
+        3.times {
+          server = Server.new
+          server.add_network(network_a)
+          server.add_network(network_b)
+        }
+        assert_equal 3, network_a.servers.size
+        network_a.servers.each do |server|
+          assert_equal 2, server.networks.size
+        end
+        assert_equal 3, network_b.servers.size
+        network_b.servers.each do |server|
+          assert_equal 2, server.networks.size
+        end
+      end
+
+      should "work relations from both sides - regardless from where the add was called" do
+        network_a = Network.create(:klass => "A")
+        network_b = Network.create(:klass => "B")
+        3.times {
+          server = Server.new
+          network_a.add_server(server)
+          network_b.add_server(server)
+        }
+        assert_equal 3, network_a.servers.size
+        network_a.servers.each do |server|
+          assert_equal 2, server.networks.size, server.network_ids.inspect
+        end
+        assert_equal 3, network_b.servers.size
+        network_b.servers.each do |server|
+          assert_equal 2, server.networks.size
+        end
+      end
+
+      should "cound correctly - regardless of the side of the relation" do
+        network_a = Network.create(:klass => "A")
+        network_b = Network.create(:klass => "B")
+        3.times {
+          server = Server.new
+          network_a.add_server(server)
+          network_b.add_server(server)
+        }
+        assert_equal 3, network_a.server_count
+        assert_equal 3, network_b.server_count
+        assert_equal 2, network_a.servers.first.network_count
+        assert_equal 2, network_b.servers.first.network_count
+      end
+
+      should "support mixing order and limit" do
+        network_1 = Network.find(Network.create!(:klass => "A").id)
+        network_1.created_at = Time.local(2001)
+        network_1.save!
+
+        network_2 = Network.find(Network.create!(:klass => "B").id)
+        network_2.created_at = Time.local(2002)
+        network_2.save!
+
+        server_1 = Server.find(Server.create!(:hostname => 'www.example.com').id)
+        server_1.created_at = Time.local(2003)
+        network_1.add_server(server_1)
+        network_2.add_server(server_1)
+
+        server_2 = Server.find(Server.create!(:hostname => 'foo.com').id)
+        server_2.created_at = Time.local(2004)
+        network_1.add_server(server_2)
+        network_2.add_server(server_2)
+
+        assert_equal ['www.example.com', 'foo.com'], network_1.servers(:order => :asc).map(&:hostname)
+        assert_equal ['www.example.com', 'foo.com'].reverse, network_1.servers(:order => :desc).map(&:hostname)
+
+        assert_equal ['A', 'B'], server_2.networks(:order => :asc).map(&:klass)
+        assert_equal ['A', 'B'].reverse, server_2.networks(:order => :desc).map(&:klass)
+
+        assert_equal ['www.example.com'], network_1.servers(:order => :asc, :limit => 1).map(&:hostname)
+        assert_equal ['foo.com'], network_1.servers(:order => :desc, :limit => 1).map(&:hostname)
+
+        assert_equal ['A'], server_2.networks(:order => :asc, :limit => 1).map(&:klass)
+        assert_equal ['B'], server_2.networks(:order => :desc, :limit => 1).map(&:klass)
+      end
+      
+      should "when counting cache the result" do
+        @network = Network.create(:klass => "C")
+        @server = Server.create
+        assert_equal 0, @network.server_count
+        Server.create(:network_ids => [@network.id])
+        assert_equal 0, @network.server_count
+        assert_equal 0, @network.instance_variable_get("@server_count")
+        @network.instance_variable_set("@server_count", nil)
+        assert_equal 1, @network.server_count
+      end
+
+      should "when counting cache the result - from both directions" do
+        @network = Network.create(:klass => "C")
+        @server = Server.create
+        assert_equal 0, @server.network_count
+        @server.network_ids = [@network.id]
+        @server.save!
+        assert_equal 0, @server.network_count
+        assert_equal 0, @server.instance_variable_get("@network_count")
+        @server.instance_variable_set("@network_count", nil)
+        assert_equal 1, @server.network_count
+      end
+    end
+
     context "when deleting all design docs" do
       should "reset all design docs" do
         User.find_all_by_firstname('a')

data/test/view_test.rb

@@ -46,15 +46,19 @@ class ViewTest < Test::Unit::TestCase
             'map' => "function(item){emit(item)}"
           },
           'by_firstname' => {
-            'reduce' => "function(key, values){ return values.length }",
+            'reduce' => "_sum",
             "map" => "function(doc) {\n if(doc.ruby_class && doc.ruby_class == 'Instance') {\n emit(doc['created_at'], null);\n }\n }"
           },
           'by_firstname_and_lastname' => {
-            'reduce' => "function(key, values){ return values.length }",
+            'reduce' => "_sum",
             "map" => "function(doc) {\n if(doc.ruby_class && doc.ruby_class == 'Instance') {\n emit(doc['created_at'], null);\n }\n }"
           },
           'association_user_belongs_to_project' => {
-            'reduce' => "function(key, values){ return values.length }",
+            'reduce' => "_sum",
+            "map" => "function(doc) {\n if(doc.ruby_class && doc.ruby_class == 'Instance') {\n emit(doc['created_at'], null);\n }\n }"
+          },
+          'association_user_has_and_belongs_to_many_groups' => {
+            'reduce' => "_sum",
             "map" => "function(doc) {\n if(doc.ruby_class && doc.ruby_class == 'Instance') {\n emit(doc['created_at'], null);\n }\n }"
           }
         }}
@@ -366,6 +370,80 @@ class ViewTest < Test::Unit::TestCase
         end
       end
       
+      context "has and belongs to many views" do
+        setup do
+          @db['group_1'] = {"name" => 'A', 'ruby_class' => 'Group'}
+          @db['group_2'] = {"name" => 'B', 'ruby_class' => 'Group'}
+          @db['user_1'] = {"group_ids" => ['group_1', 'group_2'], 'firstname' => 'Bert', 'ruby_class' => 'User'}
+          @db['user_2'] = {"group_ids" => ['group_1'], 'firstname' => 'Alf', 'ruby_class' => 'User'}
+          @db['_design/group'] = { 'language' => 'javascript', 'views' => {
+            'all_documents' => {
+              'reduce' => nil,
+              'map' => "function(item){emit(item)}"
+            },
+            'association_group_has_and_belongs_to_many_users' => {
+              'reduce' => "function(key, values){ return values.length }",
+              "map" => "function(doc) {\n if(doc.ruby_class && doc.ruby_class == 'Instance') {\n emit(doc['created_at'], null);\n }\n }"
+            }
+          }}
+        end
+
+        should "return all item not storing keys" do
+          assert_equal(JSON.parse({
+            "total_rows" => 2,
+            "rows" => [
+              {"doc" => {
+                  "_rev" => "the-rev",
+                  "group_ids" => ["group_1","group_2"],
+                  "_id" => "user_1",
+                  "firstname" => "Bert",
+                  "ruby_class" => "User"
+                },
+                "id" => "user_1",
+                "value" => nil,
+                "key" => "group_1"
+              },{
+                "doc" => {
+                  "_rev" => "the-rev",
+                  "group_ids" => ["group_1"],
+                  "_id" => "user_2",
+                  "firstname" => "Alf",
+                  "ruby_class" => "User"
+                },
+                "id" => "user_2",
+                "value" => nil,
+                "key" => "group_1"
+              }],
+              "offset" => 0}.to_json), JSON.parse(@db.view('user', 'association_user_has_and_belongs_to_many_groups', 'key' => "group_1".to_json, 'include_docs' => 'true')))
+        end
+
+        should "return all item storing keys" do
+          assert_equal(JSON.parse({
+            "total_rows" => 2,
+            "rows" => [
+              {"doc" => {
+                  "_rev" => "the-rev",
+                  "_id" => "group_1",
+                  "name" => "A",
+                  "ruby_class" => "Group"
+                },
+                "id" => "group_1",
+                "value" => nil,
+                "key" => "user_1"
+              },{
+                "doc" => {
+                  "_rev" => "the-rev",
+                  "_id" => "group_2",
+                  "name" => "B",
+                  "ruby_class" => "Group"
+                },
+                "id" => "group_2",
+                "value" => nil,
+                "key" => "user_1"
+              }],
+              "offset" => 0}.to_json), JSON.parse(@db.view('group', 'association_group_has_and_belongs_to_many_users', 'key' => "user_1".to_json, 'include_docs' => 'true')))
+        end
+      end
     end
     
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rocking_chair
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 5
-  version: 0.2.5
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Jonathan Weiss
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-30 00:00:00 +02:00
+date: 2011-02-22 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency