dbf 2.0.3 → 2.0.4

data/spec/dbf/file_formats_spec.rb

@@ -4,151 +4,151 @@ shared_examples_for 'DBF' do
   specify "sum of column lengths should equal record length specified in header plus one" do
     header_record_length = table.instance_eval {@record_length}
     sum_of_column_lengths = table.columns.inject(1) {|sum, column| sum += column.length}
-    
-    header_record_length.should == sum_of_column_lengths
+
+    expect(header_record_length).to eq sum_of_column_lengths
   end
 
   specify "records should be instances of DBF::Record" do
-    table.all? {|record| record.is_a?(DBF::Record)}.should be_true
+    expect(table.all? {|record| record.is_a?(DBF::Record)}).to be_true
   end
-  
+
   specify "record count should be the same as reported in the header" do
-    table.entries.size.should == table.record_count
+    expect(table.entries.size).to eq table.record_count
   end
-  
+
   specify "column names should not be blank" do
-    table.columns.all? {|column| !column.name.empty?}.should be_true
+    expect(table.columns.all? {|column| !column.name.empty?}).to be_true
   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.all? {|column| valid_column_types.include?(column.type)}.should be_true
+    expect(table.columns.all? {|column| valid_column_types.include?(column.type)}).to be_true
   end
-  
+
   specify "column lengths should be instances of Fixnum" do
-    table.columns.all? {|column| column.length.is_a?(Fixnum)}.should be_true
+    expect(table.columns.all? {|column| column.length.is_a?(Fixnum)}).to be_true
   end
-  
+
   specify "column lengths should be larger than 0" do
-    table.columns.all? {|column| column.length > 0}.should be_true
+    expect(table.columns.all? {|column| column.length > 0}).to be_true
   end
-  
+
   specify "column decimals should be instances of Fixnum" do
-    table.columns.all? {|column| column.decimal.is_a?(Fixnum)}.should be_true
+    expect(table.columns.all? {|column| column.decimal.is_a?(Fixnum)}).to be_true
   end
 end
 
 shared_examples_for 'Foxpro DBF' do
   specify "columns should be instances of DBF::FoxproColumn" do
-    table.columns.all? {|column| column.is_a?(DBF::Column::Foxpro)}.should be_true
+    expect(table.columns.all? {|column| column.is_a?(DBF::Column::Foxpro)}).to be_true
   end
 end
 
 describe DBF, "of type 03 (dBase III without memo file)" do
   let(:table) { DBF::Table.new "#{DB_PATH}/dbase_03.dbf" }
-  
+
   it_should_behave_like "DBF"
-  
+
   it "should report the correct version number" do
-    table.version.should == "03"
+    expect(table.version).to eq "03"
   end
-  
+
   it "should report the correct version description" do
-    table.version_description.should == "dBase III without memo file"
+    expect(table.version_description).to eq "dBase III without memo file"
   end
-  
+
   it "should determine the number of records" do
-    table.record_count.should == 14
+    expect(table.record_count).to eq 14
   end
 end
 
 describe DBF, "of type 30 (Visual FoxPro)" do
   let(:table) { DBF::Table.new "#{DB_PATH}/dbase_30.dbf" }
-  
+
   it_should_behave_like "DBF"
-  
+
   it "should report the correct version number" do
-    table.version.should == "30"
+    expect(table.version).to eq "30"
   end
-  
+
   it "should report the correct version description" do
-    table.version_description.should == "Visual FoxPro"
+    expect(table.version_description).to eq "Visual FoxPro"
   end
 
   it "should determine the number of records" do
-    table.record_count.should == 34
+    expect(table.record_count).to eq 34
   end
 end
 
 describe DBF, "of type 31 (Visual FoxPro with AutoIncrement field)" do
   let(:table) { DBF::Table.new "#{DB_PATH}/dbase_31.dbf" }
-  
+
   it_should_behave_like "DBF"
-  
+
   it "should have a dBase version of 31" do
-    table.version.should == "31"
+    expect(table.version).to eq "31"
   end
-  
+
   it "should report the correct version description" do
-    table.version_description.should == "Visual FoxPro with AutoIncrement field"
+    expect(table.version_description).to eq "Visual FoxPro with AutoIncrement field"
   end
-  
+
   it "should determine the number of records" do
-    table.record_count.should == 77
+    expect(table.record_count).to eq 77
   end
 end
 
 describe DBF, "of type 83 (dBase III with memo file)" do
   let(:table) { DBF::Table.new "#{DB_PATH}/dbase_83.dbf" }
-  
+
   it_should_behave_like "DBF"
