beezwax 0.6.0 → 0.6.1

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.6.1

data/beezwax.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{beezwax}
-  s.version = "0.6.0"
+  s.version = "0.6.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Patrick Lardin"]
-  s.date = %q{2010-12-19}
+  s.date = %q{2010-12-20}
   s.description = %q{Access Btrieve database files through a ruby API.}
   s.email = %q{plardin@gmail.com}
   s.extra_rdoc_files = [

data/lib/btrieve/btrieve_const.rb

@@ -18,13 +18,18 @@ module BtrCodes
   BEGIN_TRANSACTION = 19
   END_TRANSACTION = 20
   ABORT_TRANSACTION = 21
+  GET_POSITION = 22
+  GET_DIRECT = 23
   STEP_NEXT = 24
   STOP = 25
   RESET = 28
   GET_EQUAL_KEY = 55
   GET_NEXT_KEY = 56
   POS_BLOCK_SIZE = 128
+  RECORD_POSITION_SIZE = 4
   NULL_KEY = 0x00
+  NO_LOGICAL_CURRENCY_KEY = -1
+  SYSTEM_LOG_KEY = 125
   NULL_BUFFER = ''
   NORMAL_MODE = 0x00
   ACCELERATED_MODE = 0xFF

data/lib/btrieve/btrieve_core.rb

@@ -32,7 +32,7 @@ module Btrieve
 
   # Utility method to create a buffer of a given size.
   def self.create_string_buffer(size)
-    0.chr*(size)
+    (0.chr*(size)).force_encoding("ASCII-8BIT")
   end    
 end
 

data/lib/btrieve/btrieve_record.rb

@@ -4,26 +4,36 @@ require 'digest/md5'
 class BtrieveRecord
   include Btrieve
   attr_reader :data_buffer, :btrieve_table
+  attr_accessor :position
 
   # Initializes a btrieve record.  
   def initialize(btrieve_table, data_buffer=nil)
     @btrieve_table = btrieve_table
     @data_buffer = data_buffer.nil? ? Btrieve.create_string_buffer(@btrieve_table.schema[:record_size]) : data_buffer
+    reset_physical_position
   end
 
   # Inserts a new btrieve record through the transactional BTR engine.
   def insert
-    btr_op(@btrieve_table.session, INSERT, @btrieve_table.pos_buffer, @data_buffer, NULL_BUFFER, NO_CURRENCY_CHANGE)
+    btr_op(INSERT, @btrieve_table.pos_buffer, @data_buffer, NULL_BUFFER, SYSTEM_LOG_KEY)
+    set_physical_position
   end
 
   # Updates an existing btrieve record through the transactional BTR engine.
   def update
-    btr_op(@btrieve_table.session, UPDATE, @btrieve_table.pos_buffer, @data_buffer, NULL_BUFFER, NO_CURRENCY_CHANGE)
+    new_state="#{@data_buffer}"
+    @data_buffer[0..3]=@position
+    btr_op(GET_DIRECT, @btrieve_table.pos_buffer, @data_buffer, NULL_BUFFER, SYSTEM_LOG_KEY) 
+    btr_op(UPDATE, @btrieve_table.pos_buffer, new_state, NULL_BUFFER, SYSTEM_LOG_KEY)
+    set_physical_position
   end
   
   # Deletes an existing btrieve record through the transactional BTR engine.
   def delete
-    btr_op(@btrieve_table.session, DELETE, @btrieve_table.pos_buffer, NULL_BUFFER, NULL_BUFFER, NULL_KEY)
+    @data_buffer[0..3]=@position
+    btr_op(GET_DIRECT, @btrieve_table.pos_buffer, @data_buffer, NULL_BUFFER, SYSTEM_LOG_KEY)  
+    btr_op(DELETE, @btrieve_table.pos_buffer, NULL_BUFFER, NULL_BUFFER, NULL_KEY)
+    reset_physical_position
   end
 
   # Returns hash of column-value pairs for this btrieve record, given an array of named columns. 
@@ -34,6 +44,11 @@ class BtrieveRecord
     end 
     column_names.inject({}){|vals, key| vals[key]=self[key]; vals}
   end
+  
+  # Sets the column valuesof this record based on the values passed through the 'column_values' map.
+  def values=(column_values)
+    column_values.each{ |key, value| self[key]=value }
+  end
 
   # Returns this record's primary key value. Supports composite keys.
   def primary_key()
@@ -44,38 +59,53 @@ class BtrieveRecord
   def [](key_name)
     column_info = get_column_info(key_name)
     return nil if(column_info.nil?)
-    @data_buffer.unpack(column_info[:unpacker])[0]
+    val = @data_buffer.unpack(column_info[:unpacker])[0]  
+    val = val.strip if val.respond_to?('strip')
+    val
   end
   
   # Sets this record's value for a particular column.
   def []=(key_name, value)
-    schema_key = get_schema_key(key_name)
+    schema_key = get_column_info(key_name)
     packer_string = schema_key[:unpacker]
     match = packer_string.match(/@(\d+)([a-zA-Z]+)(\d*)/)
     offset = match[1].to_i
     datatype = match[2]
-    thesizeof = BtrieveSchema.sizeof(datatype)
+    thesizeof = BtrieveSchema::SIZEOF[datatype]
     thesizeof *= match[3].empty? ? 1 : match[3].to_i
     packer = "#{datatype}#{thesizeof}"
     array = [value]
     packed_value = array.pack(packer)
     range = (offset..offset+packed_value.size-1)
-    @data_buffer[range] = packed_value
+    data_buffer[range] = packed_value
   end
   
+  # Determines if a record is nil.
   def nil?()
-    data_buffer.gsub("\x00", "").size==0
+    @data_buffer.gsub("\x00", "").size==0
   end
   
   # Returns a string representation of this record.
   def to_s()
-    @btrieve_table.schema[:columns].keys.inject(''){|pretty_print, key| pretty_print = "#{pretty_print} #{key}=>#{self[key]}"; pretty_print}
+    @btrieve_table.schema[:columns].keys.inject("[position=>'#{position.unpack('i')[0]}'"){|pretty_print, key| pretty_print << ", #{key}=>'#{self[key]}'"; pretty_print } << "]"
   end
 
   # Returns this record's version as a MD5 Digest value. 
   def version()
     Digest::MD5.hexdigest(@data_buffer)
   end
+  
+  # TODO - documentation
+  def set_physical_position
+    reset_physical_position
+    btr_op(GET_POSITION, @btrieve_table.pos_buffer, @position, NULL_BUFFER, NULL_KEY)
+    self
+  end
+  
+  # TODO - documentation
+  def reset_physical_position
+    @position = Btrieve.create_string_buffer(RECORD_POSITION_SIZE)
+  end
 
   private
 

data/lib/btrieve/btrieve_session.rb

@@ -28,20 +28,40 @@ class BtrieveSession
     @@instance=nil
   end
 
-  # Executes a block of BTR directive in a transaction. 
+  # Wraps and executes the block passed in inside a transaction.
+  # The transaction is aborted if the block raises an exception.
   def BtrieveSession.transaction(&block)
     begin
-      @@instance.btr_op(BEGIN_TRANSACTION, NULL_BUFFER, NULL_BUFFER, NULL_BUFFER, NULL_KEY)
+      begin_transaction
       yield
+      end_transaction
     rescue Exception => exception
       # Oops! We must roll back the whole shebang!
-      @@instance.btr_op(ABORT_TRANSACTION, NULL_BUFFER, NULL_BUFFER, NULL_BUFFER, NULL_KEY)
+      abort_transaction
       raise "PSQL TX ABORTED!!! - #{exception.message}\n#{exception.backtrace.join("\n\t")}"
-    ensure
-      @@instance.btr_op(END_TRANSACTION, NULL_BUFFER, NULL_BUFFER, NULL_BUFFER, NULL_KEY)
     end
   end
   
+  # Delineates the begining of a transaction boundary. If a client calls this method explicitely, 
+  # the client also has the responsibility of explicitely ending the transaction once done, 
+  # or abort the transaction if things did not go well.
+  def BtrieveSession.begin_transaction()
+    @@instance.btr_op(BEGIN_TRANSACTION, NULL_BUFFER, NULL_BUFFER, NULL_BUFFER, NULL_KEY)
+  end
+  
+  # Delineates the end of a transaction boundary. The client has the responsibility of calling this method
+  # when a transaction was started _without_ a block. 
+  def BtrieveSession.end_transaction()
+    @@instance.btr_op(END_TRANSACTION, NULL_BUFFER, NULL_BUFFER, NULL_BUFFER, NULL_KEY)
+  end
+  
+  # Aborts a transaction when something goes wrong. The client has the responsibility of calling this method
+  # when a transaction was started _without_ a block AND some unexpected event occured and the client wants
+  # to prevent any changes to the persistence to be commited. 
+  def BtrieveSession.abort_transaction()
+    @@instance.btr_op(ABORT_TRANSACTION, NULL_BUFFER, NULL_BUFFER, NULL_BUFFER, NULL_KEY)
+  end
+  
   def set_schema(schema)
     @btrieve_schema=schema
   end

data/lib/btrieve/btrieve_table.rb

@@ -47,6 +47,8 @@ class BtrieveTable
   # Finds an array of records in this table, using the specified index number, a key and a range of values.
   # If a block is passed in, the entries of this set are passed into this block one by one. Otherwise,
   # the set is returned to the caller. 
+  # WARNING - NO UNIT TEST EXIST!
+  # TODO - Add a unit test for this method. 
   def find_in_range(index_num, key, range, &block)
     index = @schema[:indices][index_num]
     columns = @schema[:columns]
@@ -80,6 +82,7 @@ class BtrieveTable
   # Closes this btrieve table to conclude a sequence of BTR operation(s). 
   def close
     btr_op(CLOSE, @pos_buffer, NULL_BUFFER, NULL_BUFFER, NULL_KEY)
+    @pos_buffer=Btrieve.create_string_buffer(POS_BLOCK_SIZE)
   end
 
   # Loops over the records of this BTR table and passes each record to the block passed in.
@@ -151,8 +154,11 @@ class BtrieveTable
   def find_in_unique_index(match, index_number=nil)
     finder(match, index_number) do |key_buffer, index|
       btr_record = BtrieveRecord.new(self)
-      batch(){ btr_op(GET_EQUAL, @pos_buffer, btr_record.data_buffer, key_buffer, index, [KEY_NOT_FOUND, OK, EOF]) }
-      btr_record.nil? ? nil : btr_record
+      open
+      btr_op(GET_EQUAL, @pos_buffer, btr_record.data_buffer, key_buffer, index, [KEY_NOT_FOUND, OK, EOF])
+      btr_record = btr_record.nil? ? nil : btr_record.set_physical_position
+      close
+      btr_record
     end
   end
 
@@ -170,7 +176,7 @@ class BtrieveTable
           ops_result = btr_op(ops, @pos_buffer, btr_record.data_buffer, key_buffer, index, [OK, EOF])
           break if(key_buffer!=org_key_buffer)
           ops=GET_NEXT
-          result << btr_record if(ops_result == OK)
+          result << btr_record.set_physical_position if(ops_result == OK)
         end
       end
       result
@@ -182,6 +188,6 @@ class BtrieveTable
     raise "Cannot manipulate a BtrieveTable when no BtrieveSession exists." if s.nil?
     s
   end
-    
+  
 end
 

data/test/btrieve/test_beezwax.rb

@@ -15,22 +15,50 @@ class TestBeezwax < Test::Unit::TestCase
     end
  
     should "return a handle to the session singleton" do
-      session=BtrieveSession.get_session
+      session=nil
+      assert_nothing_raised{session=BtrieveSession.get_session}
       assert_not_nil session 
     end
     
     should "permit the instanciation of a DB table" do
-      table=BtrieveTable.new(:course)
+      table=nil
+      assert_nothing_raised{table=BtrieveTable.new(:course)}
       assert_not_nil table
     end
     
+    should "permit the instanciation of multiple instances for the same DB table" do
+      table0 = table1 = nil
+      assert_nothing_raised do
+        table0=BtrieveTable.new(:course)
+        table1=BtrieveTable.new(:course)
+      end
+      assert_not_nil table0
+      assert_not_nil table1
+    end
+    
     should "allow an empty transaction to go through" do
-      BtrieveSession.transaction{}
+      assert_nothing_raised{BtrieveSession.transaction{}}
+    end
+    
+    should "allow an empty transaction to go through, with explicit boundaries" do
+      assert_nothing_raised do
+        BtrieveSession.begin_transaction
+        BtrieveSession.end_transaction
+      end
+    end
+    
+    should "allow a transaction to be aborted" do
+      assert_nothing_raised do
+        BtrieveSession.begin_transaction
+        BtrieveSession.abort_transaction
+      end
+      assert_raise(RuntimeError){BtrieveSession.end_transaction}
     end
     
     context "and an instance of BtrieveTable is created, it" do
       setup do
         @table=BtrieveTable.new(:course)
+        @table.primary_key = [:name]
       end
       
       teardown do
@@ -38,17 +66,18 @@ class TestBeezwax < Test::Unit::TestCase
       end
     
       should "be possible to open it for operations, then close it" do
-        assert_nothing_raised(RuntimeError){@table.open}
-        assert_nothing_raised(RuntimeError){@table.close}
+        assert_nothing_raised{ @table.open }
+        assert_nothing_raised{ @table.close }
       end
       
       should "be possible to have the file automatically closed when a block is passed when opening a table" do
-        @table.open{}
-        assert_raise(RuntimeError){@table.close}
+        assert_nothing_raised{ @table.open{} }
+        assert_raise(RuntimeError){ @table.close }
       end
       
       should "return a version number for that table" do
-        table_version=@table.version
+        table_version=nil
+        assert_nothing_raised{ table_version=@table.version }
         assert_not_nil table_version
         assert_equal 32, table_version.size
       end  
@@ -65,16 +94,13 @@ class TestBeezwax < Test::Unit::TestCase
       
       should "be possible to find a particular record in a unique index" do
         name = 'PHI 101'
-        record=@table.find({:name=>name}, 0).first
+        record = nil
+        record_name = nil
+        assert_nothing_raised{record=@table.find({:name=>name}, 0).first}
         assert_not_nil record
-        assert_equal record[:name], name
-      end
-      
-      should "be possible to fetch a particular record and all its columns should be properly set" do
-        name = 'PHI 101'
-        record=@table.find({:name=>name}, 0).first
-        expected_values={:name=>name, :description=>'Introduction to Ethics', :credit_hours=>3, :dept_name=>'Philosophy'}
-        assert_equal expected_values, record.values
+        assert_nothing_raised{record_name=record[:name]}
+        assert_not_nil record_name 
+        assert_equal record_name, name
       end
       
       should "be possible to search for a unique key that doesn't exist and not cause an exception" do
@@ -96,9 +122,7 @@ class TestBeezwax < Test::Unit::TestCase
       should "support finding records and looping over them if a block is passed in" do
         dept_name = 'Mathematics'
         counter = 0 
-        @table.find({:dept_name=>dept_name}, 1) do
-          counter += 1
-        end
+        assert_nothing_raised{@table.find({:dept_name=>dept_name}, 1){counter += 1}}
         assert_equal 9, counter
       end
       
@@ -108,9 +132,125 @@ class TestBeezwax < Test::Unit::TestCase
         assert_not_nil records
         assert records.empty?, "records is NOT empty"
       end
-     
-     
-    end
+      
+      context "and an instance of BtrieveRecord is fetched, it" do
+        setup do
+          @name = 'PHI 101'
+          @record=@table.find({:name=>@name}, 0).first
+        end
+        
+        teardown do
+          @record=nil
+        end
+        
+        should "be possible to get the record's primary key" do
+          expected_value = {:name=>@name}
+          pk = nil
+          assert_nothing_raised{ pk = @record.primary_key }
+          assert_not_nil pk
+          assert_equal expected_value, pk
+        end
+        
+        should "be possible retrieve all its columns" do
+          expected_values={:name=>@name, :description=>'Introduction to Ethics', :credit_hours=>3, :dept_name=>'Philosophy'}
+          values = nil
+          assert_nothing_raised{ values = @record.values }
+          assert_not_nil values
+          assert_equal expected_values, values
+        end
+        
+        should "be possible retrieve a subset of its columns" do
+          expected_values={:description=>'Introduction to Ethics', :credit_hours=>3}
+          values = nil
+          assert_nothing_raised{ values = @record.values([:description, :credit_hours]) }
+          assert_not_nil values
+          assert_equal expected_values, values
+        end
+      end
+      
+      context "for a BtrieveRecord to be created, it" do
+        setup do
+          @values={:name=>'FRA 303', :description=>'Francais Avance', :credit_hours=>3, :dept_name=>"Latin".force_encoding("ASCII-8BIT")}
+          @rb_values={:name=>'FRE 303', :description=>'Frenceis Evence', :credit_hours=>3, :dept_name=>'Latin'}
+        end
+        
+        teardown do
+          # meh
+        end
+
+        should "be able to create a persistent entry in a transaction, but then rollback and not commit anything" do
+          BtrieveSession.begin_transaction
+          assert_nothing_raised do
+            @table.open do
+              record=BtrieveRecord.new(@table)
+              record.values=@rb_values
+              record.insert
+            end
+          end
+          new_record = nil
+          new_values = nil
+          assert_nothing_raised{ new_record = @table.find({:name=>'FRE 303'}, 0).first }
+          assert_not_nil new_record
+          assert_nothing_raised { new_values = new_record.values }
+          assert_not_nil new_values
+          assert !new_values.empty?
+          assert_equal @rb_values, new_values
+          BtrieveSession.abort_transaction
+          post_rollback=nil
+          assert_nothing_raised{ post_rollback = @table.find({:name=>'FRE 303'}, 0) }
+          assert_not_nil post_rollback
+          assert post_rollback.empty?
+        end
+
+        should "be to persist a record, find it, change it and then delete it" do
+          BtrieveSession.transaction do
+            assert_nothing_raised do
+              @table.open do
+                record=BtrieveRecord.new(@table)
+                record.values=@values
+                record.insert
+              end
+            end
+          end
+          new_record = nil
+          new_values = nil
+          assert_nothing_raised{ new_record = @table.find({:name=>'FRA 303'}, 0).first }
+          assert_not_nil new_record
+          assert_nothing_raised { new_values = new_record.values }
+          assert_not_nil new_values
+          assert !new_values.empty?
+          assert_equal @values, new_values
+          updated_dept = 'D.M.V.'
+          BtrieveSession.transaction do
+            assert_nothing_raised do
+              @table.open do
+                buffer_length=new_record.data_buffer.size
+                new_record[:dept_name]=updated_dept
+                assert_equal buffer_length, new_record.data_buffer.size
+                new_record.update
+                assert_equal buffer_length, new_record.data_buffer.size
+                str = nil
+                assert_nothing_raised{ str = new_record.to_s }
+                assert str.size > 0
+              end
+            end
+          end        
+          assert_nothing_raised{ new_record = @table.find({:name=>'FRA 303'}, 0).first }
+          assert_not_nil new_record
+          assert_nothing_raised { new_values = new_record.values }
+          assert_not_nil new_values
+          assert !new_values.empty?
+          assert_equal updated_dept, new_values[:dept_name]
+          BtrieveSession.transaction do
+            assert_nothing_raised do
+              @table.open{new_record.delete}
+            end
+          end
+          assert_nothing_raised{ new_record = @table.find({:name=>'FRA 303'}, 0).first }
+          assert_nil new_record
+        end
+      end
+    end    
   end
   
   context "A destroyed BtrieveSession" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 6
-  - 0
-  version: 0.6.0
+  - 1
+  version: 0.6.1
 platform: ruby
 authors: 
 - Patrick Lardin
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-19 00:00:00 -08:00
+date: 2010-12-20 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency