dbf 0.5.4 → 1.0.0

data/History.txt

@@ -1,3 +1,7 @@
+== 0.5.4
+
+* Ignore deleted records in both memory modes
+
 == 0.5.3
 
 * Added a standalone dbf utility (try dbf -h for help)

data/Manifest.txt

@@ -1,4 +1,3 @@
-.DS_Store
 History.txt
 Manifest.txt
 README.txt
@@ -7,12 +6,10 @@ benchmarks/performance.rb
 benchmarks/seek_benchmark.rb
 bin/dbf
 lib/dbf.rb
-lib/dbf/field.rb
+lib/dbf/column.rb
 lib/dbf/globals.rb
-lib/dbf/reader.rb
 lib/dbf/record.rb
-spec/.DS_Store
-spec/fixtures/.DS_Store
+lib/dbf/table.rb
 spec/fixtures/dbase_03.dbf
 spec/fixtures/dbase_30.dbf
 spec/fixtures/dbase_30.fpt
@@ -30,6 +27,6 @@ spec/functional/format_83_spec.rb
 spec/functional/format_8b_spec.rb
 spec/functional/format_f5_spec.rb
 spec/spec_helper.rb
-spec/unit/field_spec.rb
-spec/unit/reader_spec.rb
+spec/unit/column_spec.rb
 spec/unit/record_spec.rb
+spec/unit/table_spec.rb

data/README.txt

@@ -29,30 +29,33 @@ Copyright (c) 2006-2007 Keith Morrison <keithm@infused.org, www.infused.org>
   require 'rubygems'
   require 'dbf'
 
-  reader = DBF::Reader.new("old_data.dbf")
+  table = DBF::Table.new("old_data.dbf")
   
   # Print the 'name' field from record number 4
-  puts reader.record(4)['name'] 
+  puts table.record(4).name
+
+	# Attributes can also be accessed using the column name as a Hash key
+	puts table.record(4)["name"]
   
   # Print the 'name' and 'address' fields from each record
-  reader.records.each do |record|
-    puts record['name']
-    puts record['email']
+  table.records.each do |record|
+    puts record.name
+    puts record.email
   end
 
   # Find records
-  reader.find :all, :first_name => 'Keith'
-  reader.find :all, :first_name => 'Keith', :last_name => 'Morrison'
-  reader.find :first, :first_name => 'Keith'
-  reader.find(10)
+  table.find :all, :first_name => 'Keith'
+  table.find :all, :first_name => 'Keith', :last_name => 'Morrison'
+  table.find :first, :first_name => 'Keith'
+  table.find(10)
   
 == Large databases
 
-DBF::Reader defaults to loading all records into memory. This may not be what
+DBF::Table defaults to loading all records into memory. This may not be what
 you want, especially if the database is large. To disable this behavior, set
 the in_memory option to false during initialization.
 
-  reader = DBF::Reader.new("old_data.dbf", :in_memory => false)
+  table = DBF::Table.new("old_data.dbf", :in_memory => false)
 
 == Command-line utility
 
@@ -66,8 +69,8 @@ A small command-line utility called dbf is installed along with the gem.
   
 == Limitations and known bugs
   
-* DBF is read-only at the moment
-* Index files are not utilized
+* DBF is read-only
+* Index files are not used
 
 == License
 

data/Rakefile

@@ -2,7 +2,7 @@ require 'hoe'
 require 'spec/rake/spectask'
 
 PKG_NAME = "dbf"
-PKG_VERSION = "0.5.4"
+PKG_VERSION = "1.0.0"
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 Hoe.new PKG_NAME, PKG_VERSION do |p|

data/bin/dbf

@@ -33,7 +33,7 @@ else
     puts "\nFields:"
     puts "Name             Type       Length     Decimal"
     puts "-" * 78
-    reader.fields.each do |f|
+    reader.columns.each do |f|
       puts "%-16s %-10s %-10s %-10s" % [f.name, f.type, f.length, f.decimal]
     end
   end

data/lib/dbf.rb

