metar-parser 0.1.1 → 0.1.2

data/lib/metar.rb

@@ -8,7 +8,7 @@ module Metar
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY = 1
+    TINY = 2
  
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/metar/data.rb

@@ -7,6 +7,27 @@ module Metar
   locales_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'locales'))
   I18n.load_path += Dir.glob("#{ locales_path }/*.yml")
 
+  # Subclasses M9t::Distance
+  # Uses kilometers as desired default output unit
+  class Distance < M9t::Distance
+
+    # nil is taken to mean 'data unavailable'
+    def initialize(meters = nil, options = {})
+      if meters
+        super(meters, { :units => :kilometers, :precision => 0, :abbreviated => true }.merge(options))
+      else
+        @value = nil
+      end
+    end
+
+    # Handles nil case differently to M9t::Distance
+    def to_s
+      return I18n.t('metar.distance.unknown') if @value.nil?
+      super
+    end
+
+  end
+
   # Adds a parse method to the M9t base class
   class Speed < M9t::Speed
 
@@ -46,39 +67,87 @@ module Metar
 
   end
 
-  class Distance < M9t::Distance
+  # Adds a parse method to the M9t base class
+  class Pressure < M9t::Pressure
 
-    # Subclasses M9t::Distance
-    # Uses kilometers as desired default output unit
-    # nil is taken to mean 'data unavailable'
-    def initialize(meters = nil, options = {})
-      if meters
-        super(meters, { :units => :kilometers, :precision => 0, :abbreviated => true }.merge(options))
+    def Pressure.parse(pressure)
+      case
+      when pressure =~ /^Q(\d{4})$/
+        hectopascals($1.to_f)
+      when pressure =~ /^A(\d{4})$/
+        inches_of_mercury($1.to_f / 100.0)
+      end
+    end
+
+  end
+
+  class Wind
+    
+    def Wind.parse(s)
+      case
+      when s =~ /^(\d{3})(\d{2}(|MPS|KMH|KT))$/
+        new(M9t::Direction.new($1, { :abbreviated => true }), Speed.parse($2))
+      when s =~ /^(\d{3})(\d{2})G(\d{2,3}(|MPS|KMH|KT))$/
+        new(M9t::Direction.new($1, { :abbreviated => true }), Speed.parse($2))
+      when s =~ /^VRB(\d{2}(|MPS|KMH|KT))$/
+        new(:variable_direction, Speed.parse($1))
+      when s =~ /^\/{3}(\d{2}(|MPS|KMH|KT))$/
+        new(:unknown_direction, Speed.parse($1))
+      when s =~ /^\/{3}(\/{2}(|MPS|KMH|KT))$/
+        new(:unknown_direction, :unknown)
       else
-        @value = nil
+        nil
       end
     end
 
-    # Handles nil case differently to M9t::Distance
+    attr_reader :direction, :speed, :units
+
+    def initialize(direction, speed, units = :kilometers_per_hour)
+      @direction, @speed = direction, speed
+    end
+
     def to_s
-      return I18n.t('metar.distance.unknown') if @value.nil?
-      super
+      direction =
+        case @direction
+        when :variable_direction
+          I18n.t('metar.wind.variable_direction')
+        when :unknown_direction
+          I18n.t('metar.wind.unknown_direction')
+        else
+          @direction.to_s
+        end
+      speed =
+        case @speed
+        when :unknown
+          I18n.t('metar.wind.unknown_speed')
+        else
+          @speed.to_s
+        end  
+      "#{ direction }, #{ speed }"
     end
 
   end
 
-  # Adds a parse method to the M9t base class
-  class Pressure < M9t::Pressure
+  class VariableWind
 
-    def Pressure.parse(pressure)
-      case
-      when pressure =~ /^Q(\d{4})$/
-        hectopascals($1.to_f)
-      when pressure =~ /^A(\d{4})$/
-        inches_of_mercury($1.to_f / 100.0)
+    def VariableWind.parse(variable_wind)
+      if variable_wind =~ /^(\d+)V(\d+)$/
+        new(M9t::Direction.new($1), M9t::Direction.new($2))
+      else
+        nil
       end
     end
 
