dbf 5.1.1 → 5.2.0

data/lib/dbf/record.rb

@@ -6,14 +6,13 @@ module DBF
     # Initialize a new DBF::Record
     #
     # @param data [String, StringIO] data
-    # @param columns [Column]
-    # @param version [String]
-    # @param memo [DBF::Memo]
-    def initialize(data, columns, version, memo)
-      @data = StringIO.new(data)
-      @columns = columns
-      @version = version
-      @memo = memo
+    # @param context [DBF::RecordContext]
+    # @param offset [Integer]
+    def initialize(data, context, offset = 0)
+      @data = data
+      @context = context
+      @offset = offset
+      @to_a = nil
     end
 
     # Equality
@@ -21,7 +20,9 @@ module DBF
     # @param [DBF::Record] other
     # @return [Boolean]
     def ==(other)
-      other.respond_to?(:attributes) && other.attributes == attributes
+      attributes == other.attributes
+    rescue NoMethodError
+      false
     end
 
     # Reads attributes by column name
@@ -29,10 +30,13 @@ module DBF
     # @param name [String, Symbol] key
     def [](name)
       key = name.to_s
-      if attributes.key?(key)
+      if @context.column_offsets && !@to_a
+        index = column_name_index(key)
+        index ? column_value(index) : nil
+      elsif attributes.key?(key)
         attributes[key]
       elsif (index = underscored_column_names.index(key))
-        attributes[@columns[index].name]
+        attributes[@context.columns[index].name]
       end
     end
 
@@ -55,43 +59,65 @@ module DBF
     #
     # @return [Array]
     def to_a
-      @to_a ||= @columns.map { |column| init_attribute(column) }
+      @to_a ||= begin
+        data = @data
+        offset = @offset
+        columns = @context.columns
+        col_count = columns.length
+        result = Array.new(col_count)
+        index = 0
+        while index < col_count
+          column = columns[index]
+          len = column.length
+          raw = data.byteslice(offset, len)
+          offset += len
+          result[index] = decode_column(raw, column)
+          index += 1
+        end
+        @offset = offset
+        result
+      end
     end
 
     private
 
-    def column_names # :nodoc:
-      @column_names ||= @columns.map(&:name)
+    def decode_memo_value(raw) # :nodoc:
+      memo = @context.memo
+      return nil unless memo
+
+      version = @context.version
+      raw = raw.unpack1('V') if version == '30' || version == '31'
+      memo.get(raw.to_i)
     end
 
-    def get_data(column) # :nodoc:
-      @data.read(column.length)
+    def column_name_index(key) # :nodoc:
+      column_names.index(key) || underscored_column_names.index(key)
     end
 
-    def get_memo(column) # :nodoc:
-      if @memo
-        @memo.get(memo_start_block(column))
-      else
-        # the memo file is missing, so read ahead to next record and return nil
-        @data.read(column.length)
-        nil
-      end
+    def column_value(index) # :nodoc:
+      column = @context.columns[index]
+      col_offset = @offset + @context.column_offsets[index]
+      len = column.length
+      raw = @data.byteslice(col_offset, len)
+      decode_column(raw, column)
     end
 
-    def init_attribute(column) # :nodoc:
-      value = column.memo? ? get_memo(column) : get_data(column)
-      column.type_cast(value)
+    def decode_column(raw, column) # :nodoc:
+      column.decode(raw) { |raw_memo| decode_memo_value(raw_memo) }
     end
 
-    def memo_start_block(column) # :nodoc:
-      data = get_data(column)
-      data = data.unpack1('V') if %w[30 31].include?(@version)
-      data.to_i
+    def column_names # :nodoc:
+      @column_names ||= @context.columns.map(&:name)
     end
 
     def method_missing(method, *args) # :nodoc:
-      if (index = underscored_column_names.index(method.to_s))
-        attributes[@columns[index].name]
+      key = method.to_s
+      if (index = underscored_column_names.index(key))
+        if @context.column_offsets && !@to_a
+          column_value(index)
+        else
+          attributes[@context.columns[index].name]
+        end
       else
         super
       end
