dbf 1.0.5 → 1.0.6

data/History.txt

@@ -1,3 +1,9 @@
+== 1.0.6
+
+* DBF::Table now includes the Enumerable module
+* Return nil for memo values if the memo file is missing
+* Finder conditions now support the original and downcased/underscored column names
+
 == 1.0.5
 
 * Strip non-ascii characters from column names

data/Manifest.txt

@@ -2,9 +2,8 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
-benchmarks/performance.rb
-benchmarks/seek_benchmark.rb
 bin/dbf
+dbf.gemspec
 lib/dbf.rb
 lib/dbf/column.rb
 lib/dbf/globals.rb

data/README.txt

@@ -70,14 +70,6 @@ An example of migrating a DBF book table to ActiveRecord using a migration:
     end
   end
   
-== Large databases
-
-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.
-
-  table = DBF::Table.new("old_data.dbf", :in_memory => false)
-
 == Command-line utility
 
 A small command-line utility called dbf is installed along with the gem.
@@ -97,7 +89,7 @@ A small command-line utility called dbf is installed along with the gem.
 
 (The MIT Licence)
 
-Copyright (c) 2006-2007 Keith Morrison <keithm@infused.org>
+Copyright (c) 2006-2008 Keith Morrison <keithm@infused.org>
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/Rakefile

@@ -2,7 +2,7 @@ require 'hoe'
 require 'spec/rake/spectask'
 
 PKG_NAME = "dbf"
-PKG_VERSION = "1.0.5"
+PKG_VERSION = "1.0.6"
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 Hoe.new PKG_NAME, PKG_VERSION do |p|
@@ -12,12 +12,12 @@ Hoe.new PKG_NAME, PKG_VERSION do |p|
   p.summary = "A small fast library for reading dBase, xBase, Clipper and FoxPro database files."
   p.description = p.paragraphs_of("README.txt", 1..3).join("\n\n")
   p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
-  p.url = "http://dbf.rubyforge.org"
+  p.url = "http://github.com/infused/dm-dbf/tree/master"
   p.need_tar = true
   p.need_zip = true
 end
 
-task :default => [:spec]
+task :default => :spec
 
 desc "Run specs"
 Spec::Rake::SpecTask.new :spec do |t|
@@ -28,4 +28,9 @@ desc "Run spec docs"
 Spec::Rake::SpecTask.new :specdoc do |t|
   t.spec_opts = ["-f specdoc"]
   t.spec_files = FileList['spec/**/*spec.rb']
+end
+
+desc "Generate gemspec"
+task :gemspec do |t|
+  `rake debug_gem > dbf.gemspec`
 end

data/dbf.gemspec