+    attr_reader :direction1, :direction2
+
+    def initialize(direction1, direction2)
+      @direction1, @direction2 = direction1, direction2
+    end
+
+    def to_s
+      "#{ @direction1 } - #{ @direction2 }"
+    end
+
   end
 
   class Visibility
@@ -127,59 +196,6 @@ module Metar
     end
   end
 
-  class Wind
-
-    def Wind.parse(s)
-      case
-      when s =~ /^(\d{3})(\d{2}(KT|MPS|KMH|))$/
-        new(M9t::Direction.new($1, { :abbreviated => true }), Speed.parse($2))
-      when s =~ /^(\d{3})(\d{2})G(\d{2,3}(KT|MPS|KMH|))$/
-        new(M9t::Direction.new($1, { :abbreviated => true }), Speed.parse($2))
-      when s =~ /^VRB(\d{2}(KT|MPS|KMH|))$/
-        new('variable direction', Speed.parse($1))
-      when s =~ /^\/{3}(\d{2}(KT|MPS|KMH|))$/
-        new('unknown direction', Speed.parse($1))
-      when s =~ /^\/{3}(\/{2}(KT|MPS|KMH|))$/
-        new('unknown direction', 'unknown')
-      else
-        nil
-      end
-    end
-
-    attr_reader :direction, :speed, :units
-
-    def initialize(direction, speed, units = :kilometers_per_hour)
-      @direction, @speed = direction, speed
-    end
-
-    def to_s
-      "#{ @direction } #{ @speed }"
-    end
-
-  end
-
-  class VariableWind
-
-    def VariableWind.parse(variable_wind)
-      if variable_wind =~ /^(\d+)V(\d+)$/
-        new(M9t::Direction.new($1), M9t::Direction.new($2))
-      else
-        nil
-      end
-    end
-
-    attr_reader :direction1, :direction2
-
-    def initialize(direction1, direction2)
-      @direction1, @direction2 = direction1, direction2
-    end
-
-    def to_s
-      "#{ @direction1 } - #{ @direction2 }"
-    end
-
-  end
-
   class RunwayVisibleRange
 
     TENDENCY   = { '' => nil, 'N' => :no_change, 'U' => :improving, 'D' => :worsening }
@@ -226,17 +242,12 @@ module Metar
       end
     end
 
-    private
-
-    def RunwayVisibleRange.parse_visibility(distance)
-    end
-
   end
 
   class WeatherPhenomenon
 
     Modifiers = {
-      '\+' => 'heavy',
+      '+' => 'heavy',
       '-'  => 'light',
       'VC' => 'nearby'
     }
@@ -290,6 +301,7 @@ module Metar
       codes = Phenomena.keys.join('|')
       descriptors = Descriptors.keys.join('|')
       modifiers = Modifiers.keys.join('|')
+      modifiers.gsub!(/([\+\-])/) { "\\#$1" }
       rxp = Regexp.new("^(#{ modifiers })?(#{ descriptors })?(#{ codes })$")
       if rxp.match(s)
         modifier_code = $1

data/locales/en.yml

@@ -15,11 +15,21 @@ en:
       at: at
     distance:
       unknown: unknown
+    wind:
+      variable_direction: variable direction
+      unknown_direction: unknown direction
+      unknown_speed: unknown speed
     sky_conditions:
       clear skies: clear skies
       broken: broken cloud
+      broken cumulonimbus: broken cumulonimbus
+      broken towering cumulus: broken towering cumulus clouds
       few: few clouds
+      few cumulonimbus: few cumulonimbus
+      few towering cumulus: few towering cumulus clouds
       scattered: scattered cloud
+      scattered cumulonimbus: scattered cumulonimbus
+      scattered towering cumulus: scattered towering cumulus clouds
       overcast: overcast
     runway_visible_range:
       runway: runway

data/locales/it.yml

