metar-parser 1.1.8 → 1.2.0

data/spec/unit/runway_visible_range_spec.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+require "spec_helper"
 
 RSpec::Matchers.define :be_runway_visible_range do | designator, visibility1, visibility2, tendency |
   match do | rvr |
@@ -44,7 +44,7 @@ describe Metar::RunwayVisibleRange do
       [ 'returns nil for nil',               nil,               [ nil,   nil,                        nil,                nil ] ],
     ].each do | docstring, raw, expected |
       example docstring do
-        Metar::RunwayVisibleRange.parse( raw ).should be_runway_visible_range( *expected )
+        expect(Metar::RunwayVisibleRange.parse(raw)).to be_runway_visible_range( *expected )
       end
     end
 
@@ -78,8 +78,7 @@ describe Metar::RunwayVisibleRange do
 
       example docstring + " (#{locale})" do
         I18n.locale = locale
-        Metar::RunwayVisibleRange.new( '14', v1, v2, tendency ).to_s.
-                                  should     == expected
+        expect(Metar::RunwayVisibleRange.new('14', v1, v2, tendency).to_s).to eq(expected)
       end
     end
 

data/spec/unit/sky_condition_spec.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+require "spec_helper"
 
 RSpec::Matchers.define :be_sky_condition do |quantity, height, type|
   match do |sk|
@@ -31,7 +31,7 @@ describe Metar::SkyCondition do
       ['returns nil for unmatched',     'FUBAR',    [:expect_nil,    nil,            nil]],
     ].each do |docstring, raw, expected|
       example docstring do
-        Metar::SkyCondition.parse(raw).should be_sky_condition(*expected)
+        expect(Metar::SkyCondition.parse(raw)).to be_sky_condition(*expected)
       end
     end
   end

data/spec/unit/speed_spec.rb

@@ -1,51 +1,45 @@
-# encoding: utf-8
-load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+require "spec_helper"
 
 describe Metar::Speed do
-
   context '.parse' do
-
     it 'returns nil for nil' do
       speed = Metar::Speed.parse( nil )
 
-      speed.                      should     be_nil
+      expect(speed).to be_nil
     end
 
     it 'parses knots' do
       speed = Metar::Speed.parse( '5KT' )
 
-      speed.                      should     be_a( Metar::Speed )
-      speed.value.                should     be_within( 0.01 ).of( 2.57 )
+      expect(speed).to be_a( Metar::Speed )
+      expect(speed.value).to be_within( 0.01 ).of( 2.57 )
     end
 
     it 'parses meters per second' do
       speed = Metar::Speed.parse( '7MPS' )
 
-      speed.                      should     be_a( Metar::Speed )
-      speed.value.                should     be_within( 0.01 ).of( 7.00 )
+      expect(speed).to be_a( Metar::Speed )
+      expect(speed.value).to be_within( 0.01 ).of( 7.00 )
     end
 
     it 'parses kilometers per hour' do
       speed = Metar::Speed.parse( '14KMH' )
 
-      speed.                      should     be_a( Metar::Speed )
-      speed.value.                should     be_within( 0.01 ).of( 3.89 )
+      expect(speed).to be_a( Metar::Speed )
+      expect(speed.value).to be_within( 0.01 ).of( 3.89 )
     end
 
     it 'trates straight numbers as kilomters per hour' do
       speed = Metar::Speed.parse( '14' )
 
-      speed.                      should     be_a( Metar::Speed )
-      speed.value.                should     be_within( 0.01 ).of( 3.89 )
+      expect(speed).to be_a( Metar::Speed )
+      expect(speed.value).to be_within( 0.01 ).of( 3.89 )
     end
 
     it 'returns nil for other strings' do
       speed = Metar::Speed.parse( '' )
 
-      speed.                      should     be_nil
+      expect(speed).to be_nil
     end
-
   end
-
 end
-

data/spec/unit/station_spec.rb

@@ -1,9 +1,9 @@
 # encoding: utf-8
-load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+require "spec_helper"
 
-require 'stringio'
+require "stringio"
 
-RSpec::Matchers.define :have_attribute do | attribute |
+RSpec::Matchers.define :have_attribute do |attribute|
   match do | object |
     if ! object.respond_to?( attribute )
       false