@@ -0,0 +1,35 @@
+(in /Users/keithm/projects/dbf)
+Gem::Specification.new do |s|
+  s.name = %q{dbf}
+  s.version = "1.0.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Keith Morrison"]
+  s.date = %q{2008-06-30}
+  s.default_executable = %q{dbf}
+  s.description = %q{DBF is a small fast library for reading dBase, xBase, Clipper and FoxPro database files.  It is written completely in Ruby and has no external dependencies.  Copyright (c) 2006-2007 Keith Morrison <keithm@infused.org, www.infused.org>  * Official project page: http://rubyforge.org/projects/dbf * API Documentation: http://dbf.rubyforge.org/docs * To report bugs: http://www.rubyforge.org/tracker/?group_id=2009 * Questions: Email keithm@infused.org and put DBF somewhere in the subject line}
+  s.email = %q{keithm@infused.org}
+  s.executables = ["dbf"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt", "spec/fixtures/dbase_83_schema.txt"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "bin/dbf", "dbf.gemspec", "lib/dbf.rb", "lib/dbf/column.rb", "lib/dbf/globals.rb", "lib/dbf/record.rb", "lib/dbf/table.rb", "spec/fixtures/dbase_03.dbf", "spec/fixtures/dbase_30.dbf", "spec/fixtures/dbase_30.fpt", "spec/fixtures/dbase_83.dbf", "spec/fixtures/dbase_83.dbt", "spec/fixtures/dbase_83_schema.txt", "spec/fixtures/dbase_8b.dbf", "spec/fixtures/dbase_8b.dbt", "spec/fixtures/dbase_f5.dbf", "spec/fixtures/dbase_f5.fpt", "spec/functional/dbf_shared.rb", "spec/functional/format_03_spec.rb", "spec/functional/format_30_spec.rb", "spec/functional/format_83_spec.rb", "spec/functional/format_8b_spec.rb", "spec/functional/format_f5_spec.rb", "spec/spec_helper.rb", "spec/unit/column_spec.rb", "spec/unit/record_spec.rb", "spec/unit/table_spec.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/infused/dm-dbf/tree/master}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{dbf}
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{A small fast library for reading dBase, xBase, Clipper and FoxPro database files.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if current_version >= 3 then
+      s.add_runtime_dependency(%q<hoe>, [">= 1.6.0"])
+    else
+      s.add_dependency(%q<hoe>, [">= 1.6.0"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 1.6.0"])
+  end
+end

data/lib/dbf/column.rb

@@ -2,6 +2,8 @@ module DBF
   class ColumnLengthError < DBFError; end
   
   class Column
+    include Helpers
+    
     attr_reader :name, :type, :length, :decimal
 
     def initialize(name, type, length, decimal)
@@ -10,8 +12,7 @@ module DBF
     end
     
     def schema_definition
-      "\"#{underscore(name)}\", " + 
-      case type
+      data_type = case type
       when "N" # number
         if decimal > 0
           ":float"
@@ -26,19 +27,12 @@ module DBF
         ":text"
       else
         ":string, :limit => #{length}"
-      end + 
-      "\n"
+      end
+      
+      "\"#{underscore(name)}\", #{data_type}\n"
     end
     
     private
-
-    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
     
     def strip_non_ascii_chars(s)
       clean = ''

data/lib/dbf/globals.rb

@@ -1,7 +1,7 @@
 module DBF
   DBF_HEADER_SIZE = 32
   FPT_HEADER_SIZE = 512
-  FPT_BLOCK_HEADER_SIZE = 8
+  BLOCK_HEADER_SIZE = 8
   DATE_REGEXP = /([\d]{4})([\d]{2})([\d]{2})/
   VERSION_DESCRIPTIONS = {
     "02" => "FoxBase",
@@ -20,9 +20,17 @@ module DBF
   
   MS_PER_SECOND = 1000
   MS_PER_MINUTE = MS_PER_SECOND * 60
-  MS_PER_HOUR = MS_PER_MINUTE * 60
+  MS_PER_HOUR   = MS_PER_MINUTE * 60
   
   class DBFError < StandardError; end
-  class InvalidColumnName < DBFError; end
-  class InvalidColumnLength < DBFError; end
+  
+  module Helpers
+    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/record.rb

@@ -1,33 +1,34 @@
 module DBF
   class Record
-    attr_reader :attributes
+    include Helpers
     
-    @@accessors_defined = false
+    attr_reader :attributes
     
     def initialize(table)
       @table, @data, @memo = table, table.data, table.memo
-      @attributes = {}
       initialize_values(table.columns)
       define_accessors
-      self
+    end
+    
+    def ==(other)
+      other.respond_to?(:attributes) && other.attributes == attributes
     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)
+        unless 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)
+      @attributes = {}
       columns.each do |column|
         @attributes[column.name] = case column.type
         when 'N' # number
@@ -54,11 +55,13 @@ module DBF
         else
           unpack_string(column).strip
         end
+        @attributes[underscore(column.name)] = @attributes[column.name]
+        @attributes
       end
     end
   
     def unpack_column(column)
-      @data.read(column.length).unpack("a#{column.length}")
+      @data.read(column.length).to_s.unpack("a#{column.length}")
     end
   
     def unpack_string(column)
@@ -78,42 +81,53 @@ module DBF
     end
   
     def read_memo(start_block)
-      return nil if start_block <= 0 || @table.memo_block_size.nil?
-      @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")
+      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
+    
+    def build_fpt_memo(start_block)
+      @memo.seek(start_block * memo_block_size)
       
-        # skip the memo if it isn't text
-        return nil unless memo_type == 1
-        
-        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
+      memo_type, memo_size, memo_string = @memo.read(memo_block_size).unpack("NNa56")
+      return nil unless memo_type == 1 and memo_size > 0
+      
+      if memo_size > memo_block_content_size
+        memo_string << @memo.read(memo_content_size(memo_size))
       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)
+        memo_string = memo_string[0, memo_size]
+      end
+      memo_string
+    end
+    
+    def build_dbt_memo(start_block)
+      @memo.seek(start_block * memo_block_size)
+      
+      case @table.version
+      when "83" # dbase iii
+        memo_string = ""
+        loop do
+          memo_string << block = @memo.read(memo_block_size)
+          break if block.rstrip.size < memo_block_size
         end
+      when "8b" # dbase iv
+        memo_type, memo_size = @memo.read(BLOCK_HEADER_SIZE).unpack("LL")
+        memo_string = @memo.read(memo_size)
       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
+    def memo_block_size
+      @memo_block_size ||= @table.memo_block_size
     end
+    
+    def memo_block_content_size
+      memo_block_size - BLOCK_HEADER_SIZE
+    end
+    
+    def memo_content_size(memo_size)
+      (memo_size - memo_block_size) + BLOCK_HEADER_SIZE
+    end
+    
   end
 end

data/lib/dbf/table.rb

@@ -1,40 +1,25 @@
 module DBF
 
   class Table
-    # The total number of columns (columns)
-    attr_reader :column_count
-    
-    # An array of DBF::Column records
-    attr_reader :columns
-    
-    # Internal dBase version number
-    attr_reader :version
-    
-    # Last updated datetime
-    attr_reader :last_updated
-    
-    # Either :fpt or :dpt
-    attr_reader :memo_file_format
-    
-    # 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.
+    include Enumerable
+    
+    attr_reader :column_count           # The total number of columns (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 :data                   # DBF file handle
+    attr_reader :memo                   # Memo file handle
+    
+    # Initializes a new DBF::Reader
     # Example:
     #   reader = DBF::Reader.new 'data.dbf'
     def initialize(filename, options = {})
-      @options = {:in_memory => true, :accessors => true}.merge(options)
-      
-      @in_memory = @options[:in_memory]
-      @accessors = @options[:accessors]
       @data = File.open(filename, 'rb')
       @memo = open_memo(filename)
+      @options = options
       reload!
     end
     
@@ -57,8 +42,8 @@ module DBF
       @db_index.size
     end
     
-    # Returns an instance of DBF::Column for <b>column_name</b>.  <b>column_name</b>
-    # can be a symbol or a string.
+    # 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.
     def column(column_name)
       @columns.detect {|f| f.name == column_name.to_s}
     end
@@ -66,22 +51,28 @@ module DBF
     # 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 options[:in_memory]
-        @records ||= get_all_records_from_file
-      else
-        get_all_records_from_file
+      self.to_a
+    end
+
+    alias_method :rows, :records
+    
+    def each
+      0.upto(@record_count - 1) do |n|
+        seek_to_record(n)
+        unless deleted_record?
+          yield DBF::Record.new(self)
+        end
       end
     end
     
-    alias_method :rows, :records
+    # def get_record_from_file(index)
+    #   seek_to_record(@db_index[index])
+    #   Record.new(self)
+    # 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)
-      if options[:in_memory]
-        records[index]
-      else
-        get_record_from_file(index)
-      end
+      records[index]
     end
     
     # Find records using a simple ActiveRecord-like syntax.
@@ -158,21 +149,38 @@ module DBF
       end
     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
+    
     private
     
       def open_memo(file)
-        %w(fpt FPT dbt DBT).each do |extension|
-          filename = file.sub(/#{File.extname(file)[1..-1]}$/, extension)
+        %w(fpt FPT dbt DBT).each do |extname|
+          filename = replace_extname(file, extname)
           if File.exists?(filename)
-            @memo_file_format = extension.downcase.to_sym
+            @memo_file_format = extname.downcase.to_sym
             return File.open(filename, 'rb')
           end
         end
         nil
       end
+      
+      def replace_extname(filename, extension)
+        filename.sub(/#{File.extname(filename)[1..-1]}$/, extension)
+      end
     
       def deleted_record?
-        @data.read(1).unpack('a') == ['*']
+        if @data.read(1).unpack('a') == ['*']
+          @data.rewind
+          true
+        else
+          false
+        end
       end
     
       def get_header_info
@@ -189,7 +197,7 @@ module DBF
             @columns << Column.new(name.strip, type, length, decimal)
           end
         end
-        # Reset the column count
+        # Reset the column count in case any were skipped
         @column_count = @columns.size
         
         @columns
@@ -199,6 +207,7 @@ module DBF
         @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
@@ -213,23 +222,6 @@ module DBF
         seek(index * @record_length)
       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])
-        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)
-          all_records << DBF::Record.new(self) unless deleted_record?
-        end
-        all_records
-      end
-    
       def build_db_index
         @db_index = []
         @deleted_records = []

data/spec/functional/dbf_shared.rb

@@ -36,11 +36,9 @@ describe DBF, :shared => true do
   end
   
   specify "column read accessors should return the attribute after typecast" do
-    if @table.options[:accessors]
-      @table.columns do |column|
-        record = table.records.first
-        record.send(column.name).should == record[column.name]
-      end
+    @table.columns do |column|
+      record = table.records.first
+      record.send(column.name).should == record[column.name]
     end
   end
   

data/spec/spec_helper.rb

@@ -6,5 +6,5 @@ require "dbf"
 DB_PATH = File.dirname(__FILE__) + '/fixtures' unless defined?(DB_PATH)
 
 Spec::Runner.configure do |config|
-  config.mock_with :mocha
+  
 end

data/spec/unit/column_spec.rb

@@ -1,34 +1,71 @@
 require File.dirname(__FILE__) + "/../spec_helper"
 
-describe DBF::Column, "when initialized" do
+describe DBF::Column do
   
-  before(:each) do
-    @column = DBF::Column.new "ColumnName", "N", 1, 0
-  end
+  context "when initialized" do
+    before do
+      @column = DBF::Column.new "ColumnName", "N", 1, 0
+    end
+
+    it "should set the #name accessor" do
+      @column.name.should == "ColumnName"
+    end
   
-  it "should set the #name accessor" do
-    @column.name.should == "ColumnName"
-  end
+    it "should set the #type accessor" do
+      @column.type.should == "N"
+    end
   
-  it "should set the #type accessor" do
-    @column.type.should == "N"
-  end
+    it "should set the #length accessor" do
+      @column.length.should == 1
+    end
   
-  it "should set the #length accessor" do
-    @column.length.should == 1
-  end
+    it "should set the #decimal accessor" do
+      @column.decimal.should == 0
+    end
   
-  it "should set the #decimal accessor" do
-    @column.decimal.should == 0
+    it "should raise an error if length is greater than 0" do
+      lambda { column = DBF::Column.new "ColumnName", "N", -1, 0 }.should raise_error(DBF::ColumnLengthError)
+    end
+
   end
   
-  it "should raise an error if length is greater than 0" do
-    lambda { column = DBF::Column.new "ColumnName", "N", -1, 0 }.should raise_error(DBF::ColumnLengthError)
+  context "#schema_definition" do
+    it "should define an integer column if type is (N)umber with 9 decimals" do
+      column = DBF::Column.new "ColumnName", "N", 1, 0
+      column.schema_definition.should == "\"column_name\", :integer\n"
+    end
+    
+    it "should define a float colmn if type is (N)umber with more than 0 decimals" do
+      column = DBF::Column.new "ColumnName", "N", 1, 2
+      column.schema_definition.should == "\"column_name\", :float\n"
+    end
+    
+    it "should define a datetime column if type is (D)ate" do
+      column = DBF::Column.new "ColumnName", "D", 8, 0
+      column.schema_definition.should == "\"column_name\", :datetime\n"
+    end
+    
+    it "should define a boolean column if type is (L)ogical" do
+      column = DBF::Column.new "ColumnName", "L", 1, 0
+      column.schema_definition.should == "\"column_name\", :boolean\n"
+    end
+    
+    it "should define a text column if type is (M)emo" do
+      column = DBF::Column.new "ColumnName", "M", 1, 0
+      column.schema_definition.should == "\"column_name\", :text\n"
+    end
+    
+    it "should define a string column with length for any other data types" do
+      column = DBF::Column.new "ColumnName", "X", 20, 0
+      column.schema_definition.should == "\"column_name\", :string, :limit => 20\n"
+    end
   end
   
-  it "should strip non-ascii characters from the name" do
-    column = DBF::Column.new "Col\200umn\0Name\037", "N", 1, 0
-    column.name.should == "ColumnName"
+  context "#strip_non_ascii_chars" do
+    it "should strip characters below decimal 32 and above decimal 128" do
+      column = DBF::Column.new "ColumnName", "N", 1, 0
+      column.send(:strip_non_ascii_chars, "--\x1F-\x68\x65\x6C\x6C\x6F world-\x80--").should == "---hello world---"
+    end
   end
   
 end

data/spec/unit/record_spec.rb

@@ -1,56 +1,100 @@
 require File.dirname(__FILE__) + "/../spec_helper"
 
-describe DBF::Record, "when initialized" do
-  
-  def standalone_record(binary_data)
-    table = mock
-    table.stubs(:data)
-    table.data.stubs(:read).returns(binary_data)
-    table.stubs(:memo).returns(nil)
-    table.stubs(:columns).returns([])
-    DBF::Record.new(table)
-  end
-
-  it "should typecast number columns with decimals == 0 to Integer" 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)}
+describe DBF::Record do
+  
+  def example_record(data = '')
+    DBF::Record.new(mock_table(data))
   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)}
