tokyo_wrapper 0.1.8 → 0.1.9

data/README.rdoc

@@ -76,16 +76,29 @@
              Use when table file already exists and you want to read data from it. 
              It doesn't lock the table. 
 
-    2-2. Table object must be closed when all the operations are done by calling close method. 
+    2-2. Closing table. 
 
-         e.g. 
+      2-2-1. Table object must be closed when all the operations are done by calling close method. 
 
-           begin
-             write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock("table.txt")
+           e.g. 
+
+             begin
+               write_table = TokyoWrapper::Table.create_with_create_write_non_blocking_lock("table.txt")
   
-           ensure
-             write_table.close unless write_table.nil?
-           end
+             ensure
+               write_table.close unless write_table.nil?
+             end
+  
+      2-2-2. Alternatively, you can pass a block with the operations to a create method. 
+             It is ensured that the table is closed. 
+             The return value is the return value from the block.
+
+           e.g. This acts same as the example for 2-2-1. above 
+              except that the return value is the last value in the block.
+
+             TokyoWrapper::Table.create_with_create_write_non_blocking_lock("table.txt") do |write_table|
+
+             end
 
     2-3. Basic operations. (Defined in TokyoWrapper::Table class itself.)
 
@@ -109,6 +122,17 @@
              ensure
                write_table.close unless write_table.nil?
              end        
+
+           e.g. This acts exactly same as the example above.
+
+             id = TokyoWrapper::Table.create_with_create_write_non_blocking_lock("table.txt") do |write_table|
+
+               data_hash = {"street" => "1111 Main", 
+                            "city" => "Montreal", 
+                            "notes" => "Some notes"}
+               write_table.add(data_hash)
+
+             end        
   
       2-3-2. Updating data. 
 

data/lib/tokyo_wrapper/table.rb

@@ -13,21 +13,34 @@ module TokyoWrapper
       @table = table
     end
   
-    def self.create_with_create_write_non_blocking_lock(file)
-      table = Rufus::Tokyo::Table.new(File.expand_path(file), :mode => "cwf")
-      self.new(table)
+    def self.create_with_create_write_non_blocking_lock(file, &block)
+      create(file, "cwf", &block)
     end  
   
-    def self.create_with_write_non_blocking_lock(file)
-      table = Rufus::Tokyo::Table.new(File.expand_path(file), :mode => "wf")
-      self.new(table)
+    def self.create_with_write_non_blocking_lock(file, &block)
+      create(file, "wf", &block)
     end
   
-    def self.create_with_read_non_locking(file)
-      table = Rufus::Tokyo::Table.new(File.expand_path(file), :mode => "re")
-      self.new(table)
+    def self.create_with_read_non_locking(file, &block)
+      create(file, "re", &block)
     end
 
+    def self.create(file, mode, &block)
+      if block_given?
+        begin
+          table = Rufus::Tokyo::Table.new(File.expand_path(file), :mode => mode)
+          return_value_from_block = block.call(new(table))
+        ensure
+          table.close unless table.nil?
+        end
+        return_value_from_block
+      else
+        new(Rufus::Tokyo::Table.new(File.expand_path(file), :mode => mode))
+      end
+    end
+
+    private_class_method :new, :create    
+
     def close
       @table.close
     end  

data/spec/tokyo_wrapper/table_spec.rb

@@ -338,4 +338,33 @@ describe TokyoWrapper::Table do
     
   end
   
+  context "Taking care of closing table after the given block is executed" do
+    
+    it "should add data by providing the code to do so in the block" do
+      
+      id = TokyoWrapper::Table.create_with_create_write_non_blocking_lock(@table_file) do |write_table|
+        
+        data_hash = {"street" => "1111 Main", 
+                     "city" => "Montreal", 
+                     "notes" => "Some notes"}
+        write_table.add(data_hash)
+        
+      end
+      
+      TokyoWrapper::Table.create_with_read_non_locking(@table_file) do |read_table|
+
+        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"} 
+                                       
+      end           
+      
+    end    
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tokyo_wrapper
 version: !ruby/object:Gem::Version 
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors: 
 - Tadatoshi Takahashi
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-05 00:00:00 -05:00
+date: 2010-02-20 00:00:00 -05:00
 default_executable: 
 dependencies: []