@@ -2,5 +2,5 @@ require 'date'
 
 require 'dbf/globals'
 require 'dbf/record'
-require 'dbf/field'
-require 'dbf/reader'
+require 'dbf/column'
+require 'dbf/table'

data/lib/dbf/{field.rb → column.rb}

@@ -1,11 +1,11 @@
 module DBF
-  class FieldLengthError < DBFError; end
+  class ColumnLengthError < DBFError; end
   
-  class Field
+  class Column
     attr_reader :name, :type, :length, :decimal
 
     def initialize(name, type, length, decimal)
-      raise FieldLengthError, "field length must be greater than 0" unless length > 0
+      raise ColumnLengthError, "field length must be greater than 0" unless length > 0
       @name, @type, @length, @decimal = name.gsub(/\0/, ''), type, length, decimal
     end
   end

data/lib/dbf/record.rb

@@ -1,71 +1,102 @@
 module DBF
-  class Record < Hash
-    def initialize(reader, data_file, memo_file)
-      @reader, @data_file, @memo_file = reader, data_file, memo_file
-      reader.fields.each do |field| 
-        case field.type
+  class Record
+    attr_reader :attributes
+    
+    @@accessors_defined = false
+    
+    def initialize(table)
+      @table, @data, @memo = table, table.data, table.memo
+      @attributes = {}
+      initialize_values(table.columns)
+      define_accessors
+      self
+    end
+    
+    private
+    
+    def define_accessors
+      return if @@accessors_defined
+      @table.columns.each do |column|
+        underscored_column_name = underscore(column.name)
+        if @table.options[:accessors] && !respond_to?(underscored_column_name)
+          self.class.send :define_method, underscored_column_name do
+            @attributes[column.name]
+          end
+          @@accessors_defined = true
+        end
+      end
+    end
+    
+    def initialize_values(columns)
+      columns.each do |column|
+        case column.type
         when 'N' # number
-          self[field.name] = field.decimal == 0 ? unpack_string(field).to_i : unpack_string(field).to_f
+          @attributes[column.name] = column.decimal.zero? ? unpack_string(column).to_i : unpack_string(column).to_f
         when 'D' # date
-          raw = unpack_string(field).strip
+          raw = unpack_string(column).strip
           unless raw.empty?
             begin
-              self[field.name] = Time.gm(*raw.match(DATE_REGEXP).to_a.slice(1,3).map {|n| n.to_i})
+              @attributes[column.name] = Time.gm(*raw.match(DATE_REGEXP).to_a.slice(1,3).map {|n| n.to_i})
             rescue
-              self[field.name] = Date.new(*raw.match(DATE_REGEXP).to_a.slice(1,3).map {|n| n.to_i})
+              @attributes[column.name] = Date.new(*raw.match(DATE_REGEXP).to_a.slice(1,3).map {|n| n.to_i})
             end
           end
         when 'M' # memo
-          starting_block = unpack_string(field).to_i
-          self[field.name] = read_memo(starting_block)
+          starting_block = unpack_string(column).to_i
+          @attributes[column.name] = read_memo(starting_block)
         when 'L' # logical
-          self[field.name] = unpack_string(field) =~ /^(y|t)$/i ? true : false
+          @attributes[column.name] = unpack_string(column) =~ /^(y|t)$/i ? true : false
         else
-          self[field.name] = unpack_string(field).strip
+          @attributes[column.name] = unpack_string(column).strip
         end
       end
-      self
     end
-    
-    private
-    
-      def unpack_field(field)
-        @data_file.read(field.length).unpack("a#{field.length}")
-      end
-    
-      def unpack_string(field)
-        unpack_field(field).to_s
-      end
-    
-      def read_memo(start_block)
-        return nil if start_block == 0
-        @memo_file.seek(start_block * @reader.memo_block_size)
-        if @reader.memo_file_format == :fpt
-          memo_type, memo_size, memo_string = @memo_file.read(@reader.memo_block_size).unpack("NNa56")
+  
+    def unpack_column(column)
+      @data.read(column.length).unpack("a#{column.length}")
+    end
+  
+    def unpack_string(column)
+      unpack_column(column).to_s
+    end
+  
+    def read_memo(start_block)
+      return nil if start_block == 0
+      @memo.seek(start_block * @table.memo_block_size)
+      if @table.memo_file_format == :fpt
+        memo_type, memo_size, memo_string = @memo.read(@table.memo_block_size).unpack("NNa56")
+      
+        # skip the memo if it isn't text
+        return nil unless memo_type == 1
         
