metar-parser 1.2.1 → 1.3.0

data/spec/data/remark_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+describe Metar::Data::Remark do
+  context '.parse' do
+    it 'delegate to subclasses' do
+      expect(described_class.parse('21012')).to be_a(Metar::Data::TemperatureExtreme)
+    end
+
+    it 'returns nil for unrecognised' do
+      expect(described_class.parse('FOO')).to be_nil
+    end
+
+    context '6-hour maximum or minimum' do
+      [
+        ['positive maximum', '10046', [:maximum,  4.6]],
+        ['negative maximum', '11012', [:maximum, -1.2]],
+        ['positive minimum', '20046', [:minimum,  4.6]],
+        ['negative minimum', '21012', [:minimum, -1.2]],
+      ].each do |docstring, raw, expected|
+        example docstring do
+          expect(described_class.parse(raw)).to be_temperature_extreme(*expected)
+        end
+      end
+    end
+
+    context '24-hour maximum and minimum' do
+      it 'returns minimum and maximum' do
+        max, min = described_class.parse('400461006')
+
+        expect(max).to be_temperature_extreme(:maximum,  4.6)
+        expect(min).to be_temperature_extreme(:minimum, -0.6)
+      end
+    end
+
+    context 'pressure tendency' do
+      it 'steady_then_decreasing' do
+        pt = described_class.parse('58033')
+
+        expect(pt).to be_a(Metar::Data::PressureTendency)
+        expect(pt.character).to eq(:steady_then_decreasing)
+        expect(pt.value).to eq(3.3)
+      end
+    end
+
+    context '3-hour and 6-hour precipitation' do
+      it '60009' do
+        pr = described_class.parse('60009')
+
+        expect(pr).to be_a(Metar::Data::Precipitation)
+        expect(pr.period).to eq(3)
+        expect(pr.amount.value).to eq(0.002286)
+      end
+    end
+
+    context '24-hour precipitation' do
+      it '70015' do
+        pr = described_class.parse('70015')
+
+        expect(pr).to be_a(Metar::Data::Precipitation)
+        expect(pr.period).to eq(24)
+        expect(pr.amount.value).to eq(0.003810)
+      end
+    end
+
+    context 'automated station' do
+
+      [
+        ['with precipitation dicriminator', 'AO1', [Metar::Data::AutomatedStationType, :with_precipitation_discriminator]],
+        ['without precipitation dicriminator', 'AO2', [Metar::Data::AutomatedStationType, :without_precipitation_discriminator]],
+      ].each do |docstring, raw, expected|
+        example docstring do
+          aut = described_class.parse(raw)
+
+          expect(aut).to be_a(expected[0])
+          expect(aut.type).to eq(expected[1])
+        end
+      end
+    end
+
+    context 'sea-level pressure' do
+      it 'SLP125' do
+        slp = described_class.parse('SLP125')
+
+        expect(slp).to be_a(Metar::Data::SeaLevelPressure)
+        expect(slp.pressure.value).to eq(0.0125)
+      end
+    end
+
+    context 'hourly temperature and dew point' do
+      it 'T00640036' do
+        htm = described_class.parse('T00641036')
+
+        expect(htm).to be_a(Metar::Data::HourlyTemperatureAndDewPoint)
+        expect(htm.temperature.value).to eq(6.4)
+        expect(htm.dew_point.value).to eq(-3.6)
+      end
+    end
+  end
+end

