dbf 5.1.0 → 5.2.0

data/spec/dbf/file_formats_spec.rb

@@ -1,219 +0,0 @@
-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

data/spec/dbf/record_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DBF::Record do
-  describe '#to_a' do
-    let(:table) { DBF::Table.new fixture('dbase_83.dbf') }
-
-    it 'returns an ordered array of attribute values' do
-      record = table.record(0)
-      expect(record.to_a).to eq YAML.load_file(fixture('dbase_83_record_0.yml'))
-
-      record = table.record(9)
-      expect(record.to_a).to eq YAML.load_file(fixture('dbase_83_record_9.yml'))
-    end
-
-    describe 'with missing memo file' do
-      describe 'when opening a path' do
-        let(:table) { DBF::Table.new fixture('dbase_83_missing_memo.dbf') }
-
-        it 'returns nil values for memo fields' do
-          record = table.record(0)
-          expect(record.to_a).to eq YAML.load_file(fixture('dbase_83_missing_memo_record_0.yml'))
-        end
-      end
-    end
-
-    describe 'when opening StringIO' do
-      let(:data) { StringIO.new(File.read(fixture('dbase_83_missing_memo.dbf'))) }
-      let(:table) { DBF::Table.new(data) }
-
-      it 'returns nil values for memo fields' do
-        record = table.record(0)
-        expect(record.to_a).to eq YAML.load_file(fixture('dbase_83_missing_memo_record_0.yml'))
-      end
-    end
-  end
-
-  describe '#==' do
-    let(:table) { DBF::Table.new fixture('dbase_8b.dbf') }
-    let(:record) { table.record(9) }
-
-    describe 'when other does not have attributes' do
-      it 'returns false' do
-        expect(record == instance_double(DBF::Record)).to be_falsey
-      end
-    end
-
-    describe 'if other attributes match' do
-      let(:attributes) { {x: 1, y: 2} }
-      let(:other) { instance_double(DBF::Record, attributes: attributes) }
-
-      before do
-        allow(record).to receive(:attributes).and_return(attributes)
-      end
-
-      it 'returns true' do
-        expect(record == other).to be_truthy
-      end
-    end
-
-  end
-
-  describe 'column accessors' do
-    let(:table) { DBF::Table.new fixture('dbase_8b.dbf') }
-    let(:record) { table.find(0) }
-
-    %w[character numerical date logical float memo].each do |column_name|
-      it "defines accessor method for '#{column_name}' column" do
-        expect(record).to respond_to(column_name.to_sym)
-      end
-
-    end
-  end
-
-  describe 'column data for table' do
-    describe 'using specified in dbf encoding' do
-      let(:table) { DBF::Table.new fixture('cp1251.dbf') }
-      let(:record) { table.find(0) }
-
-      it 'encodes to default system encoding' do
-        expect(record.name.encoding).to eq Encoding.default_external
-
-        # russian a
-        expect(record.name.encode('UTF-8').unpack1('H4')).to eq 'd0b0'
-      end
-    end
-
-    describe 'overriding specified in dbf encoding' do
-      let(:table) { DBF::Table.new fixture('cp1251.dbf'), nil, 'cp866' }
-      let(:record) { table.find(0) }
-
-      it 'transcodes from manually specified encoding to default system encoding' do
-        expect(record.name.encoding).to eq Encoding.default_external
-
-        # russian а encoded in cp1251 and read as if it was encoded in cp866
-        expect(record.name.encode('UTF-8').unpack1('H4')).to eq 'd180'
-      end
-    end
-  end
-
-  describe '#attributes' do
-    let(:table) { DBF::Table.new fixture('dbase_8b.dbf') }
-    let(:record) { table.find(0) }
-
-    it 'is a hash of attribute name/value pairs' do
-      expect(record.attributes).to be_a(Hash)
-      expect(record.attributes['CHARACTER']).to eq 'One'
-    end
-
-    it 'has only original field names as keys' do
-      original_field_names = %w[CHARACTER DATE FLOAT LOGICAL MEMO NUMERICAL]
-      expect(record.attributes.keys.sort).to eq original_field_names
-    end
-  end
-end

data/spec/dbf/table_spec.rb