-          # skip the memo if it isn't texst
-          return nil unless memo_type == 1
-          
-          memo_block_content_size = @reader.memo_block_size - FPT_BLOCK_HEADER_SIZE
-          if memo_size > memo_block_content_size
-            memo_string << @memo_file.read(memo_size - @reader.memo_block_size + FPT_BLOCK_HEADER_SIZE)
-          elsif memo_size > 0 and memo_size < memo_block_content_size
-            memo_string = memo_string[0, memo_size]
-          end
-        else
-          case @reader.version
-          when "83" # dbase iii
-            memo_string = ""
-            loop do
-              memo_string << block = @memo_file.read(512)
-              break if block.strip.size < 512
-            end
-          when "8b" # dbase iv
-            memo_type, memo_size = @memo_file.read(8).unpack("LL")
-            memo_string = @memo_file.read(memo_size)
+        memo_block_content_size = @table.memo_block_size - FPT_BLOCK_HEADER_SIZE
+        if memo_size > memo_block_content_size
+          memo_string << @memo.read(memo_size - @table.memo_block_size + FPT_BLOCK_HEADER_SIZE)
+        elsif memo_size > 0 and memo_size < memo_block_content_size
+          memo_string = memo_string[0, memo_size]
+        end
+      else
+        case @table.version
+        when "83" # dbase iii
+          memo_string = ""
+          loop do
+            memo_string << block = @memo.read(512)
+            break if block.strip.size < 512
           end
+        when "8b" # dbase iv
+          memo_type, memo_size = @memo.read(8).unpack("LL")
+          memo_string = @memo.read(memo_size)
         end
-        memo_string
       end
+      memo_string
+    end
+    
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
     end
+  end
 end

data/lib/dbf/{reader.rb → table.rb}

@@ -1,10 +1,11 @@
 module DBF
-  class Reader
-    # The total number of fields (columns)
-    attr_reader :field_count
+
+  class Table
+    # The total number of columns (columns)
+    attr_reader :column_count
     
-    # An array of DBF::Field records
-    attr_reader :fields
+    # An array of DBF::Column records
+    attr_reader :columns
     
     # Internal dBase version number
     attr_reader :version
@@ -18,15 +19,22 @@ module DBF
     # The block size for memo records
     attr_reader :memo_block_size
     
+    # The options that were used when initializing DBF::Table.  This is a Hash.
+    attr_reader :options
+    
+    attr_reader :data
+    attr_reader :memo
+    
     # Initialize a new DBF::Reader.
     # Example:
     #   reader = DBF::Reader.new 'data.dbf'
     def initialize(filename, options = {})
-      options = {:in_memory => true}.merge(options)
+      @options = {:in_memory => true, :accessors => true}.merge(options)
       
-      @in_memory = options[:in_memory]
-      @data_file = File.open(filename, 'rb')
-      @memo_file = open_memo(filename)
+      @in_memory = @options[:in_memory]
+      @accessors = @options[:accessors]
+      @data = File.open(filename, 'rb')
+      @memo = open_memo(filename)
       reload!
     end
     
@@ -34,21 +42,14 @@ module DBF
     def reload!
       @records = nil
       get_header_info
-      get_memo_header_info if @memo_file
-      get_field_descriptors
+      get_memo_header_info if @memo
+      get_column_descriptors
       build_db_index
     end
     
     # Returns true if there is a corresponding memo file
     def has_memo_file?