+  def mock_table(data = '')
+    table = mock('table')
+    table.stub!(:memo_block_size).and_return(8)
+    table.stub!(:memo).and_return(nil)
+    table.stub!(:columns).and_return([])
+    table.stub!(:data)
+    table.stub!(:has_memo_file?).and_return(true)
+    table.data.stub!(:read).and_return(data)
+    table
   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)}
+  context "when initialized" do
+    it "should typecast number columns with decimals == 0 to Integer" 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)}
+    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)}
+    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)}
+    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}}
+    end
+  
+    it "should typecast datetime columns to DateTime" do
+      record = example_record("Nl%\000\300Z\252\003")
+      column = mock('column', :length => 8)
+  
+      record.instance_eval {unpack_datetime(column)}.to_s.should == "2002-10-10T17:04:56+00:00"
+    end
+  
+    it "should typecast integers to Fixnum" do
+      record = example_record("\017\020\000\000")
+      column = mock('column', :length => 4)
+  
+      record.instance_eval {unpack_integer(column)}.should == 4111
+    end
   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}}
+  describe '#memo_block_content_size' do
+    it "should equal the difference between the table's memo_block_size and 8" do
+      table = mock_table
+      table.should_receive(:memo_block_size).and_return(128)
+      record = DBF::Record.new(table)
+      
+      record.send(:memo_block_content_size).should == 120
+    end
   end
   