data/spec/data/runway_visible_range_spec.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+require "spec_helper"
+
+RSpec::Matchers.define :be_runway_visible_range do |designator, visibility1, visibility2, tendency|
+  match do |rvr|
+    if rvr.nil?                && designator.nil?
+      true
+    elsif rvr.nil?             != designator.nil?
+      false
+    elsif rvr.visibility1.nil? != visibility1.nil?
+      false
+    elsif rvr.visibility2.nil? != visibility2.nil?
+      false
+    elsif rvr.tendency.nil? != tendency.nil?
+      false
+    elsif ! visibility1.nil? &&
+          ((rvr.visibility1.distance.value - visibility1[0]).abs > 0.01 ||
+            rvr.visibility1.comparator != visibility1[ 2 ])
+      false
+    elsif ! visibility2.nil? &&
+          ((rvr.visibility2.distance.value - visibility2[0]).abs > 0.02 ||
+            rvr.visibility2.comparator != visibility2[2])
+      false
+    elsif tendency != rvr.tendency
+      false
+    else
+      true
+    end
+  end
+end
+
+describe Metar::Data::RunwayVisibleRange do
+  context '.parse' do
+    [
+      ['understands R + nn + / + nnnn',           'R12/3400',           ['12',  [3400.00, nil, nil],        nil,                  nil]],
+      ['understands runway positions: RLC',       'R12L/3400',          ['12L', [3400.00, nil, nil],        nil,                  nil]],
+      ['understands comparators: PM',             'R12/P3400',          ['12',  [3400.00, nil, :more_than], nil,                  nil]],
+      ['understands tendencies: NUD',             'R12/3400U',          ['12',  [3400.00, nil, nil],        nil,                  :improving]],
+      ['understands feet',                        'R12/3400FT',         ['12',  [1036.32, nil, nil],        nil,                  nil]],
+      ['understands second visibilities (m)',     'R26/0750V1200U',     ['12',  [ 750.0,  nil, nil],        [1200.0, nil, nil],   :improving]],
+      ['understands second visibilities (ft)',    'R12/1800V3400FT',    ['12',  [548.64, nil, nil],         [1036.32, nil, nil],  nil]],
+      ['understands second RVR (ft) w/ tendency', 'R29/1800V3400FT/U',  ['29',  [548.64, nil, nil],         [1036.32, nil, nil],  :improving]],
+      ['returns nil for nil',                     nil,                  [nil,   nil,                        nil,                  nil]],
+    ].each do |docstring, raw, expected|
+      example docstring do
+        expect(described_class.parse(raw)).to be_runway_visible_range(*expected)
+      end
+    end
+  end
+
+  context '#to_s' do
+    before :all do
+      @locale = I18n.locale
+      I18n.locale = :it
+    end
+
+    after :all do
+      I18n.locale = @locale
+    end
+
+    [
+      ['v1',        :en, [[3400.00, nil, nil], nil,                 nil], 'runway 14: 3400m'],
+      ['v1 and v2',       :en,  [[3400.00, nil, nil], [1900.00, nil, nil], nil ], 'runway 14: from 3400m to 1900m'],
+      ['v1 and tendency', :en, [[3400.00, nil, nil], nil,                 :improving ], 'runway 14: 3400m improving'],
+    ].each do |docstring, locale, (visibility1, visibility2, tendency), expected|
+      d1 = Metar::Data::Distance.new(visibility1[0])
+      v1 = Metar::Data::Visibility.new(
+        nil, distance: d1, direction: visibility1[1], comparator: visibility1[2]
+      )
+      v2 =
+        if ! visibility2.nil?
+          d2 = Metar::Data::Distance.new(visibility2[0])
+          Metar::Data::Visibility.new(
+            nil,
+            distance: d2, direction: visibility2[1], comparator: visibility2[2]
+          )
+        else
+          nil
+        end
+
+      example docstring + " (#{locale})" do
+        I18n.locale = locale
+        subject = described_class.new(
+          nil,
+          designator: '14',
+          visibility1: v1, visibility2: v2, tendency: tendency
+        )
+        expect(subject.to_s).to eq(expected)
+      end
+    end
+  end
+end

data/spec/{sky_condition_spec.rb → data/sky_condition_spec.rb}

@@ -9,7 +9,7 @@ RSpec::Matchers.define :be_sky_condition do |quantity, height, type|
       false
     elsif sk.quantity != quantity
       false
-    elsif sk.height.is_a?(Metar::Distance) && sk.height.value != height
+    elsif sk.height.is_a?(Metar::Data::Distance) && sk.height.value != height
       false
     elsif sk.type != type
       false
@@ -19,7 +19,7 @@ RSpec::Matchers.define :be_sky_condition do |quantity, height, type|
   end
 end
 
