tokyo_wrapper 0.1.1 → 0.1.2

data/README.rdoc

@@ -4,9 +4,11 @@
 
   It is extracted from the code I frequently use when using rufus-tokyo to access Tokyo Cabinet. 
 
-  For example, for table, I always add a row with unique id so I always use generate_unique_id method. By wrapping the call to this method, the code that is using the rufus/tokyo doesn't get cluttered. 
+  For example, for table, I always add a row with unique id so I always use generate_unique_id method. 
+  By wrapping the call to this method, the code that is using the rufus/tokyo doesn't get cluttered. 
 
-  rufus-tokyo is "ffi based ruby library to access Tokyo Cabinet and Tokyo Tyrant" by John Mettraux (Copyright (c) 2009-2010, see http://github.com/jmettraux/rufus-tokyo/blob/master/LICENSE.txt).
+  rufus-tokyo is "ffi based ruby library to access Tokyo Cabinet and Tokyo Tyrant" by John Mettraux 
+  (Copyright (c) 2009-2010, see http://github.com/jmettraux/rufus-tokyo/blob/master/LICENSE.txt).
 
 == Required Ruby Gems
 

data/lib/tokyo_wrapper/table.rb

@@ -1,6 +1,9 @@
+require 'tokyo_wrapper/table_methods/associations'
+
 module TokyoWrapper
 
   class Table
+    include TokyoWrapper::TableMethods::Associations
     
     def initialize(table)
       @table = table
@@ -38,19 +41,11 @@ module TokyoWrapper
       else
         false
       end
-    end    
-
-    def add_association_id(id, association_id_name, association_id) 
-      if !@table[id.to_s].nil? && !@table[id.to_s].empty?
-        association_ids_string = @table[id.to_s]["#{association_id_name}s"]
-        unless association_ids_string.split(",").include?(association_id.to_s)
-          @table[id.to_s] = @table[id.to_s].merge({"#{association_id_name}s" => "#{association_ids_string},#{association_id}"})
-        end
-        true
-      else
-        false
-      end      
-    end
+    end   
+    
+    def delete(id)
+      @table.delete(id.to_s)
+    end     
   
     def all
       @table.query

data/lib/tokyo_wrapper/table_methods/associations.rb

@@ -0,0 +1,55 @@
+module TokyoWrapper
+
+  module TableMethods
+  
+    module Associations
+
+      def add_has_many_association_id(id, association_id_name, association_id)
+        if !@table[id.to_s].nil? && !@table[id.to_s].empty?
+          association_ids_string = @table[id.to_s]["#{association_id_name}s"]
+          if association_ids_string.nil?
+            @table[id.to_s] = @table[id.to_s].merge({"#{association_id_name}s" => association_id.to_s})
+          elsif !association_ids_string.split(",").include?(association_id.to_s)
+            @table[id.to_s] = @table[id.to_s].merge({"#{association_id_name}s" => "#{association_ids_string},#{association_id}"})
+          end
+          true
+        else
+          false
+        end      
+      end  
+      
+      def all_by_has_many_association_id(association_id_name, association_id)
+        @table.query do | query | 
+          query.add "#{association_id_name}s", :stror, association_id.to_s
+          query.no_pk
+        end
+      end
+      
+      def set_belongs_to_association_id(id, association_id_name, association_id)
+        if !@table[id.to_s].nil? && !@table[id.to_s].empty?
+          @table[id.to_s] = @table[id.to_s].merge({association_id_name => association_id.to_s})
+          true
+        else
+          false
+        end
+      end   
+      
+      def keys_for_belongs_to_association_id(association_id_name, association_id)
+        table_result_set = @table.query do |query|
+          query.add association_id_name, :equals, association_id.to_s
+          query.no_pk
+        end
+        keys = []
+        table_result_set.each do |row|
+          keys += row.keys
+          keys.uniq!
+        end
+        keys.delete(association_id_name)
+        keys.sort
+      end
+      
+    end
+  
+  end
+
+end

data/spec/tokyo_wrapper/table_methods/associations_spec.rb

@@ -0,0 +1,451 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe TokyoWrapper::TableMethods::Associations do
+  include RufusTokyoMacros
+  
+  before(:each) do
+    @table_file = File.expand_path(File.dirname(__FILE__) + '/../../tokyo_cabinet_files/table.tct')
+    clear_table(@table_file)
+  end
+
+  after(:each) do
+    clear_table(@table_file)
+  end
+  
+  context "has_many associations" do 
+    
+    it "should convert array parameter value to joined comma-separated string" do
+      
+      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) 
+      
+      params_1 = { "name" => "Temp name", "sector_ids" => [2,5,34,8] }
+      
+      write_table.send(:convert_params, params_1).should == { "name" => "Temp name", "sector_ids" => "2,5,34,8" }
+      
+      params_2 = { "name" => "Temp name", "sector_ids" => ["2","5","34","8"] }
+      
+      write_table.send(:convert_params, params_2).should == { "name" => "Temp name", "sector_ids" => "2,5,34,8" }   
+      
+      write_table.close   
+      
+    end
+    
+    it "should add data with has_many association" do
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) 
+      
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes", 
+                     "sector_ids" => ["2","5","34","8"]}
+        id = write_table.add(data_hash)
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+
+        read_table.all.should == [{:pk => id.to_s,
+                                   "street" => "1111 Main", 
+                                   "city" => "Montreal", 
+                                   "notes" => "Some notes", 
+                                   "sector_ids" => "2,5,34,8"}]
+                                      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes", 
+                                       "sector_ids" => "2,5,34,8"}
+      ensure                           
+        read_table.close unless read_table.nil?
+      end                           
+
+    end
+    
+    it "should update data with has_many association" do
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
+      
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes", 
+                     "sector_ids" => ["2","5","34","8"]}
+        id = write_table.add(data_hash)
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+                                      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes", 
+                                       "sector_ids" => "2,5,34,8"}  
+      ensure                           
+        read_table.close unless read_table.nil?
+      end                           
+                                 
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)                             
+                                          
+        result = write_table.update(id, "notes" => "Recently situation has been changed.", "sector_ids" => ["2","5","40","8","12"])
+        result.should be_true
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Recently situation has been changed.", 
+                                       "sector_ids" => "2,5,40,8,12"}  
+      ensure      
+        read_table.close unless read_table.nil?
+      end                                   
+      
+    end
+    
+    it "should add a has_many association id" do
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
+      
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes", 
+                     "sector_ids" => ["2","5","34","8"]}
+        id = write_table.add(data_hash)
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+                                      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes", 
+                                       "sector_ids" => "2,5,34,8"}  
+      ensure                      
+        read_table.close unless read_table.nil?
+      end                           
+        
+      begin                           
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)                            
+                                 
+        result_1 = write_table.add_has_many_association_id(id, "sector_id", 78)
+        result_1.should be_true
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes", 
+                                       "sector_ids" => "2,5,34,8,78"}  
+      ensure        
+        read_table.close unless read_table.nil?
+      end
+                                 
+      begin                           
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)                            
+                                 
+        result_2 = write_table.add_has_many_association_id(id, "sector_id", "3")
+        result_2.should be_true
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes", 
+                                       "sector_ids" => "2,5,34,8,78,3"} 
+      ensure          
+        read_table.close unless read_table.nil?
+      end                                                                       
+      
+    end
+    
+    it "should not add a has_many association id if it's already set" do
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
+      
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes", 
+                     "sector_ids" => ["2","5","34","8"]}
+        id = write_table.add(data_hash)
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+                                      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes", 
+                                       "sector_ids" => "2,5,34,8"} 
+      ensure       
+        read_table.close unless read_table.nil?
+      end                           
+                                 
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)                             
+                                 
+        result_1 = write_table.add_has_many_association_id(id, "sector_id", "8")
+        result_1.should be_true
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes", 
+                                       "sector_ids" => "2,5,34,8"}  
+      ensure          
+        read_table.close unless read_table.nil?
+      end                                                                     
+      
+    end
+    
+    it "should add a has_many association id when no association id is set for the association" do
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
+      
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes"}
+        id = write_table.add(data_hash)
+      
+        result_1 = write_table.add_has_many_association_id(id, "sector_id", "8")
+        result_1.should be_true      
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes", 
+                                       "sector_ids" => "8"}  
+      ensure
+        read_table.close unless read_table.nil?
+      end      
+      
+    end
+    
+    it "should find all the rows with the given has_many association id" do
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
+      
+        data_hash_1 = {"street" => "1111 Main", 
+                       "city" => "Montreal", 
+                       "notes" => "Some notes", 
+                       "sector_ids" => ["2","5","32","8"]}
+        id_1 = write_table.add(data_hash_1)
+        data_hash_2 = {"street" => "1111 Masonneuve", 
+                       "city" => "Montreal", 
+                       "notes" => "Another notes", 
+                       "sector_ids" => ["1","2","3458","9"]}
+        id_2 = write_table.add(data_hash_2) 
+        data_hash_3 = {"street" => "1111 Desjardins", 
+                       "city" => "Quebec", 
+                       "notes" => "Different notes", 
+                       "sector_ids" => ["87","45","1","727"]}
+        id_3 = write_table.add(data_hash_3)                
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+
+        read_table.all_by_has_many_association_id("sector_id", "2").should == [{"street" => "1111 Main", 
+                                                                                "city" => "Montreal", 
+                                                                                "notes" => "Some notes", 
+                                                                                "sector_ids" => "2,5,32,8"}, 
+                                                                               {"street" => "1111 Masonneuve", 
+                                                                                "city" => "Montreal", 
+                                                                                "notes" => "Another notes", 
+                                                                                "sector_ids" => "1,2,3458,9"}]
+        read_table.all_by_has_many_association_id("sector_id", "45").should == [{"street" => "1111 Desjardins", 
+                                                                                 "city" => "Quebec", 
+                                                                                 "notes" => "Different notes", 
+                                                                                 "sector_ids" => "87,45,1,727"}]
+        read_table.all_by_has_many_association_id("sector_id", "3458").should == [{"street" => "1111 Masonneuve", 
+                                                                                   "city" => "Montreal", 
+                                                                                   "notes" => "Another notes", 
+                                                                                   "sector_ids" => "1,2,3458,9"}]                                                                                
+      ensure
+        read_table.close unless read_table.nil?
+      end
+      
+    end
+    
+  end
+  
+  context "belongs_to associations" do
+    
+    it "should set belongs_to association id (integer)" do
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
+      
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes"}
+        id = write_table.add(data_hash)
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+                                      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes"}  
+      ensure                      
+        read_table.close unless read_table.nil?
+      end                           
+        
+      begin                           
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)                            
+                                 
+        result_1 = write_table.set_belongs_to_association_id(id, "register_id", 78)
+        result_1.should be_true
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes", 
+                                       "register_id" => "78"}  
+      ensure        
+        read_table.close unless read_table.nil?
+      end                              
+      
+    end
+    
+    it "should set belongs_to association id (string)" do
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
+      
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes"}
+        id = write_table.add(data_hash)
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+                                      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes"}  
+      ensure                      
+        read_table.close unless read_table.nil?
+      end                           
+        
+      begin                           
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)                            
+                                 
+        result_1 = write_table.set_belongs_to_association_id(id, "register_id", "78")
+        result_1.should be_true
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes", 
+                                       "register_id" => "78"}  
+      ensure        
+        read_table.close unless read_table.nil?
+      end                              
+      
+    end
+    
+    it "should get all the keys for the rows associated with the belongs_to association_id" do
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
+      
+        data_hash_1 = {"street" => "1111 Main", 
+                       "city" => "Montreal", 
+                       "notes" => "Some notes", 
+                       "register_id" => "45"}
+        id_1 = write_table.add(data_hash_1)
+        data_hash_2 = {"city" => "Montreal", 
+                       "province" => "Quebec", 
+                       "notes" => "Another notes", 
+                       "register_id" => "45"}
+        id_2 = write_table.add(data_hash_2)
+        data_hash_3 = {"street" => "1111 Main", 
+                       "city" => "Montreal", 
+                       "country" => "Canada", 
+                       "notes" => "Different notes", 
+                       "register_id" => "45"}
+        id_3 = write_table.add(data_hash_3)        
+        
+      ensure
+        write_table.close unless write_table.nil?
+      end      
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+      
+        read_table.find(id_1).should == {"street" => "1111 Main", 
+                                         "city" => "Montreal", 
+                                         "notes" => "Some notes", 
+                                         "register_id" => "45"}
+        read_table.find(id_2).should == {"city" => "Montreal", 
+                                         "province" => "Quebec", 
+                                         "notes" => "Another notes", 
+                                         "register_id" => "45"}
+        read_table.find(id_3).should == {"street" => "1111 Main", 
+                                         "city" => "Montreal", 
+                                         "country" => "Canada", 
+                                         "notes" => "Different notes", 
+                                         "register_id" => "45"}
+
+        read_table.keys_for_belongs_to_association_id("register_id", "45").should == ["city", "country", "notes", "province", "street"]        
+      ensure
+        read_table.close unless read_table.nil?
+      end            
+      
+    end
+    
+  end
+  
+end