-  
+
   it "should report the correct version number" do
-    table.version.should == "83"
+    expect(table.version).to eq "83"
   end
-  
+
   it "should report the correct version description" do
-    table.version_description.should == "dBase III with memo file"
+    expect(table.version_description).to eq "dBase III with memo file"
   end
-  
+
   it "should determine the number of records" do
-    table.record_count.should == 67
+    expect(table.record_count).to eq 67
   end
 end
 
 describe DBF, "of type 8b (dBase IV with memo file)" do
   let(:table) { DBF::Table.new "#{DB_PATH}/dbase_8b.dbf" }
-  
+
   it_should_behave_like "DBF"
-  
+
   it "should report the correct version number" do
-    table.version.should == "8b"
+    expect(table.version).to eq "8b"
   end
-  
+
   it "should report the correct version description" do
-    table.version_description.should == "dBase IV with memo file"
+    expect(table.version_description).to eq "dBase IV with memo file"
   end
-  
+
   it "should determine the number of records" do
-    table.record_count.should == 10
+    expect(table.record_count).to eq 10
   end
 end
 
 describe DBF, "of type f5 (FoxPro with memo file)" do
   let(:table) { DBF::Table.new "#{DB_PATH}/dbase_f5.dbf" }
-  
+
   it_should_behave_like "DBF"
   it_should_behave_like "Foxpro DBF"
-  
+
   it "should report the correct version number" do
-    table.version.should == "f5"
+    expect(table.version).to eq "f5"
   end
-  
+
   it "should report the correct version description" do
-    table.version_description.should == "FoxPro with memo file"
+    expect(table.version_description).to eq "FoxPro with memo file"
   end
-  
+
   it "should determine the number of records" do
-    table.record_count.should == 975
+    expect(table.record_count).to eq 975
   end
 end

data/spec/dbf/record_spec.rb

@@ -3,26 +3,34 @@ require "spec_helper"
 describe DBF::Record do
 
   describe '#to_a' do
+    let(:table) { DBF::Table.new "#{DB_PATH}/dbase_83.dbf" }
     it 'should return an ordered array of attribute values' do
-      table = DBF::Table.new "#{DB_PATH}/dbase_8b.dbf"
-
       record = table.record(0)
-      record.to_a.should == ["One", 1.0, Date.new(1970, 1, 1), true, 1.23456789012346, "First memo\r\n\037 \037 \037 \037 "]
+      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]
 
       record = table.record(9)
-      record.to_a.should == ["Ten records stored in this database", 10.0, nil, false, 0.1, nil]
+      expect(record.to_a).to eq [34, 1, 0, 0, 34, "AB01", "Apricot Brandy Fruitcake", "graphics/00000001/t_AB01.jpg", "graphics/00000001/AB01.jpg", 37.95, 37.95, "Once tasted you will understand why we won The\r\nBoston Herald's Fruitcake Taste-off. Judges liked its generous size,\r\nluscious appearance, moist texture and fruit to cake ratio ... commented one\r\njudge \"It's a lip Smacker!\" Our signature fruitcake is baked with carefully\r\nselected ingredients that will be savored until the last moist crumb is\r\ndevoured each golden slice is brimming with Australian glaced apricots,\r\ntoasted pecans, candied orange peel, and currants, folded gently into a\r\nbrandy butter batter and slowly baked to perfection and then generously\r\nimbibed with \"Holiday Spirits\". Presented in a gift tin.  (3lbs. 4oz)", 0.0, false, true]
+    end
+
+    describe 'with missing memo file' do
+      let(:table) { DBF::Table.new "#{DB_PATH}/dbase_83_missing_memo.dbf" }
+
+      it 'returns nil values for memo fields' 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, nil, 1.0, false, false]
+      end
     end
   end
 
-  describe '#==' do    
+  describe '#==' do
     let :record do
       table = DBF::Table.new "#{DB_PATH}/dbase_8b.dbf"
       table.record(9)
     end
-    
+
     describe 'when other does not have attributes' do
       it 'is false' do
-        (record == mock('other')).should be_false
+        expect((record == mock('other'))).to be_false
       end
     end
 
@@ -31,10 +39,10 @@ describe DBF::Record do
         attributes = {:x => 1, :y => 2}
         record.stub!(:attributes).and_return(attributes)
         other = mock('object', :attributes => attributes)
-        (record == other).should be_true
+        expect((record == other)).to be_true
       end
     end
-    
+
   end
 
   describe 'column accessors' do
@@ -42,16 +50,16 @@ describe DBF::Record do
     let(:record) { table.find(0) }
 
     it 'should have dynamic accessors for the columns' do
