dbf 5.1.1 → 5.3.0

data/lib/dbf/encoder.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module DBF
+  # Transcodes strings from a source encoding to a target encoding.
+  #
+  # Most DBF code pages map to encodings built into Ruby and are converted
+  # with String#encode. A few (Mazovia cp620, Kamenický cp895) have no Ruby
+  # equivalent and are decoded through vendored byte-to-Unicode tables.
+  module Encoder
+    # Byte-to-Unicode tables generated from
+    # https://github.com/SheetJS/js-codepage/blob/master/codepages/620.TBL and
+    # https://github.com/SheetJS/js-codepage/blob/master/codepages/895.TBL
+
+    # Mazovia (Polish) MS-DOS
+    CP620_TO_UNICODE = [
+      0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+      0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+      0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+      0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+      0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+      0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+      0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+      0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+      0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+      0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+      0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+      0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+      0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+      0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+      0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+      0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+      0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x0105, 0x00E7,
+      0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0107, 0x00C4, 0x0104,
+      0x0118, 0x0119, 0x0142, 0x00F4, 0x00F6, 0x0106, 0x00FB, 0x00F9,
+      0x015A, 0x00D6, 0x00DC, 0x00A2, 0x0141, 0x00A5, 0x015B, 0x0192,
+      0x0179, 0x017B, 0x00F3, 0x00D3, 0x0144, 0x0143, 0x017A, 0x017C,
+      0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+      0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+      0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+      0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+      0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+      0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+      0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+      0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+      0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+      0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+      0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
+    ].freeze
+
+    # Kamenický (Czech) MS-DOS
+    CP895_TO_UNICODE = [
+      0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+      0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+      0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+      0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+      0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+      0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+      0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+      0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+      0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+      0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+      0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+      0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+      0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+      0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+      0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+      0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+      0x010C, 0x00FC, 0x00E9, 0x010F, 0x00E4, 0x010E, 0x0164, 0x010D,
+      0x011B, 0x011A, 0x0139, 0x00CD, 0x013E, 0x01EA, 0x00C4, 0x00C1,
+      0x00C9, 0x017E, 0x017D, 0x00F4, 0x00F6, 0x00D3, 0x016F, 0x00DA,
+      0x00FD, 0x00D6, 0x00DC, 0x0160, 0x013D, 0x00DD, 0x0158, 0x0165,
+      0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x0148, 0x0147, 0x016E, 0x00D4,
+      0x0161, 0x0159, 0x0155, 0x0154, 0x00BC, 0x00A7, 0x00AB, 0x00BB,
+      0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+      0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+      0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+      0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+      0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+      0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+      0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+      0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+      0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+      0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
+    ].freeze
+
+    CUSTOM_TABLES = {
+      'cp620' => CP620_TO_UNICODE,
+      'cp895' => CP895_TO_UNICODE
+    }.freeze
+
+    # Is the encoding a code page without a Ruby Encoding, decoded through
+    # a vendored table?
+    #
+    # @param encoding [String, Encoding, nil]
+    # @return [Boolean]
+    def self.custom?(encoding)
+      encoding.is_a?(::String) && CUSTOM_TABLES.key?(encoding.downcase)
+    end
+
+    # Transcode a string from source_encoding to target_encoding
+    #
+    # @param string [String]
+    # @param source_encoding [String, Encoding]
+    # @param target_encoding [Encoding]
+    # @return [String]
+    def self.encode(string, source_encoding, target_encoding = Encoding.default_external)
+      table = source_encoding.is_a?(::String) && CUSTOM_TABLES[source_encoding.downcase]
+      if table
+        decoded = string.each_byte.map { |byte| table[byte] }.pack('U*')
+        target_encoding == Encoding::UTF_8 ? decoded : decoded.encode(target_encoding, undef: :replace, invalid: :replace)
+      else
+        string.force_encoding(source_encoding).encode(target_encoding, undef: :replace, invalid: :replace)
+      end
+    end
+  end
+end

data/lib/dbf/encodings.rb

@@ -5,6 +5,7 @@ module DBF
     '01' => 'cp437',       # U.S. MS-DOS
     '02' => 'cp850',       # International MS-DOS
     '03' => 'cp1252',      # Windows ANSI
+    '04' => 'macRoman',    # Standard Macintosh
     '08' => 'cp865',       # Danish OEM
     '09' => 'cp437',       # Dutch OEM
     '0a' => 'cp850',       # Dutch OEM*
@@ -45,6 +46,8 @@ module DBF
     '65' => 'cp866',       # Russian MS-DOS
     '66' => 'cp865',       # Nordic MS-DOS
     '67' => 'cp861',       # Icelandic MS-DOS
+    '68' => 'cp895',       # Kamenicky (Czech) MS-DOS
+    '69' => 'cp620',       # Mazovia (Polish) MS-DOS
     '6a' => 'cp737',       # Greek MS-DOS (437G)
     '6b' => 'cp857',       # Turkish MS-DOS
     '6c' => 'cp863',       # French-Canadian MS-DOS
