aipp 0.2.4 → 1.0.0

data/lib/aipp/regions/LF/serviced_airspaces.rb

@@ -0,0 +1,70 @@
+module AIPP
+  module LF
+
+    class ServicedAirspaces < AIP
+
+      include AIPP::LF::Helpers::Base
+
+      # Map source types to type and optional local type and skip regexp
+      SOURCE_TYPES = {
+        'FIR' => { type: 'FIR' },
+        'UIR' => { type: 'UIR' },
+        'UTA' => { type: 'UTA' },
+        'CTA' => { type: 'CTA' },
+        'LTA' => { type: 'CTA', local_type: 'LTA' },
+        'TMA' => { type: 'TMA', skip: /geneve/i },   # Geneva listed FYI only
+        'SIV' => { type: 'SECTOR', local_type: 'FIZ/SIV' },   # providing FIS
+        'CTR' => { type: 'CTR' },
+        'RMZ' => { type: 'RAS', local_type: 'RMZ' },
+        'TMZ' => { type: 'RAS', local_type: 'TMZ' },
+        'RMZ-TMZ' => { type: 'RAS', local_type: 'RMZ-TMZ' }
+      }.freeze
+
+      # Map airspace "<type> <name>" to location indicator
+      FIR_LOCATION_INDICATORS = {
+        'BORDEAUX' => 'LFBB',
+        'BREST' => 'LFRR',
+        'MARSEILLE' => 'LFMM',
+        'PARIS' => 'LFFF',
+        'REIMS' => 'LFRR'
+      }.freeze
+
+      def parse
+        SOURCE_TYPES.each do |source_type, target|
+          verbose_info("processing #{source_type}")
+          cache.espace.css(%Q(Espace[lk^="[LF][#{source_type} "])).each do |espace_node|
+            # Skip all delegated airspaces
+            next if espace_node.(:Nom).match? /deleg/i
+            next if (re = target[:skip]) && espace_node.(:Nom).match?(re)
+            # Build airspaces and layers
+            cache.partie.css(%Q(Partie:has(Espace[pk="#{espace_node['pk']}"]))).each do |partie_node|
+              add(
+                AIXM.airspace(
+                  source: source(section: 'ENR', position: espace_node.line),
+                  name: [
+                    espace_node.(:Nom),
+                    partie_node.(:NomPartie).remove(/^\.$/).blank_to_nil
+                  ].compact.join(' '),
+                  type: target[:type],
+                  local_type: target[:local_type]
+                ).tap do |airspace|
+                  airspace.meta = espace_node.attr('pk')
+                  airspace.geometry = geometry_from(partie_node.(:Contour))
+                  fail("geometry is not closed") unless airspace.geometry.closed?
+                  cache.volume.css(%Q(Volume:has(Partie[pk="#{partie_node['pk']}"]))).each do |volume_node|
+                    airspace.add_layer(
+                      layer_from(volume_node).tap do |layer|
+                        layer.location_indicator = FIR_LOCATION_INDICATORS.fetch(airspace.name) if airspace.type == :flight_information_region
+                      end
+                    )
+                  end
+                end
+              )
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/aipp/regions/LF/services.rb

