aipp 0.2.6 → 1.0.0

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

@@ -0,0 +1,153 @@
+module AIPP
+  module LF
+
+    class Obstacles < AIP
+
+      include AIPP::LF::Helpers::Base
+
+      # Map type descriptions to AIXM types and remarks
+      TYPES = {
+        'Antenne' => [:antenna],
+        'Autre' => [:other],
+        'Bâtiment' => [:building],
+        'Câble' => [:other, 'Cable / Câble'],
+        'Centrale thermique' => [:building, 'Thermal power plant / Centrale thermique'],
+        "Château d'eau" => [:tower, "Water tower / Château d'eau"],
+        'Cheminée' => [:chimney],
+        'Derrick' => [:tower, 'Derrick'],
+        'Eglise' => [:tower, 'Church / Eglise'],
+        'Eolienne' => [:wind_turbine],
+        'Eolienne(s)' => [:wind_turbine],
+        'Grue' => [:tower, 'Crane / Grue'],
+        'Mât' => [:mast],
+        'Phare marin' => [:tower, 'Lighthouse / Phare marin'],
+        'Pile de pont' => [:other, 'Bridge piers / Pile de pont'],
+        'Portique' => [:building, 'Arch / Portique'],
+        'Pylône' => [:mast, 'Pylon / Pylône'],
+        'Silo' => [:tower, 'Silo'],
+        'Terril' => [:other, 'Spoil heap / Teril'],
+        'Torchère' => [:chimney, 'Flare / Torchère'],
+        'Tour' => [:tower],
+        'Treillis métallique' => [:other, 'Metallic grid / Treillis métallique']
+      }.freeze
+
+      def parse
+        if options[:region_options].include? 'lf_obstacles_xlsx'
+          info("reading obstacles from XLSX")
+          @xlsx = read('Obstacles')
+          parse_from_xlsx
+        else
+          parse_from_xml
+        end
+      end
+
+      private
+
+      def parse_from_xlsx
+        # Build obstacles
+        @xlsx.sheet(@xlsx.sheets.find(/^data/i).first).each(
+          name: 'IDENTIFICATEUR',
+          type: 'TYPE',
+          count: 'NOMBRE',
+          longitude: 'LONGITUDE DECIMALE',
+          latitude: 'LATITUDE DECIMALE',
+          elevation: 'ALTITUDE AU SOMMET',
+          height: 'HAUTEUR HORS SOL',
+          height_unit: 'UNITE',
+          horizontal_accuracy: 'PRECISION HORIZONTALE',
+          vertical_accuracy: 'PRECISION VERTICALE',
+          visibility: 'BALISAGE',
+          remarks: 'REMARK',
+          effective_on: 'DATE DE MISE EN VIGUEUR'
+        ).with_index(0) do |row, index|
+          next unless row[:effective_on].to_s.match? /\d{8}/
+          type, type_remarks = TYPES.fetch(row[:type])
+          count = row[:count].to_i
+          obstacle = AIXM.obstacle(
+            source: source(section: 'ENR', position: index),
+            name: row[:name],
+            type: type,
+            xy: AIXM.xy(lat: row[:latitude].to_f, long: row[:longitude].to_f),
+            z: AIXM.z(row[:elevation].to_i, :qnh)
+          ).tap do |obstacle|
+            obstacle.height = AIXM.d(row[:height].to_i, row[:height_unit])
+            if row[:horizontal_accuracy]
+              accuracy = row[:horizontal_accuracy].split
+              obstacle.xy_accuracy = AIXM.d(accuracy.first.to_i, accuracy.last)
+            end
+            if row[:vertical_accuracy]
+              accuracy = row[:horizontal_accuracy].split
+              obstacle.z_accuracy = AIXM.d(accuracy.first.to_i, accuracy.last)
+            end
+            obstacle.marking = row[:visibility].match?(/jour/i)
+            obstacle.lighting = row[:visibility].match?(/nuit/i)
+            obstacle.remarks = {
+              'type' => type_remarks,
+              'number/nombre' => (count if count > 1),
+              'details' => row[:remarks],
+              'effective/mise en vigueur' => (row[:effective_on].to_s.unpack("a4a2a2").join("-") if row[:updated_on])
+            }.to_remarks
+            # Group obstacles
+            if aixm.features.find_by(:obstacle, xy: obstacle.xy).any?
+              warn("duplicate obstacle #{obstacle.name}", severe: false)
+            else
+              if count > 1
+                obstacle_group = AIXM.obstacle_group(
+                  source: obstacle.source,
+                  name: obstacle.name
+                ).tap do |obstacle_group|
+                  obstacle_group.remarks = "#{count} obstacles"
+                end
+                obstacle_group.add_obstacle obstacle
+                add obstacle_group
+              else
+                add obstacle
+              end
+            end
+          end
+        end
+      end
+
+      def parse_from_xml
+        cache.obstacle.css(%Q(Obstacle[lk^="[LF]"])).each do |node|
+          # Build obstacles
+          type, type_remarks = TYPES.fetch(node.(:TypeObst))
+          count = node.(:Combien).to_i
+          obstacle = AIXM.obstacle(
+            source: source(section: 'ENR', position: node.line),
+            name: node.(:NumeroNom),
+            type: type,
+            xy: xy_from(node.(:Geometrie)),
+            z: AIXM.z(node.(:AmslFt).to_i, :qnh)
+          ).tap do |obstacle|
+            obstacle.height = AIXM.d(node.(:AglFt).to_i, :ft)
+            obstacle.marking = node.(:Balisage).match?(/jour/i)
+            obstacle.lighting = node.(:Balisage).match?(/nuit/i)
+            obstacle.remarks = {
+              'type' => type_remarks,
+              'number/nombre' => (count if count > 1)
+            }.to_remarks
+          end
+          # Group obstacles
+          if aixm.features.find_by(:obstacle, xy: obstacle.xy).any?
+            warn("duplicate obstacle #{obstacle.name}", severe: false)
+          else
+            if count > 1
+              obstacle_group = AIXM.obstacle_group(
+                source: obstacle.source,
+                name: obstacle.name
+              ).tap do |obstacle_group|
+                obstacle_group.remarks = "#{count} obstacles"
+              end
+              obstacle_group.add_obstacle obstacle
+              add obstacle_group
+            else
+              add obstacle
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

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,8 +18,8 @@ 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)
@@ -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 { subhash_for(_1, 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.6".freeze
+  VERSION = "1.0.0".freeze
 end

data/lib/aipp.rb

@@ -1,40 +1,42 @@
+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'

data/lib/core_ext/enumerable.rb

@@ -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

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