-      @memo_file ? true : false
-    end
-    
-    # If true, DBF::Reader will load all records into memory.  If false, records are retrieved using file I/O.
-    # You can set this option is set during initialization of the DBF::Reader. Defaults to true. Example:
-    #   reader = DBF::Reader.new 'data.dbf', :in_memory => false
-    def in_memory?
-      @in_memory
+      @memo ? true : false
     end
     
     # The total number of active records.
@@ -56,16 +57,16 @@ module DBF
       @db_index.size
     end
     
-    # Returns an instance of DBF::Field for <b>field_name</b>.  <b>field_name</b>
+    # Returns an instance of DBF::Column for <b>column_name</b>.  <b>column_name</b>
     # can be a symbol or a string.
-    def field(field_name)
-      @fields.detect {|f| f.name == field_name.to_s}
+    def column(column_name)
+      @columns.detect {|f| f.name == column_name.to_s}
     end
     
     # An array of all the records contained in the database file.  Each record is an instance
     # of DBF::Record (or nil if the record is marked for deletion).
     def records
-      if in_memory?
+      if options[:in_memory]
         @records ||= get_all_records_from_file
       else
         get_all_records_from_file
@@ -76,14 +77,16 @@ module DBF
     
     # Returns a DBF::Record (or nil if the record has been marked for deletion) for the record at <tt>index</tt>.
     def record(index)
-      if in_memory?
+      if options[:in_memory]
         records[index]
       else
         get_record_from_file(index)
       end
     end
     
-    # Find records.  Examples:
+    # Find records using a simple ActiveRecord-like syntax.
+    #
+    # Examples:
     #   reader = DBF::Reader.new 'mydata.dbf'
     #   
     #   # Find record number 5
@@ -97,25 +100,23 @@ module DBF
     #
     # The <b>command</b> can be an id, :all, or :first.
     # <b>options</b> is optional and, if specified, should be a hash where the keys correspond
-    # to field names in the database.  The values will be matched exactly with the value
+    # to column names in the database.  The values will be matched exactly with the value
     # in the database.  If you specify more than one key, all values must match in order 
     # for the record to be returned.  The equivalent SQL would be "WHERE key1 = 'value1'
     # AND key2 = 'value2'".
     def find(command, options = {})
       case command
       when Fixnum
-        if !options.empty?
-          raise ArgumentError, "options are not allowed when command is a record number"
-        end
         record(command)
       when :all
+        return records if options.empty?
         records.select do |record|
-          options.map {|key, value| record[key.to_s] == value}.all?
+          options.map {|key, value| record.attributes[key.to_s] == value}.all?
         end
       when :first
         return records.first if options.empty?
         records.detect do |record|
-          options.map {|key, value| record[key.to_s] == value}.all?
+          options.map {|key, value| record.attributes[key.to_s] == value}.all?
         end
       end
     end
@@ -130,13 +131,13 @@ module DBF
     # Returns a database schema in the portable ActiveRecord::Schema format.
     # 
     # xBase data types are converted to generic types as follows:
-    # - Number fields are converted to :integer if there are no decimals, otherwise
+    # - Number columns are converted to :integer if there are no decimals, otherwise
     #   they are converted to :float
-    # - Date fields are converted to :datetime
-    # - Logical fields are converted to :boolean
-    # - Memo fields are converted to :text
-    # - Character fields are converted to :string and the :limit option is set
-    #   to the length of the character field
+    # - Date columns are converted to :datetime
+    # - Logical columns are converted to :boolean
+    # - Memo columns are converted to :text
+    # - Character columns are converted to :string and the :limit option is set
+    #   to the length of the character column
     #
     # Example:
     #   create_table "mydata" do |t|
@@ -148,12 +149,12 @@ module DBF
     #   end
     def schema(path = nil)
       s = "ActiveRecord::Schema.define do\n"
-      s << "  create_table \"#{File.basename(@data_file.path, ".*")}\" do |t|\n"
-      fields.each do |field|
-        s << "    t.column \"#{field.name}\""
-        case field.type
+      s << "  create_table \"#{File.basename(@data.path, ".*")}\" do |t|\n"
+      columns.each do |column|
+        s << "    t.column \"#{column.name}\""
+        case column.type
         when "N" # number