@@ -0,0 +1,172 @@
+module AIPP
+  module LF
+
+    class Services < AIP
+
+      include AIPP::LF::Helpers::Base
+
+      DEPENDS = %w(aerodromes serviced_airspaces)
+
+      # Service types and how to treat them
+      SOURCE_TYPES = {
+        'A/A' => :address,
+        'AFIS' => :service,
+        'APP' => :service,
+        'ATIS' => :service,
+        'CCM' => :ignore,      # centre de contrôle militaire
+        'CEV' => :ignore,      # centre d’essai en vol
+        'D-ATIS' => :ignore,   # data link ATIS
+        'FIS' => :service,
+        'PAR' => :service,
+        'SRE' => :ignore,      # surveillance radar element of PAR
+        'TWR' => :service,
+        'UAC' => :ignore,      # upper area control
+        'VDF' => :service,
+        'OTHER' => :service    # no <Service> specified at source
+      }.freeze
+
+      # Map French callsigns to English and service type
+      CALLSIGNS = {
+        'Approche' => { en: 'Approach', service_type: 'APP' },
+        'Contrôle' => { en: 'Control', service_type: 'ACS' },
+        'Information' => { en: 'Information', service_type: 'FIS' },
+        'GCA' => { en: 'GCA', service_type: 'GCA' },
+        'Gonio' => { en: 'Gonio', service_type: 'VDF' },
+        'Prévol' => { en: 'Delivery', service_type: 'SMC' },
+        'Sol' => { en: 'Ground', service_type: 'SMC' },
+        'Tour' => { en: 'Tower', service_type: 'TWR' },
+        'Trafic' => { en: 'Apron', service_type: 'SMC' }
+      }.freeze
+
+      def parse
+        cache.service.css(%Q(Service[lk^="[LF]"][pk])).each do |service_node|
+          # Ignore private services/frequencies
+          next if service_node.(:IndicLieu) == 'XX'
+          # Load referenced airport
+          airport = given(service_node.at_css('Ad')&.attr('pk')) do
+            find_by(:airport, meta: _1).first
+          end
+          # Build addresses and services
+          case SOURCE_TYPES.fetch(type_for(service_node))
+          when :address
+            fail "dangling address without airport" unless airport
+            addresses_from(service_node).each { airport.add_address(_1) }
+          when :service
+            given service_from(service_node) do |service|
+              cache.frequence.css(%Q(Frequence:has(Service[pk="#{service_node['pk']}"]))).each do |frequence_node|
+                if frequency = frequency_from(frequence_node, service_node)
+                  service.add_frequency frequency
+                end
+              end
+              if airport
+                airport.add_unit(service.unit) if airport.units.find(service.unit).none?
+                airport.add_service(service) if airport.services.find(service).none?
+              end
+              given service_node.at_css('Espace')&.attr('pk') do |espace_pk|
+                find_by(:airspace, meta: espace_pk).each do |airspace|
+                  airspace.layers.each { _1.add_service(service) }
+                end
+              end
+            end
+          end
+        end
+        # Assign fallback address (default A/A frequency) to all yet radioless airports
+        find_by(:airport).each do |airport|
+          unless airport.services.find_by(:service, type: :aerodrome_control_tower_service).any? || airport.addresses.any?
+            airport.add_address(fallback_address_for(airport.name))
+          end
+        end
+      end
+
+      private
+
+      def type_for(service_node)
+        SOURCE_TYPES.include?(type = service_node.(:Service)) ? type : 'OTHER'
+      end
+
+      def addresses_from(service_node)
+        cache.frequence.css(%Q(Frequence:has(Service[pk="#{service_node['pk']}"]))).map do |frequence_node|
+          if frequency = frequency_from(frequence_node, service_node)
+            AIXM.address(
+              type: :radio_frequency,
+              address: frequency.transmission_f
+            ).tap do |address|
+              address.remarks = {
+                'type' => service_node.(:Service),
+                'indicatif/callsign' => frequency.callsigns.map { "#{_2} (#{_1})" }.join("/n")
+              }.to_remarks
+            end
+          end
+        end.compact
+      end
+
+      def fallback_address_for(callsign)
+        AIXM.address(
+          type: :radio_frequency,
+          address: AIXM.f(123.5, :mhz)
+        ).tap do |address|
+          address.remarks = {
+            'type' => 'A/A',
+            'indicatif/callsign' => callsign
+          }.to_remarks
+        end
+      end
+
+      def service_from(service_node)
+        service_type = CALLSIGNS.dig(service_node.(:IndicService), :service_type) || type_for(service_node)
+        service = find_by(:service, type: service_type).first
+        unit = service&.unit
+        unless service
+          service = AIXM.service(type: service_type)
+          unit = find_by(:unit, name: service_node.(:IndicLieu), type: service.guessed_unit_type).first
+          unless unit
+            unit = AIXM.unit(
+              source: source(section: 'GEN', position: service_node.line),
+              organisation: organisation_lf,
+              name: service_node.(:IndicLieu),
+              type: service.guessed_unit_type,
+              class: :icao
+            )
+            add unit
+          end
+          unit.add_service service
+          service
+        end
+      end
+
+      def frequency_from(frequence_node, service_node)
+        frequency = frequence_node.(:Frequence).to_f
+        case
+        when frequency >= 137
+          nil
+        when frequency < 108
+          warn("ignoring too low frequency `#{frequency}'", severe: false)
+          nil
+        else
+          AIXM.frequency(
+            transmission_f: AIXM.f(frequency, :mhz),
+            callsigns: callsigns_from(service_node)
+          ).tap do |frequency|
+            frequency.timetable = timetable_from(frequence_node.(:HorCode))
+            frequency.remarks = frequence_node.(:Remarque)
+          end
+        end
+      end
+
+      def callsigns_from(service_node)
+        if service_node.(:IndicService) == '.'   # auto-information
+          %i(fr en).to_h { [_1, '(auto)'] }
+        else
+          warn("language other than french") unless service_node.(:Langue) == 'fr'
+          english = CALLSIGNS.fetch(service_node.(:IndicService)).fetch(:en)
+          warn("no english translation for callsign `#{service_node.(:IndicService)}'") unless english
+          {
+            fr: "#{service_node.(:IndicLieu)} #{service_node.(:IndicService)}",
+            en: ("#{service_node.(:IndicLieu)} #{english}" if english)
+          }.compact
+        end
+      end
+
+    end
+  end
+end

