dbf 2.0.7 → 2.0.8

data/lib/dbf/version.rb

@@ -1,3 +1,3 @@
 module DBF
-  VERSION = '2.0.7'
-end
+  VERSION = '2.0.8'
+end

data/spec/dbf/column_spec.rb

@@ -3,9 +3,10 @@
 require "spec_helper"
 
 describe DBF::Column::Dbase do
+  let(:table) { DBF::Table.new fixture_path('dbase_30.dbf')}
 
   context "when initialized" do
-    let(:column) { DBF::Column::Dbase.new "ColumnName", "N", 1, 0, "30" }
+    let(:column) { DBF::Column::Dbase.new table, "ColumnName", "N", 1, 0 }
 
     it "sets :name accessor" do
       expect(column.name).to eq "ColumnName"
@@ -25,19 +26,19 @@ describe DBF::Column::Dbase do
 
     describe 'with length of 0' do
       it 'raises DBF::Column::LengthError' do
-        expect { DBF::Column::Dbase.new "ColumnName", "N", 0, 0, "30" }.to raise_error(DBF::Column::LengthError)
+        expect { DBF::Column::Dbase.new table, "ColumnName", "N", 0, 0 }.to raise_error(DBF::Column::LengthError)
       end
     end
 
     describe 'with length less than 0' do
       it 'raises DBF::Column::LengthError' do
-        expect { DBF::Column::Dbase.new "ColumnName", "N", -1, 0, "30" }.to raise_error(DBF::Column::LengthError)
+        expect { DBF::Column::Dbase.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::Dbase.new "\xFF\xFC", "N", 1, 0, "30" }.to raise_error(DBF::Column::NameError)
+        expect { DBF::Column::Dbase.new table, "\xFF\xFC", "N", 1, 0 }.to raise_error(DBF::Column::NameError)
       end
     end
   end
@@ -47,7 +48,7 @@ describe DBF::Column::Dbase do
       context 'and 0 decimals' do
         it 'casts value to Fixnum' do
           value = '135'
-          column = DBF::Column::Dbase.new "ColumnName", "N", 3, 0, "30"
+          column = DBF::Column::Dbase.new table, "ColumnName", "N", 3, 0
           expect(column.type_cast(value)).to be_a(Fixnum)
           expect(column.type_cast(value)).to eq 135
         end
@@ -56,7 +57,7 @@ describe DBF::Column::Dbase do
       context 'and more than 0 decimals' do
         it 'casts value to Float' do
           value = '13.5'
-          column = DBF::Column::Dbase.new "ColumnName", "N", 2, 1, "30"
+          column = DBF::Column::Dbase.new table, "ColumnName", "N", 2, 1
           expect(column.type_cast(value)).to be_a(Float)
           expect(column.type_cast(value)).to eq 13.5
         end
@@ -66,7 +67,7 @@ describe DBF::Column::Dbase do
     context 'with type F (float)' do
       it 'casts value to Float' do
         value = '135'
-        column = DBF::Column::Dbase.new "ColumnName", "F", 3, 0, "30"
+        column = DBF::Column::Dbase.new table, "ColumnName", "F", 3, 0
         expect(column.type_cast(value)).to be_a(Float)
         expect(column.type_cast(value)).to eq 135.0
       end
@@ -75,32 +76,34 @@ describe DBF::Column::Dbase do
     context 'with type I (integer)' do
       it "casts value to Fixnum" do
         value = "\203\171\001\000"
-        column = DBF::Column::Dbase.new "ColumnName", "I", 3, 0, "30"
+        column = DBF::Column::Dbase.new table, "ColumnName", "I", 3, 0
+        expect(column.type_cast(value)).to be_a(Fixnum)
         expect(column.type_cast(value)).to eq 96643
       end
     end
 
     context 'with type L (logical/boolean)' do
-      let(:column) { DBF::Column::Dbase.new "ColumnName", "L", 1, 0, "30" }
+      let(:column) { DBF::Column::Dbase.new table, "ColumnName", "L", 1, 0 }
 
       it "casts 'y' to true" do
-        expect(column.type_cast('y')).to eq true
+        expect(column.type_cast('y')).to be true
       end
 
       it "casts 't' to true" do
-        expect(column.type_cast('t')).to eq true
+        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 eq false
+        expect(column.type_cast('n')).to be false
       end
     end
 
     context 'with type T (datetime)' do