-describe Metar::SkyCondition do
+describe Metar::Data::SkyCondition do
   context '.parse' do
     [
       ['understands clear skies codes', 'NSC',      [nil,            nil,            nil]],
@@ -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
-        expect(Metar::SkyCondition.parse(raw)).to be_sky_condition(*expected)
+        expect(described_class.parse(raw)).to be_sky_condition(*expected)
       end
     end
   end
@@ -48,7 +48,9 @@ describe Metar::SkyCondition do
       after  { I18n.locale = @old_locale }
 
       example "#{docstring} - #{locale}" do
-        condition = Metar::SkyCondition.new(quantity, height, type)
+        condition = described_class.new(
+          nil, quantity: quantity, height: height, type: type
+        )
         I18n.locale = locale
         expect(condition.to_summary).to eq(expected)
       end
@@ -62,8 +64,10 @@ describe Metar::SkyCondition do
       ['quantity + type', ['broken', 360, 'cumulonimbus'], 'broken cumulonimbus at 360'],
     ].each do |docstring, (quantity, height, type), expected|
       example docstring do
-        condition = Metar::SkyCondition.new(quantity, height, type)
-        expect(condition.to_s).to eq(expected)
+        subject = described_class.new(
+          nil, quantity: quantity, height: height, type: type
+        )
+        expect(subject.to_s).to eq(expected)
       end
     end
   end

data/spec/data/speed_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Metar::Data::Speed do
+  context ".parse" do
+    it "returns nil for nil" do
+      speed = described_class.parse(nil)
+
+      expect(speed).to be_nil
+    end
+
+    it "parses knots" do
+      speed = described_class.parse("5KT")
+
+      expect(speed).to be_a(described_class)
+      expect(speed.value).to be_within(0.01).of(2.57)
+    end
+
+    it "parses meters per second" do
+      speed = described_class.parse("7MPS")
+
+      expect(speed).to be_a(described_class)
+      expect(speed.value).to be_within(0.01).of(7.00)
+    end
+
+    it "parses kilometers per hour" do
+      speed = described_class.parse("14KMH")
+
+      expect(speed).to be_a(described_class)
+      expect(speed.value).to be_within(0.01).of(3.89)
+    end
+
+    it "treats straight numbers as kilomters per hour" do
+      speed = described_class.parse("14")
+
+      expect(speed).to be_a(described_class)
+      expect(speed.value).to be_within(0.01).of(3.89)
+    end
+
+    it "returns nil for other strings" do
+      speed = described_class.parse("")
+
+      expect(speed).to be_nil
+    end
+  end
+end

data/spec/data/temperature_spec.rb

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

data/spec/{variable_wind_spec.rb → data/variable_wind_spec.rb}

@@ -1,30 +1,30 @@
 require "spec_helper"
 
-describe Metar::VariableWind do
+describe Metar::Data::VariableWind do
   context '.parse' do
     it 'understands nnn + V + nnn' do
-      vw = Metar::VariableWind.parse('090V180')
+      vw = described_class.parse('090V180')
 
       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 = described_class.parse('360V090')
 
       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 = described_class.parse('090V360')
 
       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 = described_class.parse('XXX')
 
       expect(vw).to be_nil
     end
@@ -32,7 +32,7 @@ describe Metar::VariableWind do
 
   context '#to_s' do
     it 'renders compatible values as compass directions' do
-      vw = Metar::VariableWind.parse('090V180')
+      vw = described_class.parse('090V180')
 
       expect(vw.to_s).to eq('E - S')
     end

data/spec/{vertical_visibility_spec.rb → data/vertical_visibility_spec.rb}

@@ -16,7 +16,7 @@ RSpec::Matchers.define :be_distance do |expected|
   end
 end
 
-describe Metar::VerticalVisibility do
+describe Metar::Data::VerticalVisibility do
   context '.parse' do
     [
       ['VV + nnn',                  'VV300',  9144],
@@ -24,7 +24,7 @@ describe Metar::VerticalVisibility do
       ['returns nil for unmatched', 'FUBAR',  :expect_nil],
     ].each do |docstring, raw, expected|
       example docstring do