data/lib/aipp/t_hash.rb

@@ -18,14 +18,14 @@ module AIPP
 
     alias_method :tsort_each_node, :each_key
 
-    def tsort_each_child(node, &block)
-     fetch(node).each(&block)
+    def tsort_each_child(node, &)
+      fetch(node).each(&)
     end
 
     def tsort(node=nil)
       if node
         subhash = subhash_for node
-        super().select { |n| subhash.include? n }
+        super().select { subhash.include? _1 }
       else
         super()
       end
@@ -35,9 +35,8 @@ module AIPP
 
     def subhash_for(node, memo=[])
       memo.tap do |m|
-        fail TSort::Cyclic if m.include? node
         m << node
-        fetch(node).each { |n| subhash_for(n, m) }
+        (fetch(node) - m).each { subhash_for(_1, m) }
       end
     end
 

data/lib/aipp/version.rb

@@ -1,3 +1,3 @@
 module AIPP
-  VERSION = "0.2.4".freeze
+  VERSION = "1.0.0".freeze
 end

data/lib/aipp.rb

@@ -1,44 +1,50 @@
+require 'debug/session'
 require 'forwardable'
 require 'colorize'
-require 'pry'
-require 'pry-rescue'
 require 'optparse'
 require 'yaml'
+require 'csv'
+require 'roo'
 require 'pathname'
+require 'tmpdir'
+require 'net/http'
 require 'open-uri'
 require 'securerandom'
 require 'tsort'
 require 'ostruct'
 require 'date'
 require 'nokogiri'
-require 'nokogumbo'
 require 'pdf-reader'
 require 'json'
 require 'zip'
+require 'airac'
 require 'aixm'
 
 require 'active_support'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/string'
-require_relative 'core_ext/object'
+
 require_relative 'core_ext/integer'
 require_relative 'core_ext/string'
 require_relative 'core_ext/nil_class'
 require_relative 'core_ext/enumerable'
 require_relative 'core_ext/hash'
+require_relative 'core_ext/nokogiri'
 
 require_relative 'aipp/version'
+require_relative 'aipp/debugger'
 require_relative 'aipp/pdf'
 require_relative 'aipp/border'
 require_relative 'aipp/t_hash'
 require_relative 'aipp/executable'
-require_relative 'aipp/airac'
 require_relative 'aipp/patcher'
 require_relative 'aipp/aip'
 require_relative 'aipp/parser'
 require_relative 'aipp/downloader'
 
 # Disable "did you mean?" suggestions
+#
+# @!visibility private
 module DidYouMean::Correctable
   remove_method :to_s
 end

data/lib/core_ext/enumerable.rb

@@ -5,11 +5,11 @@ module Enumerable
   #   returning an array of these sub-enumerables.
   #
   #   @example