-      let(:column) { DBF::Column::Dbase.new "ColumnName", "T", 16, 0, "30" }
+      let(:column) { DBF::Column::Dbase.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 be_a(DateTime)
           expect(column.type_cast("Nl%\000\300Z\252\003")).to eq DateTime.parse("2002-10-10T17:04:56+00:00")
         end
       end
@@ -112,6 +115,7 @@ describe DBF::Column::Dbase do
               require 'mathn'
               column.type_cast("Nl%\000\300Z\252\003")
             end
+            expect(with_mathn.call).to be_a(DateTime)
             expect(with_mathn.call).to eq DateTime.parse("2002-10-10T17:04:56+00:00")
           end
         end
@@ -119,22 +123,25 @@ describe DBF::Column::Dbase do
 
       context 'with invalid datetime' do
         it "casts to nil" do
+          expect(column.type_cast("Nl%\000\000A\000\999")).to be_a(NilClass)
           expect(column.type_cast("Nl%\000\000A\000\999")).to be_nil
         end
       end
     end
 
     context 'with type D (date)' do
-      let(:column) { DBF::Column::Dbase.new "ColumnName", "D", 8, 0, "30" }
+      let(:column) { DBF::Column::Dbase.new table, "ColumnName", "D", 8, 0 }
 
       context 'with valid date' do
         it "casts to Date" do
+          expect(column.type_cast("20050712")).to be_a(Date)
           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("0")).to be_a(NilClass)
           expect(column.type_cast("0")).to be_nil
         end
       end
@@ -142,21 +149,24 @@ describe DBF::Column::Dbase do
 
     context 'with type M (memo)' do
       it "casts to string" do
-        column = DBF::Column::Dbase.new "ColumnName", "M", 3, 0, "30"
+        column = DBF::Column::Dbase.new table, "ColumnName", "M", 3, 0
         expect(column.type_cast('abc')).to be_a(String)
+        expect(column.type_cast('abc')).to eq 'abc'
       end
 
       it 'casts nil to nil' do
-        column = DBF::Column::Dbase.new "ColumnName", "M", 3, 0, "30"
+        column = DBF::Column::Dbase.new table, "ColumnName", "M", 3, 0
+        expect(column.type_cast(nil)).to be_a(NilClass)
         expect(column.type_cast(nil)).to be_nil
       end
     end
   end
 
   context 'with type Y (currency)' do
-    let(:column) { DBF::Column::Dbase.new "ColumnName", "Y", 8, 4, "31" }
+    let(:column) { DBF::Column::Dbase.new table, "ColumnName", "Y", 8, 4 }
 
     it 'casts to float' do
+      expect(column.type_cast(" \xBF\x02\x00\x00\x00\x00\x00")).to be_a(Float)
       expect(column.type_cast(" \xBF\x02\x00\x00\x00\x00\x00")).to eq 18.0
     end
   end
@@ -164,7 +174,7 @@ describe DBF::Column::Dbase do
   context "#schema_definition" do
     context 'with type N (number)' do
       it "outputs an integer column" do
-        column = DBF::Column::Dbase.new "ColumnName", "N", 1, 0, "30"
+        column = DBF::Column::Dbase.new table, "ColumnName", "N", 1, 0
         expect(column.schema_definition).to eq "\"column_name\", :integer\n"
       end
     end
@@ -173,14 +183,14 @@ describe DBF::Column::Dbase do
       context "with Foxpro dbf" do
         context "when decimal is greater than 0" do
           it "outputs an float column" do
-            column = DBF::Column::Dbase.new "ColumnName", "B", 1, 2, "f5"
+            column = DBF::Column::Dbase.new table, "ColumnName", "B", 1, 2
             expect(column.schema_definition).to eq "\"column_name\", :float\n"
           end
         end
 
         context "when decimal is 0" do
           it "outputs an integer column" do
-            column = DBF::Column::Dbase.new "ColumnName", "B", 1, 0, "f5"
+            column = DBF::Column::Dbase.new table, "ColumnName", "B", 1, 0
             expect(column.schema_definition).to eq "\"column_name\", :integer\n"
           end
         end
@@ -188,50 +198,50 @@ describe DBF::Column::Dbase do
     end
 
     it "defines a float colmn if type is (N)umber with more than 0 decimals" do
