notam 0.1.0

data/lib/notam/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NOTAM
+  ParseError = Class.new(StandardError)
+end

data/lib/notam/item/a.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module NOTAM
+
+  # The A item defines the locations (ICAO codes) affected by this NOTAM.
+  class A < Item
+
+    RE = %r(
+      \A
+      A\)\s?
+      (?<locations>(?:#{ICAO_RE}\s?)+)
+      (?<parts>(?<part_index>\d+)\s+OF\s+(?<part_index_max>\d+))?
+      \z
+    )x.freeze
+
+    # @return [Array<String>]
+    def locations
+      captures['locations'].split(/\s/)
+    end
+
+    # @return [Integer, nil]
+    def part_index
+      captures['parts'] ? captures['part_index'].to_i : 1
+    end
+
+    # @return [Integer, nil]
+    def part_index_max
+      captures['parts'] ? captures['part_index_max'].to_i : 1
+    end
+
+    # @see NOTAM::Item#merge
+    def merge
+      super(:locations, :part_index, :part_index_max)
+    end
+
+  end
+end

data/lib/notam/item/b.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module NOTAM
+
+  # The B item defines when the NOTAM goes into effect.
+  class B < Item
+
+    RE = %r(
+      \A
+      B\)\s?
+      (?<effective_at>#{TIME_RE})
+      \z
+    )x.freeze
+
+    # @return [Time]
+    def effective_at
+      time(captures['effective_at'])
+    end
+
+    # @see NOTAM::Item#merge
+    def merge
+      super(:effective_at)
+    end
+
+  end
+end

data/lib/notam/item/c.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module NOTAM
+
+  # The C item defines when the NOTAM expires.
+  class C < Item
+
+    RE = %r(
+      \A
+      C\)\s?
+      (?<permanent>
+        PERM|
+        (?<expiration_at>#{TIME_RE}) \s? (?<estimated>EST)?
+      )
+      \z
+    )x.freeze
+
+    # @return [Time, nil]
+    def expiration_at
+      time(captures['expiration_at']) unless no_expiration?
+    end
+
+    # @return [Boolean]
+    def estimated_expiration?
+      !captures['estimated'].nil?
+    end
+
+    # @return [Boolean]
+    def no_expiration?
+      captures['permanent'] == 'PERM'
+    end
+
+    # @see NOTAM::Item#merge
+    def merge
+      super(:expiration_at, :estimated_expiration?, :no_expiration?)
+    end
+
+  end
+end

data/lib/notam/item/d.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module NOTAM
+
+  # The D item contains timesheets to further narrow when exactly the NOTAM
+  # is effective.
+  class D < Item
+
+    # Activity schedules
+    #
+    # @return [Array<NOTAM::Schedule>]
+    attr_reader :schedules
+
+    # @see NOTAM::Item#parse
+    def parse
+      base_date = AIXM.date(data[:effective_at])
+      @schedules = cleanup(text).split(',').map do |string|
+        Schedule.parse(string, base_date: base_date)
+      end
+      self
+    end
+
+    # Whether the D item is active at the given time.
+    #
+    # @param at [Time]
+    # @return [Boolean]
+    def active?(at:)
+      schedules.any? { _1.active?(at: at, xy: data[:center_point]) }
+    end
+
+    def five_day_schedules
+      schedules.map do |schedule|
+        schedule
+          .slice(AIXM.date(data[:effective_at]), AIXM.date(data[:effective_at] + 4 * 86_400))
+          .resolve(on: data[:effective_at], xy: data[:center_point])
+      end.map { _1 unless _1.empty? }.compact
+    end
+
+    # @see NOTAM::Item#merge
+    def merge
+      super(:schedules, :five_day_schedules)
+    end
+
+    private
+
+    # @return [String]
+    def cleanup(string)
+      string
+        .gsub(/\s+/, ' ')           # collapse whitespaces to single space
+        .gsub(/ ?([-,]) ?/, '\1')   # remove spaces around dashes and commas
+        .sub(/\AD\) /, '')          # remove item identifier
+        .strip
+    end
+
+  end
+end

data/lib/notam/item/e.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module NOTAM
+
+  # The E item contains a textual description of what this NOTAM is all about.
+  class E < Item
+
+    RE = %r(
+      \A
+      E\)\s?
+      (?<content>.+)
+      \z
+    )mx.freeze
+
+    def content
+      captures['content']
+    end
+
+    def translated_content
+      content.split(/\b/).map do |word|
+        (NOTAM::expand(word, translate: true) || word).upcase
+      end.join
+    end
+
+    # @see NOTAM::Item#merge
+    def merge
+      super(:content, :translated_content)
+    end
+
+  end
+end