data/spec/tokyo_wrapper/table_spec.rb

@@ -16,27 +16,31 @@ describe TokyoWrapper::Table do
     
     it "should add data" do
       
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
 
-      data_hash = {"street" => "1111 Main", 
-                   "city" => "Montreal", 
-                   "notes" => "Some notes"}
-      id = write_table.add(data_hash)
-      
-      write_table.close
-      
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes"}
+        id = write_table.add(data_hash)
+      ensure
+        write_table.close unless write_table.nil?
+      end
+      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
 
-      read_table.all.should == [{:pk => id.to_s,
-                                 "street" => "1111 Main", 
-                                 "city" => "Montreal", 
-                                 "notes" => "Some notes"}]
+        read_table.all.should == [{:pk => id.to_s,
+                                   "street" => "1111 Main", 
+                                   "city" => "Montreal", 
+                                   "notes" => "Some notes"}]
                                       
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Some notes"} 
-                                 
-      read_table.close                      
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes"} 
+      ensure      
+        read_table.close unless read_table.nil?
+      end           
       
     end
     
@@ -46,219 +50,90 @@ describe TokyoWrapper::Table do
     
     it "should update data" do
       
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) 
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) 
       
-      data_hash = {"street" => "1111 Main", 
-                   "city" => "Montreal", 
-                   "notes" => "Some notes"}
-      id = write_table.add(data_hash)
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes"}
+        id = write_table.add(data_hash)
+      ensure
+        write_table.close unless write_table.nil?
+      end
       
