dbf 0.4.7 → 0.5.0

data/History.txt

@@ -0,0 +1,9 @@
+== 0.5.0 / 2007-05-25
+
+* New find method
+* Full compatibility with the two flavors of memo file
+* Two modes of operation:
+  * In memory (default): All records are loaded into memory on the first
+    request. Records are retrieved from memory for all subsequent requests.
+  * File I/O: All records are retrieved from disk on every request
+* Improved documentation and more usage examples

data/Manifest.txt

@@ -0,0 +1,28 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+benchmarks/performance.rb
+benchmarks/seek_benchmark.rb
+lib/dbf.rb
+lib/dbf/field.rb
+lib/dbf/globals.rb
+lib/dbf/reader.rb
+lib/dbf/record.rb
+spec/field_spec.rb
+spec/fixtures/dbase_iii_memo_schema.rb
+spec/reader_spec.rb
+spec/record_spec.rb
+spec/spec_helper.rb
+test/common.rb
+test/databases/dbase_iii.dbf
+test/databases/dbase_iii_memo.dbf
+test/databases/dbase_iii_memo.dbt
+test/databases/foxpro.dbf
+test/databases/foxpro.fpt
+test/databases/visual_foxpro.dbf
+test/databases/visual_foxpro.fpt
+test/dbase_iii_memo_read_test.rb
+test/dbase_iii_read_test.rb
+test/foxpro_read_test.rb
+test/visual_foxpro_read_test.rb

data/README.txt

@@ -2,47 +2,59 @@
 
 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
+
 == Features
 
 * No external dependencies
-* DB fields are type cast
+* Fields are type cast to the appropriate Ruby types
 * Date/Time fields are returned as either a Time or Date object.  Date 
-  will only be used if the date is outside the range for Time.
+  will only be used if the date is out of range for Ruby's built in Time
+  class.
+* Ability to dump the database schema in the portable ActiveRecord::Schema
+  format.
 
 == Installation
-
+  
   gem install dbf
   
-== Usage
+== Basic Usage
+
+  require 'rubygems'
+  require 'dbf'
 
   reader = DBF::Reader.new("old_data.dbf")
   
+  # Print the 'name' field from record number 4
+  puts reader.record(4)['name'] 
+  
+  # Print the 'name' and 'address' fields from each record
   reader.records.each do |record|
     puts record['name']
     puts record['email']
   end
-  
-  puts reader.records[4]['name']
-  puts reader.record(4)['name']
-  
-=== A note on record vs. records
-
-DBF::Reader#records is an in-memory array of all rows in the database.  All
-rows are loaded the first time that the method is called.  Subsequent calls
-retrieve the row from memory.
-
-DBF::Reader#record retrieves the requested row from the database each time
-it is called. 
-
-Using records is probably faster most of the time.  Record is more appropriate 
-for very large databases where you don't want the whole db loaded into memory.
 
+  # 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)
+  
 == Limitations and known bugs
   
-* DBF is read-only.  Writing to the database has not yet been implemented.
+* DBF is read-only at the moment
+* Index files are not utilized
 
 == License
 
+(The MIT Licence)
+
 Copyright (c) 2006-2007 Keith Morrison <keithm@infused.org>
 
 Permission is hereby granted, free of charge, to any person

data/Rakefile

@@ -2,7 +2,7 @@ require 'hoe'
 require 'spec/rake/spectask'
 
 PKG_NAME = "dbf"
-PKG_VERSION = "0.4.7"
+PKG_VERSION = "0.5.0"
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 Hoe.new PKG_NAME, PKG_VERSION do |p|
@@ -10,6 +10,7 @@ Hoe.new PKG_NAME, PKG_VERSION do |p|
   p.author = "Keith Morrison"
   p.email = "keithm@infused.org"
   p.summary = "A small fast library for reading dBase, xBase, Clipper and FoxPro database files."
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
   p.url = "http://dbf.rubyforge.org"
   p.need_tar = true
   p.need_zip = true

data/benchmarks/seek_benchmark.rb

@@ -0,0 +1,18 @@
+#!/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

data/lib/dbf.rb

@@ -3,4 +3,4 @@ require 'date'
 require 'dbf/globals'
 require 'dbf/record'
 require 'dbf/field'
-require 'dbf/reader'
+require 'dbf/reader'