@@ -102,7 +128,7 @@ module DBF
     end
 
     def underscored_column_names # :nodoc:
-      @underscored_column_names ||= @columns.map(&:underscored_name)
+      @underscored_column_names ||= @context.columns.map(&:underscored_name)
     end
   end
 end

data/lib/dbf/record_context.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DBF
+  RecordContext = Struct.new(:columns, :version, :memo, :column_offsets, keyword_init: true)
+end

data/lib/dbf/record_iterator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DBF
+  class RecordIterator
+    def initialize(data, context, header_length, record_length, record_count)
+      @data = data
+      @context = context
+      @header_length = header_length
+      @record_length = record_length
+      @record_count = record_count
+    end
+
+    def each
+      buf = read_buffer
+      return unless buf
+
+      pos = 0
+      @record_count.times do
+        if buf.getbyte(pos) == 0x2A
+          yield nil
+        else
+          yield Record.new(buf, @context, pos + 1)
+        end
+        pos += @record_length
+      end
+    end
+
+    private
+
+    def read_buffer
+      @data.seek(@header_length)
+      @data.read(@record_length * @record_count)
+    end
+  end
+end

data/lib/dbf/schema.rb

@@ -14,6 +14,11 @@ module DBF
       'B' => ':binary'
     }.freeze
 
+    STRING_DATA_FORMATS = {
+      sequel: ':varchar, :size => %s',
+      activerecord: ':string, :limit => %s'
+    }.freeze
+
     # Generate an ActiveRecord::Schema
     #
     # xBase data types are converted to generic types as follows:
@@ -49,27 +54,25 @@ module DBF
     end
 
     def activerecord_schema(*) # :nodoc:
-      s = +"ActiveRecord::Schema.define do\n"
-      s << "  create_table \"#{name}\" do |t|\n"
+      output = +"ActiveRecord::Schema.define do\n"
+      output << "  create_table \"#{name}\" do |t|\n"
       columns.each do |column|
-        s << "    t.column #{activerecord_schema_definition(column)}"
+        output << "    t.column #{activerecord_schema_definition(column)}"
       end
-      s << "  end\nend"
-      s
+      output << "  end\nend"
+      output
     end
 
     def sequel_schema(table_only: false) # :nodoc:
-      s = +''
-      s << "Sequel.migration do\n" unless table_only
-      s << "  change do\n " unless table_only
-      s << "    create_table(:#{name}) do\n"
+      output = +''
+      output << "Sequel.migration do\n  change do\n " unless table_only
+      output << "    create_table(:#{name}) do\n"
       columns.each do |column|
-        s << "      column #{sequel_schema_definition(column)}"
+        output << "      column #{sequel_schema_definition(column)}"
       end
-      s << "    end\n"
-      s << "  end\n" unless table_only
-      s << "end\n" unless table_only
-      s
+      output << "    end\n"
+      output << "  end\nend\n" unless table_only
+      output
     end
 
     def json_schema(*) # :nodoc:
@@ -93,11 +96,12 @@ module DBF
     end
 
     def schema_data_type(column, format = :activerecord) # :nodoc:
-      case column.type
+      col_type = column.type
+      case col_type
       when 'N', 'F', 'I'
         number_data_type(column)
       when 'Y', 'D', 'T', 'L', 'M', 'B'
-        OTHER_DATA_TYPES[column.type]
+        OTHER_DATA_TYPES[col_type]
       else
         string_data_format(format, column)
       end
@@ -108,11 +112,7 @@ module DBF
     end
 
     def string_data_format(format, column)
-      if format == :sequel
-        ":varchar, :size => #{column.length}"
-      else
-        ":string, :limit => #{column.length}"
-      end
+      STRING_DATA_FORMATS.fetch(format, STRING_DATA_FORMATS[:activerecord]) % column.length
     end
   end
 end

data/lib/dbf/table.rb

@@ -13,42 +13,9 @@ module DBF
     extend Forwardable
     include Enumerable
     include ::DBF::Schema
