dbf 1.0.11 → 1.1.0

data/History.txt

@@ -1,10 +1,13 @@
+== 1.0.13
+* Allow passing an array of ids to find
+
 == 1.0.11
 
 * Attributes are now accessible by original or underscored name
 
-== 1.0.11
+== 1.1.0
 
-* Minor performance improvements
+* Add support for large table that will not fit into memory
 
 == 1.0.9
 

data/README.markdown

@@ -11,7 +11,9 @@ DBF is a small fast library for reading dBase, xBase, Clipper and FoxPro databas
 
 * No external dependencies
 * Fields are type cast to the appropriate Ruby types
+* ActiveRecord like finder methods
 * Ability to dump the database schema in the portable ActiveRecord::Schema format
+* Ruby 1.9.1 compatible
 
 ## Installation
   
@@ -19,32 +21,51 @@ DBF is a small fast library for reading dBase, xBase, Clipper and FoxPro databas
   
 ## Basic Usage
 
+Load a DBF file:
+
     require 'rubygems'
     require 'dbf'
 
     table = DBF::Table.new("widgets.dbf")
 
-    # Tables are enumerable
-    widget_ids = table.map { |row| row.id }
-    abc_names = table.select { |row| row.name =~ /^[a-cA-C]/ }
-    sorted = table.sort_by { |row| row.name }
-
-    # Print the 'name' field from record number 4
-    puts table.record(4).name
+Enumerate all records
 
-    # Attributes can also be accessed using the column name as a Hash key
-    puts table.record(4).attributes["name"]
-  
-    # Print the 'name' and 'address' fields from each record
     table.records.each do |record|
       puts record.name
       puts record.email
     end
+    
+Load a single record using <tt>records</tt> or <tt>find</tt>
+
+    table.records(6)
+    table.find(6)
 
-    # Find records
-    table.find :all, :first_name => 'Keith'
-    table.find :all, :first_name => 'Keith', :last_name => 'Morrison'
+Attributes can also be accessed through the attributes hash in original or
+underscored form or as an accessor method using the underscored name.
+
+    table.record(4).attributes["PhoneBook"]
+    table.record(4).attributes["phone_book"]
+    table.record(4).phone_book
+  
+Search for records using a simple hash format.  Multiple search criteria are
+ANDed. Use the block form of find if the resulting recordset could be large
+otherwise all records will be loaded into memory.
+    
+    # find all records with first_name equal to Keith
+    table.find(:all, :first_name => 'Keith') do |record|
+      puts record.last_name
+    end
+    
+    # find all records with first_name equal to Keith and last_name equal
+    # to Morrison
+    table.find(:all, :first_name => 'Keith', :last_name => 'Morrison') do |record|
+      puts record.last_name
+    end
+    
+    # find the first record with first_name equal to Keith
     table.find :first, :first_name => 'Keith'
+    
+    # find record number 10
     table.find(10)
   
 ## Migrating to ActiveRecord
@@ -58,7 +79,7 @@ An example of migrating a DBF book table to ActiveRecord using a migration:
         table = DBF::Table.new('db/dbf/books.dbf')
         eval(table.schema)
 
-        table.records.each do |record|
+        table.each do |record|
           Book.create(record.attributes)
         end
       end
@@ -81,7 +102,7 @@ A small command-line utility called dbf is installed along with the gem.
 ## Limitations and known bugs
   
 * DBF is read-only
-* Index files are not used
+* External index files are not used
 
 ## License
 

data/Rakefile

@@ -27,6 +27,13 @@ Spec::Rake::SpecTask.new :spec do |t|
   t.spec_files = FileList['spec/**/*spec.rb']
 end
 
+desc "Run rcov"
+Spec::Rake::SpecTask.new :rcov do |t|
+  t.spec_files = FileList['spec/**/*spec.rb']
+  t.rcov = true
+  t.rcov_opts = ["--exclude ~\/.gem"]
+end
+
 desc "Run spec docs"
 Spec::Rake::SpecTask.new :specdoc do |t|
   t.spec_opts = ["-f specdoc"]

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :major: 1
-:minor: 0
-:patch: 11
+:minor: 1
+:patch: 0
 