@@ -53,9 +56,14 @@ module DBF
     '7a' => 'cp936',       # PRC GBK
     '7b' => 'cp932',       # Japanese Shift-JIS
     '7c' => 'cp874',       # Thai Windows/MS-DOS
+    '7d' => 'cp1255',      # Hebrew Windows
+    '7e' => 'cp1256',      # Arabic Windows
     '86' => 'cp737',       # Greek OEM
     '87' => 'cp852',       # Slovenian OEM
     '88' => 'cp857',       # Turkish OEM
+    '96' => 'macCyrillic', # Russian Macintosh
+    '97' => 'macCentEuro', # Macintosh EE
+    '98' => 'macGreek',    # Greek Macintosh
     'c8' => 'cp1250',      # Eastern European Windows
     'c9' => 'cp1251',      # Russian Windows
     'ca' => 'cp1254',      # Turkish Windows

data/lib/dbf/file_handler.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DBF
+  module FileHandler
+    module_function
+
+    def open_data(data)
+      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, memo_class, version)
+      if memo
+        meth = memo.is_a?(StringIO) ? :new : :open
+        memo_class.send(meth, memo, version)
+      elsif !data.is_a?(StringIO)
+        path = Dir.glob(memo_search_path(data)).first
+        path && memo_class.open(path, version)
+      end
+    end
+
+    def memo_search_path(io)
+      dirname = File.dirname(io)
+      basename = File.basename(io, '.*')
+      "#{dirname}/#{basename}*.{fpt,FPT,dbt,DBT}"
+    end
+  end
+end

data/lib/dbf/find.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DBF
+  # The Find module provides methods for searching and retrieving
+  # 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'".
+  module Find
+    # @param command [Integer, Symbol] command
+    # @param options [optional, Hash] options Hash of search parameters
+    # @yield [optional, DBF::Record, NilClass]
+    def find(command, options = {}, &)
+      case command
+      when Integer then record(command)
+      when Array then command.map { |index| record(index) }
+      when :all then find_all_records(options, &)
+      when :first then find_first_record(options)
+      end
+    end
+
+    private
+
+    def find_all_records(options)
+      select do |record|
+        next unless record&.match?(options)
+
+        yield record if block_given?
+        record
+      end
+    end
+
+    def find_first_record(options)
+      detect { |record| record&.match?(options) }
+    end
+  end
+end

data/lib/dbf/header.rb

@@ -5,19 +5,16 @@ module DBF
     attr_reader :version, :record_count, :header_length, :record_length, :encoding_key, :encoding
 
     def initialize(data)
-      @data = data
-      unpack_header
-    end
-
-    def unpack_header
-      @version = @data.unpack1('H2')
+      @version = data.unpack1('H2')
+      @encoding_key = nil
+      @encoding = nil
 
       case @version
       when '02'
-        @record_count, @record_length = @data.unpack('x v x3 v')
+        @record_count, @record_length = data.unpack('x v x3 v')
         @header_length = 521
       else
-        @record_count, @header_length, @record_length, @encoding_key = @data.unpack('x x3 V v2 x17 H2')
+        @record_count, @header_length, @record_length, @encoding_key = data.unpack('x x3 V v2 x17 H2')
         @encoding = DBF::ENCODINGS[@encoding_key]
       end
     end

data/lib/dbf/memo/base.rb

@@ -31,6 +31,8 @@ module DBF
 
       private
 
+      attr_reader :data
+
       def offset(start_block) # :nodoc:
         start_block * block_size
       end

data/lib/dbf/memo/dbase3.rb

@@ -4,10 +4,10 @@ module DBF
   module Memo
     class Dbase3 < Base
       def build_memo(start_block) # :nodoc:
-        @data.seek offset(start_block)
+        data.seek offset(start_block)
         memo_string = +''
         loop do
-          block = @data.read(BLOCK_SIZE).gsub(/(\000|\032)/, '')
+          block = data.read(BLOCK_SIZE).gsub(/(\000|\032)/, '')
           memo_string << block
           break if block.size < BLOCK_SIZE
         end

data/lib/dbf/memo/dbase4.rb

@@ -4,8 +4,8 @@ module DBF
   module Memo
     class Dbase4 < Base
       def build_memo(start_block) # :nodoc:
-        @data.seek offset(start_block)
-        @data.read(@data.read(BLOCK_HEADER_SIZE).unpack1('x4L'))
+        data.seek offset(start_block)
+        data.read(data.read(BLOCK_HEADER_SIZE).unpack1('x4L'))
       end
     end
   end

data/lib/dbf/memo/foxpro.rb

@@ -5,24 +5,31 @@ module DBF
     class Foxpro < Base
       FPT_HEADER_SIZE = 512
 
+      def initialize(data, version)
+        @data = data
+        super
+      end
+
       def build_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
+        read_memo_content(memo_string, memo_size)
       rescue StandardError
         nil
       end
 
       private
 
+      def read_memo_content(memo_string, memo_size) # :nodoc:
+        if memo_size > block_content_size
+          memo_string << @data.read(content_size(memo_size))
+        else
+          memo_string[0, memo_size]
+        end
+      end
+
       def block_size # :nodoc:
         @block_size ||= begin
           @data.rewind

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