data/lib/notam/item/f.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module NOTAM
+
+  # The F item defines the upper limit for this NOTAM.
+  class F < Item
+
+    RE = %r(
+      \A
+      F\)\s?
+      (?<all>
+        SFC|GND|UNL|
+        (?<value>\d+)\s?(?<unit>FT|M)\s?(?<base>AMSL|AGL)|
+        (?<unit>FL)\s?(?<value>\d+)
+      )
+      \z
+    )x.freeze
+
+    # @return [AIXM::Z]
+    def upper_limit
+      case captures['all']
+        when 'UNL' then AIXM::UNLIMITED
+        when 'SFC', 'GND' then AIXM::GROUND
+        else limit(*captures.values_at('value', 'unit', 'base'))
+      end
+    end
+
+    # @see NOTAM::Item#merge
+    def merge
+      super(:upper_limit)
+    end
+
+  end
+end

data/lib/notam/item/footer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module NOTAM
+
+  # The footer items contain meta information.
+  class Footer < Item
+
+    RE = %r(
+      \A
+      (?<key>CREATED|SOURCE):\s*
+      (?<value>.+)
+      \z
+    )x.freeze
+
+    # @return [String]
+    def key
+      captures['key'].downcase.to_sym
+    end
+
+    # @return [String, Time]
+    def value
+      case key
+        when :created then Time.parse(captures['value'] + ' UTC')
+        else captures['value']
+      end
+    end
+
+    # @see NOTAM::Item#merge
+    def merge
+      data[key] = value
+      self
+    end
+
+    # @return [String]
+    def inspect
+      %Q(#<#{self.class} "#{truncated_text(start: 0)}">)
+    end
+
+  end
+end

data/lib/notam/item/g.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module NOTAM
+
+  # The G item defines the lower limit for this NOTAM.
+  class G < Item
+
+    RE = %r(
+      \A
+      G\)\s?
+      (?<all>
+        SFC|GND|UNL|
+        (?<value>\d+)\s?(?<unit>FT|M)\s?(?<base>AMSL|AGL)|
+        (?<unit>FL)\s?(?<value>\d+)
+      )
+      \z
+    )x.freeze
+
+    # @return [AIXM::Z]
+    def lower_limit
+      case captures['all']
+        when 'UNL' then AIXM::UNLIMITED
+        when 'SFC', 'GND' then AIXM::GROUND
+        else limit(*captures.values_at('value', 'unit', 'base'))
+      end
+    end
+
+    # @see NOTAM::Item#merge
+    def merge
+      super(:lower_limit)
+    end
+
+  end
+end

