metar-parser 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b47782dda9aa78314cf6244e1d395acff88cd025
-  data.tar.gz: 097ed5364bdf7ded700dd77b5722a863655ae2b9
+  metadata.gz: ae0329de719ceb6a7302bf28a0b2eb60224b6220
+  data.tar.gz: 2f480c17d9cd2f3df30ee882ebbf45605bdae90d
 SHA512:
-  metadata.gz: ebf5217c8b8edbe61045f48f7293ed479864208021c16792b0d436292ac4513c74688fa0d09e05a23140cafb3b0dc93b97a6165b661b4e5f5d77e6ab42b4e4f5
-  data.tar.gz: 84a588b82027c09eab3856a0dacafad06b2638a8ab34e1f75c5047f81af5018b7964e6a0319d8849a9918322060ea71bb4058f7affe7fb1f81d7892ce5ec016b
+  metadata.gz: a1c5d02054171c2b5d1a70d01caf6be3a2af8fa574e7a1b93595e0e5ce9e2b079bcab873bf2b2a82b9331c2dea2b7df01d493fe40f234d198c0f1c6b71712c32
+  data.tar.gz: ae061b3580ad88b8463af928ae8537bc58a99ae95c3553a9eb68a89320f4fa5712de1e6a84bfefe5cc0bdb7e877fbf7e619c59844e83a72a8e0f7d618ae244ee

data/lib/metar/data/base.rb

@@ -0,0 +1,15 @@
+class Metar::Data::Base
+  def self.parse(raw)
+    new(raw)
+  end
+
+  attr_reader :raw
+
+  def initialize(raw)
+    @raw = raw
+  end
+
+  def value
+    raw
+  end
+end

data/lib/metar/data/density_altitude.rb

@@ -0,0 +1,15 @@
+class Metar::Data::DensityAltitude < Metar::Data::Base
+  def self.parse(raw)
+    feet = raw[/^(\d+)(FT)/, 1]
+    height = Metar::Data::Distance.feet(feet)
+
+    new(raw, height: height)
+  end
+
+  attr_accessor :height
+
+  def initialize(raw, height:)
+    @raw = raw
+    @height = height
+  end
+end

data/lib/metar/data/direction.rb

@@ -0,0 +1,9 @@
+require "i18n"
+require "m9t"
+
+class Metar::Data::Direction < M9t::Direction
+  def initialize(direction)
+    direction = M9t::Direction::normalize(direction.to_f)
+    super(direction)
+  end
+end

data/lib/metar/data/distance.rb

@@ -0,0 +1,27 @@
+require "i18n"
+require "m9t"
+
+class Metar::Data::Distance < M9t::Distance
+  attr_accessor :units
+
+  # nil is taken to mean 'data unavailable'
+  def initialize(meters = nil)
+    @units = :meters
+    if meters
+      super
+    else
+      @value = nil
+    end
+  end
+
+  # Handles nil case differently to M9t::Distance
+  def to_s(options = {})
+    options = {
+      units:       units,
+      precision:   0,
+      abbreviated: true,
+    }.merge(options)
+    return I18n.t("metar.distance.unknown") if @value.nil?
+    super(options)
+  end
+end

data/lib/metar/data/lightning.rb

@@ -0,0 +1,61 @@
+class Metar::Data::Lightning < Metar::Data::Base
+  TYPE = {'' => :default}
+
+  def self.parse_chunks(chunks)
+    raw = chunks.shift
+    m = raw.match(/^LTG(|CG|IC|CC|CA)$/)
+    raise 'first chunk is not lightning' if m.nil?
+    type = TYPE[m[1]]
+
+    frequency = nil
+    distance = nil
+    directions = []
+
+    if chunks[0] == 'DSNT'
+      distance = Metar::Data::Distance.miles(10) # Should be >10SM, not 10SM
+      raw += " " + chunks.shift
+    end
+
+    loop do
+      if is_compass?(chunks[0])
+        direction = chunks.shift
+        raw += " " + direction
+        directions << direction
+      elsif 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]
+          raw += " " + chunks.shift
+        else
+          break
+        end
+      elsif chunks[0] == 'AND'
+        raw += " " + chunks.shift
+      else
+        break
+      end
+    end
+
+    new(
+      raw,
+      frequency: frequency, type: type,
+      distance: distance, directions: directions
+    )
+  end
+
+  def self.is_compass?(s)
+    s =~ /^([NESW]|NE|SE|SW|NW)$/
+  end
+
+  attr_accessor :frequency
+  attr_accessor :type
+  attr_accessor :distance
+  attr_accessor :directions
+
+  def initialize(raw, frequency:, type:, distance:, directions:)
+    @raw = raw
+    @frequency, @type, @distance, @directions = frequency, type, distance, directions
+  end
+end