-      write_table.close
-      
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)      
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)      
                                       
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Some notes"}   
-                                 
-      read_table.close
-      
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) 
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes"}   
+      ensure
+        read_table.close unless read_table.nil?
+      end
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) 
                                                          
-      result = write_table.update(id, "notes" => "Recently situation has been changed.")
-      result.should be_true
-      
-      write_table.close
+        result = write_table.update(id, "notes" => "Recently situation has been changed.")
+        result.should be_true
+      ensure
+        write_table.close unless write_table.nil?
+      end
 
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)  
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)  
       
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Recently situation has been changed."}
-                                 
-      read_table.close                                   
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Recently situation has been changed."}
+      ensure
+        read_table.close unless read_table.nil?
+      end                                   
       
     end
     
   end
   
-  context "One-to-many and many-to-many associations" do 
-    
-    it "should convert array parameter value to joined comma-separated string" do
-      
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) 
-      
-      params_1 = { "name" => "Temp name", "sector_ids" => [2,5,34,8] }
-      
-      write_table.send(:convert_params, params_1).should == { "name" => "Temp name", "sector_ids" => "2,5,34,8" }
-      
-      params_2 = { "name" => "Temp name", "sector_ids" => ["2","5","34","8"] }
-      
-      write_table.send(:convert_params, params_2).should == { "name" => "Temp name", "sector_ids" => "2,5,34,8" }   
-      
-      write_table.close   
-      
-    end
+  context "Delete" do
     
