metar-parser 1.3.1 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2e0388461861adfdb50306cdb0b8044056ba41f
-  data.tar.gz: 160ed08277376b4f977b1fc67a0bd97d6969ac76
+  metadata.gz: 456cd34e625a1ba09f41ae95253611d7fcacdf20
+  data.tar.gz: 45063d94795f39b8bd092258e1ad72eeb207a3c3
 SHA512:
-  metadata.gz: df0e0d548d8365d4b637e6fc75287891f640f8df24534a4849fd4d7e805bd389460096eccfd5040a0cf16dc7df74b2936cd996b2ba41e7fd13fdbf3d73e00af7
-  data.tar.gz: aed5bba18e4875247db0f99762bf9babaf9ff3cc79ada5483ca4c601db6d15fb8360a2a43a5b7af99279ae914881b52a86559e9682a7d138dee282b8cd8cd77d
+  metadata.gz: 2a052fccc41b27c6cc87380892c2ac563aaa53b763669c3347d1fdf4daa9c4b3719937880ec5ee820e829cb138262c3a8aa1a37479e0b100159723fcee52c22e
+  data.tar.gz: 30afb02c2e7a5b8ecd30fa4e37b03300dffb3600f1224b4d50aa2d5f8f4c63c453ee2530342ca48bf2e04582b65692ab68819607caaeb2d6e2010bae86a6a00b

data/lib/metar/data/lightning.rb

@@ -17,25 +17,38 @@ class Metar::Data::Lightning < Metar::Data::Base
     end
 
     loop do
+      break if chunks[0].nil?
+
       if is_compass?(chunks[0])
         direction = chunks.shift
         raw += " " + direction
         directions << direction
-      elsif chunks[0] == 'ALQDS'
+        next
+      end
+
+      if chunks[0] == 'ALQDS'
         directions += ['N', 'E', 'S', 'W']
         raw += " " + chunks.shift
-      elsif chunks[0] =~ /^([NESW]{1,2})-([NESW]{1,2})$/
-        if is_compass?($1) and is_compass?($2)
-          directions += [$1, $2]
+        next
+      end
+
+      m = chunks[0].match(/^([NESW]{1,2})-([NESW]{1,2})$/)
+      if m
+        if is_compass?(m[1]) && is_compass?(m[1])
+          directions += [m[1], m[2]]
           raw += " " + chunks.shift
         else
           break
         end
-      elsif chunks[0] == 'AND'
+        next
+      end
+
+      if chunks[0] == 'AND'
         raw += " " + chunks.shift
-      else
-        break
+        next
       end