@@ -16,54 +16,56 @@ RSpec::Matchers.define :have_attribute do | attribute |
 end
 
 describe Metar::Station do
+  let(:file) { double(File) }
 
-  before :each do
-    @file = stub( 'file' )
-  end
-
-  context 'using structures' do
-
-    before :each do
-      Metar::Station.stub!(:open).with(Metar::Station::NOAA_STATION_LIST_URL).and_return(nsd_file)
+  context "using structures" do
+    before do
+      allow(Metar::Station).to receive(:open).with(Metar::Station::NOAA_STATION_LIST_URL) { nsd_file }
     end
 
-    context '.countries' do
-      it 'lists unique countries in alphabetical order' do
-        Metar::Station.countries. should     == [ 'Aaaaa', 'Bbbbb', 'Ppppp' ]
+    context ".countries" do
+      it "lists unique countries in alphabetical order" do
+        expect(Metar::Station.countries).to eq(%w(Aaaaa Bbbbb Ppppp))
       end
     end
 
-    context '.all' do
-      it 'lists all stations' do
-        all = Metar::Station.all
+    context ".all" do
+      it "lists all stations" do
+        all_ccccs = Metar::Station.all.map(&:cccc)
 
-        all.map(&:cccc).          should     == ['PPPP', 'AAAA', 'AAAB', 'BBBA']
+        expect(all_ccccs).to eq(%w(PPPP AAAA AAAB BBBA))
       end
     end
 
-    context '.find_by_cccc' do
-      it 'returns the matching station, if is exists' do
-        Metar::Station.find_by_cccc( 'AAAA' ).name.
-                                  should     == 'Airport A1'
-        Metar::Station.find_by_cccc( 'ZZZZ' ).
-                                  should     be_nil
+    context ".find_by_cccc" do
+      context "when the station exists" do
+        it "returns the matching station" do
+          expect(Metar::Station.find_by_cccc("AAAA").name).to eq("Airport A1")
+        end
+      end
+
+      context "when the station doesn't exist" do
+        it "is nil" do
+          expect(Metar::Station.find_by_cccc("ZZZZ")).to be_nil
+        end
       end
     end
 
-    context '.exist?' do
-      it 'check if the cccc code exists' do
-        Metar::Station.exist?( 'AAAA' ).
-                                  should     be_true
-        Metar::Station.exist?( 'ZZZZ' ).
-                                  should     be_false
+    context ".exist?" do
+      it "is true if the cccc exists" do
+        expect(Metar::Station.exist?("AAAA")).to be_truthy
+      end
+
+      it "is false if the cccc doesn't exist" do
+        expect(Metar::Station.exist?("ZZZZ")).to be_falsey
       end
     end
 
-    context '.find_all_by_country' do
-      it 'lists all stations in a country' do
-        aaaaa = Metar::Station.find_all_by_country( 'Aaaaa' )
+    context ".find_all_by_country" do
+      it "lists all stations in a country" do
+        aaaaa = Metar::Station.find_all_by_country("Aaaaa")
 
-        aaaaa.map(&:cccc).        should     == [ 'AAAA', 'AAAB' ]
+        expect(aaaaa.map(&:cccc)).to eq(%w(AAAA AAAB))
       end
     end
 
@@ -81,104 +83,93 @@ EOT
 
   end
 
-  context '.to_longitude' do
-    it 'converts strings to longitude' do
-      Metar::Station.to_longitude('055-24E').
-                                  should     == 55.4
+  context ".to_longitude" do
+    it "converts strings to longitude" do
+      expect(Metar::Station.to_longitude("055-24E")).to eq(55.4)
     end
-    it 'returns nil for badly formed strings' do
-      Metar::Station.to_longitude('aaa').
-                                  should     be_nil
+
+    it "returns nil for badly formed strings" do
+      expect(Metar::Station.to_longitude("aaa")).to be_nil
     end
   end
 
-  context '.to_latitude' do
-    it 'converts strings to latitude' do
-      Metar::Station.to_latitude('11-03S').
-                                  should     == -11.05
+  context ".to_latitude" do
+    it "converts strings to latitude" do
+      expect(Metar::Station.to_latitude("11-03S")).to eq(-11.05)
     end