+    include ::DBF::Find
 
-    DBASE2_HEADER_SIZE = 8
-    DBASE3_HEADER_SIZE = 32
-    DBASE7_HEADER_SIZE = 68
-
-    VERSIONS = {
-      '02' => 'FoxBase',
-      '03' => 'dBase III without memo file',
-      '04' => 'dBase IV without memo file',
-      '05' => 'dBase V without memo file',
-      '07' => 'Visual Objects 1.x',
-      '30' => 'Visual FoxPro',
-      '32' => 'Visual FoxPro with field type Varchar or Varbinary',
-      '31' => 'Visual FoxPro with AutoIncrement field',
-      '43' => 'dBASE IV SQL table files, no memo',
-      '63' => 'dBASE IV SQL system files, no memo',
-      '7b' => 'dBase IV with memo file',
-      '83' => 'dBase III with memo file',
-      '87' => 'Visual Objects 1.x with memo file',
-      '8b' => 'dBase IV with memo file',
-      '8c' => 'dBase 7',
-      '8e' => 'dBase IV with SQL table',
-      'cb' => 'dBASE IV SQL table files, with memo',
-      'f5' => 'FoxPro with memo file',
-      'fb' => 'FoxPro without memo file'
-    }.freeze
-
-    FOXPRO_VERSIONS = {
-      '30' => 'Visual FoxPro',
-      '31' => 'Visual FoxPro with AutoIncrement field',
-      'f5' => 'FoxPro with memo file',
-      'fb' => 'FoxPro without memo file'
-    }.freeze
-
-    attr_accessor :encoding
-    attr_writer :name
+    attr_reader :encoding
 
     def_delegator :header, :header_length
     def_delegator :header, :record_count
@@ -76,10 +43,12 @@ module DBF
     # @param data [String, StringIO] data Path to the dbf file or a StringIO object
     # @param memo [optional String, StringIO] memo Path to the memo file or a StringIO object
     # @param encoding [optional String, Encoding] encoding Name of the encoding or an Encoding object
-    def initialize(data, memo = nil, encoding = nil)
-      @data = open_data(data)
-      @encoding = encoding || header.encoding || Encoding.default_external
-      @memo = open_memo(data, memo)
+    def initialize(data, memo = nil, encoding = nil, name: nil)
+      @data = FileHandler.open_data(data)
+      @user_encoding = encoding
+      @encoding = determine_encoding
+      @memo = FileHandler.open_memo(data, memo, version_config.memo_class, version)
+      @name = name
       yield self if block_given?
     end
 
@@ -93,11 +62,7 @@ module DBF
 
     # @return [TrueClass, FalseClass]
     def closed?
-      if @memo
-        @data.closed? && @memo.closed?
-      else
-        @data.closed?
-      end
+      @data.closed? && (!@memo || @memo.closed?)
     end
 
     # Column names
@@ -107,6 +72,20 @@ module DBF
       @column_names ||= columns.map(&:name)
     end
 
+    # Cumulative byte offsets for each column within a record
+    #
+    # @return [Array<Integer>]
+    def column_offsets
+      @column_offsets ||= begin
+        sum = 0
+        columns.map { |col| sum.tap { sum += col.length } }
+      end
+    end
+
+    def record_context
+      @record_context ||= RecordContext.new(columns:, version:, memo: @memo, column_offsets:)
+    end
+
     # All columns
     #
     # @return [Array]
@@ -118,53 +97,16 @@ module DBF
     # if the record has been marked as deleted.
     #
     # @yield [nil, DBF::Record]
-    def each
-      record_count.times { |i| yield record(i) }
+    def each(&)
+      return enum_for(:each) unless block_given?
+      return if columns.empty?
+
+      RecordIterator.new(@data, record_context, header_length, record_length, record_count).each(&)
     end
 
     # @return [String]
     def filename