-    it "should add data with association" do
-      
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) 
+    it "should delete a row" do
       
-      data_hash = {"street" => "1111 Main", 
-                   "city" => "Montreal", 
-                   "notes" => "Some notes", 
-                   "sector_ids" => ["2","5","34","8"]}
-      id = write_table.add(data_hash)
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) 
       
-      write_table.close
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes"}
+        id = write_table.add(data_hash)
+      ensure
+        write_table.close unless write_table.nil?
+      end
       
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
-
-      read_table.all.should == [{:pk => id.to_s,
-                                 "street" => "1111 Main", 
-                                 "city" => "Montreal", 
-                                 "notes" => "Some notes", 
-                                 "sector_ids" => "2,5,34,8"}]
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)      
                                       
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Some notes", 
-                                     "sector_ids" => "2,5,34,8"}
-                                 
-      read_table.close                           
+        read_table.find(id).should == {"street" => "1111 Main", 
+                                       "city" => "Montreal", 
+                                       "notes" => "Some notes"}   
+      ensure
+        read_table.close unless read_table.nil?
+      end
+      
+      begin
+        write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) 
+                                                         
+        write_table.delete(id)
+      ensure
+        write_table.close unless write_table.nil?
+      end
 
-    end
-    
-    it "should update data with association" do
-      
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
-      
-      data_hash = {"street" => "1111 Main", 
-                   "city" => "Montreal", 
-                   "notes" => "Some notes", 
-                   "sector_ids" => ["2","5","34","8"]}
-      id = write_table.add(data_hash)
-      
-      write_table.close
-      
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
-                                      
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Some notes", 
-                                     "sector_ids" => "2,5,34,8"}  
-                                 
-      read_table.close                             
-                                 
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)                             
-                                          
-      result = write_table.update(id, "notes" => "Recently situation has been changed.", "sector_ids" => ["2","5","40","8","12"])
-      result.should be_true
-      
-      write_table.close
-      
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
-      
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Recently situation has been changed.", 
-                                     "sector_ids" => "2,5,40,8,12"}  
-                              
-      read_table.close                                   
-      
-    end
-    
-    it "should add an association id" do
-      
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
-      
-      data_hash = {"street" => "1111 Main", 
-                   "city" => "Montreal", 
-                   "notes" => "Some notes", 
-                   "sector_ids" => ["2","5","34","8"]}
-      id = write_table.add(data_hash)
-      
-      write_table.close
-      
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
-                                      
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Some notes", 
-                                     "sector_ids" => "2,5,34,8"}  
-                                 
-      read_table.close                           
-                                 
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)                            
-                                 
-      result_1 = write_table.add_association_id(id, "sector_id", 78)
-      result_1.should be_true
-      
-      write_table.close
-      
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
-      
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Some notes", 
-                                     "sector_ids" => "2,5,34,8,78"}  
-                                 
-      read_table.close                           
-                                 
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)                            
-                                 
-      result_2 = write_table.add_association_id(id, "sector_id", "3")
-      result_2.should be_true
-      
-      write_table.close
-      
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
-      
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Some notes", 
-                                     "sector_ids" => "2,5,34,8,78,3"} 
-                                 
-      read_table.close                                                                       
-      
-    end
-    
-    it "should not add an association id if it's already set" do
-      
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)
-      
-      data_hash = {"street" => "1111 Main", 
-                   "city" => "Montreal", 
-                   "notes" => "Some notes", 
-                   "sector_ids" => ["2","5","34","8"]}
-      id = write_table.add(data_hash)
-      
-      write_table.close
-      
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
-                                      
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Some notes", 
-                                     "sector_ids" => "2,5,34,8"} 
-                                 
-      read_table.close                           
-                                 
-      write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file)                             
-                                 
-      result_1 = write_table.add_association_id(id, "sector_id", "8")
-      result_1.should be_true
-      
-      write_table.close
-      
-      read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)
+      begin
+        read_table = TokyoWrapper::Table.create_with_read_non_locking(@table_file)  
       
-      read_table.find(id).should == {"street" => "1111 Main", 
-                                     "city" => "Montreal", 
-                                     "notes" => "Some notes", 
-                                     "sector_ids" => "2,5,34,8"}  
-                                 
-      read_table.close                                                                     
+        read_table.find(id).should be_nil
+      ensure
+        read_table.close unless read_table.nil?
+      end         
       
     end
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tokyo_wrapper
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Tadatoshi Takahashi
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-20 00:00:00 -05:00
+date: 2010-01-23 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -25,12 +25,14 @@ extra_rdoc_files:
 files: 
 - init.rb
 - lib/tokyo_wrapper/table.rb
+- lib/tokyo_wrapper/table_methods/associations.rb
 - lib/tokyo_wrapper.rb
 - Rakefile
 - README.rdoc
 - spec/macros/rufus_tokyo_macros.rb
 - spec/spec_helper.rb
 - spec/tokyo_cabinet_files/table.tct
+- spec/tokyo_wrapper/table_methods/associations_spec.rb
 - spec/tokyo_wrapper/table_spec.rb
 has_rdoc: true
 homepage: http://github.com/tadatoshi/tokyo_wrapper