-    it 'returns nil for badly formed strings' do
-      Metar::Station.to_latitude('aaa').
-                                  should     be_nil
+
+    it "returns nil for badly formed strings" do
+      expect(Metar::Station.to_latitude("aaa")).to be_nil
     end
   end
 
   def noaa_data
     {
-      :cccc      => 'DDDD',
-      :name      => 'Station name',
-      :state     => 'State',
-      :country   => 'Country',
-      :longitude => '055-24E',
-      :latitude  => '11-03S',
-      :raw       => 'DDDD;00;000;Station name;State;Country;1;11-03S;055-24E;11-03S;055-24E;000;000;P',
+      :cccc      => "DDDD",
+      :name      => "Station name",
+      :state     => "State",
+      :country   => "Country",
+      :longitude => "055-24E",
+      :latitude  => "11-03S",
+      :raw       => "DDDD;00;000;Station name;State;Country;1;11-03S;055-24E;11-03S;055-24E;000;000;P",
     }
   end
 
-  context 'attributes' do
- 
-     subject { Metar::Station.new( 'DDDD', noaa_data ) }
-     it { should have_attribute( :cccc )     }
-     it { should have_attribute( :code )     }
-     it { should have_attribute( :name )     }
-     it { should have_attribute( :state )    }
-     it { should have_attribute( :country )  }
-     it { should have_attribute( :longitude) }
-     it { should have_attribute( :latitude ) }
-     it { should have_attribute( :raw )      }
- 
+  context "attributes" do
+     subject { Metar::Station.new("DDDD", noaa_data) }
+     it { should have_attribute(:cccc)     }
+     it { should have_attribute(:code)     }
+     it { should have_attribute(:name)     }
+     it { should have_attribute(:state)    }
+     it { should have_attribute(:country)  }
+     it { should have_attribute(:longitude) }
+     it { should have_attribute(:latitude) }
+     it { should have_attribute(:raw)      }
   end
   
-  context 'initialization' do
-  
-     it 'should fail if cccc is missing' do
+  context "initialization" do
+     it "should fail if cccc is missing" do
        expect do
          Metar::Station.new( nil, {} )
-       end.       to         raise_error( RuntimeError, /must not be nil/ )      
+       end.to raise_error(RuntimeError, /must not be nil/)      
      end
   
-     it 'should fail if cccc is empty' do
+     it "should fail if cccc is empty" do
        expect do
-         Metar::Station.new( '', {} )
-       end.       to         raise_error( RuntimeError, /must not be empty/ )      
+         Metar::Station.new("", {})
+       end.to raise_error( RuntimeError, /must not be empty/)      
      end
    
-    context 'with noaa data' do
-    
-      subject { Metar::Station.new( 'DDDD', noaa_data ) }
-      specify { subject.cccc.      should     == 'DDDD' }
-      specify { subject.name.      should     == 'Station name' }
-      specify { subject.state.     should     == 'State' }
-      specify { subject.country.   should     == 'Country' }
-      specify { subject.longitude. should     == 55.4 }
-      specify { subject.latitude.  should     == -11.05 }
-      specify { subject.raw.       should     == 'DDDD;00;000;Station name;State;Country;1;11-03S;055-24E;11-03S;055-24E;000;000;P' }
-    
-    end
+    context "with noaa data" do
+      subject { Metar::Station.new("DDDD", noaa_data) }
 
+      specify { expect(subject.cccc).to eq("DDDD") }
+      specify { expect(subject.name).to eq("Station name") }
+      specify { expect(subject.state).to eq("State") }
+      specify { expect(subject.country).to eq("Country") }
+      specify { expect(subject.longitude).to eq(55.4) }
+      specify { expect(subject.latitude).to eq(-11.05) }
+      specify { expect(subject.raw).to eq("DDDD;00;000;Station name;State;Country;1;11-03S;055-24E;11-03S;055-24E;000;000;P") }
+    end
   end
 
-  context 'object navigation' do
-    before :each do
-      @raw = stub('raw', :metar => 'PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000', :time => '2010/02/06 16:10' )
+  context "object navigation" do
+    let(:raw) { double(Metar::Raw, :metar => "PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000", :time => "2010/02/06 16:10") }
+
+    before do
       # TODO: hack - once parser returns station this can be removed
-      Metar::Raw::Noaa.           should_receive( :new ).
-                                  and_return( @raw )
+      allow(Metar::Raw::Noaa).to receive(:new) { raw }
+      allow(Metar::Station).to receive(:find_by_cccc) { subject }
     end
 