data/lib/dbf/reader.rb

@@ -1,119 +1,247 @@
 module DBF
   class Reader
+    # The total number of fields (columns)
     attr_reader :field_count
+    # An array of DBF::Field records
     attr_reader :fields
+    # The total number of records.  This number includes any deleted records.
     attr_reader :record_count
+    # 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
     
-    def initialize(file)
-      @data_file = File.open(file, 'rb')
-      @memo_file = open_memo(file)
+    # Initialize a new DBF::Reader.
+    # Example:
+    #   reader = DBF::Reader.new 'data.dbf'
+    def initialize(filename)
+      @in_memory = true
+      @data_file = File.open(filename, 'rb')
+      @memo_file = open_memo(filename)
       reload!
     end
     
+    # Reloads the database and memo files
     def reload!
+      @records = nil
       get_header_info
       get_memo_header_info if @memo_file
       get_field_descriptors
     end
     
+    # Returns true if there is a corresponding memo file
     def has_memo_file?
       @memo_file ? true : false
     end
     
-    def open_memo(file)
-      %w(fpt FPT dbt DBT).each do |extension|
-        filename = file.sub(/#{File.extname(file)[1..-1]}$/, extension)
-        if File.exists?(filename)
-          @memo_file_format = extension.downcase.to_sym
-          return File.open(filename, 'rb')
-        end
-      end
-      nil
+    # If true, DBF::Reader will load all records into memory.  If false, records are retrieved using file I/O.
+    def in_memory?
+      @in_memory
     end
     
+    # Tells DBF::Reader whether to load all records into memory.  Defaults to true.
+    # You may need to set this to false if the database is very large in order to reduce memory usage.
+    def in_memory=(boolean)
+      @in_memory = boolean
+    end
+    
+    # Returns an instance of DBF::Field for <b>field_name</b>.  <b>field_name</b>
+    # can be a symbol or a string.
     def field(field_name)
       @fields.detect {|f| f.name == field_name.to_s}
     end
     
     # An array of all the records contained in the database file
     def records
-      seek_to_record(0)
-      @records ||= Array.new(@record_count) do |i|
-        if active_record?
-          DBF::Record.new(self, @data_file, @memo_file)
-        else
-          seek_to_record(i + 1)
-          nil
-        end
+      if in_memory?
+        @records ||= get_all_records_from_file
+      else
+        get_all_records_from_file
       end
     end
     
     alias_method :rows, :records
     
-    # Returns the record at <a>index</i> 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.
+    # Returns the record at <tt>index</tt>.
     def record(index)
-      seek_to_record(index)
-      active_record? ? Record.new(self, @data_file, @memo_file) : nil
+      if in_memory?
+        records[index]
+      else
+        get_record_from_file(index)
+      end
+    end
+    
+    # Find records.  Examples:
+    #   reader = DBF::Reader.new 'mydata.dbf'
+    #   
+    #   # Find record number 5
+    #   reader.find(5)
+    #
+    #   # Find all records for Keith Morrison
+    #   reader.find :all, :first_name => "Keith", :last_name => "Morrison"
+    # 
+    #   # Find first record
+    #   reader.find :first, :first_name => "Keith"
+    #
+    # 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
+    # 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
+        records.select do |record|
+          options.map {|key, value| record[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?
+        end
+      end
     end
     
     alias_method :row, :record
     
+    # Returns a description of the current database file.
     def version_description
       VERSION_DESCRIPTIONS[version]
     end
     
+    # 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
+    #   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
+    #
+    # Example:
+    #   create_table "mydata" do |t|
+    #     t.column :name, :string, :limit => 30
+    #     t.column :last_update, :datetime
+    #     t.column :is_active, :boolean
+    #     t.column :age, :integer
+    #     t.column :notes, :text
+    #   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
+        when "N" # number
+          if field.decimal > 0
+            s << ", :float"
+          else
+            s << ", :integer"
+          end
+        when "D" # date
+          s << ", :datetime"
+        when "L" # boolean
+          s << ", :boolean"
+        when "M" # memo
+          s << ", :text"
+        else
+          s << ", :string, :limit => #{field.length}"
+        end
+        s << "\n"
+      end
+      s << "  end\nend"
+      
+      if path
+        return File.open(path, 'w') {|f| f.puts(s)}
+      else
+       return s
+     end
+    end
+    
     private
     
-    # 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
-    end
+      def open_memo(file)
+        %w(fpt FPT dbt DBT).each do |extension|
+          filename = file.sub(/#{File.extname(file)[1..-1]}$/, extension)
+          if File.exists?(filename)
+            @memo_file_format = extension.downcase.to_sym
+            return File.open(filename, 'rb')
+          end
+        end
+        nil
+      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
-    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
+      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
+      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_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)
+          end
         end
+        # adjust field count
+        @field_count = @fields.size
+        @fields
       end
-      # adjust field count
-      @field_count = @fields.size
-      @fields
-    end
     
-    def get_memo_header_info
-      @memo_file.rewind
-      if @memo_file_format == :fpt
-        @memo_next_available_block, @memo_block_size = @memo_file.read(FPT_HEADER_SIZE).unpack('Nxxn')
-      else
-        @memo_block_size = 512
-        @memo_next_available_block = File.size(@memo_file.path) / @memo_block_size
+      def get_memo_header_info
+        @memo_file.rewind
+        if @memo_file_format == :fpt
+          @memo_next_available_block, @memo_block_size = @memo_file.read(FPT_HEADER_SIZE).unpack('Nxxn')
+        else
+          @memo_block_size = 512
+          @memo_next_available_block = File.size(@memo_file.path) / @memo_block_size
+        end
       end
-    end
     
-    def seek(offset)
-      @data_file.seek(@header_length + offset)
-    end
+      def seek(offset)
+        @data_file.seek(@header_length + offset)
+      end
     
-    def seek_to_record(index)
-      seek(index * @record_length)
-    end
+      def seek_to_record(index)
+        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(index)
+        active_record? ? Record.new(self, @data_file, @memo_file) : nil
+      end
+      
+      def get_all_records_from_file
+        seek_to_record(0)
+        Array.new(@record_count) do |i|
+          active_record? ? DBF::Record.new(self, @data_file, @memo_file) : nil
+        end
+      end
     
   end
   

data/lib/dbf/record.rb

@@ -21,7 +21,7 @@ module DBF
         when 'L' # logical
           self[field.name] = unpack_string(field) =~ /^(y|t)$/i ? true : false
         else
-          self[field.name] = unpack_string(field)
+          self[field.name] = unpack_string(field).strip
         end
       end
       self

data/spec/field_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe DBF::Field, "when initialized" do
+  
+  before(:each) do
+    @field = DBF::Field.new "FieldName", "N", 1, 0
+  end
+  
+  it "should set the 'name' accessor" do
+    @field.name.should == "FieldName"
+  end
+  
+  it "should set the 'type' accessor" do
+    @field.type.should == "N"
+  end
+  
+  it "should set the 'length' accessor" do
+    @field.length.should == 1
+  end
+  
+  it "should set the 'decimal' accessor" do
+    @field.decimal.should == 0
+  end
+  
+  it "should raise an error if length is greater than 0" do
+    lambda { field = DBF::Field.new "FieldName", "N", -1, 0 }.should raise_error(DBF::FieldLengthError)
+  end
+  
+  it "should strip null characters from the name" do
+    field = DBF::Field.new "Field\0Name\0", "N", 1, 0
+    field.name.should == "FieldName"
+  end
+  
+end

data/spec/fixtures/dbase_iii_memo_schema.rb

@@ -0,0 +1,19 @@
+ActiveRecord::Schema.define do
+  create_table "dbase_iii_memo" do |t|
+    t.column "ID", :integer
+    t.column "CATCOUNT", :integer
+    t.column "AGRPCOUNT", :integer
+    t.column "PGRPCOUNT", :integer
+    t.column "ORDER", :integer
+    t.column "CODE", :string, :limit => 50
+    t.column "NAME", :string, :limit => 100
+    t.column "THUMBNAIL", :string, :limit => 254
+    t.column "IMAGE", :string, :limit => 254
+    t.column "PRICE", :float
+    t.column "COST", :float
+    t.column "DESC", :text
+    t.column "WEIGHT", :float
+    t.column "TAXABLE", :boolean
+    t.column "ACTIVE", :boolean
+  end
+end

data/spec/reader_spec.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe DBF::Reader, "when initialized" do
+  
+  before(:all) do
+    @reader = DBF::Reader.new File.dirname(__FILE__) + '/../test/databases/dbase_iii_memo.dbf'
+  end
+  
+  it "should load the data file" do
+    @reader.instance_eval("@data_file").should be_kind_of(File)
+  end
+  
+  it "should locate load the memo file" do
+    @reader.has_memo_file?.should be_true
+    @reader.instance_eval("@memo_file").should be_kind_of(File)
+  end
+  
+  it "should determine the memo file format" do
+    @reader.memo_file_format.should == :dbt
+  end
+  
+  it "should determine the memo block size" do
+    @reader.memo_block_size.should == 512
+  end
+  
+  it "should default to loading all records into memory" do
+    @reader.in_memory?.should be_true
+  end
+  
+  it "should determine the number of fields in each record" do
+    @reader.fields.size.should == 15
+  end
+  
+  it "should determine the number of records in the database" do
+    @reader.record_count.should == 67
+  end
+  
+  it "should determine the database version" do
+    @reader.version.should == "83"
+  end
+  
+end
+
+describe DBF::Reader, "when the in_memory flag is true" do
+  
+  before(:each) do
+    @reader = DBF::Reader.new File.dirname(__FILE__) + '/../test/databases/dbase_iii_memo.dbf'
+  end
+  
+  it "should build the records array from disk only on the first request" do
+    @reader.expects(:get_all_records_from_file).at_most_once.returns([])
+    3.times { @reader.records }
+  end
+  
+  it "should read from the records array when using the record() method" do
+    @reader.expects(:get_all_records_from_file).at_most_once.returns([])
+    @reader.expects(:get_record_from_file).never
+    @reader.expects(:records).times(2).returns([])
+    @reader.record(1)
+    @reader.record(10)
+  end
+  
+end
+
+describe DBF::Reader, "when the in_memory flag is false" do
+  
+  before(:each) do
+    @reader = DBF::Reader.new File.dirname(__FILE__) + '/../test/databases/dbase_iii_memo.dbf'
+  end
+  
+  it "should read the records from disk on every request" do
+    @reader.in_memory = false
+    @reader.expects(:get_all_records_from_file).times(3).returns([])
+    3.times { @reader.records }
+  end
+end
+
+describe DBF::Reader, "schema" do
+  
+  it "should match test schema " do
+    reader = DBF::Reader.new File.dirname(__FILE__) + '/../test/databases/dbase_iii_memo.dbf'
+    control_schema = File.read(File.dirname(__FILE__) + '/fixtures/dbase_iii_memo_schema.rb')
+    
+    reader.schema.should == control_schema
+  end
+  
+end
+
+describe DBF::Reader, "find(index)" do
+  
+  before(:all) do
+    @reader = DBF::Reader.new File.dirname(__FILE__) + '/../test/databases/dbase_iii_memo.dbf'
+  end
+  
+  it "should return the correct record" do
+    @reader.find(5).should == @reader.record(5)
+  end
+  
+  it "should raise an error if options are not empty" do
+    lambda { @reader.find(5, :name => 'test') }.should raise_error(ArgumentError)
+  end
+  
+end
+
+describe DBF::Reader, "find(:all)" do
+  
+  before(:all) do
+    @reader = DBF::Reader.new File.dirname(__FILE__) + '/../test/databases/dbase_iii_memo.dbf'
+  end
+  
+  it "should return all records if options are empty" do
+    @reader.find(:all).should == @reader.records
+  end
+  
+  it "should return matching records when used with options" do
+    @reader.find(:all, "WEIGHT" => 0.0).should == @reader.records.select {|r| r["WEIGHT"] == 0.0}
+  end
+  
+  it "with multiple options should search for all search terms as if using AND" do
+    @reader.find(:all, "ID" => 30, "IMAGE" => "graphics/00000001/TBC01.jpg").should == []
+  end
+end
+
+describe DBF::Reader, "find(:first)" do
+  
+  before(:all) do
+    @reader = DBF::Reader.new File.dirname(__FILE__) + '/../test/databases/dbase_iii_memo.dbf'
+  end
+  
+  it "should return the first record if options are empty" do
+    @reader.find(:first).should == @reader.records.first
+  end
+  
+  it "should return the first matching record when used with options" do
+    @reader.find(:first, "CODE" => "C").should == @reader.record(5)
+  end
+  
+  it "with multiple options should search for all search terms as if using AND" do
+    @reader.find(:first, "ID" => 30, "IMAGE" => "graphics/00000001/TBC01.jpg").should be_nil
+  end
+end
+

data/spec/record_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe DBF::Record, "when initialized" do
+  
+  it "should convert number fields with 0 decimals to integers" do
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+require "rubygems"
+require "spec"
+require "dbf"
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end

data/test/dbase_iii_memo_read_test.rb

@@ -0,0 +1,27 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+require 'test/unit'
+require 'dbf'
+require 'common'
+
+class DBaseIIIWithMemoReadTest < Test::Unit::TestCase
+  include CommonTests::Read
+  
+  def setup
+    @controls = {
+      :version => "83",
+      :has_memo_file => true,
+      :memo_file_format => :dbt,
+      :field_count => 15,
+      :record_count => 67,
+      :record_length => 805,
+      :testable_character_field_names => ["CODE"],
+      :testable_date_field_names => [],
+      :testable_integer_field_names => ["AGRPCOUNT"],
+      :testable_float_field_names => ["PRICE"],
+      :testable_logical_field_names => ["TAXABLE"],
+      :testable_memo_field_names => ["DESC"]
+    }
+    @dbf = DBF::Reader.new(File.join(File.dirname(__FILE__),'databases', 'dbase_iii_memo.dbf'))
+  end
+  
+end

data/test/visual_foxpro_read_test.rb

@@ -0,0 +1,27 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+require 'test/unit'
+require 'dbf'
+require 'common'
+
+class VisualFoxproReadTest < Test::Unit::TestCase
+  include CommonTests::Read
+  
+  def setup
+    @controls = {
+      :version => "30",
+      :has_memo_file => true,
+      :memo_file_format => :fpt,
+      :field_count => 145,
+      :record_count => 34,
+      :record_length => 3907,
+      :testable_character_field_names => [],
+      :testable_date_field_names => [],
+      :testable_integer_field_names => ["IMAGENO"],
+      :testable_float_field_names => [],
+      :testable_logical_field_names => [],
+      :testable_memo_field_names => ["CREDIT"]
+    }
+    @dbf = DBF::Reader.new(File.join(File.dirname(__FILE__),'databases', 'visual_foxpro.dbf'))
+  end
+  
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: dbf
 version: !ruby/object:Gem::Version 
-  version: 0.4.7
-date: 2007-05-25 00:00:00 -07:00
+  version: 0.5.0
+date: 2007-05-26 00:00:00 -07:00
 summary: A small fast library for reading dBase, xBase, Clipper and FoxPro database files.
 require_paths: 
 - lib
@@ -29,31 +29,43 @@ post_install_message:
 authors: 
 - Keith Morrison
 files: 
-- Rakefile
+- History.txt
+- Manifest.txt
 - README.txt
-- LICENSE.txt
+- Rakefile
+- benchmarks/performance.rb
+- benchmarks/seek_benchmark.rb
 - lib/dbf.rb
 - lib/dbf/field.rb
 - lib/dbf/globals.rb
 - lib/dbf/reader.rb
 - lib/dbf/record.rb
+- spec/field_spec.rb
+- spec/fixtures/dbase_iii_memo_schema.rb
+- spec/reader_spec.rb
+- spec/record_spec.rb
+- spec/spec_helper.rb
 - test/common.rb
-- test/dbase_iii_read_test.rb
-- test/foxpro_read_test.rb
-- test/performance.rb
 - test/databases/dbase_iii.dbf
+- test/databases/dbase_iii_memo.dbf
+- test/databases/dbase_iii_memo.dbt
 - test/databases/foxpro.dbf
 - test/databases/foxpro.fpt
 - test/databases/visual_foxpro.dbf
 - test/databases/visual_foxpro.fpt
+- test/dbase_iii_memo_read_test.rb
+- test/dbase_iii_read_test.rb
+- test/foxpro_read_test.rb
+- test/visual_foxpro_read_test.rb
 test_files: []
 
 rdoc_options: 
 - --main
 - README.txt
 extra_rdoc_files: 
+- History.txt
+- Manifest.txt
 - README.txt
-- LICENSE.txt
 executables: []
 
 extensions: []

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2006-2007 Keith Morrison <keithm@infused.org>
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.