dbf 1.3.0 → 1.5.0

data/lib/dbf/memo.rb

@@ -0,0 +1,88 @@
+module DBF
+  class Memo
+    BLOCK_HEADER_SIZE = 8
+    FPT_HEADER_SIZE = 512
+    
+    def initialize(data, version)
+      @data, @version = data, version
+    end
+    
+    def get(start_block)
+      if start_block > 0
+        if format_fpt?
+          build_fpt_memo start_block 
+        else
+          build_dbt_memo start_block
+        end
+      end
+    end
+    
+    def close
+      @data.close
+    end
+    
+    private
+    
+    def format_fpt? #nodoc
+      File.extname(@data.path) =~ /fpt/i
+    end
+    
+    def build_fpt_memo(start_block) #nodoc
+      @data.seek offset(start_block)
+      
+      memo_type, memo_size, memo_string = @data.read(block_size).unpack("NNa*")
+      return nil unless memo_type == 1 && memo_size > 0
+      
+      if memo_size > block_content_size
+        memo_string << @data.read(content_size(memo_size))
+      else
+        memo_string = memo_string[0, memo_size]
+      end
+      memo_string
+    end
+    
+    def build_dbt_memo(start_block) #nodoc
+      case @version
+      when "83" # dbase iii
+        build_dbt_83_memo(start_block)
+      when "8b" # dbase iv
+        build_dbt_8b_memo(start_block)
+      end
+    end
+    
+    def build_dbt_83_memo(start_block)
+      @data.seek offset(start_block)
+      memo_string = ""
+      begin
+        block = @data.read(block_size).gsub(/(\000|\032)/, '')
+        memo_string << block
+      end until block.size < block_size
+      memo_string
+    end
+    
+    def build_dbt_8b_memo(start_block)
+      @data.seek offset(start_block)
+      @data.read(@data.read(BLOCK_HEADER_SIZE).unpack("x4L").first)
+    end
+    
+    def offset(start_block) #nodoc
+      start_block * block_size
+    end
+
+    def content_size(memo_size) #nodoc
+      (memo_size - block_size) + BLOCK_HEADER_SIZE
+    end
+
+    def block_content_size #nodoc
+      @block_content_size ||= block_size - BLOCK_HEADER_SIZE
+    end
+    
+    def block_size #nodoc
+      @block_size ||= begin
+        @data.rewind
+        format_fpt? ? @data.read(FPT_HEADER_SIZE).unpack('x6n').first || 0 : 512
+      end
+    end
+    
+  end
+end

data/lib/dbf/record.rb

@@ -1,21 +1,11 @@
 module DBF
   # An instance of DBF::Record represents a row in the DBF file 
   class Record
-    BLOCK_HEADER_SIZE = 8
-    
-    attr_reader :table
-    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
+    def initialize(data, columns, version, memo)
+      @data, @columns, @version, @memo = StringIO.new(data), columns, version, memo
       define_accessors
     end
     
@@ -31,7 +21,7 @@ module DBF
     # 
     # @return [Array]
     def to_a
-      columns.map { |column| @attributes[column.name.underscore] }
+      @columns.map { |column| attributes[column.name.underscore] }
     end
     
     # Do all search parameters match?
@@ -42,109 +32,44 @@ module DBF
       options.all? {|key, value| attributes[key.to_s.underscore] == value}
     end
     
+    def attributes
+      return @attributes if @attributes
+      
+      @attributes = Attributes.new
+      @columns.each do |column|
+        @attributes[column.name] = init_attribute(column)
+      end
+      @attributes
+    end
+    
     private
     
-    # Defined attribute accessor methods
-    def define_accessors
-      columns.each do |column|
-        unless self.class.method_defined?(column.name.underscore)
-          self.class.send :define_method, column.name.underscore do
-            @attributes[column.name.underscore]
-          end
+    def define_accessors #nodoc
+      @columns.each do |column|
+        unless self.class.method_defined? column.underscored_name
+          self.class.class_eval <<-END
+            def #{column.underscored_name}
+              @#{column.underscored_name} ||= attributes['#{column.underscored_name}']
+            end
+          END
         end
       end
     end
     
