dbf 5.1.1 → 5.3.0

data/spec/dbf/column_spec.rb

@@ -1,287 +0,0 @@
-# frozen_string_literal: true
-# encoding: ascii-8bit
-
-require 'spec_helper'
-
-RSpec.describe DBF::Column do
-  let(:table) { DBF::Table.new fixture('dbase_30.dbf') }
-
-  context 'when initialized' do
-    let(:column) { DBF::Column.new table, 'ColumnName', 'N', 1, 0 }
-
-    it 'sets :name accessor' do
-      expect(column.name).to eq 'ColumnName'
-    end
-
-    it 'sets :type accessor' do
-      expect(column.type).to eq 'N'
-    end
-
-    it 'sets the #length accessor' do
-      expect(column.length).to eq 1
-    end
-
-    it 'sets the #decimal accessor' do
-      expect(column.decimal).to eq 0
-    end
-
-    it 'accepts length of 0' do
-      column = DBF::Column.new table, 'ColumnName', 'N', 0, 0
-      expect(column.length).to eq 0
-    end
-
-    describe 'with length less than 0' do
-      it 'raises DBF::Column::LengthError' do
-        expect { DBF::Column.new table, 'ColumnName', 'N', -1, 0 }.to raise_error(DBF::Column::LengthError)
-      end
-    end
-
-    describe 'with empty column name' do
-      it 'raises DBF::Column::NameError' do
-        expect { DBF::Column.new table, '', 'N', 1, 0 }.to raise_error(DBF::Column::NameError)
-      end
-    end
-  end
-
-  describe '#type_cast' do
-    context 'with type N (number)' do
-      context 'when value is empty' do
-        it 'returns nil' do
-          value = ''
-          column = DBF::Column.new table, 'ColumnName', 'N', 5, 2
-          expect(column.type_cast(value)).to be_nil
-        end
-      end
-
-      context 'with 0 length' do
-        it 'returns nil' do
-          column = DBF::Column.new table, 'ColumnName', 'N', 0, 0
-          expect(column.type_cast('')).to be_nil
-        end
-      end
-
-      context 'with 0 decimals' do
-        it 'casts value to Integer' do
-          value = '135'
-          column = DBF::Column.new table, 'ColumnName', 'N', 3, 0
-          expect(column.type_cast(value)).to eq 135
-        end
-
-        it 'supports negative Integer' do
-          value = '-135'
-          column = DBF::Column.new table, 'ColumnName', 'N', 3, 0
-          expect(column.type_cast(value)).to eq(-135)
-        end
-      end
-
-      context 'with more than 0 decimals' do
-        it 'casts value to Float' do
-          value = '13.5'
-          column = DBF::Column.new table, 'ColumnName', 'N', 2, 1
-          expect(column.type_cast(value)).to eq 13.5
-        end
-
-        it 'casts negative value to Float' do
-          value = '-13.5'
-          column = DBF::Column.new table, 'ColumnName', 'N', 2, 1
-          expect(column.type_cast(value)).to eq(-13.5)
-        end
-      end
-    end
-
-    context 'with type F (float)' do
-      context 'with 0 length' do
-        it 'returns nil' do
-          column = DBF::Column.new table, 'ColumnName', 'F', 0, 0
-          expect(column.type_cast('')).to be_nil
-        end
-      end
-
-      it 'casts value to Float' do
-        value = '135'
-        column = DBF::Column.new table, 'ColumnName', 'F', 3, 0
-        expect(column.type_cast(value)).to eq 135.0
-      end
-
-      it 'casts negative value to Float' do
-        value = '-135'
-        column = DBF::Column.new table, 'ColumnName', 'F', 3, 0
-        expect(column.type_cast(value)).to eq(-135.0)
-      end
-    end
-
-    context 'with type B (binary)' do
-      context 'with Foxpro dbf' do
-        it 'casts to float' do
-          column = DBF::Column.new table, 'ColumnName', 'B', 1, 2
-          expect(column.type_cast("\xEC\x51\xB8\x1E\x85\x6B\x31\x40")).to be_a(Float)
-          expect(column.type_cast("\xEC\x51\xB8\x1E\x85\x6B\x31\x40")).to eq 17.42
-        end
-
-        it 'stores original precision' do
-          column = DBF::Column.new table, 'ColumnName', 'B', 1, 0
-          expect(column.type_cast("\xEC\x51\xB8\x1E\x85\x6B\x31\x40")).to be_a(Float)
-          expect(column.type_cast("\xEC\x51\xB8\x1E\x85\x6B\x31\x40")).to eq 17.42
-        end
-
-        it 'supports negative binary' do
-          column = DBF::Column.new table, 'ColumnName', 'B', 1, 2
-          expect(column.type_cast("\x00\x00\x00\x00\x00\xC0\x65\xC0")).to be_a(Float)
-          expect(column.type_cast("\x00\x00\x00\x00\x00\xC0\x65\xC0")).to eq(-174.0)
-        end
-      end
-    end
-
-    context 'with type I (integer)' do
-      context 'with 0 length' do
-        it 'returns nil' do
-          column = DBF::Column.new table, 'ColumnName', 'I', 0, 0
-          expect(column.type_cast('')).to be_nil
-        end
-      end
-
-      it 'casts value to Integer' do
-        value = "\203\171\001\000"
-        column = DBF::Column.new table, 'ColumnName', 'I', 3, 0
-        expect(column.type_cast(value)).to eq 96_643
-      end
-
-      it 'supports negative Integer' do
-        value = "\x24\xE1\xFF\xFF"
-        column = DBF::Column.new table, 'ColumnName', 'I', 3, 0
-        expect(column.type_cast(value)).to eq(-7900)
-      end
-    end
-
-    context 'with type L (logical/boolean)' do
-      let(:column) { DBF::Column.new table, 'ColumnName', 'L', 1, 0 }
-
-      it "casts 'y' to true" do
-        expect(column.type_cast('y')).to be true
-      end
-
-      it "casts 't' to true" do
-        expect(column.type_cast('t')).to be true
-      end
-
-      it "casts value other than 't' or 'y' to false" do
-        expect(column.type_cast('n')).to be false
-      end
-
-      context 'with 0 length' do
-        it 'returns nil' do
-          column = DBF::Column.new table, 'ColumnName', 'L', 0, 0
-          expect(column.type_cast('')).to be_nil
-        end
-      end
-    end
-
-    context 'with type T (datetime)' do
-      let(:column) { DBF::Column.new table, 'ColumnName', 'T', 16, 0 }
-
-      context 'with valid datetime' do
-        it 'casts to DateTime' do
-          expect(column.type_cast("Nl%\000\300Z\252\003")).to eq Time.parse('2002-10-10T17:04:56+00:00')
-        end
-      end
-
-      context 'with invalid datetime' do
-        it 'casts to nil' do
-          expect(column.type_cast("Nl%\000\000A\000\999")).to be_nil
-        end
-      end
-
-      context 'with 0 length' do
-        it 'returns nil' do
-          column = DBF::Column.new table, 'ColumnName', 'T', 0, 0
-          expect(column.type_cast('')).to be_nil
-        end
-      end
-    end
-
-    context 'with type D (date)' do
-      let(:column) { DBF::Column.new table, 'ColumnName', 'D', 8, 0 }
-
-      context 'with valid date' do
-        it 'casts to Date' do
-          expect(column.type_cast('20050712')).to eq Date.new(2005, 7, 12)
-        end
-      end
-
-      context 'with invalid date' do
-        it 'casts to nil' do
-          expect(column.type_cast('000000000')).to be_nil
-        end
-      end
-
-      context 'with 0 length' do
-        it 'returns nil' do
-          column = DBF::Column.new table, 'ColumnName', 'D', 0, 0
-          expect(column.type_cast('')).to be_nil
-        end
-      end
-    end
-
-    context 'with type M (memo)' do
-      it 'casts to string' do
-        column = DBF::Column.new table, 'ColumnName', 'M', 3, 0
-        expect(column.type_cast('abc')).to eq 'abc'
-      end
-
-      it 'casts nil to nil' do
-        column = DBF::Column.new table, 'ColumnName', 'M', 3, 0
-        expect(column.type_cast(nil)).to be_nil
-      end
-
-      context 'with 0 length' do
-        it 'returns nil' do
-          column = DBF::Column.new table, 'ColumnName', 'M', 0, 0
-          expect(column.type_cast('')).to be_nil
-        end
-      end
-    end
-
-    context 'with type G (memo)' do
-      it 'returns binary data' do
-        column = DBF::Column.new table, 'ColumnName', 'G', 3, 0
-        expect(column.type_cast("\000\013\120")).to eq "\000\013\120"
-        expect(column.type_cast("\000\013\120").encoding).to eq Encoding::ASCII_8BIT
-      end
-
-      it 'casts nil to nil' do
-        column = DBF::Column.new table, 'ColumnName', 'G', 3, 0
-        expect(column.type_cast(nil)).to be_nil
-      end
-
-      context 'with 0 length' do
-        it 'returns nil' do
-          column = DBF::Column.new table, 'ColumnName', 'G', 0, 0
-          expect(column.type_cast('')).to be_nil
-        end
-      end
-    end
-  end
-
-  context 'with type Y (currency)' do
-    let(:column) { DBF::Column.new table, 'ColumnName', 'Y', 8, 4 }
-
-    it 'casts to float' do
-      expect(column.type_cast(" \xBF\x02\x00\x00\x00\x00\x00")).to eq 18.0
-    end
-
-    it 'supports negative currency' do
-      expect(column.type_cast("\xFC\xF0\xF0\xFE\xFF\xFF\xFF\xFF")).to eq(-1776.41)
-    end
-
-    it 'supports 64bit negative currency' do
-      expect(column.type_cast("pN'9\xFF\xFF\xFF\xFF")).to eq(-333_609.0)
-    end
-
-    context 'with 0 length' do
-      it 'returns nil' do
-        column = DBF::Column.new table, 'ColumnName', 'Y', 0, 0
-        expect(column.type_cast('')).to be_nil
-      end
-    end
-  end
-end

