metar-parser 1.4.2 → 1.6.0

data/lib/metar/data/weather_phenomenon.rb

@@ -1,86 +1,104 @@
+# frozen_string_literal: true
+
 require "metar/i18n"
 
-class Metar::Data::WeatherPhenomenon < Metar::Data::Base
-  Modifiers = {
-    '+'   => 'heavy',
-    '-'   => 'light',
-    'VC'  => 'nearby',
-    '-VC' => 'nearby light',
-    '+VC' => 'nearby heavy',
-  }
+module Metar
+  module Data
+    class WeatherPhenomenon < Metar::Data::Base
+      MODIFIERS = {
+        '+' => 'heavy',
+        '-' => 'light',
+        'VC' => 'nearby',
+        '-VC' => 'nearby light',
+        '+VC' => 'nearby heavy'
+      }.freeze
 
-  Descriptors = {
-    'BC' => 'patches of',
-    'BL' => 'blowing',
-    'DR' => 'low drifting',
-    'FZ' => 'freezing',
-    'MI' => 'shallow',
-    'PR' => 'partial',
-    'SH' => 'shower of',
-    'TS' => 'thunderstorm and',
-  }
+      DESCRIPTORS = {
+        'BC' => 'patches of',
+        'BL' => 'blowing',
+        'DR' => 'low drifting',
+        'FZ' => 'freezing',
+        'MI' => 'shallow',
+        'PR' => 'partial',
+        'SH' => 'shower of',
+        'TS' => 'thunderstorm and'
+      }.freeze
 
-  Phenomena = {
-    'BR'   => 'mist',
-    'DU'   => 'dust',
-    'DZ'   => 'drizzle',
-    'FG'   => 'fog',
-    'FU'   => 'smoke',
-    'GR'   => 'hail',
-    'GS'   => 'small hail',
-    'HZ'   => 'haze',
-    'IC'   => 'ice crystals',
-    'PL'   => 'ice pellets',
-    'PO'   => 'dust whirls',
-    'PY'   => 'spray', # US only
-    'RA'   => 'rain',
-    'SA'   => 'sand',
-    'SH'   => 'shower',
-    'SN'   => 'snow',
-    'SG'   => 'snow grains',
-    'SQ'   => 'squall',
-    'UP'   => 'unknown phenomenon', # => AUTO
-    'VA'   => 'volcanic ash',
-    'FC'   => 'funnel cloud',
-    'SS'   => 'sand storm',
-    'DS'   => 'dust storm',
-    'TS'   => 'thunderstorm',
-  }
+      PHENOMENA = {
+        'BR' => 'mist',
+        'DU' => 'dust',
+        'DZ' => 'drizzle',
+        'FG' => 'fog',
+        'FU' => 'smoke',
+        'GR' => 'hail',
+        'GS' => 'small hail',
+        'HZ' => 'haze',
+        'IC' => 'ice crystals',
+        'PL' => 'ice pellets',
+        'PO' => 'dust whirls',
+        'PY' => 'spray', # US only
+        'RA' => 'rain',
+        'SA' => 'sand',
+        'SH' => 'shower',
+        'SN' => 'snow',
+        'SG' => 'snow grains',
+        'SQ' => 'squall',
+        'UP' => 'unknown phenomenon', # => AUTO
+        'VA' => 'volcanic ash',
+        'FC' => 'funnel cloud',
+        'SS' => 'sand storm',
+        'DS' => 'dust storm',
+        'TS' => 'thunderstorm'
+      }.freeze
 
-  # Accepts all standard (and some non-standard) present weather codes
-  def self.parse(raw)
-    phenomena   = Phenomena.keys.join('|')
-    descriptors = Descriptors.keys.join('|')
-    modifiers   = Modifiers.keys.join('|')
-    modifiers.gsub!(/([\+\-])/) { |m| "\\#{m}" }
-    rxp = Regexp.new("^(RE)?(#{modifiers})?(#{descriptors})?((?:#{phenomena}){1,2})$")
-    m   = rxp.match(raw)
-    return nil if m.nil?
+      # Accepts all standard (and some non-standard) present weather codes
+      def self.parse(raw)
+        modifiers = MODIFIERS.keys.join('|')
+        modifiers.gsub!(/([\+\-])/) { |m| "\\#{m}" }
 