-      column = DBF::Column::Dbase.new "ColumnName", "N", 1, 2, "30"
+      column = DBF::Column::Dbase.new table, "ColumnName", "N", 1, 2
       expect(column.schema_definition).to eq "\"column_name\", :float\n"
     end
 
     it "defines a date column if type is (D)ate" do
-      column = DBF::Column::Dbase.new "ColumnName", "D", 8, 0, "30"
+      column = DBF::Column::Dbase.new table, "ColumnName", "D", 8, 0
       expect(column.schema_definition).to eq "\"column_name\", :date\n"
     end
 
     it "defines a datetime column if type is (D)ate" do
-      column = DBF::Column::Dbase.new "ColumnName", "T", 16, 0, "30"
+      column = DBF::Column::Dbase.new table, "ColumnName", "T", 16, 0
       expect(column.schema_definition).to eq "\"column_name\", :datetime\n"
     end
 
     it "defines a boolean column if type is (L)ogical" do
-      column = DBF::Column::Dbase.new "ColumnName", "L", 1, 0, "30"
+      column = DBF::Column::Dbase.new table, "ColumnName", "L", 1, 0
       expect(column.schema_definition).to eq "\"column_name\", :boolean\n"
     end
 
     it "defines a text column if type is (M)emo" do
-      column = DBF::Column::Dbase.new "ColumnName", "M", 1, 0, "30"
+      column = DBF::Column::Dbase.new table, "ColumnName", "M", 1, 0
       expect(column.schema_definition).to eq "\"column_name\", :text\n"
     end
 
     it "defines a string column with length for any other data types" do
-      column = DBF::Column::Dbase.new "ColumnName", "X", 20, 0, "30"
+      column = DBF::Column::Dbase.new table, "ColumnName", "X", 20, 0
       expect(column.schema_definition).to eq "\"column_name\", :string, :limit => 20\n"
     end
   end
 
   context "#name" do
     it "contains only ASCII characters" do
-      column = DBF::Column::Dbase.new "--\x1F-\x68\x65\x6C\x6C\x6F world-\x80--", "N", 1, 0, "30"
+      column = DBF::Column::Dbase.new table, "--\x1F-\x68\x65\x6C\x6C\x6F world-\x80--", "N", 1, 0
       expect(column.name).to eq "---hello world---"
     end
 
     it "is truncated at the null character" do
-      column = DBF::Column::Dbase.new "--\x1F-\x68\x65\x6C\x6C\x6F \x00 world-\x80--", "N", 1, 0, "30"
+      column = DBF::Column::Dbase.new table, "--\x1F-\x68\x65\x6C\x6C\x6F \x00 world-\x80--", "N", 1, 0
       expect(column.name).to eq "---hello "
     end
   end
 
   context '#decode_date' do
-    let(:column) { DBF::Column::Dbase.new "ColumnName", "N", 1, 0, "30" }
+    let(:column) { DBF::Column::Dbase.new table, "ColumnName", "N", 1, 0 }
 
     it 'is nil if value is blank' do
       expect(column.send(:decode_date, '')).to be_nil

data/spec/dbf/file_formats_spec.rb

@@ -9,7 +9,9 @@ shared_examples_for 'DBF' do
   end
 
   specify "records should be instances of DBF::Record" do
-    expect(table.all? {|record| record.is_a?(DBF::Record)}).to be_true
+    table.each do |record|
+      expect(record).to be_kind_of(DBF::Record)
+    end
   end
 
   specify "record count should be the same as reported in the header" do
@@ -17,35 +19,47 @@ shared_examples_for 'DBF' do
   end
 
   specify "column names should not be blank" do
-    expect(table.columns.all? {|column| !column.name.empty?}).to be_true
+    table.columns.each do |column|
+      expect(column.name).not_to 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)
-    expect(table.columns.all? {|column| valid_column_types.include?(column.type)}).to be_true
+    table.columns.each do |column|
+      expect(valid_column_types).to include(column.type)
+    end
   end
 
   specify "column lengths should be instances of Fixnum" do
-    expect(table.columns.all? {|column| column.length.is_a?(Fixnum)}).to be_true
+    table.columns.each do |column|
+      expect(column.length).to be_kind_of(Fixnum)
+    end
   end
 
   specify "column lengths should be larger than 0" do
-    expect(table.columns.all? {|column| column.length > 0}).to be_true
+    table.columns.each do |column|
+      expect(column.length).to be > 0
+    end
   end
 
   specify "column decimals should be instances of Fixnum" do