@@ -15,11 +15,21 @@ it:
       at: a
     distance:
       unknown: sconosciuto
+    wind:
+      variable_direction: direzione variabile
+      unknown_direction: direzione sconosciuta
+      unknown_speed: velocità sconosciuta
     sky_conditions:
       clear skies: cielo sereno
       broken: nuvolosità parziale
+      broken cumulonimbus: copertura parziale di cumulonembi
+      broken towering cumulus: copertura parziale di cumulonembi
       few: poche nuvole
+      broken cumulonimbus: pochi cumulonembi
+      broken towering cumulus: pochi cumulonembi
       scattered: nuvole sparse
+      scattered cumulonimbus: cumulonembi sparsi
+      scattered towering cumulus: cumulonembi sparsi
       overcast: chiuso
     runway_visible_range:
       runway: pista
@@ -33,7 +43,7 @@ it:
       nearby blowing dust: deriva vicina di polviscolo # ?
       heavy drizzle: pioggerellina fitta
       light drizzle: pioggerellina rada
-      heavy freezing drizzle: pioggerellina ghiacciata pesante
+      heavy freezing drizzle: pioggerellina ghiacciata intensa
       light freezing drizzle: pioggerellina ghiacciata leggera
       fog: nebbia
       patches of fog: nebbia a banchi
@@ -55,11 +65,11 @@ it:
       nearby dust whirls: vortici di polvere vicini
       spray: "spruzzi d'aqua"
       rain: pioggia
-      heavy rain: pioggia pesante
+      heavy rain: pioggia intensa
       light rain: pioggia leggera
       heavy shower of rain: acquazzone intenso
       light shower of rain: acquazzone leggero
-      heavy freezing rain: pioggia ghiacciata pesante
+      heavy freezing rain: pioggia ghiacciata intensa
       light freezing rain: pioggia ghiacciata leggera
       sand: sabbia
       blowing sand: sabbia e vento
@@ -67,9 +77,9 @@ it:
       nearby blowing sand: deriva di sabbia vicina
       nearby shower: acquazzone vicino
       snow: neve
-      heavy snow: neve pesante
+      heavy snow: neve intensa
       light snow: neve leggera
-      heavy shower of snow: nevicata pesante
+      heavy shower of snow: nevicata intensa
       light shower of snow: nevicata leggera
       blowing snow: neve portata dal vento
       low drifting snow: deriva di neve
@@ -79,20 +89,20 @@ it:
       snow and rain: neve mista a pioggia
       squall: bufera
       unknown phenomenon: fenomeno sconosciuto
-      heavy freezing unknown phenomenon: fenomeno ghiacciato sconosciuto pesante
+      heavy freezing unknown phenomenon: fenomeno ghiacciato sconosciuto intenso
       light freezing unknown phenomenon: fenomeno ghiacciato sconosciuto leggero
-      heavy shower of freezing unknown phenomenon: scroscio pesante ghiacciata di fenomeno sconosciuto
+      heavy shower of freezing unknown phenomenon: scroscio intenso ghiacciata di fenomeno sconosciuto
       light shower of freezing unknown phenomenon: scroscio leggero ghiacciata di fenomeno sconosciuto
       volcanic ash: cenere volcanica
       nearby volcanic ash: cenere volcanica vicina
       funnel cloud: nube a imbuto
       nearby funnel cloud: nube a imbuto vicina
       sand storm: tempesta di sabbia
-      heavy sand storm: tempesta di sabbia pesante
+      heavy sand storm: tempesta di sabbia intensa
       light sand storm: tempesta di sabbia leggera
       nearby sand storm: tempesta di sabbia vicina
       dust storm: tempesta di polvere
-      heavy dust storm: tempesta di polvere pesante
+      heavy dust storm: tempesta di polvere intensa
       light dust storm: tempesta di polvere leggera
       nearby dust storm: tempesta di polvere vicina
       thunderstorm: temporale

data/test/unit/data_test.rb