-    # Initialize values for a row
-    def initialize_values
-      @attributes = columns.inject(Attributes.new) do |hash, column|
-        if column.memo?
-          hash[column.name] = read_memo(get_starting_block(column))
-        else
-          hash[column.name] = column.type_cast(unpack_data(column.length))
-        end
-        hash
-      end
+    def init_attribute(column) #nodoc
+      column.memo? ? @memo.get(get_memo_start_block(column)) : column.type_cast(unpack_data(column))
     end
    
-    # Unpack starting block from database
-    #
-    # @param [Fixnum] length
-    def get_starting_block(column)
-      if %w(30 31).include?(@table.version)
-        @data.read(column.length).unpack('V')[0]
+    def get_memo_start_block(column) #nodoc
+      if %w(30 31).include?(@version)
+        @data.read(column.length).unpack('V').first
       else
-        unpack_data(column.length).to_i
+        unpack_data(column).to_i
       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
-      send "build_#{@table.memo_file_format}_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)
-      
-      memo_type, memo_size, memo_string = @memo.read(memo_block_size).unpack("NNa*")
-      return nil unless memo_type == 1 && memo_size > 0
-      
-      if memo_size > memo_block_content_size
-        memo_string << @memo.read(memo_content_size(memo_size))
-      else
-        memo_string = memo_string[0, memo_size]
-      end
-      memo_string.strip
-    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)
-      
-      case @table.version
-      when "83" # dbase iii
-        memo_string = ""
-        loop do
-          block = @memo.read(memo_block_size)
-          memo_string << block
-          break if block.tr("\000",'').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
-    
-    # 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
+    def unpack_data(column) #nodoc
+      @data.read(column.length).unpack("a#{column.length}").first
     end
     
   end

data/lib/dbf/table.rb

@@ -2,9 +2,12 @@ module DBF
 
   # DBF::Table is the primary interface to a single DBF file and provides 
   # methods for enumerating and searching the records.
+  
+  # TODO set record_length to length of actual used column lengths
   class Table
+    include Enumerable
+    
     DBF_HEADER_SIZE = 32
-    FPT_HEADER_SIZE = 512
     
     VERSION_DESCRIPTIONS = {
       "02" => "FoxBase",
@@ -21,15 +24,7 @@ module DBF
       "fb" => "FoxPro without memo file"
     }
     
-    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 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
     
     # Opens a DBF::Table
@@ -39,37 +34,14 @@ module DBF
     # @param [String] path Path to the dbf file
     def initialize(path)
       @data = File.open(path, 'rb')
+      get_header_info
       @memo = open_memo(path)
-      reload!
     end
     
     # Closes the table and memo file
     def close
+      @memo && @memo.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
-      get_column_descriptors
-    end
-    
-    # Checks if there is a memo file
-    #
-    # @return [Boolean]
-    def has_memo_file?
-      @memo ? true : false
-    end
-    
-    # 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
     
     # Calls block once for each record in the table. The record may be nil
@@ -77,7 +49,7 @@ module DBF
     #
     # @yield [nil, DBF::Record]
     def each
-      0.upto(@record_count - 1) {|index| yield record(index)}
+      @record_count.times {|i| yield record(i)}
     end
     
     # Retrieve a record by index number.
@@ -120,40 +92,26 @@ module DBF
     #     t.column :notes, :text
     #   end
     #
-    # @param [optional String] path
     # @return [String]
-    def schema(path = nil)
+    def schema
       s = "ActiveRecord::Schema.define do\n"
       s << "  create_table \"#{File.basename(@data.path, ".*")}\" do |t|\n"
       columns.each do |column|
         s << "    t.column #{column.schema_definition}"
       end