-  #     [1, 2, 0, 3, 4].split { |e| e == 0 }   # => [[1, 2], [3, 4]]
-  #     [1, 2, 0, 3, 4].split(0)               # => [[1, 2], [3, 4]]
-  #     [0, 0, 1, 0, 2].split(0)               # => [[], [] [1], [2]]
-  #     [1, 0, 0, 2, 3].split(0)               # => [[1], [], [2], [3]]
-  #     [1, 0, 2, 0, 0].split(0)               # => [[1], [2]]
+  #     [1, 2, 0, 3, 4].split { _1 == 0 }   # => [[1, 2], [3, 4]]
+  #     [1, 2, 0, 3, 4].split(0)            # => [[1, 2], [3, 4]]
+  #     [0, 0, 1, 0, 2].split(0)            # => [[], [] [1], [2]]
+  #     [1, 0, 0, 2, 3].split(0)            # => [[1], [], [2], [3]]
+  #     [1, 0, 2, 0, 0].split(0)            # => [[1], [2]]
   #
   #   @note While similar to +Array#split+ from ActiveSupport, this core
   #     extension works for all enumerables and therefore works fine with.
@@ -20,9 +20,9 @@ module Enumerable
   #   @yield [Object] element to analyze
   #   @yieldreturn [Boolean] whether to split at this element or not
   #   @return [Array]
-  def split(*args, &block)
+  def split(*args, &)
     [].tap do |array|
-      while index = slice((start ||= 0)...length).find_index(*args, &block)
+      while index = slice((start ||= 0)...length).find_index(*args, &)
         array << slice(start...start+index)
         start += index + 1
       end
@@ -35,7 +35,7 @@ module Enumerable
   #   an array of subsequent elements which don't match the chunk condition.
   #
   #   @example
-  #     [1, 10, 11, 12, 2, 20, 21, 3, 30, 31, 32].group_by_chunks { |i| i < 10 }
+  #     [1, 10, 11, 12, 2, 20, 21, 3, 30, 31, 32].group_by_chunks { _1 < 10 }
   #     # => { 1 => [10, 11, 12], 2 => [20, 21], 3 => [30, 31, 32] }
   #
   #   @note The first element must match the chunk condition.
@@ -46,7 +46,7 @@ module Enumerable
   #   @return [Hash]
   def group_by_chunks
     fail(ArgumentError, "first element must match chunk condition") unless yield(first)
-    slice_when { |_, e| yield(e) }.map { |e| [e.first, e[1..]] }.to_h
+    slice_when { yield(_2) }.map { [_1.first, _1[1..]] }.to_h
   end
 
 end

data/lib/core_ext/hash.rb

@@ -4,8 +4,8 @@ class Hash
   #
   # Similar to +fetch+, search the hash keys for the search string and return
   # the corresponding value. Unlike +fetch+, however, if a hash key is a Regexp,
-  # the search string is matched against this Regexp. The hash is searched
-  # in it's natural order.
+  # the search argument is matched against this Regexp. The hash is searched
+  # in its natural order.
   #
   # @example
   #   h = { /aa/ => :aa, /a/ => :a, 'b' => :b }
@@ -18,14 +18,30 @@ class Hash
   # @param default [Object] fallback value if no key matched
   # @return [Object] hash value
   # @raise [KeyError] no key matched and no default given
-  def metch(search, default=nil)
+  def metch(search, default=:__n_o_n_e__)
     fetch search
   rescue KeyError
     each do |key, value|
       next unless key.is_a? Regexp
-      return value if search.match? key
+      return value if key.match? search
     end
-    default ? default : raise(KeyError, "no match found: #{search.inspect}")
+    raise(KeyError, "no match found: #{search.inspect}") if default == :__n_o_n_e__
+    default
   end
 
+  # Compile a titles/texts hash to remarks Markdown string
+  #
+  # @example
+  #   { name: 'foobar', ignore: => nil, 'count/quantité' => 3 }.to_remarks
+  #   # => "NAME\nfoobar\n\nCOUNT/QUANTITÉ\n3"
+  #   { ignore: nil, ignore_as_well: "" }.to_remarks
+  #   # => nil
+  #
+  # @return [String, nil] compiled remarks
+  def to_remarks
+    map { |k, v| "**#{k.to_s.upcase}**\n#{v}" unless v.blank? }.
+      compact.
+      join("\n\n").
+      blank_to_nil
+  end
 end

data/lib/core_ext/nokogiri.rb