-      record.should respond_to(:character)
-      record.character.should == 'One'
-      record.float.should == 1.23456789012346
-      record.logical.should == true
+      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
 
     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)
-      record.character.should == 'One'
+      expect(record.character).to eq 'One'
       expect { second_record.character }.to raise_error(NoMethodError)
     end
   end
@@ -63,8 +71,8 @@ describe DBF::Record do
       let(:record) { table.find(0) }
       it 'should automatically encodes to default system encoding' do
         if table.supports_encoding?
-          record.name.encoding.should == Encoding.default_external
-          record.name.encode("UTF-8").unpack("H4").should == ["d0b0"] # russian a
+          expect(record.name.encoding).to eq Encoding.default_external
+          expect(record.name.encode("UTF-8").unpack("H4")).to eq ["d0b0"] # russian a
         end
       end
     end
@@ -75,25 +83,25 @@ describe DBF::Record do
       let(:record) { table.find(0) }
       it 'should transcode from manually specified encoding to default system encoding' do
         if table.supports_encoding?
-          record.name.encoding.should == Encoding.default_external
-          record.name.encode("UTF-8").unpack("H4").should == ["d180"] # russian а encoded in cp1251 and read as if it was encoded in cp866
+          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
         end
       end
     end
   end
-  
+
   describe '#attributes' do
     let(:table) { DBF::Table.new "#{DB_PATH}/dbase_8b.dbf"}
     let(:record) { table.find(0) }
-    
+
     it 'is a hash of attribute name/value pairs' do
-      record.attributes.should be_a(Hash)
-      record.attributes['CHARACTER'] == 'One'
+      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)
-      record.attributes.keys.sort.should == original_field_names
+      expect(record.attributes.keys.sort).to eq original_field_names
     end
   end
 end

data/spec/dbf/table_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 
-describe DBF::Table do  
+describe DBF::Table do
   specify 'foxpro versions' do
-    DBF::Table::FOXPRO_VERSIONS.keys.sort.should == %w(30 31 f5 fb).sort
+    expect(DBF::Table::FOXPRO_VERSIONS.keys.sort).to eq %w(30 31 f5 fb).sort
   end
 
   describe '#initialize' do
@@ -25,42 +25,42 @@ describe DBF::Table do
       expect { DBF::Table.new data, memo }.to_not raise_error
     end
   end
-  
+
   context "when closed" do
     it "closes the data and memo files" do
       table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
       table.close
-      table.should be_closed
+      expect(table).to be_closed
     end
-    
+
     it "closes the data" do
       table = DBF::Table.new "#{DB_PATH}/dbase_30.dbf"
       table.close
-      table.should be_closed
+      expect(table).to be_closed
     end
   end
-  
+
   describe "#schema" do
     it "matches the test schema fixture" do
       table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
       control_schema = File.read("#{DB_PATH}/dbase_83_schema.txt")
-      table.schema.should == control_schema
+      expect(table.schema).to eq control_schema
     end
   end
-  
+
   describe '#to_csv' do
     let(:table) { DBF::Table.new "#{DB_PATH}/dbase_83.dbf" }
-    
+
     after do
       FileUtils.rm_f 'test.csv'
     end
-    
+
     describe 'when no path param passed' do
       it 'writes to STDOUT' do
         begin
           $stdout = StringIO.new
           table.to_csv
-          $stdout.string.should_not be_empty
+          expect($stdout.string).not_to be_empty
         ensure
           $stdout = STDOUT
         end
@@ -70,91 +70,91 @@ describe DBF::Table do
     describe 'when path param passed' do
       it 'creates a custom csv file' do
         table.to_csv('test.csv')
-        File.exists?('test.csv').should be_true
+        expect(File.exists?('test.csv')).to be_true
       end
     end
   end
-  
+
   describe "#record" do
     it "return nil for deleted records" do
       table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
       table.stub!(:deleted_record?).and_return(true)
-      table.record(5).should be_nil
+      expect(table.record(5)).to be_nil
     end
   end
-  
+
   describe "#current_record" do
     it "should return nil for deleted records" do
       table = DBF::Table.new "#{DB_PATH}/dbase_83.dbf"
       table.stub!(:deleted_record?).and_return(true)
-      table.record(0).should be_nil
+      expect(table.record(0)).to be_nil
     end
   end
-  
+
   describe "#find" do
     let(:table) { DBF::Table.new "#{DB_PATH}/dbase_83.dbf" }
-    
+
     describe "with index" do
       it "returns the correct record" do