data/dbf.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dbf}
-  s.version = "1.0.11"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Keith Morrison"]
-  s.date = %q{2009-12-05}
+  s.date = %q{2009-12-14}
   s.default_executable = %q{dbf}
   s.description = %q{A small fast library for reading dBase, xBase, Clipper and FoxPro database files.}
   s.email = %q{keithm@infused.org}

data/lib/dbf/column.rb

@@ -2,9 +2,17 @@ module DBF
   class ColumnLengthError < DBFError; end
   class ColumnNameError < DBFError; end
   
+  # DBF::Column stores all the information about a column including its name,
+  # type, length and number of decimal places (if any)
   class Column
     attr_reader :name, :type, :length, :decimal
     
+    # Initialize a new DBF::Column
+    #
+    # @param [String] name
+    # @param [String] type
+    # @param [Fixnum] length
+    # @param [Fixnum] decimal
     def initialize(name, type, length, decimal)
       @name, @type, @length, @decimal = strip_non_ascii_chars(name), type, length, decimal
       
@@ -12,6 +20,10 @@ module DBF
       raise ColumnNameError, "column name cannot be empty" if @name.length == 0
     end
     
+    # Cast value to native type
+    #
+    # @param [String] value
+    # @return [Fixnum, Float, Date, DateTime, Boolean, String] 
     def type_cast(value)
       case type
       when 'N' # number
@@ -29,28 +41,50 @@ module DBF
       end
     end
     
+    # Decode a DateTime value
+    #
+    # @param [String] value
+    # @return [DateTime]
     def decode_datetime(value)
       days, milliseconds = value.unpack('l2')
       seconds = milliseconds / 1000
       DateTime.jd(days, seconds/3600, seconds/60 % 60, seconds % 60)
     end
     
+    # Decode a number value
+    #
+    # @param [String] value
+    # @return [Fixnum, Float]
     def unpack_number(value)
       decimal.zero? ? unpack_integer(value) : value.to_f
     end
     
+    # Decode an integer
+    #
+    # @param [String] value
+    # @return [Fixnum]
     def unpack_integer(value)
       value.to_i
     end
     
+    # Decode a boolean value
+    #
+    # @param [String] value
+    # @return [Boolean]
     def boolean(value)
       value.strip =~ /^(y|t)$/i ? true : false
     end
     
+    # Schema definition
+    #
+    # @return [String]
     def schema_definition
       "\"#{name.underscore}\", #{schema_data_type}\n"
     end
     
+    # Column type for schema definition
+    #
+    # @return [String]
     def schema_data_type
       case type
       when "N"
@@ -70,7 +104,10 @@ module DBF
       end
     end
     
-    # strip all non-ascii and non-printable characters
+    # Strip all non-ascii and non-printable characters
+    #
+    # @param [String] s
+    # @return [String]
     def strip_non_ascii_chars(s)
       # truncate the string at the first null character
       s = s[0, s.index("\x00")] if s.index("\x00")

data/lib/dbf/record.rb

@@ -1,24 +1,40 @@
 module DBF
+  
+  # An instance of DBF::Record represents a row in the DBF file 
   class Record
     attr_reader :attributes
+    attr_reader :memo_block_size
+    
     delegate :columns, :to => :@table
     
+    # Initialize a new DBF::Record
+    # 
+    # @param [DBF::Table] table
     def initialize(table)
       @table, @data, @memo = table, table.data, table.memo
+      @memo_block_size = @table.memo_block_size
       initialize_values
       define_accessors
     end
     
+    # Equality
+    #
+    # @param [DBF::Record] other
+    # @return [Boolean]
     def ==(other)
       other.respond_to?(:attributes) && other.attributes == attributes
     end
     