-        expect(Metar::VerticalVisibility.parse(raw)).to be_distance(expected)
+        expect(described_class.parse(raw)).to be_distance(expected)
       end
     end
   end

data/spec/{data_spec.rb → data/visibility_remark_spec.rb}

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require "spec_helper"
 
-RSpec.describe Metar::VisibilityRemark do
+describe Metar::Data::VisibilityRemark do
   describe ".parse" do
     subject { described_class.parse("2000W") }
 
@@ -14,13 +14,3 @@ RSpec.describe Metar::VisibilityRemark do
     end
   end
 end
-
-RSpec.describe Metar::DensityAltitude do
-  describe ".parse" do
-    subject { described_class.parse("50FT") }
-
-    it "interprets the value as feet" do
-      expect(subject.height.to_feet).to eq(50)
-    end
-  end
-end

data/spec/{visibility_spec.rb → data/visibility_spec.rb}

@@ -13,9 +13,9 @@ RSpec::Matchers.define :be_visibility do |distance, direction, comparator|
       false
     elsif visibility.comparator.nil? != comparator.nil?
       false
-    elsif visibility.distance.is_a?(Metar::Distance)&& (visibility.distance.value - distance).abs > 0.01
+    elsif visibility.distance.is_a?(Metar::Data::Distance) && (visibility.distance.value - distance).abs > 0.01
       false
-    elsif visibility.direction.is_a?(M9t::Direction)&& (visibility.direction.value - direction).abs > 0.01
+    elsif visibility.direction.is_a?(M9t::Direction) && (visibility.direction.value - direction).abs > 0.01
       false
     elsif comparator.is_a?(Symbol)                   && visibility.comparator != comparator
       false
@@ -25,7 +25,7 @@ RSpec::Matchers.define :be_visibility do |distance, direction, comparator|
   end
 end
 
-describe Metar::Visibility do
+describe Metar::Data::Visibility do
   context '.parse' do
     [
       ['understands 9999',          '9999',    [10000.00, nil,   :more_than]],
@@ -41,7 +41,7 @@ describe Metar::Visibility do
       ['returns nil for unmatched', 'FUBAR',   [     nil,   nil, nil]],
     ].each do |docstring, raw, expected|
       example docstring do
-        expect(Metar::Visibility.parse(raw)).to be_visibility(*expected)
+        expect(described_class.parse(raw)).to be_visibility(*expected)
       end
     end
   end
@@ -64,14 +64,16 @@ describe Metar::Visibility do
       ['with distance and direction',             :it, [ :set, :set, nil ],        '4km ESE'],
       ['with distance, direction and comparator', :it, [ :set, :set, :more_than ], 'piú di 4km ESE'],
     ].each do |docstring, locale, (distance, direction, comparator), expected|
-      distance  = Metar::Distance.new(4321) if distance  == :set
+      distance  = Metar::Data::Distance.new(4321) if distance  == :set
       direction = M9t::Direction.new(123)   if direction == :set
 
       example docstring + " (#{locale})" do
         I18n.locale = locale
-        value = Metar::Visibility.new(distance, direction, comparator).to_s
+        subject = described_class.new(
+          nil, distance: distance, direction: direction, comparator: comparator
+        )
 
-        expect(value).to eq(expected)
+        expect(subject.to_s).to eq(expected)
       end
     end
   end

data/spec/{weather_phenomenon_spec.rb → data/weather_phenomenon_spec.rb}

@@ -19,7 +19,7 @@ RSpec::Matchers.define :be_weather_phenomenon do |modifier, descriptor, phenomen
   end
 end
 
-describe Metar::WeatherPhenomenon do
+describe Metar::Data::WeatherPhenomenon do
   context '.parse' do
     [
       ['simple phenomenon',                  'BR',     [nil,      nil,            'mist']],
@@ -33,7 +33,7 @@ describe Metar::WeatherPhenomenon do
       ['returns nil for unmatched',          'FUBAR',  [nil,      nil,            nil]],
     ].each do |docstring, raw, expected|
       example docstring do