data/spec/dbf/database/foxpro_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe DBF::Database::Foxpro do
-  let(:dbf_path) { fixture('foxprodb/FOXPRO-DB-TEST.DBC') }
-  let(:db) { DBF::Database::Foxpro.new(dbf_path) }
-
-  describe '#initialize' do
-    describe 'when given a path to an existing dbc file' do
-      it 'does not raise an error' do
-        expect { DBF::Database::Foxpro.new dbf_path }.to_not raise_error
-      end
-    end
-
-    describe 'when given a path to a non-existent dbf file' do
-      it 'raises a DBF::FileNotFound error' do
-        expect { DBF::Database::Foxpro.new 'x' }.to raise_error(DBF::FileNotFoundError, 'file not found: x')
-      end
-    end
-
-    describe 'it loads the example db correctly' do
-      it 'shows a correct list of tables' do
-        expect(db.table_names.sort).to eq(%w[contacts calls setup types].sort)
-      end
-    end
-  end
-
-  describe '#table' do
-    describe 'when accessing related tables' do
-      let(:db) { DBF::Database::Foxpro.new(dbf_path) }
-
-      it 'loads an existing related table' do
-        expect(db.contacts.record_count).to eq 5
-      end
-
-      it 'supports a long table field name' do
-        expect(db.contacts.record(1).spouses_interests).to eq 'Tennis, golf'
-      end
-
-      it 'loads an existing related table with wrong filename casing' do
-        expect(db.calls.record_count).to eq 16
-      end
-    end
-  end
-
-  describe '#table_path' do
-    it 'returns an absolute path' do
-      expect(db.table_path('contacts')).to eq File.expand_path('spec/fixtures/foxprodb/contacts.dbf')
-    end
-  end
-
-end