data/lib/metar/data/observer.rb

@@ -0,0 +1,24 @@
+class Metar::Data::Observer < Metar::Data::Base
+  def self.parse(raw)
+    case
+    when raw == 'AUTO' # WMO 15.4
+      new(raw, value: :auto)
+    when raw == 'COR'  # WMO specified code word for correction
+      new(raw, value: :corrected)
+    when raw =~ /CC[A-Z]/  # Canadian correction
+      # Canada uses CCA for first correction, CCB for second, etc...
+      new(raw, value: :corrected)
+    when raw == 'RTD'   #  Delayed observation, no comments on observer
+      new(raw, value: :rtd)
+    else
+      new(nil, value: :real)
+    end
+  end
+
+  attr_reader :value
+
+  def initialize(raw, value:)
+    @raw = raw
+    @value = value
+  end
+end

data/lib/metar/data/pressure.rb

@@ -0,0 +1,23 @@
+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
+    end
+  end
+
+  attr_reader :pressure
+
+  def initialize(raw, pressure:)
+    @raw = raw
+    @pressure = pressure
+  end
+
+  def value
+    pressure.value
+  end
+end

data/lib/metar/data/remark.rb

@@ -0,0 +1,98 @@
+require "i18n"
+require "m9t"
+
+class Metar::Data::Remark
+  PRESSURE_CHANGE_CHARACTER = [
+    :increasing_then_decreasing, # 0
+    :increasing_then_steady,     # 1
+    :increasing,                 # 2
+    :decreasing_or_steady_then_increasing, # 3
+    :steady,                     # 4
+    :decreasing_then_increasing, # 5
+    :decreasing_then_steady,     # 6
+    :decreasing,                 # 7
+    :steady_then_decreasing,     # 8
+  ]
+
+  INDICATOR_TYPE = {
+    'TS'  => :thunderstorm_information,
+    'PWI' => :precipitation_identifier,
+    'P'   => :precipitation_amount,
+  }
+
+  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)),
+      ]
+    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 '$'
+      Metar::Data::MaintenanceNeeded.new(raw)
+    else
+      nil
+    end
+  end
+
+  def self.sign(digit)
+    case digit
+    when '0'
+      1.0
+    when '1'
+      -1.0
+    else
+      raise "Unexpected sign: #{digit}"
+    end
+  end
+
+  def self.tenths(digits)
+    digits.to_f / 10.0
+  end
+
+  def self.inches_to_meters(digits)
+    digits.to_f * 0.000254
+  end
+end
+
+module Metar::Data
+  TemperatureExtreme = Struct.new(:raw, :extreme, :value)
+  PressureTendency = Struct.new(:raw, :character, :value)
+  Precipitation = Struct.new(:raw, :period, :amount)
+  AutomatedStationType = Struct.new(:raw, :type)
+  HourlyTemperatureAndDewPoint = Struct.new(:raw, :temperature, :dew_point)
+  SeaLevelPressure = Struct.new(:raw, :pressure)
+  SensorStatusIndicator = Struct.new(:raw, :type, :state)
+  ColorCode = Struct.new(:raw, :code)
+  MaintenanceNeeded = Struct.new(:raw)
+end

data/lib/metar/data/runway_visible_range.rb