-        expect(Metar::WeatherPhenomenon.parse(raw)).to be_weather_phenomenon(*expected)
+        expect(described_class.parse(raw)).to be_weather_phenomenon(*expected)
       end
     end
   end
@@ -58,7 +58,11 @@ describe Metar::WeatherPhenomenon do
     ].each do |docstring, locale, (modifier, descriptor, phenomenon), expected|
       example docstring + " (#{locale})" do
         I18n.locale = locale
-        expect(Metar::WeatherPhenomenon.new(phenomenon, modifier, descriptor).to_s).to eq(expected)
+        subject = described_class.new(
+          nil,
+          phenomenon: phenomenon, modifier: modifier, descriptor: descriptor
+        )
+        expect(subject.to_s).to eq(expected)
       end
     end
   end

data/spec/{wind_spec.rb → data/wind_spec.rb}

@@ -19,7 +19,7 @@ RSpec::Matchers.define :be_wind do |direction, speed, gusts|
       false
     elsif speed.is_a?(Symbol) && wind.speed != speed
       false
-    elsif speed.is_a?(Metar::Speed) && (wind.speed.value - speed).abs > 0.01
+    elsif speed.is_a?(Metar::Data::Speed) && (wind.speed.value - speed).abs > 0.01
       false
     elsif !wind.gusts.nil? && (wind.gusts.value - gusts).abs > 0.01
       false
@@ -29,7 +29,7 @@ RSpec::Matchers.define :be_wind do |direction, speed, gusts|
   end
 end
 
-describe Metar::Wind do
+describe Metar::Data::Wind do
   context '.parse' do
     [
       # Direction and speed
@@ -66,7 +66,7 @@ describe Metar::Wind do
       ['returns nil for nil',                                nil,           [nil, nil, nil]],
     ].each do |docstring, raw, expected|
       example docstring do
-        expect(Metar::Wind.parse(raw)).to be_wind(*expected)
+        expect(described_class.parse(raw)).to be_wind(*expected)
       end
     end
   end
@@ -86,19 +86,22 @@ describe Metar::Wind do
       ['handles variable_direction',  :en, [:variable_direction, nil,            nil                  ], '443km/h variable direction'   ],
       ['handles unknown_direction',   :en, [:unknown_direction,  nil,            nil                  ], '443km/h unknown direction'    ],
       ['handles unknown_speed',       :en, [nil,                 :unknown_speed, nil                  ], 'unknown speed ESE'            ],
-      ['includes gusts',              :en, [nil,                 nil,            Metar::Speed.new(123)], '443km/h ESE gusts 443km/h'    ],
+      ['includes gusts',              :en, [nil,                 nil,            Metar::Data::Speed.new(123)], '443km/h ESE gusts 443km/h'    ],
       ['formats speed and direction', :it, [nil,                 nil,            nil                  ], '443km/h ESE'                  ],
       ['handles variable_direction',  :it, [:variable_direction, nil,            nil                  ], '443km/h direzione variabile'  ],
       ['handles unknown_direction',   :it, [:unknown_direction,  nil,            nil                  ], '443km/h direzione sconosciuta'],
       ['handles unknown_speed',       :it, [nil,                 :unknown_speed, nil                  ], 'velocità sconosciuta ESE'     ],
-      ['includes gusts',              :it, [nil,                 nil,            Metar::Speed.new(123)], '443km/h ESE folate di 443km/h'],
+      ['includes gusts',              :it, [nil,                 nil,            Metar::Data::Speed.new(123)], '443km/h ESE folate di 443km/h'],
     ].each do |docstring, locale, (direction, speed, gusts), expected|
       direction ||= M9t::Direction.new(123)
-      speed     ||= Metar::Speed.new(123)
+      speed     ||= Metar::Data::Speed.new(123)
 
       example docstring + " (#{locale})" do
         I18n.locale = locale
-        expect(Metar::Wind.new(direction, speed, gusts).to_s).to eq(expected)
+        subject = described_class.new(
+          "chunk", direction: direction, speed: speed, gusts: gusts
+        )
+        expect(subject.to_s).to eq(expected)
       end
     end
   end