-      s << "  end\nend"
-      
-      if path
-        File.open(path, 'w') {|f| f.puts(s)}
-      end
-        
+      s << "  end\nend"        
       s
     end
     
-    def to_a
-      records = []
-      each {|record| records << record if record}
-      records
-    end
-    
     # 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|
+      path = default_csv_path unless path
+      csv_class.open(path, 'w', :force_quotes => true) do |csv|
         csv << columns.map {|c| c.name}
-        each do |record|
-          csv << record.to_a
-        end
+        each {|record| csv << record.to_a}
       end
     end
     
@@ -194,121 +152,75 @@ module DBF
       end
     end
     
-    private
-    
-    # Find all matching
-    #
-    # @param [Hash] options
-    # @yield [optional DBF::Record]
-    # @return [Array]
-    def find_all(options, &block)
-      results = []
-      each do |record|
-        if record.try(:match?, options)
-          if block_given?
-            yield record
-          else
-            results << record
-          end
-        end
+    # Retrieves column information from the database
+    def columns
+      return @columns if @columns
+      
+      @data.seek(DBF_HEADER_SIZE)
+      @columns = []
+      column_count = (@header_length - DBF_HEADER_SIZE + 1) / DBF_HEADER_SIZE
+      column_count.times do
+        name, type, length, decimal = @data.read(32).unpack('a10 x a x4 C2')
+        @columns << Column.new(name.strip, type, length, decimal) if length > 0
       end
-      results
+      @columns
     end
     
-    # Find first matching
-    # 
-    # @param [Hash] options
-    # @return [DBF::Record, nil]
-    def find_first(options)
-      each do |record|
-        return record if record.try(:match?, options)
-      end
-      nil
-    end
+    private
     
-    # Open memo file
-    #
-    # @params [String] path
-    # @return [File]
-    def open_memo(path)
+    def open_memo(path) #nodoc
       %w(fpt FPT dbt DBT).each do |extname|
-        filename = replace_extname(path, extname)
+        filename = path.sub(/#{File.extname(path)[1..-1]}$/, extname)
         if File.exists?(filename)
-          @memo_file_format = extname.downcase.to_sym
-          return File.open(filename, 'rb')
+          return Memo.new(File.open(filename, 'rb'), version)
         end
       end
       nil
     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)
+    def find_all(options) #nodoc
+      map do |record|
+        if record.try(:match?, options)
+          yield record if block_given?
+          record
+        end
+      end.compact
     end
     
-    # Is record marked for deletion
-    #
-    # @return [Boolean]
-    def deleted_record?
+    def find_first(options) #nodoc
+      each do |record|
+        return record if record.try(:match?, options)
+      end
+      nil
+    end
+    
+    def deleted_record? #nodoc
       @data.read(1).unpack('a') == ['*']
     end
     
     def current_record
-      deleted_record? ? nil : DBF::Record.new(self)
+      deleted_record? ? nil : DBF::Record.new(@data.read(@record_length), columns, version, @memo)
     end
     
-    # Determine database version, record count, header length and record length
-    def get_header_info
+    def get_header_info #nodoc
       @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
-      
-      @columns
+    def seek(offset) #nodoc
+      @data.seek @header_length + offset
     end
-    
-    # Determines the memo block size and next available block
-    def get_memo_header_info
-      if has_memo_file?
-        @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
+  
+    def seek_to_record(index) #nodoc
+      seek index * @record_length
     end
     
-    # Seek to a byte offset
-    # 
-    # @params [Fixnum] offset
-    def seek(offset)
-      @data.seek(@header_length + offset)
+    def csv_class #nodoc
+      CSV.const_defined?(:Reader) ? FCSV : CSV
     end
-  
-    # Seek to a record
-    #
-    # @param [Fixnum] index
-    def seek_to_record(index)
-      seek(index * @record_length)
+    
+    def default_csv_path #nodoc
+      File.basename(@data.path, '.dbf') + '.csv'
     end
     
   end