+    # Maps a row to an array of values
+    # 
+    # @return [Array]
     def to_a
       columns.map { |column| @attributes[column.name.underscore] }
     end
     
     private
     
+    # Defined attribute accessor methods
     def define_accessors
       columns.each do |column|
         underscored_column_name = column.name.underscore
@@ -30,6 +46,7 @@ module DBF
       end
     end
     
+    # Initialize values for a row
     def initialize_values
       @attributes = columns.inject({}) do |hash, column|
         if column.type == 'M'
@@ -44,17 +61,27 @@ module DBF
         hash
       end
     end
-  
+    
+    # Unpack raw data from database
+    # 
+    # @param [Fixnum] length
     def unpack_data(length)
       @data.read(length).unpack("a#{length}").first
     end
-  
+    
+    # Reads a memo from the memo file
+    # 
+    # @param [Fixnum] start_block
     def read_memo(start_block)
       return nil if !@table.has_memo_file? || start_block < 1
 
       @table.memo_file_format == :fpt ? build_fpt_memo(start_block) : build_dbt_memo(start_block)
     end
     
+    # Reconstructs a memo from an FPT memo file
+    #
+    # @param [Fixnum] start_block
+    # @return [String]
     def build_fpt_memo(start_block)
       @memo.seek(start_block * memo_block_size)
       
@@ -69,6 +96,10 @@ module DBF
       memo_string
     end
     
+    # Reconstucts a memo from an DBT memo file
+    # 
+    # @param [Fixnum] start_block
+    # @return [String]
     def build_dbt_memo(start_block)
       @memo.seek(start_block * memo_block_size)
       
@@ -87,14 +118,16 @@ module DBF
       memo_string
     end
     
-    def memo_block_size
-      @memo_block_size ||= @table.memo_block_size
-    end
-    
+    # The size in bytes of the content for each memo block
+    # 
+    # @return [Fixnum]
     def memo_block_content_size
       memo_block_size - BLOCK_HEADER_SIZE
     end
     
+    # The size in bytes of the entire memo
+    #
+    # @return [Fixnum]
     def memo_content_size(memo_size)
       (memo_size - memo_block_size) + BLOCK_HEADER_SIZE
     end

data/lib/dbf/table.rb

@@ -1,120 +1,93 @@
 module DBF
 
+  # DBF::Table is the primary interface to a single DBF file and provides 
+  # methods for enumerating and searching the records.
   class Table
-    include Enumerable
-    
     attr_reader :column_count           # The total number of columns
     attr_reader :columns                # An array of DBF::Column
     attr_reader :version                # Internal dBase version number
     attr_reader :last_updated           # Last updated datetime
     attr_reader :memo_file_format       # :fpt or :dpt
     attr_reader :memo_block_size        # The block size for memo records
-    attr_reader :options                # The options hash that was used to initialize the table
+    attr_reader :options                # The options hash used to initialize the table
     attr_reader :data                   # DBF file handle
     attr_reader :memo                   # Memo file handle
+    attr_reader :record_count           # Total number of records
     
-    # Initializes a new DBF::Table
+    # Opens a DBF::Table
     # Example:
     #   table = DBF::Table.new 'data.dbf'
-    def initialize(filename, options = {})
-      @data = File.open(filename, 'rb')
-      @memo = open_memo(filename)
-      @options = options
+    #
+    # @param [String] path Path to the dbf file
+    def initialize(path)
+      @data = File.open(path, 'rb')
+      @memo = open_memo(path)
       reload!
     end
     
+    # Closes the table and memo file
+    def close
+      @data.close
+      @memo.close if @memo
+    end
+    
     # Reloads the database and memo files
     def reload!
       @records = nil
       get_header_info
       get_memo_header_info if @memo
       get_column_descriptors
-      build_db_index
     end
     
-    # Returns true if there is a corresponding memo file
+    # Checks if there is a memo file
+    #
+    # @return [Boolean]
     def has_memo_file?
       @memo ? true : false
     end
     