-    recent           = m[1] == "RE"
-    modifier_code    = m[2]
-    descriptor_code  = m[3]
-    phenomena_codes  = m[4].scan(/../)
-    phenomena_phrase = phenomena_codes.map { |c| Phenomena[c] }.join(' and ')
+        descriptors = DESCRIPTORS.keys.join('|')
 
-    new(
-      raw,
-      phenomenon: phenomena_phrase,
-      modifier: Modifiers[modifier_code],
-      descriptor: Descriptors[descriptor_code]
-    )
-  end
+        phenomena = PHENOMENA.keys.join('|')
 
-  attr_reader :phenomenon, :modifier, :descriptor, :recent
+        rxp = Regexp.new(
+          "^(RE)?(#{modifiers})?(#{descriptors})?((?:#{phenomena}){1,2})$"
+        )
 
-  def initialize(raw, phenomenon:, modifier: nil, descriptor: nil, recent: false)
-    @raw = raw
-    @phenomenon, @modifier, @descriptor = phenomenon, modifier, descriptor
-    @recent = recent
-  end
+        m = rxp.match(raw)
+        return nil if m.nil?
+
+        recent = m[1] == "RE"
+        modifier_code = m[2]
+        descriptor_code = m[3]
+        phenomena_codes = m[4].scan(/../)
+        phenomena = phenomena_codes.map { |c| PHENOMENA[c] }
+        phenomena_phrase = phenomena.join(' and ')
+
+        new(
+          raw,
+          phenomenon: phenomena_phrase,
+          modifier: MODIFIERS[modifier_code],
+          descriptor: DESCRIPTORS[descriptor_code],
+          recent: recent
+        )
+      end
+
+      attr_reader :phenomenon, :modifier, :descriptor, :recent
+
+      def initialize(
+        raw, phenomenon:, modifier: nil, descriptor: nil, recent: false
+      )
+        @raw = raw
+        @phenomenon = phenomenon
+        @modifier = modifier
+        @descriptor = descriptor
+        @recent = recent
+      end
 
-  def to_s
-    key = [modifier, descriptor, phenomenon].compact.join(' ')
-    I18n.t("metar.present_weather.%s" % key)
+      def to_s
+        key = [modifier, descriptor, phenomenon].compact.join(' ')
+        I18n.t("metar.present_weather.#{key}")
+      end
+    end
   end
 end

data/lib/metar/data/wind.rb

@@ -1,101 +1,120 @@
-class Metar::Data::Wind < Metar::Data::Base
-  def self.parse(raw)
-    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(m1[1]),
-        speed: Metar::Data::Speed.parse(m1[2])
-      )
-    end
+# frozen_string_literal: true
 
-    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(m2[1]),
-        speed: Metar::Data::Speed.parse(m2[2] + m2[4]),
-        gusts: Metar::Data::Speed.parse(m2[3])
-      )
-    end
+module Metar
+  module Data
+    class Wind < Metar::Data::Base
+      def self.parse(raw, strict: false)
+        return nil if raw.nil?
 
-    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)
-      )
-    end
+        plain_match =
+          if strict
+            /^(\d{3})(\d{2}(|MPS|KMH|KT))$/
+          else
+            /^(\d{3})(\d{2,3}(|MPS|KMH|KT))$/
+          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
+        m1 = raw.match(plain_match)
+        if m1
+          return nil if m1[1].to_i > 360
 
-    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
+          return new(
+            raw,
+            direction: Metar::Data::Direction.new(m1[1]),
+            speed: Metar::Data::Speed.parse(m1[2])
+          )
+        end
 
-    m6 = raw.match(%r(^/////(|MPS|KMH|KT)$))
-    if m6
-      return new(raw, direction: :unknown_direction, speed: :unknown_speed)
-    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
 
-    nil
-  end
+          return new(
+            raw,
+            direction: Metar::Data::Direction.new(m2[1]),
+            speed: Metar::Data::Speed.parse(m2[2] + m2[4]),
+            gusts: Metar::Data::Speed.parse(m2[3])
+          )
+        end
 
-  attr_reader :direction, :speed, :gusts
+        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)
+          )
+        end
 
-  def initialize(raw, direction:, speed:, gusts: nil)
-    @raw = raw
-    @direction, @speed, @gusts = direction, speed, gusts
-  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
 