@@ -0,0 +1,54 @@
+module Nokogiri
+  module XML
+    class Element
+
+      BOOLEANIZE_AS_TRUE_RE = /^(true|yes|oui|ja)$/i.freeze
+      BOOLEANIZE_AS_FALSE_RE = /^(false|no|non|nein)$/i.freeze
+
+      # Traverse all child elements and build a hash mapping the symbolized
+      # child node name to the child content.
+      #
+      # @return [Hash]
+      def contents
+        @contents ||= elements.to_h { [_1.name.to_sym, _1.content] }
+      end
+
+      # Shortcut to query +contents+ array which accepts both String or
+      # Symbol queries as well as query postfixes.
+      #
+      # @example query optional content for :key
+      #   element.(:key)    # same as element.contents[:key]
+      #
+      # @example query mandatory content for :key
+      #   element.(:key!)   # fails if the key does not exist
+      #
+      # @example query boolean content for :key
+      #   element.(:key?)   # returns true or false
+      #
+      # @see +BOOLEANIZE_AS_TRUE_RE+ and +BOOLEANIZE_AS_FALSE_RE+ define the
+      #   regular expressions which convert the content to boolean. Furthermore,
+      #   nil is interpreted as false as well.
+      #
+      # @raise KeyError mandatory or boolean content not found
+      # @return [String, Boolean]
+      def call(query)
+        case query
+          when /\?$/ then booleanize(contents.fetch(query[...-1].to_sym))
+          when /\!$/ then contents.fetch(query[...-1].to_sym)
+          else contents[query.to_sym]
+        end
+      end
+
+      private
+
+      def booleanize(content)
+        case content
+          when nil then false
+          when BOOLEANIZE_AS_TRUE_RE then true
+          when BOOLEANIZE_AS_FALSE_RE then false
+          else fail(KeyError, "`#{content}' not recognized as boolean")
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/string.rb