-    expect(table.columns.all? {|column| column.decimal.is_a?(Fixnum)}).to be_true
+    table.columns.each do |column|
+      expect(column.decimal).to be_kind_of(Fixnum)
+    end
   end
 end
 
 shared_examples_for 'Foxpro DBF' do
   specify "columns should be instances of DBF::FoxproColumn" do
-    expect(table.columns.all? {|column| column.is_a?(DBF::Column::Foxpro)}).to be_true
+    table.columns.each do |column|
+      expect(column).to be_kind_of(DBF::Column::Foxpro)
+    end
   end
 end
 
 describe DBF, "of type 03 (dBase III without memo file)" do
-  let(:table) { DBF::Table.new "#{DB_PATH}/dbase_03.dbf" }
+  let(:table) { DBF::Table.new fixture_path('dbase_03.dbf') }
 
   it_should_behave_like "DBF"
 
@@ -63,7 +77,7 @@ describe DBF, "of type 03 (dBase III without memo file)" do
 end
 
 describe DBF, "of type 30 (Visual FoxPro)" do
-  let(:table) { DBF::Table.new "#{DB_PATH}/dbase_30.dbf" }
+  let(:table) { DBF::Table.new fixture_path('dbase_30.dbf') }
 
   it_should_behave_like "DBF"
 
@@ -85,7 +99,7 @@ describe DBF, "of type 30 (Visual FoxPro)" do
 end
 
 describe DBF, "of type 31 (Visual FoxPro with AutoIncrement field)" do
-  let(:table) { DBF::Table.new "#{DB_PATH}/dbase_31.dbf" }
+  let(:table) { DBF::Table.new fixture_path('dbase_31.dbf') }
 
   it_should_behave_like "DBF"
 
@@ -103,7 +117,7 @@ describe DBF, "of type 31 (Visual FoxPro with AutoIncrement field)" do
 end
 
 describe DBF, "of type 83 (dBase III with memo file)" do
-  let(:table) { DBF::Table.new "#{DB_PATH}/dbase_83.dbf" }
+  let(:table) { DBF::Table.new fixture_path('dbase_83.dbf') }
 
   it_should_behave_like "DBF"
 
@@ -121,7 +135,7 @@ describe DBF, "of type 83 (dBase III with memo file)" do
 end
 
 describe DBF, "of type 8b (dBase IV with memo file)" do
-  let(:table) { DBF::Table.new "#{DB_PATH}/dbase_8b.dbf" }
+  let(:table) { DBF::Table.new fixture_path('dbase_8b.dbf') }
 
   it_should_behave_like "DBF"
 
@@ -139,7 +153,7 @@ describe DBF, "of type 8b (dBase IV with memo file)" do
 end
 
 describe DBF, "of type f5 (FoxPro with memo file)" do
-  let(:table) { DBF::Table.new "#{DB_PATH}/dbase_f5.dbf" }
+  let(:table) { DBF::Table.new fixture_path('dbase_f5.dbf') }
 
   it_should_behave_like "DBF"
   it_should_behave_like "Foxpro DBF"
@@ -157,6 +171,6 @@ describe DBF, "of type f5 (FoxPro with memo file)" do
   end
 
   it "reads memo data" do
-    expect(table.record(3).obse).to match(/\Ajos.*pare\.\Z/m)
+    expect(table.record(3).datn.to_s).to eq '1870-06-30'
   end
 end

data/spec/dbf/record_spec.rb

@@ -3,7 +3,8 @@ require "spec_helper"
 describe DBF::Record do
 
   describe '#to_a' do
-    let(:table) { DBF::Table.new "#{DB_PATH}/dbase_83.dbf" }
+    let(:table) { DBF::Table.new fixture_path('dbase_83.dbf') }
+
     it 'should return an ordered array of attribute values' do
       record = table.record(0)
       expect(record.to_a).to eq [87, 2, 0, 0, 87, "1", "Assorted Petits Fours", "graphics/00000001/t_1.jpg", "graphics/00000001/1.jpg", 0.0, 0.0, "Our Original assortment...a little taste of heaven for everyone.  Let us\r\nselect a special assortment of our chocolate and pastel favorites for you.\r\nEach petit four is its own special hand decorated creation. Multi-layers of\r\nmoist cake with combinations of specialty fillings create memorable cake\r\nconfections. Varietes include; Luscious Lemon, Strawberry Hearts, White\r\nChocolate, Mocha Bean, Roasted Almond, Triple Chocolate, Chocolate Hazelnut,\r\nGrand Orange, Plum Squares, Milk chocolate squares, and Raspberry Blanc.", 5.51, true, true]