-  it "should typecast datetime columns to DateTime" do
-    binary_data = "Nl%\000\300Z\252\003"
-    record = standalone_record(binary_data)
-    column = stub(:length => 8)
-    
-    record.instance_eval {unpack_datetime(column)}.to_s.should == "2002-10-10T17:04:56+00:00"
+  describe '#memo_content_size' do
+    it "should equal 8 plus the difference between memo_size and the table's memo_block_size" do
+      record = example_record
+      record.should_receive(:memo_block_size).and_return(8)
+      
+      record.send(:memo_content_size, 1024).should == 1024
+    end
   end
   
-  it "should typecast integers to Fixnum" do
-    binary_data = "\017\020\000\000"
-    record = standalone_record(binary_data)
-    column = stub(:length => 4)
+  describe '#read_memo' do
+    it 'should return nil if start_block is less than 1' do
+      table = mock_table
+      record = DBF::Record.new(table)
+      
+      record.send(:read_memo, 0).should be_nil
+      record.send(:read_memo, -1).should be_nil
+    end
+    
+    it 'should return nil if memo file is missing' do
+      table = mock_table
+      table.should_receive(:has_memo_file?).and_return(false)
+      record = DBF::Record.new(table)
       
-    record.instance_eval {unpack_integer(column)}.should == 4111
+      record.send(:read_memo, 5).should be_nil
+    end
+
   end
 
 end