-    # The total number of active records.
-    def record_count
-      @db_index.size
-    end
-    
-    # Returns an instance of DBF::Column for <b>column_name</b>.  The <b>column_name</b>
-    # can be a specified as either a symbol or string.
+    # Retrieve a Column by name
+    # 
+    # @param [String, Symbol] column_name 
+    # @return [DBF::Column]
     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
-      self.to_a
-    end
-
-    alias_method :rows, :records
-    
+    # Calls block once for each record in the table. The record may be nil
+    # if the record has been marked as deleted.
+    #
+    # @yield [nil, DBF::Record]
     def each
       0.upto(@record_count - 1) do |n|
         seek_to_record(n)
-        unless deleted_record?
-          yield DBF::Record.new(self)
-        end
+        yield deleted_record? ? nil : DBF::Record.new(self)
       end
     end
     
-    # Returns a DBF::Record (or nil if the record has been marked for deletion) for the record at <tt>index</tt>.
-    def record(index)
-      records[index]
-    end
-    
-    # Find records using a simple ActiveRecord-like syntax.
-    #
-    # Examples:
-    #   table = DBF::Table.new 'mydata.dbf'
-    #   
-    #   # Find record number 5
-    #   table.find(5)
-    #
-    #   # Find all records for Keith Morrison
-    #   table.find :all, :first_name => "Keith", :last_name => "Morrison"
-    # 
-    #   # Find first record
-    #   table.find :first, :first_name => "Keith"
+    # Retrieve a record by index number
     #
-    # 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 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 = {})
-      results = options.empty? ? records : records.select {|record| all_values_match?(record, options)}
-      
-      case command
-      when Fixnum
-        record(command)
-      when :all
-        results
-      when :first
-        results.first
-      end
+    # @param [Fixnum] index
+    # @return [DBF::Record]
+    def record(index)
+      seek_to_record(index)
+      deleted_record? ? nil : DBF::Record.new(self)
     end
     
     alias_method :row, :record
     
-    # Returns a description of the current database file.
+    # Human readable version description
+    #
+    # @return [String]
     def version_description
       VERSION_DESCRIPTIONS[version]
     end
     
-    # Returns a database schema in the portable ActiveRecord::Schema format.
+    # Generate an ActiveRecord::Schema
     # 
     # xBase data types are converted to generic types as follows:
-    # - Number columns are converted to :integer if there are no decimals, otherwise
-    #   they are converted to :float
+    # - Number columns with no decimals are converted to :integer
+    # - Number columns with decimals are converted to :float
     # - Date columns are converted to :datetime
     # - Logical columns are converted to :boolean
     # - Memo columns are converted to :text
@@ -129,6 +102,9 @@ module DBF
     #     t.column :age, :integer
     #     t.column :notes, :text
     #   end
+    #
+    # @param [optional String] path
+    # @return [String]
     def schema(path = nil)
       s = "ActiveRecord::Schema.define do\n"
       s << "  create_table \"#{File.basename(@data.path, ".*")}\" do |t|\n"
@@ -139,105 +115,181 @@ module DBF
       
       if path
         File.open(path, 'w') {|f| f.puts(s)}
-      else
-        s
       end
+        
+      s
     end
     
-    # Returns the record at <tt>index</tt> by seeking to the record in the
-    # physical database file. See the documentation for the records method for
-    # information on how these two methods differ.
-    def get_record_from_file(index)
-      seek_to_record(@db_index[index])
-      Record.new(self)
-    end
-    
-    # Dumps all records into a CSV file
-    def to_csv(filename = nil)
-      filename = File.basename(@data.path, '.dbf') + '.csv' if filename.nil?
-      FCSV.open(filename, 'w', :force_quotes => true) do |csv|
-        records.each do |record|
+    # Dumps all records to a CSV file.  If no filename is given then CSV is
+    # output to STDOUT.
+    #
+    # @param [optional String] path Defaults to basename of dbf file
+    def to_csv(path = nil)
+      path = File.basename(@data.path, '.dbf') + '.csv' if path.nil?
+      FCSV.open(path, 'w', :force_quotes => true) do |csv|
+        each do |record|
           csv << record.to_a
         end
       end
     end
     