-      return unless @data.respond_to?(:path)
-
-      File.basename(@data.path)
-    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 command [Integer, Symbol] command
-    # @param options [optional, Hash] options Hash of search parameters
-    # @yield [optional, DBF::Record, NilClass]
-    def find(command, options = {}, &block)
-      case command
-      when Integer
-        record(command)
-      when Array
-        command.map { |i| record(i) }
-      when :all
-        find_all(options, &block)
-      when :first
-        find_first(options)
-      end
+      File.basename(@data.path) if @data.is_a?(File)
     end
 
     # @return [TrueClass, FalseClass]
@@ -190,7 +132,7 @@ module DBF
       return nil if deleted_record?
 
       record_data = @data.read(record_length)
-      DBF::Record.new(record_data, columns, version, @memo)
+      DBF::Record.new(record_data, record_context)
     end
 
     alias row record
@@ -200,8 +142,7 @@ module DBF
     #
     # @param [optional String] path Defaults to STDOUT
     def to_csv(path = nil)
-      out_io = path ? File.open(path, 'w') : $stdout
-      csv = CSV.new(out_io, force_quotes: true)
+      csv = CSV.new(path ? File.open(path, 'w') : $stdout, force_quotes: true)
       csv << column_names
       each { |record| csv << record.to_a }
     end
@@ -210,7 +151,7 @@ module DBF
     #
     # @return [String]
     def version_description
-      VERSIONS[version]
+      version_config.version_description
     end
 
     # Encode string
@@ -230,104 +171,27 @@ module DBF
 
     private
 
-    def build_columns # :nodoc:
-      safe_seek do
-        @data.seek(header_size)
-        [].tap do |columns|
-          until end_of_record?
-            args = case version
-            when '02'
-              [self, *@data.read(header_size * 2).unpack('A11 a C'), 0]
-            when '04', '8c'
-              [self, *@data.read(48).unpack('A32 a C C x13')]
-            else
-              [self, *@data.read(header_size).unpack('A11 a x4 C2')]
-            end
-
-            columns << Column.new(*args)
-          end
-        end
-      end
-    end
-
-    def header_size
-      case version
-      when '02'
-        DBASE2_HEADER_SIZE
-      when '04', '8c'
-        DBASE7_HEADER_SIZE
-      else 
-        DBASE3_HEADER_SIZE
-      end
-    end
-
-    def deleted_record? # :nodoc:
-      flag = @data.read(1)
-      flag ? flag.unpack1('a') == '*' : true
-    end
-
-    def end_of_record? # :nodoc:
-      safe_seek { @data.read(1).ord == 13 }
+    def version_config
+      @version_config ||= VersionConfig.new(version)
     end
 
-    def find_all(options) # :nodoc:
-      select do |record|
-        next unless record&.match?(options)
-
-        yield record if block_given?
-        record
-      end
+    def determine_encoding
+      @user_encoding || header.encoding || Encoding.default_external
     end
 
-    def find_first(options) # :nodoc:
-      detect { |record| record&.match?(options) }
+    def build_columns # :nodoc:
+      ColumnBuilder.new(self, @data, version_config).build
     end
 
-    def foxpro? # :nodoc:
-      FOXPRO_VERSIONS.key?(version)
+    def deleted_record? # :nodoc:
+      flag = @data.read(1)
+      flag ? flag.getbyte(0) == 0x2A : true
     end
 
     def header # :nodoc:
       @header ||= safe_seek do
         @data.seek(0)
-        Header.new(@data.read(DBASE3_HEADER_SIZE))
-      end
-    end
-
-    def memo_class # :nodoc:
-      @memo_class ||= if foxpro?
-        Memo::Foxpro
-      else
-        version == '83' ? Memo::Dbase3 : Memo::Dbase4
-      end
-    end
-
-    def memo_search_path(io) # :nodoc:
-      dirname = File.dirname(io)
-      basename = File.basename(io, '.*')
-      "#{dirname}/#{basename}*.{fpt,FPT,dbt,DBT}"
-    end
-
-    def open_data(data) # :nodoc:
-      case data
-      when StringIO
-        data
-      when String
-        File.open(data, 'rb')
-      else
-        raise ArgumentError, 'data must be a file path or StringIO object'
-      end
-    rescue Errno::ENOENT
-      raise DBF::FileNotFoundError, "file not found: #{data}"
-    end
-
-    def open_memo(data, memo = nil) # :nodoc:
-      if memo
-        meth = memo.is_a?(StringIO) ? :new : :open
-        memo_class.send(meth, memo, version)
-      elsif !data.is_a?(StringIO)
-        files = Dir.glob(memo_search_path(data))
-        files.any? ? memo_class.open(files.first, version) : nil
+        Header.new(@data.read(VersionConfig::DBASE3_HEADER_SIZE))
       end
     end
 