data/spec/unit/table_spec.rb

@@ -1,167 +1,161 @@
 require File.dirname(__FILE__) + "/../spec_helper"
 
-describe DBF::Table, "when initialized" do
-  
-  before(:all) do
-    @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
-  end
-  
-  it "should load the data file" do
-    @table.data.should be_kind_of(File)
-  end
-  
-  it "should locate load the memo file" do
-    @table.has_memo_file?.should be_true
-    @table.instance_eval("@memo").should be_kind_of(File)
-  end
-  
-  it "should determine the memo file format" do
-    @table.memo_file_format.should == :dbt
-  end
-  
-  it "should determine the correct memo block size" do
-    @table.memo_block_size.should == 512
-  end
-  
-  it "should default to loading all records into memory" do
-    @table.options[:in_memory].should be_true
-  end
-  
-  it "should determine the number of columns in each record" do
-    @table.columns.size.should == 15
-  end
-  
-  it "should determine the number of records in the database" do
-    @table.record_count.should == 67
-  end
-  
-  it "should determine the database version" do
-    @table.version.should == "83"
-  end
-  
-  it "should set the in_memory option" do
-    table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf", :in_memory => false
-    table.options[:in_memory].should be_false
-  end
+describe DBF::Table do
   
-end
+  context "when initialized" do
+    before do
+      @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+    end
 