data/lib/notam/item/header.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+using AIXM::Refinements
+
+module NOTAM
+
+  # The header item contains the NOTAM ID as well as information as to whether
+  # its a new NOTAM or merely replacing or cancelling another one.
+  class Header < Item
+
+    RE = %r(
+      \A
+      (?<id>#{ID_RE})\s+
+      NOTAM(?<operation>[NRC])\s*
+      (?<old_id>#{ID_RE.decapture})?
+      \z
+    )x.freeze
+
+    # @return [String] ID of this message
+    def id
+      captures['id']
+    end
+
+    # @return [String] series letter
+    def id_series
+      captures['id_series']
+    end
+
+    # @return [Integer] serial number
+    def id_number
+      captures['id_number'].to_i
+    end
+
+    # @return [Integer] year identifier
+    def id_year
+      captures['id_year'].to_i + (Date.today.year / 1000 * 1000)
+    end
+
+    # @return [Boolean] +true+ if this is a new message, +false+ if it
+    #   replaces or cancels another message
+    def new?
+      captures['operation'] == 'N'
+    end
+
+    # @return [String, nil] message being replaced by this message or +nil+
+    #   if this message is a new or cancelling one
+    def replaces
+      captures['old_id'] if captures['operation'] == 'R'
+    end
+
+    # @return [String, nil] message being cancelled by this message or +nil+
+    #   if this message is a new or replacing one
+    def cancels
+      captures['old_id'] if captures['operation'] == 'C'
+    end
+
+    # @see NOTAM::Item#parse
+    def parse
+      super
+      fail! "invalid operation" unless (new? && !captures['old_id']) || replaces || cancels
+      self
+    end
+
+    # @see NOTAM::Item#merge
+    def merge
+      super(:id, :id_series, :id_number, :id_year, :new?, :replaces, :cancels)
+    end
+
+    # @return [String]
+    def inspect
+      %Q(#<#{self.class} "#{truncated_text(start: 0)}">)
+    end
+
+  end
+end

data/lib/notam/item/q.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module NOTAM
+
+  # The Q item provides the context such as the FIR or conditions.
+  class Q < Item
+
+    RE = %r(
+      \A
+      Q\)\s?
+      (?<fir>#{ICAO_RE})/
+      Q(?<subject>[A-Z]{2})(?<condition>[A-Z]{2})/
+      (?<traffic>IV|(?:[IVK]\s?))/
+      (?<purpose>NBO|BO\s?|(?:[BMK]\s{0,2}))/
+      (?<scope>A[EW]|(?:[AEWK]\s?))/
+      (?<lower_limit>\d{3})/
+      (?<upper_limit>\d{3})/
+      (?<lat_deg>\d{2})(?<lat_min>\d{2})(?<lat_dir>[NS])
+      (?<long_deg>\d{3})(?<long_min>\d{2})(?<long_dir>[EW])
+      (?<radius>\d{3})
+      \z
+    )x.freeze
+
+    # @return [String]
+    def fir
+      captures['fir']
+    end
+
+    # @return [Symbol]
+    def subject
+      NOTAM.subject_for(captures['subject'])
+    end
+
+    # @return [Symbol]
+    def condition
+      NOTAM.condition_for(captures['condition'])
+    end
+
+    # @return [Symbol]
+    def traffic
+      NOTAM.traffic_for(captures['traffic'].strip)
+    end
+
+    # @return [Array<Symbol>]
+    def purpose
+      captures['purpose'].strip.chars.map { NOTAM.purpose_for(_1) }
+    end
+
+    # @return [Array<Symbol>]
+    def scope
+      captures['scope'].strip.chars.map { NOTAM.scope_for(_1) }
+    end
+
+    # @return [AIXM::Z] lower limit (QNE flight level) or {AIXM::GROUND}
+    #   (aka: 0ft QFE)
+    def lower_limit
+      if (limit = captures['lower_limit'].to_i).zero?
+        AIXM::GROUND
+      else
+        AIXM.z(captures['lower_limit'].to_i, :qne)
+      end
+    end
+
+    # @return [AIXM::Z] upper limit (QNE  flight level) or {AIXM::UNLIMITED}
+    #   (aka: FL999 QNE)
+    def upper_limit
+      AIXM.z(captures['upper_limit'].to_i, :qne)
+    end
+
+    # @return [AIXM::XY] approximately affected area center point
+    def center_point
+      AIXM.xy(
+        lat: %Q(#{captures['lat_deg']}°#{captures['lat_min']}'00"#{captures['lat_dir']}),
+        long: %Q(#{captures['long_deg']}°#{captures['long_min']}'00"#{captures['long_dir']})
+      )
+    end
+
+    # @return [AIXM::D] approximately affected area radius
+    def radius
+      AIXM.d(captures['radius'].to_i, :nm)
+    end
+
+    # @see NOTAM::Item#merge
+    def merge
+      super(:fir, :subject, :condition, :traffic, :purpose, :scope, :lower_limit, :upper_limit, :center_point, :radius)
+    end
+
+  end
+end

data/lib/notam/item.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module NOTAM
+
+  # Items are the building blocks of a NOTAM message. They usually consist of
+  # only one line of plain text each, however, D and E items may span over
+  # multiple lines of plain text.
+  class Item
+
+    RE = /[QA-G]\)\s/.freeze
+
+    ID_RE = /(?<id_series>[A-Z])(?<id_number>\d{4})\/(?<id_year>\d{2})/.freeze
+    ICAO_RE = /[A-Z]{4}/.freeze
+    TIME_RE = /(?:\d{2})(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])(?:[01]\d|[2][0-4])(?:[0-5]\d)/.freeze
+
+    # Raw NOTAM item text
+    #
+    # @return [String]
+    attr_reader :text
+
+    # Captures from the default item regexp +RE+
+    #
+    # @return [MatchData]
+    attr_reader :captures
+
+    # Parsed NOTAM message payload
+    #
+    # @return [Hash]
+    attr_reader :data
+
+    # Analyses the raw NOTAM item text and initialize the corresponding item
+    # object.
+    #
+    # @note Some NOTAM items (most notably {NOTAM::D}) depend on previous items
+    #   for meaningful parsing and may fail if this information is not made
+    #   available by passing the NOTAM message payload parsed so far as +data+.
+    #
+    # @example
+    #   NOTAM::Item.new('A0135/20 NOTAMN')   # => #<NOTAM::Head id="A0135/20">
+    #   NOTAM::Item.new('B) 0208231540')     # => #<NOTAM::B>
+    #   NOTAM::Item.new('foobar')            # => NOTAM::ParseError
+    #
+    # @param text [String]
+    # @param data [Hash]
+    # @return [NOTAM::Header, NOTAM::Q, NOTAM::A, NOTAM::B, NOTAM::C,
+    #   NOTAM::D, NOTAM::E, NOTAM::F, NOTAM::G, NOTAM::Footer]
+    def initialize(text, data: {})
+      @text, @data = text.strip, data
+    end
+
+    class << self
+      # @!visibility private
+      def new(text, data: {})
+        NOTAM.const_get(type(text)).allocate.instance_eval do
+          initialize(text, data: data)
+          self
+        end
+      end
+
+      # Analyses the raw NOTAM item text and detect its type.
+      #
+      # @example
+      #   NOTAM::Item.type('A0135/20 NOTAMN')   # => :Header
+      #   NOTAM::Item.type('B) 0208231540')     # => :B
+      #   NOTAM::Item.type('SOURCE: LFNT')      # => :Footer
+      #   NOTAM::Item.type('foobar')            # => NOTAM::ParseError
+      #
+      # @raise [NOTAM::ParseError]
+      # @return [String]
+      def type(text)
+        case text.strip
+          when /\A([A-GQ])\)/ then $1
+          when NOTAM::Header::RE then 'Header'
+          when NOTAM::Footer::RE then 'Footer'
+          else fail(NOTAM::ParseError, 'item not recognized')
+        end.to_sym
+      end
+    end
+
+    # Matches the raw NOTAM item text against +RE+ and populates {#captures}.
+    #
+    # @note May be extended or overwritten in subclasses, but must always
+    #   return +self+!
+    #
+    # @example
+    #   NOTAM::Item.new('A0135/20 NOTAMN').parse   # => #<NOTAM::Header id="A0135/20">
+    #   NOTAM::Item.new('foobar').parse            # => NOTAM::ParseError
+    #
+    # @abstract
+    # @raise [NOTAM::ParseError]
+    # @return [self]
+    def parse
+      if match_data = self.class::RE.match(text)
+        @captures = match_data.named_captures
+        self
+      else
+        fail! 'text does not match regexp'
+      end
+    end
+
+    # Merges the return values of the given methods into the +data+ hash.
+    #
+    # @note Must be extended in subclasses.
+    #
+    # @abstract
+    # @params methods [Array<Symbol>]
+    # @return [self]
+    def merge(*methods)
+      fail 'nothing to merge' unless methods.any?
+      methods.each { @data[_1] = send(_1) }
+      @data.compact!
+      self
+    end
+
+    # Type of the item
+    #
+    # @return [Symbol] either +:Header+, +:Q+, +(:A..:G)+ or +:Footer+
+    def type
+      self.class.to_s[7..].to_sym
+    end
+
+    # Raise {NOTAM::ParseError} along with some debugging information.
+    #
+    # @param message [String] optional error message
+    # @raise [NOTAM::ParseError]
+    def fail!(message=nil)
+      fail(NOTAM::ParseError, [message, text].compact.join(': '))
+    end
+
+    # @return [String]
+    def inspect
+      %Q(#<#{self.class} "#{truncated_text}">)
+    end
+
+    private
+
+    def time(timestamp)
+      short_year, month, day, hour, minute = timestamp.scan(/\d{2}/).map(&:to_i)
+      millenium = Time.now.year / 100 * 100
+      Time.utc(millenium + short_year, month, day, hour, minute)
+    end
+
+    def limit(value, unit, base)
+      if captures['base']
+        d = AIXM.d(value.to_i, unit).to_ft
+        AIXM.z(d.dim.round, { 'AMSL' => :qnh, 'AGL' => :qfe }[base])
+      else
+        AIXM.z(value.to_i, :qne)
+      end
+    end
+
+    def truncated_text(start: 3, length: 40)
+      if text.length > start + length - 1
+        text[start, length - 1] + '…'
+      else
+        text[start..]
+      end
+    end
+
+  end
+end