-        table.find(5).should == table.record(5)
+        expect(table.find(5)).to eq table.record(5)
       end
     end
-    
-    describe 'with array of indexes' do      
+
+    describe 'with array of indexes' do
       it "returns the correct records" do
-        table.find([1, 5, 10]).should == [table.record(1), table.record(5), table.record(10)]
+        expect(table.find([1, 5, 10])).to eq [table.record(1), table.record(5), table.record(10)]
       end
     end
-    
+
     describe "with :all" do
       it "accepts a block" do
         records = []
         table.find(:all, :weight => 0.0) do |record|
           records << record
         end
-        records.should == table.find(:all, :weight => 0.0)
+        expect(records).to eq table.find(:all, :weight => 0.0)
       end
 
       it "returns all records if options are empty" do
-        table.find(:all).should == table.to_a
+        expect(table.find(:all)).to eq table.to_a
       end
 
       it "returns matching records when used with options" do
-        table.find(:all, "WEIGHT" => 0.0).should == table.select {|r| r["weight"] == 0.0}
+        expect(table.find(:all, "WEIGHT" => 0.0)).to eq table.select {|r| r["weight"] == 0.0}
       end
 
       it "should AND multiple search terms" do
-        table.find(:all, "ID" => 30, "IMAGE" => "graphics/00000001/TBC01.jpg").should == []
+        expect(table.find(:all, "ID" => 30, "IMAGE" => "graphics/00000001/TBC01.jpg")).to eq []
       end
-      
+
       it "should match original column names" do
-        table.find(:all, "WEIGHT" => 0.0).should_not be_empty
+        expect(table.find(:all, "WEIGHT" => 0.0)).not_to be_empty
       end
-      
+
       it "matches symbolized column names" do
-        table.find(:all, :WEIGHT => 0.0).should_not be_empty
+        expect(table.find(:all, :WEIGHT => 0.0)).not_to be_empty
       end
-      
+
       it "matches downcased column names" do
-        table.find(:all, "weight" => 0.0).should_not be_empty
+        expect(table.find(:all, "weight" => 0.0)).not_to be_empty
       end
-      
+
       it "matches symbolized downcased column names" do
-        table.find(:all, :weight => 0.0).should_not be_empty
+        expect(table.find(:all, :weight => 0.0)).not_to be_empty
       end
     end
-    
+
     describe "with :first" do
       it "returns the first record if options are empty" do
-        table.find(:first).should == table.record(0)
+        expect(table.find(:first)).to eq table.record(0)
       end
 
       it "returns the first matching record when used with options" do
-        table.find(:first, "CODE" => "C").should == table.record(5)
+        expect(table.find(:first, "CODE" => "C")).to eq table.record(5)
       end
 
       it "ANDs multiple search terms" do
-        table.find(:first, "ID" => 30, "IMAGE" => "graphics/00000001/TBC01.jpg").should be_nil
+        expect(table.find(:first, "ID" => 30, "IMAGE" => "graphics/00000001/TBC01.jpg")).to be_nil
       end
     end
   end
@@ -162,22 +162,22 @@ describe DBF::Table do
   describe "filename" do
     it 'is dbase_03.dbf' do
       table = DBF::Table.new "#{DB_PATH}/dbase_03.dbf"
-      table.filename.should == "dbase_03.dbf"
+      expect(table.filename).to eq "dbase_03.dbf"
     end
   end
-  
+
   describe 'has_memo_file?' do
     describe 'without a memo file' do
       it 'is false' do
         table = DBF::Table.new "#{DB_PATH}/dbase_03.dbf"
-        table.has_memo_file?.should be_false
+        expect(table.has_memo_file?).to be_false
       end
     end
-    
+
     describe 'with a memo file' do
       it 'is true' do
-        table = DBF::Table.new "#{DB_PATH}/dbase_30.dbf" 
-        table.has_memo_file?.should be_true
+        table = DBF::Table.new "#{DB_PATH}/dbase_30.dbf"
+        expect(table.has_memo_file?).to be_true
       end
     end
   end
@@ -186,12 +186,12 @@ describe DBF::Table do
     let(:table) { DBF::Table.new "#{DB_PATH}/dbase_03.dbf" }
 
     it 'should have correct size' do
-      table.columns.size.should == 31
+      expect(table.columns.size).to eq 31
     end
 
     it 'should have correct names' do
-      table.columns.first.name.should == 'Point_ID'
-      table.columns[29].name.should == 'Easting'
+      expect(table.columns.first.name).to eq 'Point_ID'
+      expect(table.columns[29].name).to eq 'Easting'
     end
   end
 end