@@ -23,7 +23,7 @@ class String
     gsub(/[#{AIXM::MIN}]{2}|[#{AIXM::SEC}]/, '"').   # unify quotes
       gsub(/[#{AIXM::MIN}]/, "'").   # unify apostrophes
       gsub(/"[[:blank:]]*(.*?)[[:blank:]]*"/m, '"\1"').   # remove whitespace within quotes
-      split(/\r?\n/).map { |s| s.strip.blank_to_nil }.compact.join("\n")   # remove blank lines
+      split(/\r?\n/).map { _1.strip.blank_to_nil }.compact.join("\n")   # remove blank lines
   end
 
   # Strip and collapse unnecessary whitespace
@@ -32,64 +32,53 @@ class String
   #   are preserved and not collapsed into one space.
   #
   # @example
-  #   "  foo\n\nbar \r".copact   # => "foo\nbar"
+  #   "  foo\n\nbar \r".compact   # => "foo\nbar"
   #
   # @return [String] compacted string
   def compact
-    split("\n").map { |s| s.squish.blank_to_nil }.compact.join("\n")
+    split("\n").map { _1.squish.blank_to_nil }.compact.join("\n")
   end
 
-  # Calculate the correlation of two strings by counting mutual words
-  #
-  # Both strings are normalized as follows:
-  # * remove accents, umlauts etc
-  # * remove everything but members of the +\w+ class
-  # * downcase
-  #
-  # The normalized strings are split into words. Only words fulfilling either
-  # of the following conditions are taken into consideration:
-  # * words present in and translated by the +synonyms+ map
-  # * words of at least 5 characters length
-  # * words consisting of exactly one letter followed by any number of digits
-  #   (an optional whitespace between the two is ignored, e.g. "D 25" is the
-  #   same as "D25")
-  #
-  # The +synonyms+ map is an array where terms in even positions map to their
-  # synonym in the following (odd) position:
-  #
-  #   SYNONYMS = ['term1', 'synonym1', 'term2', 'synonym2']
+  # Similar to +strip+, but remove any leading or trailing non-letters/numbers
+  # which includes whitespace
+  def full_strip
+    remove(/\A[^\p{L}\p{N}]*|[^\p{L}\p{N}]*\z/)
+  end
+
+  # Similar to +scan+, but remove matches from the string
+  def extract(pattern)
+    scan(pattern).tap { remove! pattern }
+  end
+
+  # Apply the patterns in the given order and return...
+  # * first capture group - if a pattern matches and contains a capture group
+  # * entire match - if a pattern matches and contains no capture group
+  # * +default+ - if no pattern matches and a +default+ is set
+  # * +nil+ - if no pattern matches and no +default+ is set
   #
   # @example
-  #   subject = "Truck en route on N 3 sud"
-  #   subject.correlate("my car is on D25")          # => 0
-  #   subject.correlate("my truck is on D25")        # => 1
-  #   subject.correlate("my truck is on N3")         # => 2
-  #   subject.correlate("south", ['sud', 'south'])   # => 1
-  #
-  # @param other [String] string to compare with
-  # @param synonyms [Array<String>] array of synonym pairs
-  # @return [Integer] 0 for unrelated strings and positive integers for related
-  #   strings with higher numbers indicating tighter correlation
-  def correlate(other, synonyms=[])
-    self_words, other_words = [self, other].map do |string|
-      string.
-        unicode_normalize(:nfd).
-        downcase.gsub(/[-\u2013]/, ' ').
-        remove(/[^\w\s]/).
-        gsub(/\b(\w)\s?(\d+)\b/, '\1\2').
-        compact.
-        split(/\W+/).
-        map { |w| (i = synonyms.index(w)).nil? ? w : (i.odd? ? w : synonyms[i + 1]).upcase }.
-        keep_if { |w| w.match?(/\w{5,}|\w\d+|[[:upper:]]/) }.
-        uniq
+  #   "A/A: 123.5 mhz".first_match(/123\.5/)                   # => "123.5"
+  #   "A/A: 123.5 mhz".first_match(/:\s+([\d.]+)/)             # => "123.5"
+  #   "A/A: 123.5 mhz".first_match(/121\.5/)                   # nil
+  #   "A/A: 123.5 mhz".first_match(/(121\.5)/)                 # nil
+  #   "A/A: 123.5 mhz".first_match(/121\.5/, default: "123")   # "123"
+  #
+  # @param patterns [Array<Regexp>] one or more patterns to apply in order
+  # @param default [String] string to return instead of +nil+ if the pattern
+  #   doesn't match
+  # @return [String, nil]
+  def first_match(*patterns, default: nil)
+    patterns.each do |pattern|
+      if captures = match(pattern)
+        return captures[1] || captures[0]
+      end
     end
-    (self_words & other_words).count
+    default
   end
 
-  # Similar to +strip+, but remove any leading or trailing non-letters/numbers
-  # which includes whitespace
-  def full_strip
-    remove(/\A[^\p{L}\p{N}]*|[^\p{L}\p{N}]*\z/)
+  # Remove all XML/HTML tags and entities from the string
+  def strip_markup
+    self.gsub(/<.*?>|&[#\da-z]+;/i, '')
   end
 
   # Same as +to_f+ but accept both dot and comma as decimal separator
@@ -104,21 +93,4 @@ class String
     sub(/,/, '.').to_f
   end
 
-  # Add spaces between obviously glued words:
-  # * camel glued words
-  # * three-or-more-letter and number-only words
-  #
-  # @example
-  #   "thisString has spaceProblems".unglue   # => "this String has space problems"
-  #   "the first123meters of D25".unglue      # => "the first 123 meters of D25"
-  #
-  # @return [String] unglued string
-  def unglue
-    self.dup.tap do |string|
-      [/([[:lower:]])([[:upper:]])/, /([[:alpha:]]{3,})(\d)/, /(\d)([[:alpha:]]{3,})/].freeze.each do |regexp|
-        string.gsub!(regexp, '\1 \2')
-      end
-    end
-  end
-
 end

data.tar.gz.sig

@@ -0,0 +1,2 @@
+h�ƅ:�/n�!�Ud�����.u��<-���"譈!�����Z<��V�����Z�{ �����c��M$���J�Z.	�n��C�5[��f��XR̘�H@y9d�!�
+\�ۃ�{W!`��m���nC��uk2���qOܱsAy��l;��U�?y�!�4�=;v��4�[���]P�j]s*ݷ!�g�:�\ӬD��8�,�*,^��zA�4��,1�:�x�)��š�!z�t���?W$��1�k