+
+      break
     end
 
     new(

data/lib/metar/data/pressure.rb

@@ -1,13 +1,20 @@
 class Metar::Data::Pressure < Metar::Data::Base
   def self.parse(raw)
-    case
-    when raw =~ /^Q(\d{4})$/
-      new(raw, pressure: M9t::Pressure.hectopascals($1.to_f))
-    when raw =~ /^A(\d{4})$/
-      new(raw, pressure: M9t::Pressure.inches_of_mercury($1.to_f / 100.0))
-    else
-      nil
+    return nil if raw.nil?
+
+    m1 = raw.match(/^Q(\d{4})$/)
+    if m1
+      pressure = M9t::Pressure.hectopascals(m1[1].to_f)
+      return new(raw, pressure: pressure)
+    end
+
+    m2 = raw.match(/^A(\d{4})$/)
+    if m2
+      pressure = M9t::Pressure.inches_of_mercury(m2[1].to_f / 100.0)
+      return new(raw, pressure: pressure)
     end
+
+    nil
   end
 
   attr_reader :pressure

data/lib/metar/data/remark.rb

@@ -23,46 +23,84 @@ class Metar::Data::Remark
   COLOR_CODE = ['RED', 'AMB', 'YLO', 'GRN', 'WHT', 'BLU']
 
   def self.parse(raw)
-    case raw
-    when /^([12])([01])(\d{3})$/
-      extreme = {'1' => :maximum, '2' => :minimum}[$1]
-      value   = sign($2) * tenths($3)
-      Metar::Data::TemperatureExtreme.new(raw, extreme, value)
-    when /^4([01])(\d{3})([01])(\d{3})$/
-      [
-        Metar::Data::TemperatureExtreme.new(raw, :maximum, sign($1) * tenths($2)),
-        Metar::Data::TemperatureExtreme.new(raw, :minimum, sign($3) * tenths($4)),
+    if !raw
+      return nil
+    end
+
+    m1 = raw.match(/^([12])([01])(\d{3})$/)
+    if m1
+      extreme = {'1' => :maximum, '2' => :minimum}[m1[1]]
+      value   = sign(m1[2]) * tenths(m1[3])
+      return Metar::Data::TemperatureExtreme.new(raw, extreme, value)
+    end
+
+    m2 = raw.match(/^4([01])(\d{3})([01])(\d{3})$/)
+    if m2
+      return [
+        Metar::Data::TemperatureExtreme.new(raw, :maximum, sign(m2[1]) * tenths(m2[2])),
+        Metar::Data::TemperatureExtreme.new(raw, :minimum, sign(m2[3]) * tenths(m2[4])),
       ]
-    when /^5([0-8])(\d{3})$/
-      character = PRESSURE_CHANGE_CHARACTER[$1.to_i]
-      Metar::Data::PressureTendency.new(raw, character, tenths($2))
-    when /^6(\d{4})$/
-      Metar::Data::Precipitation.new(raw, 3, Metar::Data::Distance.new(inches_to_meters($1))) # actually 3 or 6 depending on reporting time
-    when /^7(\d{4})$/
-      Metar::Data::Precipitation.new(raw, 24, Metar::Data::Distance.new(inches_to_meters($1)))
-    when /^A[0O]([12])$/
-      type = [:with_precipitation_discriminator, :without_precipitation_discriminator][$1.to_i - 1]
-      Metar::Data::AutomatedStationType.new(raw, type)
-    when /^P(\d{4})$/
-      Metar::Data::Precipitation.new(raw, 1, Metar::Data::Distance.new(inches_to_meters($1)))
-    when /^T([01])(\d{3})([01])(\d{3})$/
-      temperature = Metar::Data::Temperature.new(sign($1) * tenths($2))
-      dew_point   = Metar::Data::Temperature.new(sign($3) * tenths($4))
-      Metar::Data::HourlyTemperatureAndDewPoint.new(raw, temperature, dew_point)
-    when /^SLP(\d{3})$/
-      Metar::Data::SeaLevelPressure.new(raw, M9t::Pressure.hectopascals(tenths($1)))
-    when /^(#{INDICATOR_TYPE.keys.join('|')})NO$/
-      type = INDICATOR_TYPE[$1]
-      Metar::Data::SensorStatusIndicator.new(raw, :type, :not_available)
-    when /^(#{COLOR_CODE.join('|')})$/
-      Metar::Data::ColorCode.new(raw, $1)
-    when 'SKC'
-      Metar::Data::SkyCondition.new(raw)
-    when '$'
+    end
+
+    m3 = raw.match(/^5([0-8])(\d{3})$/)
+    if m3
+      character = PRESSURE_CHANGE_CHARACTER[m3[1].to_i]
+      return Metar::Data::PressureTendency.new(raw, character, tenths(m3[2]))
+    end
+
+    m4 = raw.match(/^6(\d{4})$/)
+    if m4
+      return Metar::Data::Precipitation.new(raw, 3, Metar::Data::Distance.new(inches_to_meters(m4[1]))) # actually 3 or 6 depending on reporting time
+    end
+
+    m5 = raw.match(/^7(\d{4})$/)
+    if m5
+      return Metar::Data::Precipitation.new(raw, 24, Metar::Data::Distance.new(inches_to_meters(m5[1])))
+    end
+
+    m6 = raw.match(/^A[0O]([12])$/)
+    if m6
+      type = [:with_precipitation_discriminator, :without_precipitation_discriminator][m6[1].to_i - 1]
+      return Metar::Data::AutomatedStationType.new(raw, type)
+    end
+
+    m7 = raw.match(/^P(\d{4})$/)
+    if m7
+      return Metar::Data::Precipitation.new(raw, 1, Metar::Data::Distance.new(inches_to_meters(m7[1])))
+    end
+
+    m8 = raw.match(/^T([01])(\d{3})([01])(\d{3})$/)
+    if m8
+      temperature = Metar::Data::Temperature.new(sign(m8[1]) * tenths(m8[2]))
+      dew_point   = Metar::Data::Temperature.new(sign(m8[3]) * tenths(m8[4]))
+      return Metar::Data::HourlyTemperatureAndDewPoint.new(raw, temperature, dew_point)
+    end
+
+    m9 = raw.match(/^SLP(\d{3})$/)
+    if m9
+      return Metar::Data::SeaLevelPressure.new(raw, M9t::Pressure.hectopascals(tenths(m9[1])))
+    end
+
+    m10 = raw.match(/^(#{INDICATOR_TYPE.keys.join('|')})NO$/)
+    if m10
+      type = INDICATOR_TYPE[m10[1]]
+      return Metar::Data::SensorStatusIndicator.new(raw, type, :not_available)
+    end
+
+    m11 = raw.match(/^(#{COLOR_CODE.join('|')})$/)
+    if m11
+      return Metar::Data::ColorCode.new(raw, m11[1])
+    end
+
+    if raw == 'SKC'
+      return Metar::Data::SkyCondition.new(raw)
+    end
+
+    if raw == '$'
       Metar::Data::MaintenanceNeeded.new(raw)
-    else
-      nil
     end
+
+    nil
   end
 
   def self.sign(digit)

data/lib/metar/data/runway_visible_range.rb

@@ -4,29 +4,34 @@ class Metar::Data::RunwayVisibleRange < Metar::Data::Base
   UNITS      = {'' => :meters, 'FT' => :feet}
 
   def self.parse(raw)
-    case
-    when raw =~ /^R(\d+[RLC]?)\/(P|M|)(\d{4})(FT|)\/?(N|U|D|)$/
-      designator = $1
-      comparator = COMPARATOR[$2]
-      count      = $3.to_f
-      units      = UNITS[$4]
-      tendency   = TENDENCY[$5]
+    return nil if raw.nil?
+
+    m1 = raw.match(/^R(\d+[RLC]?)\/(P|M|)(\d{4})(FT|)\/?(N|U|D|)$/)
+    if m1
+      designator = m1[1]
+      comparator = COMPARATOR[m1[2]]
+      count      = m1[3].to_f
+      units      = UNITS[m1[4]]
+      tendency   = TENDENCY[m1[5]]
       distance   = Metar::Data::Distance.send(units, count)
       visibility = Metar::Data::Visibility.new(
         nil, distance: distance, comparator: comparator
       )
-      new(
+      return new(
         raw,
         designator: designator, visibility1: visibility, tendency: tendency
       )
-    when raw =~ /^R(\d+[RLC]?)\/(P|M|)(\d{4})V(P|M|)(\d{4})(FT|)\/?(N|U|D)?$/
-      designator  = $1
-      comparator1 = COMPARATOR[$2]
-      count1      = $3.to_f
-      comparator2 = COMPARATOR[$4]
-      count2      = $5.to_f
-      units       = UNITS[$6]
-      tendency    = TENDENCY[$7]
+    end
+
+    m2 = raw.match(/^R(\d+[RLC]?)\/(P|M|)(\d{4})V(P|M|)(\d{4})(FT|)\/?(N|U|D)?$/)
+    if m2
+      designator  = m2[1]
+      comparator1 = COMPARATOR[m2[2]]
+      count1      = m2[3].to_f
+      comparator2 = COMPARATOR[m2[4]]
+      count2      = m2[5].to_f
+      units       = UNITS[m2[6]]
+      tendency    = TENDENCY[m2[7]]
       distance1   = Metar::Data::Distance.send(units, count1)
       distance2   = Metar::Data::Distance.send(units, count2)
       visibility1 = Metar::Data::Visibility.new(
@@ -35,15 +40,15 @@ class Metar::Data::RunwayVisibleRange < Metar::Data::Base
       visibility2 = Metar::Data::Visibility.new(
         nil, distance: distance2, comparator: comparator2
       )
-      new(
+      return new(
         raw,
         designator: designator,
         visibility1: visibility1, visibility2: visibility2,
         tendency: tendency, units: units
       )
-    else
-      nil
     end
+
+    nil
   end
 
   attr_reader :designator, :visibility1, :visibility2, :tendency

data/lib/metar/data/sky_condition.rb

@@ -14,25 +14,34 @@ class Metar::Data::SkyCondition < Metar::Data::Base
   ]
 
   def self.parse(raw)
-    case
-    when CLEAR_SKIES.include?(raw)
-      new(raw)
-    when raw =~ /^(BKN|FEW|OVC|SCT)(\d+|\/{3})(CB|TCU|\/{3}|)?$/
-      quantity = QUANTITY[$1]
+    if !raw
+      return nil
+    end
+
+    if CLEAR_SKIES.include?(raw)
+      return new(raw)
+    end
+
+    m1 = raw.match(/^(BKN|FEW|OVC|SCT)(\d+|\/{3})(CB|TCU|\/{3}|)?$/)
+    if m1
+      quantity = QUANTITY[m1[1]]
       height   =
-        if $2 == '///'
+        if m1[2] == '///'
           nil
         else
-          Metar::Data::Distance.new($2.to_i * 30.48)
+          Metar::Data::Distance.new(m1[2].to_i * 30.48)
         end
-      type = CONDITION[$3]
-      new(raw, quantity: quantity, height: height, type: type)
-    when raw =~ /^(CB|TCU)$/
-      type = CONDITION[$1]
-      new(raw, type: type)
-    else
-      nil
+      type = CONDITION[m1[3]]
+      return new(raw, quantity: quantity, height: height, type: type)
+    end
+
+    m2 = raw.match(/^(CB|TCU)$/)
+    if m2
+      type = CONDITION[m2[1]]
+      return new(raw, type: type)
     end
+
+    nil
   end
 
   attr_reader :quantity, :height, :type

data/lib/metar/data/speed.rb

@@ -11,12 +11,10 @@ class Metar::Data::Speed < M9t::Speed
   }
 
   def self.parse(raw)
-    case
-    when raw =~ /^(\d+)(|KT|MPS|KMH)$/
-      # Call the appropriate factory method for the supplied units
-      send(METAR_UNITS[$2], $1.to_i)
-    else
-      nil
-    end
+    return nil if raw.nil?
+    m = raw.match(/^(\d+)(|KT|MPS|KMH)$/)
+    return nil if m.nil?
+    # Call the appropriate factory method for the supplied units
+    return send(METAR_UNITS[m[2]], m[1].to_i)
   end
 end

data/lib/metar/data/temperature.rb

@@ -4,14 +4,12 @@ require "m9t"
 # Adds a parse method to the M9t base class
 class Metar::Data::Temperature < M9t::Temperature
   def self.parse(raw)
-    if raw =~ /^(M?)(\d+)$/
-      sign = $1
-      value = $2.to_i
-      value *= -1 if sign == 'M'
-      new(value)
-    else
-      nil
-    end
+    m = raw.match(/^(M?)(\d+)$/)
+    return nil if !m
+    sign = m[1]
+    value = m[2].to_i
+    value *= -1 if sign == 'M'
+    new(value)
   end
 
   def to_s(options = {})

data/lib/metar/data/temperature_and_dew_point.rb

@@ -1,10 +1,13 @@
 class Metar::Data::TemperatureAndDewPoint < Metar::Data::Base
   def self.parse(raw)
-    if raw =~ /^(M?\d+|XX|\/\/)\/(M?\d+|XX|\/\/)?$/
-      temperature = Metar::Data::Temperature.parse($1)
-      dew_point = Metar::Data::Temperature.parse($2)
-      new(raw, temperature: temperature, dew_point: dew_point)
-    end
+    return nil if !raw
+
+    m = raw.match(/^(M?\d+|XX|\/\/)\/(M?\d+|XX|\/\/)?$/)
+    return nil if !m
+
+    temperature = Metar::Data::Temperature.parse(m[1])
+    dew_point = Metar::Data::Temperature.parse(m[2])
+    new(raw, temperature: temperature, dew_point: dew_point)
   end
 
   attr_reader :temperature

data/lib/metar/data/time.rb

@@ -10,18 +10,17 @@ class Metar::Data::Time < Metar::Data::Base
         /^(\d{1,2})(\d{2})(\d{2})Z$/
       end
 
-    if raw =~ date_matcher
-      day, hour, minute = $1.to_i, $2.to_i, $3.to_i
+    m1 = raw.match(date_matcher)
+    if m1
+      day, hour, minute = m1[1].to_i, m1[2].to_i, m1[3].to_i
     else
       return nil if strict
 
-      if raw =~ /^(\d{1,2})(\d{2})Z$/
-        # The day is missing, use today's date
-        day           = Time.now.day
-        hour, minute = $1.to_i, $2.to_i
-      else
-        return nil
-      end
+      m2 = raw.match(/^(\d{1,2})(\d{2})Z$/)
+      return nil if !m2
+      # The day is missing, use today's date
+      day           = Time.now.day
+      hour, minute = m2[1].to_i, m2[2].to_i
     end
 
     new(

data/lib/metar/data/variable_wind.rb

@@ -1,14 +1,15 @@
 class Metar::Data::VariableWind < Metar::Data::Base
   def self.parse(raw)
-    if raw =~ /^(\d+)V(\d+)$/
-      new(
-        raw,
-        direction1: Metar::Data::Direction.new($1),
-        direction2: Metar::Data::Direction.new($2)
-      )
-    else
-      nil
-    end
+    return nil if raw.nil?
+
+    m = raw.match(/^(\d+)V(\d+)$/)
+    return nil if m.nil?
+
+    return new(
+      raw,
+      direction1: Metar::Data::Direction.new(m[1]),
+      direction2: Metar::Data::Direction.new(m[2])
+    )
   end
 
   attr_reader :direction1

data/lib/metar/data/vertical_visibility.rb

@@ -3,14 +3,19 @@ require "m9t"
 
 class Metar::Data::VerticalVisibility < Metar::Data::Base
   def self.parse(raw)
-    case
-    when raw =~ /^VV(\d{3})$/
-      new(raw, distance: Metar::Data::Distance.new($1.to_f * 30.48))
-    when raw == '///'
-      new(raw, distance: Metar::Data::Distance.new)
-    else
-      nil
+    if !raw
+      return nil
     end
+    m1 = raw.match(/^VV(\d{3})$/)
+    if m1
+      return new(raw, distance: Metar::Data::Distance.new(m1[1].to_f * 30.48))
+    end
+
+    if raw == '///'
+      return new(raw, distance: Metar::Data::Distance.new)
+    end
+
+    nil
   end
 
   attr_reader :distance

data/lib/metar/data/visibility.rb

@@ -1,36 +1,59 @@
 class Metar::Data::Visibility < Metar::Data::Base
   def self.parse(raw)
-    case
-    when raw == '9999'
-      new(raw, distance: Metar::Data::Distance.new(10000), comparator: :more_than)
-    when raw =~ /(\d{4})NDV/ # WMO
-      new(raw, distance: Metar::Data::Distance.new($1.to_f)) # Assuming meters
-    when (raw =~ /^((1|2)\s|)([1357])\/([248]|16)SM$/) # US
-      miles          = $1.to_f + $3.to_f / $4.to_f
+    if !raw
+      return nil
+    end
+
+    if raw == '9999'
+      return new(raw, distance: Metar::Data::Distance.new(10000), comparator: :more_than)
+    end
+
+    m1 = raw.match(/(\d{4})NDV/) # WMO
+    if m1
+      return new(raw, distance: Metar::Data::Distance.new(m1[1].to_f)) # Assuming meters
+    end
+
+    m2 = raw.match(/^((1|2)\s|)([1357])\/([248]|16)SM$/) # US
+    if m2
+      miles          = m2[1].to_f + m2[3].to_f / m2[4].to_f
       distance       = Metar::Data::Distance.miles(miles)
       distance.units = :miles
-        new(raw, distance: distance)
-    when raw =~ /^(\d+)SM$/ # US
-      distance       = Metar::Data::Distance.miles($1.to_f)
+      return new(raw, distance: distance)
+    end
+
+    m3 = raw.match(/^(\d+)SM$/) # US
+    if m3
+      distance       = Metar::Data::Distance.miles(m3[1].to_f)
       distance.units = :miles
-        new(raw, distance: distance)
-    when raw == 'M1/4SM' # US
+      return new(raw, distance: distance)
+    end
+
+    if raw == 'M1/4SM' # US
       distance       = Metar::Data::Distance.miles(0.25)
       distance.units = :miles
-        new(raw, distance: distance, comparator: :less_than)
-    when raw =~ /^(\d+)KM$/
-      new(raw, distance: Metar::Data::Distance.kilometers($1))
-    when raw =~ /^(\d+)$/ # We assume meters
-      new(raw, distance: Metar::Data::Distance.new($1))
-    when raw =~ /^(\d+)(N|NE|E|SE|S|SW|W|NW)$/
-      new(
+      return new(raw, distance: distance, comparator: :less_than)
+    end
+
+    m4 = raw.match(/^(\d+)KM$/)
+    if m4
+      return new(raw, distance: Metar::Data::Distance.kilometers(m4[1]))
+    end
+
+    m5 = raw.match(/^(\d+)$/) # We assume meters
+    if m5
+      return new(raw, distance: Metar::Data::Distance.new(m5[1]))
+    end
+
+    m6 = raw.match(/^(\d+)(N|NE|E|SE|S|SW|W|NW)$/)
+    if m6
+      return new(
         raw,
-        distance: Metar::Data::Distance.meters($1),
-        direction: M9t::Direction.compass($2)
+        distance: Metar::Data::Distance.meters(m6[1]),
+        direction: M9t::Direction.compass(m6[2])
       )
-    else
-      nil
     end
+
+    nil
   end
 
   attr_reader :distance, :direction, :comparator

data/lib/metar/data/weather_phenomenon.rb

@@ -52,7 +52,7 @@ class Metar::Data::WeatherPhenomenon < Metar::Data::Base
     phenomena   = Phenomena.keys.join('|')
     descriptors = Descriptors.keys.join('|')
     modifiers   = Modifiers.keys.join('|')
-    modifiers.gsub!(/([\+\-])/) { "\\#$1" }
+    modifiers.gsub!(/([\+\-])/) { |m| "\\#{m}" }
     rxp = Regexp.new("^(RE)?(#{modifiers})?(#{descriptors})?((?:#{phenomena}){1,2})$")
     m   = rxp.match(raw)
     return nil if m.nil?

data/lib/metar/data/wind.rb

@@ -1,39 +1,58 @@
 class Metar::Data::Wind < Metar::Data::Base
   def self.parse(raw)
-    case
-    when raw =~ /^(\d{3})(\d{2}(|MPS|KMH|KT))$/
-      return nil if $1.to_i > 360
-      new(
+    return nil if raw.nil?
+
+    m1 = raw.match(/^(\d{3})(\d{2}(|MPS|KMH|KT))$/)
+    if m1
+      return nil if m1[1].to_i > 360
+      return new(
         raw,
-        direction: Metar::Data::Direction.new($1),
-        speed: Metar::Data::Speed.parse($2)
+        direction: Metar::Data::Direction.new(m1[1]),
+        speed: Metar::Data::Speed.parse(m1[2])
       )
-    when raw =~ /^(\d{3})(\d{2})G(\d{2,3}(|MPS|KMH|KT))$/
-      return nil if $1.to_i > 360
-      new(
+    end
+
+    m2 = raw.match(/^(\d{3})(\d{2})G(\d{2,3}(|MPS|KMH|KT))$/)
+    if m2
+      return nil if m2[1].to_i > 360
+      return new(
         raw,
-        direction: Metar::Data::Direction.new($1),
-        speed: Metar::Data::Speed.parse($2 + $4),
-        gusts: Metar::Data::Speed.parse($3)
+        direction: Metar::Data::Direction.new(m2[1]),
+        speed: Metar::Data::Speed.parse(m2[2] + m2[4]),
+        gusts: Metar::Data::Speed.parse(m2[3])
       )
-    when raw =~ /^VRB(\d{2})G(\d{2,3})(|MPS|KMH|KT)$/
-      speed = $1 + $3
-      gusts = $2 + $3
-      new(
+    end
+
+    m3 = raw.match(/^VRB(\d{2})G(\d{2,3})(|MPS|KMH|KT)$/)
+    if m3
+      speed = m3[1] + m3[3]
+      gusts = m3[2] + m3[3]
+      return new(
         raw,
         direction: :variable_direction,
         speed: Metar::Data::Speed.parse(speed),
         gusts: Metar::Data::Speed.parse(gusts)
       )
-    when raw =~ /^VRB(\d{2}(|MPS|KMH|KT))$/
-      new(raw, direction: :variable_direction, speed: Metar::Data::Speed.parse($1))
-    when raw =~ /^\/{3}(\d{2}(|MPS|KMH|KT))$/
-      new(raw, direction: :unknown_direction, speed: Metar::Data::Speed.parse($1))
-    when raw =~ %r(^/////(|MPS|KMH|KT)$)
-      new(raw, direction: :unknown_direction, speed: :unknown_speed)
-    else
-      nil
     end
+
+    m4 = raw.match(/^VRB(\d{2}(|MPS|KMH|KT))$/)
+    if m4
+      speed = Metar::Data::Speed.parse(m4[1])
+      return new(raw, direction: :variable_direction, speed: speed)
+    end
+
+    m5 = raw.match(/^\/{3}(\d{2}(|MPS|KMH|KT))$/)
+    if m5
+      speed = Metar::Data::Speed.parse(m5[1])
+      return new(raw, direction: :unknown_direction, speed: speed)
+    end
+
+    m6 = raw.match(%r(^/////(|MPS|KMH|KT)$))
+    if m6
+      return new(raw, direction: :unknown_direction, speed: :unknown_speed)
+    end
+
+    nil
   end
 
   attr_reader :direction, :speed, :gusts

data/lib/metar/station.rb

@@ -7,7 +7,7 @@ require 'set'
 
 module Metar
   class Station
-    NOAA_STATION_LIST_URL = 'http://weather.noaa.gov/data/nsd_cccc.txt'
+    NOAA_STATION_LIST_URL = 'http://tgftp.nws.noaa.gov/data/nsd_cccc.txt'
 
     class << self
       @nsd_cccc = nil # Contains the text of the station list
@@ -38,13 +38,15 @@ module Metar
       end
 
       def to_longitude(s)
-        s =~ /^(\d+)-(\d+)([EW])/ or return nil
-        ($3 == 'E' ? 1.0 : -1.0) * ($1.to_f + $2.to_f / 60.0)
+        m = s.match(/^(\d+)-(\d+)([EW])/)
+        return nil if !m
+        (m[3] == 'E' ? 1.0 : -1.0) * (m[1].to_f + m[2].to_f / 60.0)
       end
 
       def to_latitude(s)
-        s =~ /^(\d+)-(\d+)([SN])/ or return nil
-        ($3 == 'N' ? 1.0 : -1.0) * ($1.to_f + $2.to_f / 60.0)
+        m = s.match(/^(\d+)-(\d+)([SN])/)
+        return nil if !m
+        (m[3] == 'E' ? 1.0 : -1.0) * (m[1].to_f + m[2].to_f / 60.0)
       end
     end
 

data/lib/metar/version.rb

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

data/spec/parser_spec.rb

@@ -457,7 +457,6 @@ describe Metar::Parser do
         sky_conditions
       ).each do |attr|
         specify "#{attr} is not set" do
-          puts "attr: #{attr}"
           expect(result).to_not include(attr)
         end
       end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: metar-parser
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.2
 platform: ruby
 authors:
 - Joe Yates
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-16 00:00:00.000000000 Z
+date: 2017-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -237,7 +237,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: nowarning
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: A Ruby gem for worldwide weather reports