data/spec/dbf/encoding_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'DBF::Table' do
-  context 'with default encoding' do
-    let(:dbf_path) { fixture('dbase_03_cyrillic.dbf') }
-    let(:table) { DBF::Table.new dbf_path }
-  
-    it 'defaults to UTF-8 encoding' do
-      expect(table.encoding).to eq Encoding::UTF_8
-    end
-  
-    it 'uses the table encoding for column encoding' do
-      column = table.columns.first
-      expect(column.encoding).to eq table.encoding
-    end
-  
-    it 'encodes column names' do
-      expect(table.column_names).to eq %w[ШАР ПЛОЩА]
-    end
-  
-    it 'encodes record values' do
-      expect(table.record(0).attributes['ШАР']).to eq 'Номер'
-    end
-  end
-
-  context 'with embedded encoding' do
-    let(:dbf_path) { fixture('cp1251.dbf') }
-    let(:table) { DBF::Table.new dbf_path }
-  
-    it 'defaults to UTF-8 encoding' do
-      expect(table.encoding).to eq 'cp1251'
-    end
-  
-    it 'uses the table encoding for column encoding' do
-      column = table.columns.first
-      expect(column.encoding).to eq table.encoding
-    end
-  
-    it 'encodes column names' do
-      expect(table.column_names).to eq %w[RN NAME]
-    end
-  
-    it 'encodes record values' do
-      expect(table.record(0).attributes['NAME']).to eq 'амбулаторно-поликлиническое'
-    end
-  end
-end