-          if field.decimal > 0
+          if column.decimal > 0
             s << ", :float"
           else
             s << ", :integer"
@@ -165,17 +166,17 @@ module DBF
         when "M" # memo
           s << ", :text"
         else
-          s << ", :string, :limit => #{field.length}"
+          s << ", :string, :limit => #{column.length}"
         end
         s << "\n"
       end
       s << "  end\nend"
       
       if path
-        return File.open(path, 'w') {|f| f.puts(s)}
+        File.open(path, 'w') {|f| f.puts(s)}
       else
-       return s
-     end
+        s
+      end
     end
     
     private
@@ -191,45 +192,42 @@ module DBF
         nil
       end
     
-      # Returns false if the record has been marked as deleted, otherwise it returns true. When dBase records are deleted a
-      # flag is set, marking the record as deleted. The record will not be fully removed until the database has been compacted.
-      def active_record?
-        @data_file.read(1).unpack('H2').to_s == '20'
-      rescue
-        false
+      def deleted_record?
+        @data.read(1).unpack('a') == ['*']
       end
     
       def get_header_info
-        @data_file.rewind
-        @version, @record_count, @header_length, @record_length = @data_file.read(DBF_HEADER_SIZE).unpack('H2xxxVvv')
-        @field_count = (@header_length - DBF_HEADER_SIZE + 1) / DBF_HEADER_SIZE
+        @data.rewind
+        @version, @record_count, @header_length, @record_length = @data.read(DBF_HEADER_SIZE).unpack('H2 x3 V v2')
+        @column_count = (@header_length - DBF_HEADER_SIZE + 1) / DBF_HEADER_SIZE
       end
     
-      def get_field_descriptors
-        @fields = []
-        @field_count.times do
-          name, type, length, decimal = @data_file.read(32).unpack('a10xax4CC')
-          if length > 0 && !name.strip.empty?
-            @fields << Field.new(name, type, length, decimal)
+      def get_column_descriptors
+        @columns = []
+        @column_count.times do
+          name, type, length, decimal = @data.read(32).unpack('a10 x a x4 C2')
+          if length > 0 && name.strip.any?
+            @columns << Column.new(name, type, length, decimal)
           end
         end
-        # adjust field count
-        @field_count = @fields.size
-        @fields
+        # Reset the column count
+        @column_count = @columns.size
+        
+        @columns
       end
     
       def get_memo_header_info
-        @memo_file.rewind
+        @memo.rewind
         if @memo_file_format == :fpt
-          @memo_next_available_block, @memo_block_size = @memo_file.read(FPT_HEADER_SIZE).unpack('Nxxn')
+          @memo_next_available_block, @memo_block_size = @memo.read(FPT_HEADER_SIZE).unpack('N x2 n')
         else
           @memo_block_size = 512
-          @memo_next_available_block = File.size(@memo_file.path) / @memo_block_size
+          @memo_next_available_block = File.size(@memo.path) / @memo_block_size
         end
       end
     
       def seek(offset)
-        @data_file.seek(@header_length + offset)
+        @data.seek(@header_length + offset)
       end
     
       def seek_to_record(index)
@@ -241,16 +239,14 @@ module DBF
       # information on how these two methods differ.
       def get_record_from_file(index)
         seek_to_record(@db_index[index])
-        active_record? ? Record.new(self, @data_file, @memo_file) : nil
+        deleted_record? ? nil : Record.new(self)
       end
       
       def get_all_records_from_file
         all_records = []
         0.upto(@record_count - 1) do |n|
           seek_to_record(n)
-          if active_record?
-            all_records << DBF::Record.new(self, @data_file, @memo_file)
-          end
+          all_records << DBF::Record.new(self) unless deleted_record?
         end
         all_records
       end
@@ -260,10 +256,10 @@ module DBF
         @deleted_records = []
         0.upto(@record_count - 1) do |n|
           seek_to_record(n)
-          if active_record?
-            @db_index << n
-          else
+          if deleted_record?
             @deleted_records << n
+          else
+            @db_index << n
           end
         end
       end