-  def to_s(options = {})
-    options = {
-      direction_units: :compass,
-      speed_units:     :kilometers_per_hour,
-    }.merge(options)
-    speed =
-      case @speed
-      when :unknown_speed
-           I18n.t('metar.wind.unknown_speed')
-      else
-        @speed.to_s(
-          abbreviated: true,
-          precision:   0,
-          units:       options[:speed_units]
-        )
+        m5 = raw.match(%r{^/{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
+
+      def initialize(raw, direction:, speed:, gusts: nil)
+        @raw = raw
+        @direction = direction
+        @speed = speed
+        @gusts = gusts
       end
-    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(units: options[:direction_units])
+
+      def to_s(options = {})
+        options = {
+          direction_units: :compass,
+          speed_units: :kilometers_per_hour
+        }.merge(options)
+        speed =
+          case @speed
+          when :unknown_speed
+            I18n.t('metar.wind.unknown_speed')
+          else
+            @speed.to_s(
+              abbreviated: true,
+              precision: 0,
+              units: options[:speed_units]
+            )
+          end
+        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(units: options[:direction_units])
+          end
+        s = "#{speed} #{direction}"
+
+        if !@gusts.nil?
+          g = @gusts.to_s(
+            abbreviated: true,
+            precision: 0,
+            units: options[:speed_units]
+          )
+          s += " #{I18n.t('metar.wind.gusts')} #{g}"
+        end
+
+        s
       end
-    s = "#{speed} #{direction}"
-    if not @gusts.nil?
-      g = @gusts.to_s(
-        abbreviated: true,
-        precision:   0,
-        units:       options[:speed_units]
-      )
-      s += " #{I18n.t('metar.wind.gusts')} #{g}"
     end
-    s
   end
 end

data/lib/metar/data.rb

@@ -1,25 +1,27 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-module Metar::Data
-  autoload :Base, "metar/data/base"
-  autoload :DensityAltitude, "metar/data/density_altitude"
-  autoload :Direction, "metar/data/direction"
-  autoload :Distance, "metar/data/distance"
-  autoload :Lightning, "metar/data/lightning"
-  autoload :Observer, "metar/data/observer"
-  autoload :Pressure, "metar/data/pressure"
-  autoload :Remark, "metar/data/remark"
-  autoload :RunwayVisibleRange, "metar/data/runway_visible_range"
-  autoload :SkyCondition, "metar/data/sky_condition"
-  autoload :Speed, "metar/data/speed"
-  autoload :StationCode, "metar/data/station_code"
-  autoload :Temperature, "metar/data/temperature"
-  autoload :TemperatureAndDewPoint, "metar/data/temperature_and_dew_point"
-  autoload :Time, "metar/data/time"
-  autoload :VariableWind, "metar/data/variable_wind"
-  autoload :VerticalVisibility, "metar/data/vertical_visibility"
-  autoload :Visibility, "metar/data/visibility"
-  autoload :VisibilityRemark, "metar/data/visibility_remark"
-  autoload :WeatherPhenomenon, "metar/data/weather_phenomenon"
-  autoload :Wind, "metar/data/wind"
+module Metar
+  module Data
+    autoload :Base, "metar/data/base"
+    autoload :DensityAltitude, "metar/data/density_altitude"
+    autoload :Direction, "metar/data/direction"
+    autoload :Distance, "metar/data/distance"
+    autoload :Lightning, "metar/data/lightning"
+    autoload :Observer, "metar/data/observer"
+    autoload :Pressure, "metar/data/pressure"
+    autoload :Remark, "metar/data/remark"
+    autoload :RunwayVisibleRange, "metar/data/runway_visible_range"
+    autoload :SkyCondition, "metar/data/sky_condition"
+    autoload :Speed, "metar/data/speed"
+    autoload :StationCode, "metar/data/station_code"
+    autoload :Temperature, "metar/data/temperature"
+    autoload :TemperatureAndDewPoint, "metar/data/temperature_and_dew_point"
+    autoload :Time, "metar/data/time"
+    autoload :VariableWind, "metar/data/variable_wind"
+    autoload :VerticalVisibility, "metar/data/vertical_visibility"
+    autoload :Visibility, "metar/data/visibility"
+    autoload :VisibilityRemark, "metar/data/visibility_remark"
+    autoload :WeatherPhenomenon, "metar/data/weather_phenomenon"
+    autoload :Wind, "metar/data/wind"
+  end
 end

data/lib/metar/i18n.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "i18n"
 
-locales_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "locales"))
+locales_path = File.expand_path(
+  File.join(File.dirname(__FILE__), "..", "..", "locales")
+)
 I18n.load_path += Dir.glob("#{locales_path}/*.yml")
 I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-