-describe DBF::Table, "when the in_memory flag is true" do
-  
-  before(:each) do
-    @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
-  end
-  
-  it "should build the records array from disk only on the first request" do
-    @table.expects(:get_all_records_from_file).at_most_once.returns([])
-    3.times { @table.records }
-  end
-  
-  it "should read from the records array when using the record() method" do
-    @table.expects(:get_all_records_from_file).at_most_once.returns([])
-    @table.expects(:get_record_from_file).never
-    @table.expects(:records).times(2).returns([])
-    @table.record(1)
-    @table.record(10)
-  end
-  
-end
+    it "should load the data file" do
+      @table.data.should be_kind_of(File)
+    end
 
-describe DBF::Table, "when the in_memory flag is false" do
-  
-  it "should read the records from disk on every request" do
-    table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf", :in_memory => false
-    table.expects(:get_all_records_from_file).times(3).returns([])
-    3.times { table.records }
-  end
-end
+    it "should locate load the memo file" do
+      @table.has_memo_file?.should be_true
+      @table.instance_eval("@memo").should be_kind_of(File)
+    end
 
-describe DBF::Table, "schema" do
-  
-  it "should match test schema " do
-    table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
-    control_schema = File.read(File.dirname(__FILE__) + '/../fixtures/dbase_83_schema.txt')
-    
-    table.schema.should == control_schema
-  end
-  
-end
+    it "should determine the memo file format" do
+      @table.memo_file_format.should == :dbt
+    end
 
-describe DBF::Table, "find(index)" do
-  
-  before(:all) 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
+    it "should determine the correct memo block size" do
+      @table.memo_block_size.should == 512
+    end
 
-describe DBF::Table, "find(:all)" do
-  
-  before(:all) 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.records.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
-end
+    it "should determine the number of columns in each record" do
+      @table.columns.size.should == 15
+    end
+
+    it "should determine the number of records in the database" do
+      @table.record_count.should == 67
+    end
+
+    it "should determine the database version" do
+      @table.version.should == "83"
+    end
 
-describe DBF::Table, "find(:first)" do
-  
-  before(:all) 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
+  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
+    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
+    end
   end
   
-  it "should return the first matching record when used with options" do
-    @table.find(:first, "CODE" => "C").should == @table.record(5)
+  describe "#reload" do
+    # TODO
   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
-end
-
-describe DBF::Table do
+  describe "#column" do
+    it "should accept a string or symbol as input" do
+      table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+      table.column(:IMAGE).should be_kind_of(DBF::Column)
+      table.column("IMAGE").should be_kind_of(DBF::Column)
+    end
+    
+    it "should return a DBF::Field object when the column_name exists" do
+      table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+      table.column(:IMAGE).should be_kind_of(DBF::Column)
+    end
   
-  before(:each) do
-    @table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+    it "should return nil when the column_name does not exist" do
+      table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+      table.column(:NOTANIMAGE).should be_nil
+    end
   end
   
-  it "should reload all data when sent #reload!" do
-    @table.records
-    @table.instance_eval("@records").should be_kind_of(Array)
-    @table.reload!
-    @table.instance_eval("@records").should be_nil
+  describe "#schema" do
+    it "should match the test schema fixture" do
+      table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+      control_schema = File.read(File.dirname(__FILE__) + '/../fixtures/dbase_83_schema.txt')
+
+      table.schema.should == control_schema
+    end
   end
   
-  it "should return a DBF::Field object when sent #column with a valid column_name given as a string or symbol" do
-    @table.column("IMAGE").should be_kind_of(DBF::Column)
-    @table.column(:IMAGE).should be_kind_of(DBF::Column)
+  describe "#version_description" do
+    it "should return a text description of the database type" do
+      table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+      table.version_description.should == "dBase III with memo file"
+    end
   end
   