@@ -13,13 +13,33 @@ class TestMetarData < Test::Unit::TestCase
     assert_equal('10 kilometers', M9t::Distance.new(10000, {:units => :kilometers, :precision => 0}).to_s)
   end
 
+  # Distance
+  def test_distance_nil
+    distance = Metar::Distance.new
+    I18n.locale = :en
+    assert_equal('unknown', distance.to_s)
+    I18n.locale = :it
+    assert_equal('sconosciuto', distance.to_s)
+  end
+
+  def test_distance_with_default_options
+    distance = Metar::Distance.new(123)
+    assert_equal(123, distance.value)
+    assert_equal(:kilometers, distance.options[:units])
+  end
+
+  def test_distance_setting_options
+    distance = Metar::Distance.new(123, { :units => :feet })
+    assert_equal('404ft', distance.to_s)
+  end
+
   # Speed
   def test_speed_parse_blank_gives_nil
     speed = Metar::Speed.parse('')
     assert_nil(speed)
   end
 
-  def test_class_options_set
+  def test_speed_class_options_set
     assert_not_nil(Metar::Speed.options)
   end
 
@@ -44,7 +64,7 @@ class TestMetarData < Test::Unit::TestCase
     speed = Metar::Speed.parse('12MPS')
     assert_equal(:meters_per_second, speed.options[:units])
   end
-  
+
   # Temperature
   def test_temperature_parse_blank_gives_nil
     temperature = Metar::Temperature.parse('')
@@ -59,6 +79,7 @@ class TestMetarData < Test::Unit::TestCase
   def test_temperature_parse_positive
     temperature = Metar::Temperature.parse('12')
     assert_equal(12, temperature.value)
+    assert_equal(:degrees, temperature.options[:units])
   end
 
   def test_temperature_parse_negative
@@ -66,23 +87,74 @@ class TestMetarData < Test::Unit::TestCase
     assert_equal(-12, temperature.value)
   end
 
-  # Distance
-  def test_distance_nil
-    distance = Metar::Distance.new
-    I18n.locale = :en
-    assert_equal('unknown', distance.to_s)
-    I18n.locale = :it
-    assert_equal('sconosciuto', distance.to_s)
+  # Pressure
+  def test_pressure_parse_hectopascals
+    pressure = Metar::Pressure.parse('Q1002')
+    assert_equal(1.002, pressure.value)
+  end
+
+  def test_pressure_parse_hectopascals_leading_zero
+    pressure = Metar::Pressure.parse('Q0992')
+    assert_equal(0.992, pressure.value)
+  end
+
+  def test_pressure_parse_inches_of_mercury
+    pressure = Metar::Pressure.parse('A3019')
+    assert_in_delta(1.02235, pressure.value, 0.00001)
   end
 
   # Wind
-  def test_wind
+  def test_wind_parse_default_units
+    wind = Metar::Wind.parse('18012')
+    assert_equal(180, wind.direction.value)
+    assert_equal(12.0, wind.speed.to_kilometers_per_hour)
+    assert_equal(:kilometers_per_hour, wind.speed.options[:units])
+  end
+
+  def test_wind_parse_mps
+    wind = Metar::Wind.parse('18012MPS')
+    assert_equal(180, wind.direction.value)
+    assert_equal(12.0, wind.speed.value)
+    assert_equal(:meters_per_second, wind.speed.options[:units])
+  end
+
+  def test_wind_parse_kmh
+    wind = Metar::Wind.parse('27012KMH')
+    assert_equal(270, wind.direction.value)
+    assert_equal(12.0, wind.speed.to_kilometers_per_hour)
+    assert_equal(:kilometers_per_hour, wind.speed.options[:units])
+  end
+
+  def test_wind_parse_knots
     wind = Metar::Wind.parse('24006KT')
     assert_equal(240, wind.direction.value)
     assert_equal(6, wind.speed.to_knots)
     assert_equal(:knots, wind.speed.options[:units])
   end
 