data/spec/dbf/file_formats_spec.rb

@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.shared_examples_for 'DBF' do
-  let(:header_record_length) { table.instance_eval { header.record_length } }
-  let(:sum_of_column_lengths) { table.columns.inject(1) { |sum, column| sum + column.length } }
-
-  specify 'sum of column lengths should equal record length specified in header plus one' do
-    expect(header_record_length).to eq sum_of_column_lengths
-  end
-
-  specify 'records should be instances of DBF::Record' do
-    expect(table).to all be_a(DBF::Record)
-  end
-
-  specify 'record count should be the same as reported in the header' do
-    expect(table.entries.size).to eq table.record_count
-  end
-
-  specify 'column names should not be blank' do
-    table.columns.each do |column|
-      expect(column.name).to_not be_empty
-    end
-  end
-
-  specify 'column types should be valid' do
-    valid_column_types = %w[C N L D M F B G P Y T I V X @ O + 0]
-    table.columns.each do |column|
-      expect(valid_column_types).to include(column.type)
-    end
-  end
-
-  specify 'column lengths should be instances of Integer' do
-    table.columns.each do |column|
-      expect(column.length).to be_a(Integer)
-    end
-  end
-
-  specify 'column lengths should be larger than 0' do
-    table.columns.each do |column|
-      expect(column.length).to be > 0
-    end
-  end
-
-  specify 'column decimals should be instances of Integer' do
-    table.columns.each do |column|
-      expect(column.decimal).to be_a(Integer)
-    end
-  end
-end
-
-RSpec.describe DBF, 'of type 02 (FoxBase)' do
-  let(:table) { DBF::Table.new fixture('dbase_02.dbf') }
-
-  it_behaves_like 'DBF'
-
-  it 'reports the correct version number' do
-    expect(table.version).to eq '02'
-  end
-
-  it 'reports the correct version description' do
-    expect(table.version_description).to eq 'FoxBase'
-  end
-
-  it 'determines the number of records' do
-    expect(table.record_count).to eq 9
-  end
-end
-
-RSpec.describe DBF, 'of type 03 (dBase III without memo file)' do
-  let(:table) { DBF::Table.new fixture('dbase_03.dbf') }
-
-  it_behaves_like 'DBF'
-
-  it 'reports the correct version number' do
-    expect(table.version).to eq '03'
-  end
-
-  it 'reports the correct version description' do
-    expect(table.version_description).to eq 'dBase III without memo file'
-  end
-
-  it 'determines the number of records' do
-    expect(table.record_count).to eq 14
-  end
-end
-
-RSpec.describe DBF, 'of type 30 (Visual FoxPro)' do
-  let(:table) { DBF::Table.new fixture('dbase_30.dbf') }
-
-  it_behaves_like 'DBF'
-
-  it 'reports the correct version number' do
-    expect(table.version).to eq '30'
-  end
-
-  it 'reports the correct version description' do
-    expect(table.version_description).to eq 'Visual FoxPro'
-  end
-
-  it 'determines the number of records' do
-    expect(table.record_count).to eq 34
-  end
-
-  it 'reads memo data' do
-    expect(table.record(3).classes).to match(/\AAgriculture.*Farming\r\n\Z/m)
-  end
-end
-
-RSpec.describe DBF, 'of type 31 (Visual FoxPro with AutoIncrement field)' do
-  let(:table) { DBF::Table.new fixture('dbase_31.dbf') }
-
-  it_behaves_like 'DBF'
-
-  it 'has a dBase version of 31' do
-    expect(table.version).to eq '31'
-  end
-
-  it 'reports the correct version description' do
-    expect(table.version_description).to eq 'Visual FoxPro with AutoIncrement field'
-  end
-
-  it 'determines the number of records' do
-    expect(table.record_count).to eq 77
-  end
-end
-
-RSpec.describe DBF, 'of type 32 (Visual FoxPro with field type Varchar or Varbinary)' do
-  let(:table) { DBF::Table.new fixture('dbase_32.dbf') }
-
-  it_behaves_like 'DBF'
-
-  it 'has a dBase version of 32' do
-    expect(table.version).to eq '32'
-  end
-
-  it 'reports the correct version description' do
-    expect(table.version_description).to eq 'Visual FoxPro with field type Varchar or Varbinary'
-  end
-
-  it 'determines the number of records' do
-    expect(table.record_count).to eq 1
-  end
-end
-
-RSpec.describe DBF, 'of type 83 (dBase III with memo file)' do
-  let(:table) { DBF::Table.new fixture('dbase_83.dbf') }
-
-  it_behaves_like 'DBF'
-
-  it 'reports the correct version number' do
-    expect(table.version).to eq '83'
-  end
-
-  it 'reports the correct version description' do
-    expect(table.version_description).to eq 'dBase III with memo file'
-  end
-
-  it 'determines the number of records' do
-    expect(table.record_count).to eq 67
-  end
-end
-
-RSpec.describe DBF, 'of type 8b (dBase IV with memo file)' do
-  let(:table) { DBF::Table.new fixture('dbase_8b.dbf') }
-
-  it_behaves_like 'DBF'
-
-  it 'reports the correct version number' do
-    expect(table.version).to eq '8b'
-  end
-
-  it 'reports the correct version description' do
-    expect(table.version_description).to eq 'dBase IV with memo file'
-  end
-
-  it 'determines the number of records' do
-    expect(table.record_count).to eq 10
-  end
-end
-
-RSpec.describe DBF, 'of type 8c (unknown)' do
-  let(:table) { DBF::Table.new fixture('dbase_8c.dbf') }
-
-  it_behaves_like 'DBF'
-
-  it 'reports the correct version number' do
-    expect(table.version).to eq '8c'
-  end
-
-  it 'reports the correct version description' do
-    expect(table.version_description).to eq 'dBase 7'
-  end
-
-  it 'determines the number of records' do
-    expect(table.record_count).to eq 10
-  end
-end
-
-RSpec.describe DBF, 'of type f5 (FoxPro with memo file)' do
-  let(:table) { DBF::Table.new fixture('dbase_f5.dbf') }
-
-  it_behaves_like 'DBF'
-
-  it 'reports the correct version number' do
-    expect(table.version).to eq 'f5'
-  end
-
-  it 'reports the correct version description' do
-    expect(table.version_description).to eq 'FoxPro with memo file'
-  end
-
-  it 'determines the number of records' do
-    expect(table.record_count).to eq 975
-  end
-
-  it 'reads memo data' do
-    expect(table.record(3).datn.to_s).to eq '1870-06-30'
-  end
-end