+    # Find records using a simple ActiveRecord-like syntax.
+    #
+    # Examples:
+    #   table = DBF::Table.new 'mydata.dbf'
+    #   
+    #   # Find record number 5
+    #   table.find(5)
+    #
+    #   # Find all records for Keith Morrison
+    #   table.find :all, :first_name => "Keith", :last_name => "Morrison"
+    # 
+    #   # Find first record
+    #   table.find :first, :first_name => "Keith"
+    #
+    # The <b>command</b> may be a record index, :all, or :first.
+    # <b>options</b> is optional and, if specified, should be a hash where the keys correspond
+    # 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'".
+    #
+    # @param [Fixnum, Symbol] command
+    # @param [optional, Hash] options Hash of search parameters
+    # @yield [optional, DBF::Record]
+    def find(command, options = {}, &block)
+      case command
+      when Fixnum
+        record(command)
+      when Array
+        command.map {|i| record(i)}
+      when :all
+        find_all(options, &block)
+      when :first
+        find_first(options)
+      end
+    end
+    
     private
     
-      def open_memo(file)
-        %w(fpt FPT dbt DBT).each do |extname|
-          filename = replace_extname(file, extname)
-          if File.exists?(filename)
-            @memo_file_format = extname.downcase.to_sym
-            return File.open(filename, 'rb')
+    # Find all matching
+    #
+    # @param [Hash] options
+    # @yield [optional DBF::Record]
+    # @return [Array]
+    def find_all(options, &block)
+      results = []
+      each do |record|
+        if all_values_match?(record, options)
+          if block_given?
+            yield(record)
+          else
+            results << record
           end
         end