+  def test_wind_parse_variable_direction
+    wind = Metar::Wind.parse('VRB20KT')
+    assert_equal(:variable_direction, wind.direction)
+    assert_equal(20, wind.speed.to_knots)
+    assert_equal(:knots, wind.speed.options[:units])
+    assert_equal('variable direction, 20 knots', wind.to_s)
+  end
+
+  def test_wind_parse_unknown_direction
+    wind = Metar::Wind.parse('///20KT')
+    assert_equal(:unknown_direction, wind.direction)
+    assert_equal(20, wind.speed.to_knots)
+    assert_equal(:knots, wind.speed.options[:units])
+    assert_equal('unknown direction, 20 knots', wind.to_s)
+  end
+
+  def test_wind_parse_unknown_direction_and_speed
+    wind = Metar::Wind.parse('/////')
+    assert_equal(:unknown_direction, wind.direction)
+    assert_equal(:unknown, wind.speed)
+    assert_equal('unknown direction, unknown speed', wind.to_s)
+  end
+
   # VariableWind
   def test_variable_wind
     variable_wind = Metar::VariableWind.parse('350V050')
@@ -143,13 +215,19 @@ class TestMetarData < Test::Unit::TestCase
     visibility.direction.options[:units] = :compass
     assert_equal('5km NE', visibility.to_s)
   end
-  
+
   # RunwayVisibleRange
   def test_runway_visible_range
     runway_visible_range = Metar::RunwayVisibleRange.parse('R12/1000N')
     assert_equal('12', runway_visible_range.designator)
     assert_equal(1000, runway_visible_range.visibility1.distance.value)
     assert_equal(:no_change, runway_visible_range.tendency)
+    assert_equal('runway 12: 1000m', runway_visible_range.to_s)
+  end
+
+  def test_runway_visible_range_descriptor_with_letter
+    runway_visible_range = Metar::RunwayVisibleRange.parse('R12R/1000N')
+    assert_equal('12R', runway_visible_range.designator)
   end
 
   def test_runway_visible_range_variable
@@ -160,24 +238,122 @@ class TestMetarData < Test::Unit::TestCase
   end
 
   # WeatherPhenomenon
-  def test_weather_phenomenon_i18n
+  def test_weather_phenomenon_snra
+    phenomenon = Metar::WeatherPhenomenon.parse('SNRA')
+    assert_equal('snow and rain', phenomenon.to_s)
+    I18n.locale =  :it
+    assert_equal('neve mista a pioggia', phenomenon.to_s)
+  end
+
+  def test_weather_phenomenon_fzfg
     freezing_rain = Metar::WeatherPhenomenon.parse('FZFG')
     assert_equal('freezing fog', freezing_rain.to_s)
     I18n.locale =  :it
     assert_equal('nebbia ghiacciata', freezing_rain.to_s)
   end
 
+  def test_weather_phenomenon_with_modifier_plus
+    phenomenon = Metar::WeatherPhenomenon.parse('+RA')
+    assert_equal('heavy', phenomenon.modifier)
+    assert_equal('heavy rain', phenomenon.to_s)
+    I18n.locale =  :it
+    assert_equal('pioggia intensa', phenomenon.to_s)
+  end
+
+  def test_weather_phenomenon_with_modifier_minus
+    phenomenon = Metar::WeatherPhenomenon.parse('-RA')
+    assert_equal('light', phenomenon.modifier)
+    assert_equal('light rain', phenomenon.to_s)
+    I18n.locale =  :it
+    assert_equal('pioggia leggera', phenomenon.to_s)
+  end
+
   # SkyCondition
-  def test_sky_condition
+  def test_sky_condition_nsc
+    sky_condition = Metar::SkyCondition.parse('NSC')
+    assert_nil(sky_condition.quantity)
+    assert_nil(sky_condition.height)
+    assert_equal('clear skies', sky_condition.to_s)
+    I18n.locale =  :it
+    assert_equal('cielo sereno', sky_condition.to_s)
+  end
+
+  def test_sky_condition_clr
+    sky_condition = Metar::SkyCondition.parse('CLR')
+    assert_equal('clear skies', sky_condition.to_s)
+    I18n.locale =  :it
+    assert_equal('cielo sereno', sky_condition.to_s)
+  end
+
+  def test_sky_condition_broken
     sky_condition = Metar::SkyCondition.parse('BKN016')
     assert_equal('broken', sky_condition.quantity)
     assert_equal(480, sky_condition.height.value)
