metar-parser 1.2.1 → 1.3.0

data/lib/metar/data/visibility_remark.rb

@@ -0,0 +1,8 @@
+class Metar::Data::VisibilityRemark < Metar::Data::Visibility
+  def self.parse(raw)
+    metres, direction = raw.scan(/^(\d{4})([NESW]?)$/)[0]
+    distance = Metar::Data::Distance.new(metres)
+
+    new(raw, distance: distance, direction: direction, comparator: :more_than)
+  end
+end

data/lib/metar/data/weather_phenomenon.rb

@@ -0,0 +1,86 @@
+require "metar/i18n"
+
+class Metar::Data::WeatherPhenomenon < Metar::Data::Base
+  Modifiers = {
+    '+'   => 'heavy',
+    '-'   => 'light',
+    'VC'  => 'nearby',
+    '-VC' => 'nearby light',
+    '+VC' => 'nearby heavy',
+  }
+
+  Descriptors = {
+    'BC' => 'patches of',
+    'BL' => 'blowing',
+    'DR' => 'low drifting',
+    'FZ' => 'freezing',
+    'MI' => 'shallow',
+    'PR' => 'partial',
+    'SH' => 'shower of',
+    'TS' => 'thunderstorm and',
+  }
+
+  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',
+  }
+
+  # 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!(/([\+\-])/) { "\\#$1" }
+    rxp = Regexp.new("^(RE)?(#{modifiers})?(#{descriptors})?((?:#{phenomena}){1,2})$")
+    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_phrase = phenomena_codes.map { |c| Phenomena[c] }.join(' and ')
+
+    new(
+      raw,
+      phenomenon: phenomena_phrase,
+      modifier: Modifiers[modifier_code],
+      descriptor: Descriptors[descriptor_code]
+    )
+  end
+
+  attr_reader :phenomenon, :modifier, :descriptor, :recent
+
+  def initialize(raw, phenomenon:, modifier: nil, descriptor: nil, recent: false)
+    @raw = raw
+    @phenomenon, @modifier, @descriptor = phenomenon, modifier, descriptor
+    @recent = recent
+  end
+
+  def to_s
+    key = [modifier, descriptor, phenomenon].compact.join(' ')
+    I18n.t("metar.present_weather.%s" % key)
+  end
+end

data/lib/metar/data/wind.rb

@@ -0,0 +1,82 @@
+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(
+        raw,
+        direction: Metar::Data::Direction.new($1),
+        speed: Metar::Data::Speed.parse($2)
+      )
+    when raw =~ /^(\d{3})(\d{2})G(\d{2,3}(|MPS|KMH|KT))$/
+      return nil if $1.to_i > 360
+      new(
+        raw,
+        direction: Metar::Data::Direction.new($1),
+        speed: Metar::Data::Speed.parse($2 + $4),
+        gusts: Metar::Data::Speed.parse($3)
+      )
+    when raw =~ /^VRB(\d{2})G(\d{2,3})(|MPS|KMH|KT)$/
+      speed = $1 + $3
+      gusts = $2 + $3
+      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
+  end
+
+  attr_reader :direction, :speed, :gusts
+
+  def initialize(raw, direction:, speed:, gusts: nil)
+    @raw = raw
+    @direction, @speed, @gusts = direction, speed, gusts
+  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]
+        )
+      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 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