metar-parser 1.4.2 → 1.6.0

data/lib/metar/data/temperature.rb

@@ -1,19 +1,27 @@
+# frozen_string_literal: true
+
 require "i18n"
 require "m9t"
 
-# Adds a parse method to the M9t base class
-class Metar::Data::Temperature < M9t::Temperature
-  def self.parse(raw)
-    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
+module Metar
+  module Data
+    class Temperature < M9t::Temperature
+      def self.parse(raw)
+        return nil if !raw
+
+        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 = {})
-    options = {abbreviated: true, precision: 0}.merge(options)
-    super(options)
+      def to_s(options = {})
+        options = {abbreviated: true, precision: 0}.merge(options)
+        super(options)
+      end
+    end
   end
 end

data/lib/metar/data/temperature_and_dew_point.rb

@@ -1,21 +1,27 @@
-class Metar::Data::TemperatureAndDewPoint < Metar::Data::Base
-  def self.parse(raw)
-    return nil if !raw
+# frozen_string_literal: true
 
-    m = raw.match(/^(M?\d+|XX|\/\/)\/(M?\d+|XX|\/\/)?$/)
-    return nil if !m
+module Metar
+  module Data
+    class TemperatureAndDewPoint < Metar::Data::Base
+      def self.parse(raw)
+        return nil if !raw
 