@@ -13,7 +14,7 @@ describe DBF::Record do
     end
 
     describe 'with missing memo file' do
-      let(:table) { DBF::Table.new "#{DB_PATH}/dbase_83_missing_memo.dbf" }
+      let(:table) { DBF::Table.new fixture_path('dbase_83_missing_memo.dbf') }
 
       it 'returns nil values for memo fields' do
         record = table.record(0)
@@ -23,75 +24,75 @@ describe DBF::Record do
   end
 
   describe '#==' do
-    let :record do
-      table = DBF::Table.new "#{DB_PATH}/dbase_8b.dbf"
-      table.record(9)
-    end
+    let(:table) { DBF::Table.new fixture_path('dbase_8b.dbf') }
+    let(:record) { table.record(9) }
 
     describe 'when other does not have attributes' do
-      it 'is false' do
-        expect((record == double('other'))).to be_false
+      it 'returns false' do
+        expect((record == double('other'))).to be_falsey
       end
     end
 
     describe 'if other attributes match' do
-      it 'is true' do
-        attributes = {:x => 1, :y => 2}
-        record.stub(:attributes).and_return(attributes)
-        other = double('object', :attributes => attributes)
-        expect((record == other)).to be_true
+      let(:attributes) { {:x => 1, :y => 2} }
+      let(:other) { double('object', :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 "#{DB_PATH}/dbase_8b.dbf"}
+    let(:table) { DBF::Table.new fixture_path('dbase_8b.dbf') }
     let(:record) { table.find(0) }
 
-    it 'should have dynamic accessors for the columns' do
-      expect(record).to respond_to(:character)
-      expect(record.character).to eq 'One'
-      expect(record.float).to eq 1.23456789012346
-      expect(record.logical).to eq true
-    end
+    %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
 
-    it 'should not define accessor methods on the base class' do
-      second_table = DBF::Table.new "#{DB_PATH}/dbase_03.dbf"
-      second_record = second_table.find(0)
-      expect(record.character).to eq 'One'
-      expect { second_record.character }.to raise_error(NoMethodError)
     end
   end
 
   describe 'column data for table' do
     describe 'using specified in dbf encoding' do
-      let(:table) { DBF::Table.new "#{DB_PATH}/cp1251.dbf"}
-
+      let(:table) { DBF::Table.new fixture_path('cp1251.dbf') }
       let(:record) { table.find(0) }
+
       it 'should automatically encodes to default system encoding' do
-        if table.supports_encoding?
+        if table.supports_string_encoding?
           expect(record.name.encoding).to eq Encoding.default_external
-          expect(record.name.encode("UTF-8").unpack("H4")).to eq ["d0b0"] # russian a
+
+          # russian a
+          expect(record.name.encode("UTF-8").unpack("H4")).to eq ["d0b0"]
         end
       end
     end
 
     describe 'overriding specified in dbf encoding' do
-      let(:table) { DBF::Table.new "#{DB_PATH}/cp1251.dbf", nil, 'cp866'}
-
+      let(:table) { DBF::Table.new fixture_path('cp1251.dbf'), nil, 'cp866'}
       let(:record) { table.find(0) }
+
       it 'should transcode from manually specified encoding to default system encoding' do
-        if table.supports_encoding?
+        if table.supports_string_encoding?
           expect(record.name.encoding).to eq Encoding.default_external
-          expect(record.name.encode("UTF-8").unpack("H4")).to eq ["d180"] # russian а encoded in cp1251 and read as if it was encoded in cp866
+
+          # russian а encoded in cp1251 and read as if it was encoded in cp866
+          expect(record.name.encode("UTF-8").unpack("H4")).to eq ["d180"]
         end
       end
     end
   end
 
   describe '#attributes' do
-    let(:table) { DBF::Table.new "#{DB_PATH}/dbase_8b.dbf"}
+    let(:table) { DBF::Table.new fixture_path('dbase_8b.dbf') }
     let(:record) { table.find(0) }
 
     it 'is a hash of attribute name/value pairs' do