-        nil
-      end
-      
-      def replace_extname(filename, extension)
-        filename.sub(/#{File.extname(filename)[1..-1]}$/, extension)
       end
+      results
+    end
     
-      def deleted_record?
-        if @data.read(1).unpack('a') == ['*']
-          @data.rewind
-          true
-        else
-          false
-        end
+    # Find first matching
+    # 
+    # @param [Hash] options
+    # @return [DBF::Record, nil]
+    def find_first(options)
+      each do |record|
+        return record if all_values_match?(record, options)
       end
+      nil
+    end
     
-      def get_header_info
-        @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
+    # Do all search parameters match?
+    #
+    # @param [DBF::Record] record
+    # @param [Hash] options
+    # @return [Boolean]
+    def all_values_match?(record, options)
+      options.all? {|key, value| record.attributes[key.to_s.underscore] == value}
+    end
     
-      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
-            @columns << Column.new(name.strip, type, length, decimal)
-          end
+    # Open memo file
+    #
+    # @params [String] path
+    # @return [File]
+    def open_memo(path)
+      %w(fpt FPT dbt DBT).each do |extname|
+        filename = replace_extname(path, extname)
+        if File.exists?(filename)
+          @memo_file_format = extname.downcase.to_sym
+          return File.open(filename, 'rb')
         end
-        # Reset the column count in case any were skipped
-        @column_count = @columns.size
-        
-        @columns
       end
+      nil
+    end
     
-      def get_memo_header_info
-        @memo.rewind
-        if @memo_file_format == :fpt
-          @memo_next_available_block, @memo_block_size = @memo.read(FPT_HEADER_SIZE).unpack('N x2 n')
-          @memo_block_size = 0 if @memo_block_size.nil?
-        else
-          @memo_block_size = 512
-          @memo_next_available_block = File.size(@memo.path) / @memo_block_size
-        end
-      end
+    # Replace the file extension
+    #
+    # @param [String] path
+    # @param [String] extension
+    # @return [String]
+    def replace_extname(path, extension)
+      path.sub(/#{File.extname(path)[1..-1]}$/, extension)
+    end
     
-      def seek(offset)
-        @data.seek(@header_length + offset)
-      end
+    # Is record marked for deletion
+    #
+    # @return [Boolean]
+    def deleted_record?
+      @data.read(1).unpack('a') == ['*']
+    end
     
-      def seek_to_record(index)
-        seek(index * @record_length)
-      end
-      
-      def build_db_index
-        @db_index = []
-        0.upto(@record_count - 1) do |n|
-          seek_to_record(n)
-          @db_index << n unless deleted_record?
+    # Determine database version, record count, header length and record length
+    def get_header_info
+      @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
+    
+    # Retrieves column information from the database
+    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
+          @columns << Column.new(name.strip, type, length, decimal)
         end
       end
+      # Reset the column count in case any were skipped
+      @column_count = @columns.size
       
-      def all_values_match?(record, options)
-        options.map {|key, value| record.attributes[key.to_s.underscore] == value}.all?
+      @columns
+    end
+    
+    # Determines the memo block size and next available block
+    def get_memo_header_info
+      @memo.rewind
+      if @memo_file_format == :fpt
+        @memo_next_available_block, @memo_block_size = @memo.read(FPT_HEADER_SIZE).unpack('N x2 n')
+        @memo_block_size = 0 if @memo_block_size.nil?
+      else
+        @memo_block_size = 512
+        @memo_next_available_block = File.size(@memo.path) / @memo_block_size
       end
+    end
+    
+    # Seek to a byte offset
+    # 
+    # @params [Fixnum] offset
+    def seek(offset)
+      @data.seek(@header_length + offset)
+    end
+  
+    # Seek to a record
+    #
+    # @param [Fixnum] index
+    def seek_to_record(index)
+      seek(index * @record_length)
+    end
+    
   end
   
 end

data/spec/functional/dbf_shared.rb

@@ -7,7 +7,9 @@ describe DBF, :shared => true do
   end
 
   specify "records should be instances of DBF::Record" do
-    @table.records.all? {|record| record.should be_an_instance_of(DBF::Record)}
+    @table.each do |record|
+      record.should be_an_instance_of(DBF::Record)
+    end
   end
   
   specify "columns should be instances of DBF::Column" do

data/spec/spec_helper.rb

@@ -1,7 +1,8 @@
-$:.unshift(File.dirname(__FILE__) + "/../lib/")
-require "rubygems"
-require "spec"
-require "dbf"
+$:.unshift(File.dirname(__FILE__) + '/../lib/')
+require 'rubygems'
+require 'spec'
+require 'dbf'
+require 'fileutils'
 
 DB_PATH = File.dirname(__FILE__) + '/fixtures' unless defined?(DB_PATH)
 
@@ -9,4 +10,4 @@ Spec::Runner.configure do |config|
   
 end
 
-self.class.send :remove_const, "Test" if defined? Test
+self.class.send :remove_const, 'Test' if defined? Test

data/spec/unit/record_spec.rb

@@ -25,26 +25,26 @@ describe DBF::Record do
       table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
       table.column("ID").type.should == "N"
       table.column("ID").decimal.should == 0
-      table.records.all? {|record| record.attributes['id'].should be_kind_of(Integer)}
+      table.record(1).attributes['id'].should be_kind_of(Integer)
     end
   
     it "should typecast number columns with decimals > 0 to Float" do
       table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
       table.column("ID").type.should == "N"
       table.column("COST").decimal.should == 2
-      table.records.all? {|record| record.attributes['cost'].should be_kind_of(Float)}
+      table.record(1).attributes['cost'].should be_kind_of(Float)
     end
   
     it "should typecast memo columns to String" do
       table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
       table.column("DESC").type.should == "M"
-      table.records.all? {|record| record.attributes['desc'].should be_kind_of(String)}
+      table.record(1).attributes['desc'].should be_kind_of(String)
     end
   
     it "should typecast logical columns to True or False" do
       table = DBF::Table.new "#{DB_PATH}/dbase_30.dbf"
       table.column("WEBINCLUDE").type.should == "L"
-      table.records.all? {|record| record.attributes["webinclude"].should satisfy {|v| v == true || v == false}}
+      table.record(1).attributes["webinclude"].should satisfy {|v| v == true || v == false}
     end
   end
   
@@ -85,13 +85,13 @@ describe DBF::Record do
     end
   end
   
-  describe '#to_a' do
-    it 'should return an ordered array of attribute values' do
-      table = DBF::Table.new "#{DB_PATH}/dbase_8b.dbf"
-      record = table.records[9]
-      record.to_a.should == ["Ten records stored in this database", 10.0, nil, false, "0.100000000000000000", nil]
-    end
-  end
+  # describe '#to_a' do
+  #   it 'should return an ordered array of attribute values' do
+  #     table = DBF::Table.new "#{DB_PATH}/dbase_8b.dbf"
+  #     record = table.records[9]
+  #     record.to_a.should == ["Ten records stored in this database", 10.0, nil, false, "0.100000000000000000", nil]
+  #   end
+  # end
   
   describe '#==' do
     before do

data/spec/unit/table_spec.rb

@@ -1,8 +1,6 @@
 require File.dirname(__FILE__) + "/../spec_helper"
-require 'fileutils'
 
 describe DBF::Table do
-  
   context "when initialized" do
     before do
       @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
@@ -12,7 +10,7 @@ describe DBF::Table do
       @table.data.should be_kind_of(File)
     end
 
-    it "should locate load the memo file" do
+    it "should load the memo file" do
       @table.has_memo_file?.should be_true
       @table.instance_eval("@memo").should be_kind_of(File)
     end
@@ -36,74 +34,19 @@ describe DBF::Table do
     it "should determine the database version" do
       @table.version.should == "83"
     end
-
   end
   
-  describe "#find" do
-    describe "with index" do
-      it "should return the correct record" do
-        table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
-        table.find(5).should == table.record(5)
-      end
-    end
-
-    describe "with :all" do
-      before do
-        @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
-      end
-
-      it "should return all records if options are empty" do
-        @table.find(:all).should == @table.records
-      end
-
-      it "should return matching records when used with options" do
-        @table.find(:all, "WEIGHT" => 0.0).should == @table.select {|r| r.attributes["weight"] == 0.0}
-      end
-
-      it "with multiple options should search for all search terms as if using AND" do
-        @table.find(:all, "ID" => 30, "IMAGE" => "graphics/00000001/TBC01.jpg").should == []
-      end
-      
-      it "should match original column names" do
-        @table.find(:all, "WEIGHT" => 0.0).should_not be_empty
-      end
-      
-      it "should match symbolized column names" do
-        @table.find(:all, :WEIGHT => 0.0).should_not be_empty
-      end
-      
-      it "should match downcased column names" do
-        @table.find(:all, "weight" => 0.0).should_not be_empty
-      end
-      
-      it "should match symbolized downcased column names" do
-        @table.find(:all, :weight => 0.0).should_not be_empty
-      end
+  context "when closed" do
+    before do
+      @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
     end
-
-    describe "with :first" do
-      before do
-        @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
-      end
-
-      it "should return the first record if options are empty" do
-        @table.find(:first).should == @table.records.first
-      end
-
-      it "should return the first matching record when used with options" do
-        @table.find(:first, "CODE" => "C").should == @table.record(5)
-      end
-
-      it "with multiple options should search for all search terms as if using AND" do
-        @table.find(:first, "ID" => 30, "IMAGE" => "graphics/00000001/TBC01.jpg").should be_nil
-      end
+    
+    it "should close the data file" do
+      @table.close
+      lambda { @table.record(1) }.should raise_error(IOError)
     end
   end
   
-  describe "#reload" do
-    # TODO
-  end
-  
   describe "#column" do
     it "should accept a string or symbol as input" do
       table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
@@ -139,22 +82,9 @@ describe DBF::Table do
   end
   
   describe '#replace_extname' do
-    it 'should replace the extname' do
+    it "should change the file extension" do
       table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
-      table.send(:replace_extname, "dbase_83.dbf", 'fpt').should == 'dbase_83.fpt'
-    end
-  end
-  
-  describe '#each' do
-    it 'should enumerate all records' do
-      table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
-      records = []
-      table.each do |record|
-        records << record
-      end
-
-      records.map! { |r| r.attributes }
-      records.should == table.records.map {|r| r.attributes}
+      table.send(:replace_extname, 'dbase_83.dbf', 'fpt').should == 'dbase_83.fpt'
     end
   end
   
@@ -178,6 +108,108 @@ describe DBF::Table do
       File.exists?('test.csv').should be_true
     end
   end
+  
+  describe "#record" do
+    before do
+      @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+      
+      @records = []
+      @table.each {|record| @records << record}
+    end
+    
+    it "should nullify deleted records" do
+      @table.stub!(:deleted_record?).and_return(true)
+      @table.record(5).should be_nil
+    end
+  end
+  
+  describe "#find" do
+    describe "with index" do
+      before do
+        @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+      end
+      
+      it "should return the correct record" do
+        @table.find(5).should == @table.record(5)
+      end
+    end
+    
+    describe 'with array of indexes' do
+      before do
+        @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+      end
+      
+      it "should return the correct records" do
+        @table.find([1, 5, 10]).should == [@table.record(1), @table.record(5), @table.record(10)]
+      end
+    end
+    
+    describe "with :all" do
+      before do
+        @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+        
+        @records = []
+        @table.each {|record| @records << record}
+      end
+      
+      it "should accept a block" do
+        records = []
+        @table.find(:all, :weight => 0.0) do |record|
+          records << record
+        end
+        records.should == @table.find(:all, :weight => 0.0)
+      end
+
+      it "should return all records if options are empty" do
+        @table.find(:all).should == @records
+      end
+
+      it "should return matching records when used with options" do
+        @table.find(:all, "WEIGHT" => 0.0).should == @records.select {|r| r.attributes["weight"] == 0.0}
+      end
+
+      it "should AND multiple search terms" do
+        @table.find(:all, "ID" => 30, "IMAGE" => "graphics/00000001/TBC01.jpg").should == []
+      end
+      
+      it "should match original column names" do
+        @table.find(:all, "WEIGHT" => 0.0).should_not be_empty
+      end
+      
+      it "should match symbolized column names" do
+        @table.find(:all, :WEIGHT => 0.0).should_not be_empty
+      end
+      
+      it "should match downcased column names" do
+        @table.find(:all, "weight" => 0.0).should_not be_empty
+      end
+      
+      it "should match symbolized downcased column names" do
+        @table.find(:all, :weight => 0.0).should_not be_empty
+      end
+    end
+    
+    describe "with :first" do
+      before do
+        @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+        
+        @records = []
+        @table.each {|record| @records << record}
+      end
+
+      it "should return the first record if options are empty" do
+        @table.find(:first).should == @records.first
+      end
+
+      it "should return the first matching record when used with options" do
+        @table.find(:first, "CODE" => "C").should == @records[5]
+      end
+
+      it "should AND multiple search terms" do
+        @table.find(:first, "ID" => 30, "IMAGE" => "graphics/00000001/TBC01.jpg").should be_nil
+      end
+    end
+  end
 
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dbf
 version: !ruby/object:Gem::Version 
-  version: 1.0.11
+  version: 1.1.0
 platform: ruby
 authors: 
 - Keith Morrison
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-05 00:00:00 -08:00
+date: 2009-12-14 00:00:00 +01:00
 default_executable: dbf
 dependencies: 
 - !ruby/object:Gem::Dependency