-    temperature = Metar::Data::Temperature.parse(m[1])
-    dew_point = Metar::Data::Temperature.parse(m[2])
-    new(raw, temperature: temperature, dew_point: dew_point)
-  end
+        m = raw.match(%r{^(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
+      attr_reader :dew_point
 
-  attr_reader :temperature
-  attr_reader :dew_point
-  
-  def initialize(raw, temperature:, dew_point:)
-    @raw = raw
-    @temperature = temperature
-    @dew_point = dew_point
+      def initialize(raw, temperature:, dew_point:)
+        @raw = raw
+        @temperature = temperature
+        @dew_point = dew_point
+      end
+    end
   end
 end

data/lib/metar/data/time.rb

@@ -1,53 +1,63 @@
-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
+# frozen_string_literal: true
 
-    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
-
-      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
+module Metar
+  module Data
+    class Time < Metar::Data::Base
+      def self.parse(raw, year: nil, month: nil, strict: true)
+        year ||= DateTime.now.year
+        month ||= DateTime.now.month
 
-    new(
-      raw,
-      strict: strict,
-      year: year, month: month, day: day, hour: hour, minute: minute
-    )
-  end
+        date_matcher =
+          if strict
+            /^(\d{2})(\d{2})(\d{2})Z$/
+          else
+            /^(\d{1,2})(\d{2})(\d{2})Z$/
+          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
+        m1 = raw.match(date_matcher)
+        if m1
+          day = m1[1].to_i
+          hour = m1[2].to_i
+          minute = m1[3].to_i
+        else
+          return nil if strict
 
-  def value
-    Time.gm(year, month, day, hour, minute)
+          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 = m2[1].to_i
+          minute = m2[2].to_i
+        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
   end
 end

data/lib/metar/data/variable_wind.rb

@@ -1,26 +1,37 @@
-class Metar::Data::VariableWind < Metar::Data::Base
-  def self.parse(raw)
-    return nil if raw.nil?
+# frozen_string_literal: true
 
-    m = raw.match(/^(\d+)V(\d+)$/)
-    return nil if m.nil?
+module Metar
+  module Data
+    class VariableWind < Metar::Data::Base
+      def self.parse(raw)
+        return nil if raw.nil?
 
-    return new(
-      raw,
-      direction1: Metar::Data::Direction.new(m[1]),
-      direction2: Metar::Data::Direction.new(m[2])
-    )
-  end
+        m = raw.match(/^(\d+)V(\d+)$/)
+        return nil if m.nil?
 
-  attr_reader :direction1
-  attr_reader :direction2
+        new(
+          raw,
+          direction1: Metar::Data::Direction.new(m[1]),
+          direction2: Metar::Data::Direction.new(m[2])
+        )
+      end
 
-  def initialize(raw, direction1:, direction2:)
-    @raw = raw
-    @direction1, @direction2 = direction1, direction2
-  end
+      attr_reader :direction1
+      attr_reader :direction2
+
+      def initialize(raw, direction1:, direction2:)
+        @raw = raw
+        @direction1 = direction1
+        @direction2 = direction2
+      end
 
-  def to_s
-    "#{direction1.to_s(units: :compass)} - #{direction2.to_s(units: :compass)}"
+      def to_s
+        format(
+          "%<direction1>s - %<direction2>s",
+          direction1: direction1.to_s(units: :compass),
+          direction2: direction2.to_s(units: :compass)
+        )
+      end
+    end
   end
 end

data/lib/metar/data/vertical_visibility.rb

@@ -1,31 +1,37 @@
+# frozen_string_literal: true
+
 require "i18n"
 require "m9t"
 
-class Metar::Data::VerticalVisibility < Metar::Data::Base
-  def self.parse(raw)
-    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
+module Metar
+  module Data
+    class VerticalVisibility < Metar::Data::Base
+      def self.parse(raw)
+        return nil if !raw
 
-    if raw == '///'
-      return new(raw, distance: Metar::Data::Distance.new)
-    end
+        m1 = raw.match(/^VV(\d{3})$/)
+        if m1
+          return new(
+            raw,
+            distance: Metar::Data::Distance.new(m1[1].to_f * 30.48)
+          )
+        end
 
-    nil
-  end
+        return new(raw, distance: Metar::Data::Distance.new) if raw == '///'
 
-  attr_reader :distance
+        nil
+      end
 
-  def initialize(raw, distance:)
-    @raw = raw
-    @distance = distance
-  end
+      attr_reader :distance
 
-  def value
-    distance.value
+      def initialize(raw, distance:)
+        @raw = raw
+        @distance = distance
+      end
+
+      def value
+        distance.value
+      end
+    end
   end
 end

data/lib/metar/data/visibility.rb

@@ -1,94 +1,106 @@
-class Metar::Data::Visibility < Metar::Data::Base
-  def self.parse(raw)
-    if !raw
-      return nil
-    end
+# frozen_string_literal: true
 
-    if raw == '9999'
-      return new(raw, distance: Metar::Data::Distance.new(10000), comparator: :more_than)
-    end
+module Metar
+  module Data
+    class Visibility < Metar::Data::Base
+      def self.parse(raw)
+        return nil if !raw
 
-    m1 = raw.match(/(\d{4})NDV/) # WMO
-    if m1
-      return new(raw, distance: Metar::Data::Distance.new(m1[1].to_f)) # Assuming meters
-    end
+        if raw == '9999'
+          return new(
+            raw,
+            distance: Metar::Data::Distance.new(10_000),
+            comparator: :more_than
+          )
+        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.serialization_units = :miles
-      return new(raw, distance: distance)
-    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
 
-    m3 = raw.match(/^(\d+)SM$/) # US
-    if m3
-      distance       = Metar::Data::Distance.miles(m3[1].to_f)
-      distance.serialization_units = :miles
-      return new(raw, distance: distance)
-    end
+        m2 = raw.match(%r{^((1|2)\s|)([1357])/([248]|16)SM$}) # US
+        if m2
+          numerator = m2[3].to_f
+          denominator = m2[4].to_f
+          miles = m2[1].to_f + numerator / denominator
+          distance = Metar::Data::Distance.miles(miles)
+          distance.serialization_units = :miles
+          return new(raw, distance: distance)
+        end
 
-    if raw == 'M1/4SM' # US
-      distance       = Metar::Data::Distance.miles(0.25)
-      distance.serialization_units = :miles
-      return new(raw, distance: distance, comparator: :less_than)
-    end
+        m3 = raw.match(/^(\d+)SM$/) # US
+        if m3
+          distance = Metar::Data::Distance.miles(m3[1].to_f)
+          distance.serialization_units = :miles
+          return new(raw, distance: distance)
+        end
 
-    m4 = raw.match(/^(\d+)KM$/)
-    if m4
-      return new(raw, distance: Metar::Data::Distance.kilometers(m4[1]))
-    end
+        if raw == 'M1/4SM' # US
+          distance = Metar::Data::Distance.miles(0.25)
+          distance.serialization_units = :miles
+          return new(raw, distance: distance, comparator: :less_than)
+        end
 
-    m5 = raw.match(/^(\d+)$/) # We assume meters
-    if m5
-      return new(raw, distance: Metar::Data::Distance.new(m5[1]))
-    end
+        m4 = raw.match(/^(\d+)KM$/)
+        return new(raw, distance: Metar::Data::Distance.kilometers(m4[1])) if m4
 
-    m6 = raw.match(/^(\d+)(N|NE|E|SE|S|SW|W|NW)$/)
-    if m6
-      return new(
-        raw,
-        distance: Metar::Data::Distance.meters(m6[1]),
-        direction: M9t::Direction.compass(m6[2])
-      )
-    end
+        m5 = raw.match(/^(\d+)$/) # We assume meters
+        return new(raw, distance: Metar::Data::Distance.new(m5[1])) if m5
 
-    nil
-  end
+        m6 = raw.match(/^(\d+)(N|NE|E|SE|S|SW|W|NW)$/)
+        if m6
+          return new(
+            raw,
+            distance: Metar::Data::Distance.meters(m6[1]),
+            direction: M9t::Direction.compass(m6[2])
+          )
+        end
 
-  attr_reader :distance, :direction, :comparator
+        nil
+      end
 
-  def initialize(raw, distance:, direction: nil, comparator: nil)
-    @raw = raw
-    @distance, @direction, @comparator = distance, direction, comparator
-  end
+      attr_reader :distance, :direction, :comparator
+
+      def initialize(raw, distance:, direction: nil, comparator: nil)
+        @raw = raw
+        @distance = distance
+        @direction = direction
+        @comparator = comparator
+      end
+
+      def to_s(options = {})
+        distance_options = {
+          abbreviated: true,
+          precision: 0,
+          units: :kilometers
+        }.merge(options)
+
+        direction_options = {units: :compass}
 
-  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(' ')
+        case
+        when @direction.nil? && @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
   end
 end

data/lib/metar/data/visibility_remark.rb

@@ -1,8 +1,19 @@
-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)
+# frozen_string_literal: true
 
-    new(raw, distance: distance, direction: direction, comparator: :more_than)
+module Metar
+  module Data
+    class 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
   end
 end