data/lib/dbf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DBF
-  VERSION = '5.1.1'.freeze
+  VERSION = '5.2.0'
 end

data/lib/dbf/version_config.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module DBF
+  class VersionConfig
+    DBASE2_HEADER_SIZE = 8
+    DBASE3_HEADER_SIZE = 32
+    DBASE7_HEADER_SIZE = 68
+
+    VERSIONS = {
+      '02' => 'FoxBase',
+      '03' => 'dBase III without memo file',
+      '04' => 'dBase IV without memo file',
+      '05' => 'dBase V without memo file',
+      '07' => 'Visual Objects 1.x',
+      '30' => 'Visual FoxPro',
+      '32' => 'Visual FoxPro with field type Varchar or Varbinary',
+      '31' => 'Visual FoxPro with AutoIncrement field',
+      '43' => 'dBASE IV SQL table files, no memo',
+      '63' => 'dBASE IV SQL system files, no memo',
+      '7b' => 'dBase IV with memo file',
+      '83' => 'dBase III with memo file',
+      '87' => 'Visual Objects 1.x with memo file',
+      '8b' => 'dBase IV with memo file',
+      '8c' => 'dBase 7',
+      '8e' => 'dBase IV with SQL table',
+      'cb' => 'dBASE IV SQL table files, with memo',
+      'f5' => 'FoxPro with memo file',
+      'fb' => 'FoxPro without memo file'
+    }.freeze
+
+    FOXPRO_VERSIONS = {
+      '30' => 'Visual FoxPro',
+      '31' => 'Visual FoxPro with AutoIncrement field',
+      'f5' => 'FoxPro with memo file',
+      'fb' => 'FoxPro without memo file'
+    }.freeze
+
+    attr_reader :version
+
+    def initialize(version)
+      @version = version
+    end
+
+    def version_description
+      VERSIONS[version]
+    end
+
+    def header_size
+      case version
+      when '02'
+        DBASE2_HEADER_SIZE
+      when '04', '8c'
+        DBASE7_HEADER_SIZE
+      else
+        DBASE3_HEADER_SIZE
+      end
+    end
+
+    def foxpro?
+      FOXPRO_VERSIONS.key?(version)
+    end
+
+    def memo_class
+      if foxpro?
+        Memo::Foxpro
+      else
+        version == '83' ? Memo::Dbase3 : Memo::Dbase4
+      end
+    end
+
+    def read_column_args(table, io)
+      case version
+      when '02' then [table, *io.read(header_size * 2).unpack('A11 a C'), 0]
+      when '04', '8c' then [table, *io.read(48).unpack('A32 a C C x13')]
+      else [table, *io.read(header_size).unpack('A11 a x4 C2')]
+      end
+    end
+  end
+end

data/lib/dbf.rb

@@ -8,11 +8,17 @@ require 'time'
 
 require 'dbf/version'
 require 'dbf/schema'
+require 'dbf/find'
 require 'dbf/record'
+require 'dbf/record_context'
 require 'dbf/column_type'
 require 'dbf/column'
 require 'dbf/encodings'
 require 'dbf/header'
+require 'dbf/version_config'
+require 'dbf/file_handler'
+require 'dbf/column_builder'
+require 'dbf/record_iterator'
 require 'dbf/table'
 require 'dbf/memo/base'
 require 'dbf/memo/dbase3'