@@ -1,375 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe DBF::Table do
-  let(:dbf_path) { fixture('dbase_83.dbf') }
-  let(:memo_path) { fixture('dbase_83.dbt') }
-  let(:table) { DBF::Table.new dbf_path }
-
-  specify 'foxpro versions' do
-    expect(DBF::Table::FOXPRO_VERSIONS.keys.sort).to eq %w[30 31 f5 fb].sort
-  end
-
-  specify 'row is an alias of record' do
-    expect(table.record(1)).to eq table.row(1)
-  end
-
-  describe '#initialize' do
-    let(:data) { StringIO.new File.read(dbf_path) }
-    let(:memo) { StringIO.new File.read(memo_path) }
-
-    describe 'when given a path to an existing dbf file' do
-      it 'does not raise an error' do
-        expect { DBF::Table.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::Table.new 'x' }.to raise_error(DBF::FileNotFoundError, 'file not found: x')
-      end
-    end
-
-    describe 'when data is nil' do
-      it 'raises ArgumentError' do
-        expect { DBF::Table.new nil }.to raise_error(ArgumentError, 'data must be a file path or StringIO object')
-      end
-    end
-
-    describe 'when given paths to existing dbf and memo files' do
-      it 'does not raise an error' do
-        expect { DBF::Table.new dbf_path, memo_path }.to_not raise_error
-      end
-    end
-
-    it 'accepts an io-like data object' do
-      expect { DBF::Table.new data }.to_not raise_error
-    end
-
-    it 'accepts an io-like data and memo object' do
-      expect { DBF::Table.new data, memo }.to_not raise_error
-    end
-  end
-
-  describe '#close' do
-    before { table.close }
-
-    it 'closes the io' do
-      expect { table.record(1) }.to raise_error(IOError)
-    end
-  end
-
-  describe '#schema' do
-    describe 'when data is IO' do
-      let(:control_schema) { File.read(fixture('dbase_83_schema_ar.txt')) }
-
-      it 'matches the test schema fixture' do
-        expect(table.schema).to eq control_schema
-      end
-
-      it 'raises ArgumentError if there is no matching schema' do
-        expect { table.schema(:invalid) }.to raise_error(
-          ArgumentError,
-          ':invalid is not a valid schema. Valid schemas are: activerecord, json, sequel.'
-        )
-      end
-    end
-
-    describe 'when data is StringIO' do
-      let(:data) { StringIO.new File.read(dbf_path) }
-      let(:table) { DBF::Table.new data }
-
-      let(:control_schema) { File.read(fixture('dbase_83_schema_ar.txt')) }
-
-      it 'matches the test schema fixture' do
-        table.name = 'dbase_83'
-        expect(table.schema).to eq control_schema
-      end
-    end
-  end
-
-  describe '#sequel_schema' do
-    it 'returns a valid Sequel migration by default' do
-      control_schema = File.read(fixture('dbase_83_schema_sq.txt'))
-      expect(table.sequel_schema).to eq control_schema
-    end
-
-    it 'returns a limited Sequel migration when passed true' do
-      control_schema = File.read(fixture('dbase_83_schema_sq_lim.txt'))
-      expect(table.sequel_schema).to eq control_schema
-    end
-
-  end
-
-  describe '#json_schema' do
-    it 'is valid JSON' do
-      expect { JSON.parse(table.json_schema) }.to_not raise_error
-    end
-
-    it 'matches the test fixture' do
-      data = JSON.parse(table.json_schema)
-      expect(data).to eq [
-        {'name' => 'ID', 'type' => 'N', 'length' => 19, 'decimal' => 0},
-        {'name' => 'CATCOUNT', 'type' => 'N', 'length' => 19, 'decimal' => 0},
-        {'name' => 'AGRPCOUNT', 'type' => 'N', 'length' => 19, 'decimal' => 0},
-        {'name' => 'PGRPCOUNT', 'type' => 'N', 'length' => 19, 'decimal' => 0},
-        {'name' => 'ORDER', 'type' => 'N', 'length' => 19, 'decimal' => 0},
-        {'name' => 'CODE', 'type' => 'C', 'length' => 50, 'decimal' => 0},
-        {'name' => 'NAME', 'type' => 'C', 'length' => 100, 'decimal' => 0},
-        {'name' => 'THUMBNAIL', 'type' => 'C', 'length' => 254, 'decimal' => 0},
-        {'name' => 'IMAGE', 'type' => 'C', 'length' => 254, 'decimal' => 0},
-        {'name' => 'PRICE', 'type' => 'N', 'length' => 13, 'decimal' => 2},
-        {'name' => 'COST', 'type' => 'N', 'length' => 13, 'decimal' => 2},
-        {'name' => 'DESC', 'type' => 'M', 'length' => 10, 'decimal' => 0},
-        {'name' => 'WEIGHT', 'type' => 'N', 'length' => 13, 'decimal' => 2},
-        {'name' => 'TAXABLE', 'type' => 'L', 'length' => 1, 'decimal' => 0},
-        {'name' => 'ACTIVE', 'type' => 'L', 'length' => 1, 'decimal' => 0}
-      ]
-    end
-  end
-
-  describe '#to_csv' do
-    after do
-      FileUtils.rm_f 'test.csv'
-    end
-
-    describe 'when no path param passed' do
-      it 'writes to STDOUT' do
-        expect { table.to_csv }.to output.to_stdout
-      end
-    end
-
-    describe 'when path param passed' do
-      before { table.to_csv('test.csv') }
-
-      it 'creates a custom csv file' do
-        expect(File).to exist('test.csv')
-      end
-    end
-  end
-
-  describe '#record' do
-    it 'return nil for deleted records' do
-      allow(table).to receive(:deleted_record?).and_return(true)
-      expect(table.record(5)).to be_nil
-    end
-
-    describe 'when dbf has no column definitions' do
-      let(:dbf_path) { fixture('polygon.dbf') }
-
-      it 'raises a DBF::NoColumnsDefined error' do
-        expect { DBF::Table.new(dbf_path).record(1) }.to raise_error(DBF::NoColumnsDefined, 'The DBF file has no columns defined')
-      end
-    end
-  end
-
-  describe '#current_record' do
-    it 'returns nil for deleted records' do
-      allow(table).to receive(:deleted_record?).and_return(true)
-      expect(table.record(0)).to be_nil
-    end
-  end
-
-  describe '#find' do
-    describe 'with index' do
-      it 'returns the correct record' do
-        expect(table.find(5)).to eq table.record(5)
-      end
-    end
-
-    describe 'with array of indexes' do
-      it 'returns the correct records' do
-        expect(table.find([1, 5, 10])).to eq [table.record(1), table.record(5), table.record(10)]
-      end
-    end
-
-    describe 'with :all' do
-      let(:records) do
-        table.find(:all, weight: 0.0)
-      end
-
-      it 'retrieves only matching records' do
-        expect(records.size).to eq 66
-      end
-
-      it 'yields to a block if given' do
-        record_count = 0
-        table.find(:all, weight: 0.0) do |record|
-          record_count += 1
-          expect(record).to be_a DBF::Record
-        end
-        expect(record_count).to eq 66
-      end
-
-      it 'returns all records if options are empty' do
-        expect(table.find(:all)).to eq table.to_a
-      end
-
-      it 'returns matching records when used with options' do
-        expect(table.find(:all, 'WEIGHT' => 0.0)).to eq(table.select { |r| r['weight'] == 0.0 })
-      end
-
-      it 'ANDS multiple search terms' do
-        expect(table.find(:all, 'ID' => 30, :IMAGE => 'graphics/00000001/TBC01.jpg')).to be_empty
-      end
-
-      it 'matches original column names' do
-        expect(table.find(:all, 'WEIGHT' => 0.0)).to_not be_empty
-      end
-
-      it 'matches symbolized column names' do
-        expect(table.find(:all, WEIGHT: 0.0)).to_not be_empty
-      end
-
-      it 'matches downcased column names' do
-        expect(table.find(:all, 'weight' => 0.0)).to_not be_empty
-      end
-
-      it 'matches symbolized downcased column names' do
-        expect(table.find(:all, weight: 0.0)).to_not be_empty
-      end
-    end
-
-    describe 'with :first' do
-      it 'returns the first record if options are empty' do
-        expect(table.find(:first)).to eq table.record(0)
-      end
-
-      it 'returns the first matching record when used with options' do
-        expect(table.find(:first, 'CODE' => 'C')).to eq table.record(5)
-      end
-
-      it 'ANDs multiple search terms' do
-        expect(table.find(:first, 'ID' => 30, 'IMAGE' => 'graphics/00000001/TBC01.jpg')).to be_nil
-      end
-    end
-  end
-
-  describe '#filename' do
-    it 'returns the filename as a string' do
-      expect(table.filename).to eq 'dbase_83.dbf'
-    end
-  end
-
-  describe '#name' do
-    describe 'when data is an IO' do
-      it 'defaults to the filename less extension' do
-        expect(table.name).to eq 'dbase_83'
-      end
-
-      it 'is mutable' do
-        table.name = 'database_83'
-        expect(table.name).to eq 'database_83'
-      end
-    end
-
-    describe 'when data is a StringIO' do
-      let(:data) { StringIO.new File.read(dbf_path) }
-      let(:memo) { StringIO.new File.read(memo_path) }
-      let(:table) { DBF::Table.new data }
-
-      it 'is nil' do
-        expect(table.name).to be_nil
-      end
-
-      it 'is mutable' do
-        table.name = 'database_83'
-        expect(table.name).to eq 'database_83'
-      end
-    end
-  end
-
-  describe '#has_memo_file?' do
-    describe 'without a memo file' do
-      let(:table) { DBF::Table.new fixture('dbase_03.dbf') }
-
-      it 'is false' do
-        expect(table).to_not have_memo_file
-      end
-    end
-
-    describe 'with a memo file' do
-      it 'is true' do
-        expect(table).to have_memo_file
-      end
-    end
-  end
-
-  describe '#columns' do
-    let(:columns) { table.columns }
-
-    it 'is an array of Columns' do
-      expect(columns).to be_an(Array)
-      expect(columns).to_not be_empty
-      expect(columns).to(be_all { |c| c.is_a? DBF::Column })
-    end
-  end
-
-  describe '#column_names' do
-    let(:column_names) do
-      %w[ID CATCOUNT AGRPCOUNT PGRPCOUNT ORDER CODE NAME THUMBNAIL IMAGE PRICE COST DESC WEIGHT TAXABLE ACTIVE]
-    end
-
-    describe 'when data is an IO' do
-      it 'is an array of all column names' do
-        expect(table.column_names).to eq column_names
-      end
-    end
-
-    describe 'when data is a StringIO' do
-      let(:data) { StringIO.new File.read(dbf_path) }
-      let(:table) { DBF::Table.new data, nil, Encoding::US_ASCII }
-
-      it 'is an array of all column names' do
-        expect(table.column_names).to eq column_names
-      end
-    end
-  end
-
-  describe '#activerecord_schema_definition' do
-    context 'with type N (number)' do
-      it 'outputs an integer column' do
-        column = DBF::Column.new table, 'ColumnName', 'N', 1, 0
-        expect(table.activerecord_schema_definition(column)).to eq "\"column_name\", :integer\n"
-      end
-    end
-
-    describe 'with type B (binary)' do
-      context 'with Foxpro dbf' do
-        it 'outputs a float column' do
-          column = DBF::Column.new table, 'ColumnName', 'B', 1, 2
-          expect(table.activerecord_schema_definition(column)).to eq "\"column_name\", :binary\n"
-        end
-      end
-    end
-
-    it 'defines a float colmn if type is (N)umber with more than 0 decimals' do
-      column = DBF::Column.new table, 'ColumnName', 'N', 1, 2
-      expect(table.activerecord_schema_definition(column)).to eq "\"column_name\", :float\n"
-    end
-
-    it 'defines a date column if type is (D)ate' do
-      column = DBF::Column.new table, 'ColumnName', 'D', 8, 0
-      expect(table.activerecord_schema_definition(column)).to eq "\"column_name\", :date\n"
-    end
-
-    it 'defines a datetime column if type is (D)ate' do
-      column = DBF::Column.new table, 'ColumnName', 'T', 16, 0
-      expect(table.activerecord_schema_definition(column)).to eq "\"column_name\", :datetime\n"
-    end
-
-    it 'defines a boolean column if type is (L)ogical' do
-      column = DBF::Column.new table, 'ColumnName', 'L', 1, 0
-      expect(table.activerecord_schema_definition(column)).to eq "\"column_name\", :boolean\n"
-    end
-
-    it 'defines a text column if type is (M)emo' do
-      column = DBF::Column.new table, 'ColumnName', 'M', 1, 0
-      expect(table.activerecord_schema_definition(column)).to eq "\"column_name\", :text\n"
-    end
-
-    it 'defines a string column with length for any other data types' do
-      column = DBF::Column.new table, 'ColumnName', 'X', 20, 0
-      expect(table.activerecord_schema_definition(column)).to eq "\"column_name\", :string, :limit => 20\n"
-    end
-  end
-end