@@ -0,0 +1,85 @@
+class Metar::Data::RunwayVisibleRange < Metar::Data::Base
+  TENDENCY   = {'' => nil, 'N' => :no_change, 'U' => :improving, 'D' => :worsening}
+  COMPARATOR = {'' => nil, 'P' => :more_than, 'M' => :less_than}
+  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]
+      distance   = Metar::Data::Distance.send(units, count)
+      visibility = Metar::Data::Visibility.new(
+        nil, distance: distance, comparator: comparator
+      )
+      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]
+      distance1   = Metar::Data::Distance.send(units, count1)
+      distance2   = Metar::Data::Distance.send(units, count2)
+      visibility1 = Metar::Data::Visibility.new(
+        nil, distance: distance1, comparator: comparator1
+      )
+      visibility2 = Metar::Data::Visibility.new(
+        nil, distance: distance2, comparator: comparator2
+      )
+      new(
+        raw,
+        designator: designator,
+        visibility1: visibility1, visibility2: visibility2,
+        tendency: tendency, units: units
+      )
+    else
+      nil
+    end
+  end
+
+  attr_reader :designator, :visibility1, :visibility2, :tendency
+
+  def initialize(
+    raw,
+    designator:, visibility1:, visibility2: nil, tendency: nil, units: :meters
+  )
+    @raw = raw
+    @designator, @visibility1, @visibility2, @tendency, @units = designator, visibility1, visibility2, tendency, units
+  end
+
+  def to_s
+    distance_options = {
+      abbreviated: true,
+      precision:   0,
+      units:       @units,
+    }
+    s =
+      if @visibility2.nil?
+        I18n.t('metar.runway_visible_range.runway') +
+          ' '  + @designator +
+          ': ' + @visibility1.to_s(distance_options)
+      else
+        I18n.t('metar.runway_visible_range.runway') +
+          ' '  + @designator +
+          ': ' + I18n.t('metar.runway_visible_range.from') +
+          ' '  + @visibility1.to_s(distance_options) +
+          ' '  + I18n.t('metar.runway_visible_range.to') +
+          ' '  + @visibility2.to_s(distance_options)
+      end
+
+    if ! tendency.nil?
+      s += ' ' + I18n.t("tendency.#{tendency}")
+    end
+
+    s
+  end
+end

data/lib/metar/data/sky_condition.rb