+    assert_equal('broken cloud at 480m', sky_condition.to_s)
+    I18n.locale =  :it
+    assert_equal('nuvolosità parziale a 480m', sky_condition.to_s)
+  end
+
+  def test_sky_condition_few
+    sky_condition = Metar::SkyCondition.parse('FEW016')
+    assert_equal('few', sky_condition.quantity)
+    assert_equal(480, sky_condition.height.value)
+    assert_equal('few clouds at 480m', sky_condition.to_s)
+    I18n.locale =  :it
+    assert_equal('poche nuvole a 480m', sky_condition.to_s)
+  end
+
+  def test_sky_condition_ovc
+    sky_condition = Metar::SkyCondition.parse('OVC016')
+    assert_equal('overcast', sky_condition.quantity)
+    assert_equal(480, sky_condition.height.value)
+    assert_equal('overcast at 480m', sky_condition.to_s)
+    I18n.locale =  :it
+    assert_equal('chiuso a 480m', sky_condition.to_s)
+  end
+
+  def test_sky_condition_sct
+    sky_condition = Metar::SkyCondition.parse('SCT016')
+    assert_equal('scattered', sky_condition.quantity)
+    assert_equal(480, sky_condition.height.value)
+    assert_equal('scattered cloud at 480m', sky_condition.to_s)
+    I18n.locale =  :it
+    assert_equal('nuvole sparse a 480m', sky_condition.to_s)
+  end
+
+  def test_sky_condition_cloud_types_cb
+    sky_condition = Metar::SkyCondition.parse('SCT016CB')
+    assert_equal('scattered', sky_condition.quantity)
+    assert_equal('cumulonimbus', sky_condition.type)
+    assert_equal(480, sky_condition.height.value)
+    assert_equal('scattered cumulonimbus at 480m', sky_condition.to_s)
+    I18n.locale =  :it
+    assert_equal('cumulonembi sparsi a 480m', sky_condition.to_s)
+  end
+
+  def test_sky_condition_cloud_types_tcu
+    sky_condition = Metar::SkyCondition.parse('SCT016TCU')
+    assert_equal('scattered', sky_condition.quantity)
+    assert_equal('towering cumulus', sky_condition.type)
+    assert_equal(480, sky_condition.height.value)
+    assert_equal('scattered towering cumulus clouds at 480m', sky_condition.to_s)
+    I18n.locale =  :it
+    assert_equal('cumulonembi sparsi a 480m', sky_condition.to_s)
   end
 
   # VerticalVisibility
   def test_vertical_visibility
     vertical_visibility = Metar::VerticalVisibility.parse('VV001')
     assert_equal(30, vertical_visibility.value)
+    assert_equal('30m', vertical_visibility.to_s)
+  end
+
+  def test_vertical_visibility_unknown
+    vertical_visibility = Metar::VerticalVisibility.parse('///')
+    assert_nil(vertical_visibility.value)
+    assert_equal('unknown', vertical_visibility.to_s)
+    I18n.locale =  :it
+    assert_equal('sconosciuto', vertical_visibility.to_s)
   end
 
 end

data/test/unit/report_test.rb

@@ -20,9 +20,9 @@ class TestMetarReport < Test::Unit::TestCase
 
   def test_wind_knots
     report = setup_report('LIRQ', "2010/02/06 15:20\nLIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
-    assert_equal('10° 7 knots', report.wind)
+    assert_equal('10°, 7 knots', report.wind)
     I18n.locale = :it
-    assert_equal('10° 7 nodi', report.wind)
+    assert_equal('10°, 7 nodi', report.wind)
   end
 
   def test_variable_wind

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Joe Yates