-  it "should return nil when sent #column with an invalid column_name given as a string or symbol" do
-    @table.column("NOTANIMAGE").should be_nil
-    @table.column(:NOTANIMAGE).should be_nil
+  describe '#replace_extname' do
+    it 'should replace the extname' do
+      table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
+      table.send(:replace_extname, "dbase_83.dbf", 'fpt').should == 'dbase_83.fpt'
+    end
   end
   
-  it "should return a text description of the database type when sent #version_description" do
-    @table.version_description.should == "dBase III with memo file"
+  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}
+    end
+
   end
 
 end

metadata

@@ -1,41 +1,45 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: dbf
 version: !ruby/object:Gem::Version 
-  version: 1.0.5
-date: 2007-11-27 00:00:00 -08:00
-summary: A small fast library for reading dBase, xBase, Clipper and FoxPro database files.
-require_paths: 
-- lib
-email: keithm@infused.org
-homepage: http://dbf.rubyforge.org
-rubyforge_project: dbf
-description: "DBF is a small fast library for reading dBase, xBase, Clipper and FoxPro database files.  It is written completely in Ruby and has no external dependencies.  Copyright (c) 2006-2007 Keith Morrison <keithm@infused.org, www.infused.org>  * Official project page: http://rubyforge.org/projects/dbf * API Documentation: http://dbf.rubyforge.org/docs * To report bugs: http://www.rubyforge.org/tracker/?group_id=2009 * Questions: Email keithm@infused.org and put DBF somewhere in the subject line"
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.0.6
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Keith Morrison
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: "DBF is a small fast library for reading dBase, xBase, Clipper and FoxPro database files.  It is written completely in Ruby and has no external dependencies.  Copyright (c) 2006-2007 Keith Morrison <keithm@infused.org, www.infused.org>  * Official project page: http://rubyforge.org/projects/dbf * API Documentation: http://dbf.rubyforge.org/docs * To report bugs: http://www.rubyforge.org/tracker/?group_id=2009 * Questions: Email keithm@infused.org and put DBF somewhere in the subject line"
+email: keithm@infused.org
+executables: 
+- dbf
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- spec/fixtures/dbase_83_schema.txt
 files: 
 - History.txt
 - Manifest.txt
 - README.txt
 - Rakefile
-- benchmarks/performance.rb
-- benchmarks/seek_benchmark.rb
 - bin/dbf
+- dbf.gemspec
 - lib/dbf.rb
 - lib/dbf/column.rb
 - lib/dbf/globals.rb
@@ -61,29 +65,32 @@ files:
 - spec/unit/column_spec.rb
 - spec/unit/record_spec.rb
 - spec/unit/table_spec.rb
-test_files: []
-
+has_rdoc: true
+homepage: http://github.com/infused/dm-dbf/tree/master
+post_install_message: 
 rdoc_options: 
 - --main
 - README.txt
-extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
-- spec/fixtures/dbase_83_schema.txt
-executables: 
-- dbf
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.3.0
-    version: 
+rubyforge_project: dbf
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A small fast library for reading dBase, xBase, Clipper and FoxPro database files.
+test_files: []
+

data/benchmarks/performance.rb

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift(File.dirname(__FILE__) + "/../lib/")
-require 'dbf'
-require 'profiler'
-
-dbf = DBF::Reader.new(File.join(File.dirname(__FILE__),'databases', 'foxpro.dbf'))
-
-Profiler__::start_profile
-
-dbf.records
-
-Profiler__::stop_profile
-Profiler__::print_profile($stdout)

data/benchmarks/seek_benchmark.rb

@@ -1,18 +0,0 @@
-#!/usr/bin/env ruby
-require 'benchmark'
-$:.unshift(File.dirname(__FILE__) + "/../lib/")
-require 'dbf'
-
-puts
-puts "Runs 5000 random row seeks first using the I/O based record(n) method and then using"
-puts "using the array of records."
-puts
-
-iterations = 5000
-Benchmark.bm(20) do |x|
-  @dbf = DBF::Reader.new(File.join(File.dirname(__FILE__), '..', 'test', 'databases', 'foxpro.dbf'))
-  max = @dbf.record_count + 1
-  
-  x.report("I/O based record(n)") { iterations.times { @dbf.record(rand(max)) } }
-  x.report("array of records[n]") { iterations.times { @dbf.records[rand(max)] } }
-end