-    subject { Metar::Station.new( 'DDDD', noaa_data ) }
+    subject { described_class.new("DDDD", noaa_data) }
 
-    it '.station should return the Parser' do
-      subject.parser.             should     be_a Metar::Parser
+    it ".station should return the Parser" do
+      expect(subject.parser).to be_a(Metar::Parser)
     end
 
-    it '.report should return the Report' do
-      Metar::Station.             should_receive( :find_by_cccc ).
-                                  and_return( subject )
-
-      subject.report.             should     be_a Metar::Report
+    it ".report should return the Report" do
+      expect(subject.report).to be_a(Metar::Report)
     end
   end
-
 end
-

data/spec/unit/temperature_spec.rb

@@ -1,47 +1,36 @@
 # encoding: utf-8
-load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+require "spec_helper"
 
 describe Metar::Temperature do
-
   context '.parse' do
-
     it 'understands numbers' do
       t = Metar::Temperature.parse( '5' )
 
-      t.value.                    should     be_within( 0.01 ).of( 5.0 )
+      expect(t.value).to be_within( 0.01 ).of( 5.0 )
     end
 
     it 'treats an M-prefix as a negative indicator' do
       t = Metar::Temperature.parse( 'M5' )
 
-      t.value.                    should     be_within( 0.01 ).of( -5.0 )
+      expect(t.value).to be_within( 0.01 ).of( -5.0 )
     end
 
     it 'returns nil for other values' do
-      Metar::Temperature.parse('').
-                                  should     be_nil
-      Metar::Temperature.parse('aaa').
-                                  should     be_nil
+      expect(Metar::Temperature.parse('')).to be_nil
+      expect(Metar::Temperature.parse('aaa')).to be_nil
     end
-
   end
 
   context '#to_s' do
-
     it 'abbreviates the units' do
       t = Metar::Temperature.new( 5 )
 
-      t.to_s.                     should     == '5°C'
+      expect(t.to_s).to eq('5°C')
     end
 
     it 'rounds to the nearest degree' do
-      Metar::Temperature.new( 5.1 ).to_s.
-                                  should     == '5°C'
-      Metar::Temperature.new( 5.5 ).to_s.
-                                  should     == '6°C'
+      expect(Metar::Temperature.new( 5.1 ).to_s).to eq('5°C')
+      expect(Metar::Temperature.new( 5.5 ).to_s).to eq('6°C')
     end
-
   end
-
 end
-

data/spec/unit/variable_wind_spec.rb

@@ -1,49 +1,41 @@
-# encoding: utf-8
-load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+require "spec_helper"
 
 describe Metar::VariableWind do
-
   context '.parse' do
-
     it 'understands nnn + V + nnn' do
       vw = Metar::VariableWind.parse( '090V180' )
 
-      vw.direction1.value.        should     ==  90.0
-      vw.direction2.value.        should     == 180.0
+      expect(vw.direction1.value).to eq( 90.0)
+      expect(vw.direction2.value).to eq(180.0)
     end
 
     it 'accepts 360, rounding to 0 - 1' do
       vw = Metar::VariableWind.parse( '360V090' )
 
-      vw.direction1.value.        should     ==   0.0
-      vw.direction2.value.        should     ==  90.0
+      expect(vw.direction1.value).to eq(  0.0)
+      expect(vw.direction2.value).to eq( 90.0)
     end
 
 
     it 'accepts 360, rounding to 0 - 2' do
       vw = Metar::VariableWind.parse( '090V360' )
 
-      vw.direction1.value.        should     ==  90.0
-      vw.direction2.value.        should     ==   0.0
+      expect(vw.direction1.value).to eq( 90.0)
+      expect(vw.direction2.value).to eq(  0.0)
     end
 
     it 'returns nil for other' do
       vw = Metar::VariableWind.parse( 'XXX' )
 
-      vw.                         should     be_nil
+      expect(vw).to be_nil
     end
-
   end
 
   context '#to_s' do
-
     it 'renders compatible values as compass directions' do
       vw = Metar::VariableWind.parse( '090V180' )
 
-      vw.to_s.                    should     == 'E - S'
+      expect(vw.to_s).to eq('E - S')
     end
-
   end
-
 end
-