@@ -0,0 +1,61 @@
+class Metar::Data::SkyCondition < Metar::Data::Base
+  QUANTITY = {'BKN' => 'broken', 'FEW' => 'few', 'OVC' => 'overcast', 'SCT' => 'scattered'}
+  CONDITION = {
+    'CB'  => 'cumulonimbus',
+    'TCU' => 'towering cumulus',
+    '///' => nil, # cloud type unknown as observed by automatic system (15.9.1.7)
+    ''    => nil,
+  }
+  CLEAR_SKIES = [
+    'NSC', # WMO
+    'NCD', # WMO
+    'CLR',
+    'SKC',
+  ]
+
+  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]
+      height   =
+        if $2 == '///'
+          nil
+        else
+          Metar::Data::Distance.new($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
+    end
+  end
+
+  attr_reader :quantity, :height, :type
+
+  def initialize(raw, quantity: nil, height: nil, type: nil)
+    @raw = raw
+    @quantity, @height, @type = quantity, height, type
+  end
+
+  def to_s
+    if @height.nil?
+      to_summary
+    else
+      to_summary + ' ' + I18n.t('metar.altitude.at') + ' ' + height.to_s
+    end
+  end
+
+  def to_summary
+    if @quantity == nil and @height == nil and @type == nil
+      I18n.t('metar.sky_conditions.clear skies')
+    else
+      type = @type ? ' ' + @type : ''
+      I18n.t("metar.sky_conditions.#{@quantity}#{type}")
+    end
+  end
+end

data/lib/metar/data/speed.rb

@@ -0,0 +1,22 @@
+require "i18n"
+require "m9t"
+
+# Adds a parse method to the M9t base class
+class Metar::Data::Speed < M9t::Speed
+  METAR_UNITS = {
+    ""    => :kilometers_per_hour,
+    "KMH" => :kilometers_per_hour,
+    "MPS" => :meters_per_second,
+    "KT"  => :knots,
+  }
+
+  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
+  end
+end

data/lib/metar/data/station_code.rb

@@ -0,0 +1,7 @@
+class Metar::Data::StationCode < Metar::Data::Base
+  def self.parse(raw)
+    if raw =~ /^[A-Z][A-Z0-9]{3}$/
+      new(raw)
+    end
+  end
+end

data/lib/metar/data/temperature.rb

@@ -0,0 +1,21 @@
+require "i18n"
+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
+  end
+
+  def to_s(options = {})
+    options = {abbreviated: true, precision: 0}.merge(options)
+    super(options)
+  end
+end

data/lib/metar/data/temperature_and_dew_point.rb

@@ -0,0 +1,18 @@
+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
+  end
+
+  attr_reader :temperature
+  attr_reader :dew_point
+  
+  def initialize(raw, temperature:, dew_point:)
+    @raw = raw
+    @temperature = temperature
+    @dew_point = dew_point
+  end
+end

data/lib/metar/data/time.rb

@@ -0,0 +1,54 @@
+class Metar::Data::Time < Metar::Data::Base
+  def self.parse(raw, year: nil, month: nil, strict: true)
+    year ||= DateTime.now.year
+    month ||= DateTime.now.month
+
+    date_matcher =
+      if strict
+        /^(\d{2})(\d{2})(\d{2})Z$/
+      else
+        /^(\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
+    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
+    end
+
+    new(
+      raw,
+      strict: strict,
+      year: year, month: month, day: day, hour: hour, minute: minute
+    )
+  end
+
+  attr_reader :strict
+  attr_reader :year
+  attr_reader :month
+  attr_reader :day
+  attr_reader :hour
+  attr_reader :minute
+
+  def initialize(raw, strict:, year:, month:, day:, hour:, minute:)
+    @raw = raw
+    @strict = strict
+    @year = year
+    @month = month
+    @day = day
+    @hour = hour
+    @minute = minute
+  end
+
+  def value
+    Time.gm(year, month, day, hour, minute)
+  end
+end

data/lib/metar/data/variable_wind.rb

@@ -0,0 +1,25 @@
+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
+  end
+
+  attr_reader :direction1
+  attr_reader :direction2
+
+  def initialize(raw, direction1:, direction2:)
+    @raw = raw
+    @direction1, @direction2 = direction1, direction2
+  end
+
+  def to_s
+    "#{direction1.to_s(units: :compass)} - #{direction2.to_s(units: :compass)}"
+  end
+end

data/lib/metar/data/vertical_visibility.rb

@@ -0,0 +1,26 @@
+require "i18n"
+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
+    end
+  end
+
+  attr_reader :distance
+
+  def initialize(raw, distance:)
+    @raw = raw
+    @distance = distance
+  end
+
+  def value
+    distance.value
+  end
+end

data/lib/metar/data/visibility.rb

@@ -0,0 +1,71 @@
+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
+      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)
+      distance.units = :miles
+        new(raw, distance: distance)
+    when 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(
+        raw,
+        distance: Metar::Data::Distance.meters($1),
+        direction: M9t::Direction.compass($2)
+      )
+    else
+      nil
+    end
+  end
+
+  attr_reader :distance, :direction, :comparator
+
+  def initialize(raw, distance:, direction: nil, comparator: nil)
+    @raw = raw
+    @distance, @direction, @comparator = distance, direction, comparator
+  end
+
+  def to_s(options = {})
+    distance_options = {
+      abbreviated: true,
+      precision:   0,
+      units:       :kilometers,
+    }.merge(options)
+    direction_options = {units: :compass}
+    case
+    when (@direction.nil? and @comparator.nil?)
+      @distance.to_s(distance_options)
+    when @comparator.nil?
+      [
+        @distance.to_s(distance_options),
+        @direction.to_s(direction_options),
+      ].join(' ')
+    when @direction.nil?
+      [
+        I18n.t('comparison.' + @comparator.to_s),
+        @distance.to_s(distance_options),
+      ].join(' ')
+    else
+      [
+        I18n.t('comparison.' + @comparator.to_s),
+        @distance.to_s(distance_options),
+        @direction.to_s(direction_options),
+      ].join(' ')
+    end
+  end
+end