aipp 0.2.4 → 1.0.0

data/lib/aipp/executable.rb

@@ -2,26 +2,40 @@ module AIPP
 
   # Executable instantiated by the console tools
   class Executable
+    include AIPP::Debugger
+
     attr_reader :options
 
     def initialize(**options)
-      @options = options
-      @options[:airac] = AIPP::AIRAC.new
-      @options[:storage] = Pathname(Dir.home).join('.aipp')
-      @options[:force] = $VERBOSE_INFO = $PRY_ON_WARN = $PRY_ON_ERROR = false
+      @options = options.merge(
+        airac: AIRAC::Cycle.new,
+        region_options: [],
+        storage: Pathname(Dir.home).join('.aipp'),
+        force: false,
+        mid: false,
+        verbose: false,
+        debug_on_warning: false,
+        debug_on_error: false
+      )
       OptionParser.new do |o|
         o.banner = <<~END
           Download online AIP and convert it to #{options[:schema].upcase}.
           Usage: #{File.basename($0)} [options]
         END
-        o.on('-d', '--airac DATE', String, %Q[AIRAC date (default: "#{@options[:airac].date.xmlschema}")]) { |v| @options[:airac] = AIPP::AIRAC.new(v) }
-        o.on('-r', '--region STRING', String, 'region (e.g. "LF")') { |v| @options[:region] = v.upcase }
-        o.on('-a', '--aip STRING', String, 'process this AIP only (e.g. "ENR-5.1")') { |v| @options[:aip] = v.upcase }
-        o.on('-s', '--storage DIR', String, 'storage directory (default: "~/.aipp")') { |v| @options[:storage] = Pathname(v) }
-        o.on('-f', '--[no-]force', 'ignore XML schema validation (default: false)') { |v| @options[:force] = v }
-        o.on('-v', '--[no-]verbose', 'verbose output (default: false)') { |v| $VERBOSE_INFO = v }
-        o.on('-w', '--pry-on-warn [ID]', Integer, 'open pry on warn with ID (default: nil)') { |v| $PRY_ON_WARN = v || true }
-        o.on('-e', '--[no-]pry-on-error', 'open pry on error (default: false)') { |v| $PRY_ON_ERROR = v }
+        o.on('-d', '--airac (DATE|INTEGER)', String, %Q[AIRAC date or delta e.g. "+1" (default: "#{@options[:airac].date.xmlschema}")]) { @options[:airac] = airac_for(_1) }
+        o.on('-r', '--region STRING', String, 'region (e.g. "LF")') { @options[:region] = _1.upcase }
+        o.on('-a', '--aip STRING', String, 'process this AIP only (e.g. "ENR-5.1")') { @options[:aip] = _1 }
+        if options[:schema] == :ofmx
+          o.on('-g', '--[no-]grouped-obstacles', 'group obstacles (default: false)') { @options[:grouped_obstacles] = _1 }
+          o.on('-m', '--[no-]mid', 'insert mid attributes into all Uid elements (default: false)') { @options[:mid] = _1 }
+        end
+        o.on('-o', '--region-options STRING', String, %Q[comma separated region specific options]) { @options[:region_options] = _1.split(',') }
+        o.on('-s', '--storage DIR', String, 'storage directory (default: "~/.aipp")') { @options[:storage] = Pathname(_1) }
+        o.on('-h', '--[no-]check-links', 'check all links with HEAD requests') { @options[:check_links] = _1 }
+        o.on('-f', '--[no-]force', 'ignore XML schema validation (default: false)') { @options[:force] = _1 }
+        o.on('-v', '--[no-]verbose', 'verbose output including unsevere warnings (default: false)') { @options[:verbose] = _1 }
+        o.on('-w', '--debug-on-warning [ID]', Integer, 'open debug session on warning with ID (default: false)') { @options[:debug_on_warning] = _1 || true }
+        o.on('-e', '--[no-]debug-on-error', 'open debug session on error (default: false)') { @options[:debug_on_error] = _1 }
         o.on('-A', '--about', 'show author/license information and exit') { about }
         o.on('-R', '--readme', 'show README and exit') { readme }
         o.on('-L', '--list', 'list implemented regions and AIPs') { list }
@@ -29,28 +43,33 @@ module AIPP
       end.parse!
     end
 
-    # Load necessary files and execute the parser.
-    #
-    # @raise [RuntimeError] if the region does not exist
     def run
-      Pry.rescue do
-        fail(OptionParser::MissingArgument, :region) unless options[:region]
+      with_debugger(**options.slice(:verbose, :debug_on_warning, :debug_on_error)) do
+        starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         AIPP::Parser.new(options: options).tap do |parser|
           parser.read_config
           parser.read_region
           parser.parse_aip
           parser.validate_aixm
+          parser.write_build
           parser.write_aixm
           parser.write_config
         end
-      rescue => error
-        puts "ERROR: #{error.message}"
-        Pry::rescued(error) if $PRY_ON_ERROR
+        ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        info("finished after %s" % Time.at(ending - starting).utc.strftime("%H:%M:%S"))
       end
     end
 
     private
 
+    def airac_for(argument)
+      if argument.match?(/^[+-]\d+$/)   # delta
+        AIRAC::Cycle.new + argument.to_i
+      else   # date
+        AIRAC::Cycle.new(argument)
+      end
+    end
+
     def about
       puts 'Written by Sven Schwyn (bitcetera.com) and distributed under MIT license.'
       exit
@@ -66,7 +85,7 @@ module AIPP
       regions_path = Pathname($0).dirname.join('..', 'gems', "aipp-#{AIPP::VERSION}", 'lib', 'aipp', 'regions')
       hash = Dir.each_child(regions_path).each.with_object({}) do |region, hash|
         hash[region] = Dir.children(regions_path.join(region)).sort.map do |aip|
-          File.basename(aip, '.rb') unless aip == 'helper.rb'
+          File.basename(aip, '.rb') if File.file?(regions_path.join(region, aip))
         end.compact
       end
       puts hash.to_yaml.sub(/\A\W*/, '')
@@ -77,6 +96,6 @@ module AIPP
       puts AIPP::VERSION
       exit
     end
-  end
 
+  end
 end

data/lib/aipp/parser.rb

@@ -2,6 +2,9 @@ module AIPP
 
   # AIP parser infrastructure
   class Parser
+    extend Forwardable
+    include AIPP::Debugger
+    using AIXM::Refinements
 
     # @return [Hash] passed command line arguments
     attr_reader :options
@@ -24,62 +27,68 @@ module AIPP
     def initialize(options:)
       @options = options
       @options[:storage] = options[:storage].join(options[:region])
-      @options[:storage].mkpath unless @options[:storage].exist?
+      @options[:storage].mkpath
       @config = {}
-      @aixm = AIXM.document(region: @options[:region], effective_at: @options[:airac].date)
+      @aixm = AIXM.document(effective_at: @options[:airac].date)
       @dependencies = THash.new
       @fixtures = {}
       @borders = {}
       @cache = OpenStruct.new
       AIXM.send("#{options[:schema]}!")
+      AIXM.config.region = options[:region]
+    end
+
+    # @return [String]
+    def inspect
+      "#<AIPP::Parser>"
     end
 
     # Read the configuration from config.yml.
     def read_config
-      info("Reading config.yml")
-      @config = YAML.load_file(config_file, fallback: {}).transform_keys(&:to_sym) if config_file.exist?
+      info("reading config.yml")
+      @config = YAML.load_file(config_file, symbolize_names: true, fallback: {}) if config_file.exist?
       @config[:namespace] ||= SecureRandom.uuid
       @aixm.namespace = @config[:namespace]
     end
 
     # Read the region directory and build the dependency list.
     def read_region
-      info("Reading region #{options[:region]}")
+      info("reading region #{options[:region]}")
       dir = Pathname(__FILE__).dirname.join('regions', options[:region])
       fail("unknown region `#{options[:region]}'") unless dir.exist?
       # Fixtures
       dir.glob('fixtures/*.yml').each do |file|
-        verbose_info "Reading fixture fixtures/#{file.basename}"
+        verbose_info "reading fixture fixtures/#{file.basename}"
         fixture = YAML.load_file(file)
         @fixtures[file.basename('.yml').to_s] = fixture
       end
       # Borders
       dir.glob('borders/*.geojson').each do |file|
-        verbose_info "Reading border borders/#{file.basename}"
-        border = AIPP::Border.new(file)
-        @borders[border.name] = border
+        verbose_info "reading border borders/#{file.basename}"
+        border = AIPP::Border.from_file(file)
+        @borders[file.basename] = border
       end
       # Helpers
       dir.glob('helpers/*.rb').each do |file|
-        verbose_info "Reading helper helpers/#{file.basename}"
+        verbose_info "reading helper helpers/#{file.basename}"
         require file
       end
       # Parsers
       dir.glob('*.rb').each do |file|
-        verbose_info "Requiring #{file.basename}"
+        verbose_info "requiring #{file.basename}"
         require file
         aip = file.basename('.*').to_s
-        @dependencies[aip] = ("AIPP::%s::%s::DEPENDS" % [options[:region], aip.remove(/\W/).classify]).constantize
+        @dependencies[aip] = ("AIPP::%s::%s::DEPENDS" % [options[:region], aip.remove(/\W/).camelcase]).constantize
       end
     end
 
     # Parse AIP by invoking the parser classes for the current region.
     def parse_aip
       info("AIRAC #{options[:airac].id} effective #{options[:airac].date}", color: :green)
-      AIPP::Downloader.new(storage: options[:storage], archive: options[:airac].date.xmlschema) do |downloader|
+      AIPP::Downloader.new(storage: options[:storage], source: options[:airac].date.xmlschema) do |downloader|
         @dependencies.tsort(options[:aip]).each do |aip|
-          info("Parsing #{aip}")
-          ("AIPP::%s::%s" % [options[:region], aip.remove(/\W/).classify]).constantize.new(
+          info("parsing #{aip}")
+          ("AIPP::%s::%s" % [options[:region], aip.remove(/\W/).camelcase]).constantize.new(
             aip: aip,
             downloader: downloader,
             fixture: @fixtures[aip],
@@ -87,34 +96,98 @@ module AIPP
           ).attach_patches.tap(&:parse).detach_patches
         end
       end
+      if options[:grouped_obstacles]
+        info("grouping obstacles")
+        aixm.group_obstacles!
+      end
+      info("counting #{aixm.features.count} features")
     end
 
     # Validate the AIXM document.
     #
     # @raise [RuntimeError] if the document is not valid
     def validate_aixm
-      info("Validating #{options[:schema].upcase}")
+      info("detecting duplicates")
+      if (duplicates = aixm.features.duplicates).any?
+        message = "duplicates found:\n" + duplicates.map { "#{_1.inspect} from #{_1.source}" }.join("\n")
+        @options[:force] ? warn(message) : fail(message)
+      end
+      info("validating #{options[:schema].upcase}")
       unless aixm.valid?
         message = "invalid #{options[:schema].upcase} document:\n" + aixm.errors.map(&:message).join("\n")
-        @options[:force] ? warn(message, pry: binding) : fail(message)
+        @options[:force] ? warn(message) : fail(message)
+      end
+    end
+
+    # Write the AIXM document and context information.
+    def write_build
+      if @options[:aip]
+        info ("skipping build")
+      else
+        info("writing build")
+        builds_path.mkpath
+        build_file = builds_path.join("#{@options[:airac].date.xmlschema}.zip")
+        Dir.mktmpdir do |tmp_dir|
+          tmp_dir = Pathname(tmp_dir)
+          # AIXM/OFMX file
+          AIXM.config.mid = true
+          File.write(tmp_dir.join(aixm_file), aixm.to_xml)
+          # Build details
+          File.write(
+            tmp_dir.join('build.yaml'), {
+              version: AIPP::VERSION,
+              config: @config,
+              options: @options
+            }.to_yaml
+          )
+          # Manifest
+          manifest = ['AIP','Feature', 'Comment', 'Short Uid Hash', 'Short Feature Hash'].to_csv
+          manifest += aixm.features.map do |feature|
+            xml = feature.to_xml
+            element = xml.first_match(/<(\w{3})\s/)
+            [
+              feature.source.split('|')[2],
+              element,
+              xml.match(/<!-- (.*?) -->/)[1],
+              AIXM::PayloadHash.new(xml.match(%r(<#{element}Uid\s.*?</#{element}Uid>)m).to_s).to_uuid[0,8],
+              AIXM::PayloadHash.new(xml).to_uuid[0,8]
+            ].to_csv
+          end.sort.join
+          File.write(tmp_dir.join('manifest.csv'), manifest)
+          # Zip it
+          build_file.delete if build_file.exist?
+          Zip::File.open(build_file, Zip::File::CREATE) do |zip|
+            tmp_dir.children.each do |entry|
+              zip.add(entry.basename.to_s, entry) unless entry.basename.to_s[0] == '.'
+            end
+          end
+        end
       end
     end
 
     # Write the AIXM document.
     def write_aixm
-      file = "#{options[:region]}_#{options[:airac].date.xmlschema}.#{options[:schema]}"
-      info("Writing #{file}")
-      File.write(file, aixm.to_xml)
+      info("writing #{aixm_file}")
+      AIXM.config.mid = options[:mid]
+      File.write(aixm_file, aixm.to_xml)
     end
 
     # Write the configuration to config.yml.
     def write_config
-      info("Writing config.yml")
+      info("writing config.yml")
       File.write(config_file, config.to_yaml)
     end
 
     private
 
+    def aixm_file
+      "#{options[:region]}_#{options[:airac].date.xmlschema}.#{options[:schema]}"
+    end
+
+    def builds_path
+      options[:storage].join('builds')
+    end
+
     def config_file
       options[:storage].join('config.yml')
     end

data/lib/aipp/patcher.rb

@@ -18,14 +18,16 @@ module AIPP
 
     def attach_patches
       parser = self
+      verbose_info_method = method(:verbose_info)
       self.class.patches[self.class]&.each do |(klass, attribute, block)|
         klass.instance_eval do
           alias_method :"original_#{attribute}=", :"#{attribute}="
           define_method(:"#{attribute}=") do |value|
-            catch :abort do
+            error = catch :abort do
               value = block.call(parser, self, value)
-              verbose_info("PATCH: #{self.inspect}", color: :magenta)
+              verbose_info_method.call("Patching #{self.inspect} with #{attribute}=#{value.inspect}", color: :magenta)
             end
+            fail "patching #{self.inspect} with #{attribute}=#{value.inspect} failed: #{error}" if error
             send(:"original_#{attribute}=", value)
           end
         end
@@ -36,6 +38,7 @@ module AIPP
     def detach_patches
       self.class.patches[self.class]&.each do |(klass, attribute, _)|
         klass.instance_eval do
+          remove_method :"#{attribute}="
           alias_method :"#{attribute}=", :"original_#{attribute}="
           remove_method :"original_#{attribute}="
         end

data/lib/aipp/pdf.rb

@@ -117,7 +117,7 @@ module AIPP
     end
 
     def page_for(index:)
-      @page_ranges.index(@page_ranges.bsearch { |i| i >= index }) + 1
+      @page_ranges.index(@page_ranges.bsearch { _1 >= index }) + 1
     end
   end
 end

data/lib/aipp/regions/LF/README.md

@@ -0,0 +1,49 @@
+# AIP LF – Mainland France
+
+## Prerequisites
+
+This parser requires the XML data dump from SIA. It is available free of charge, but has to be ordered before it can be downloaded. It's therefore necessary to perform the following steps before running the parser for any given AIRAC for the first time:
+
+1. Browse to the [SIA web shop](https://www.sia.aviation-civile.gouv.fr/produits-numeriques-en-libre-disposition/les-bases-de-donnees-sia.html).
+2. Shop the desired dump named «données aéronautiques XML AIRAC ii/yy».
+3. Browse to [your customer page](https://www.sia.aviation-civile.gouv.fr/customer/account/#orders-and-proposals).
+4. In section «mes produits téléchargeables» download the desired dump.
+5. Unzip the downloaded ZIP archive.
+6. Move the file «XML_SIA_yyyy-mm-dd.xml» to the directory in which you will execute the parser.
+
+⚠️ The SIA web shop misbehaves with some browsers, you should try Brave or Chrome.
+
+## Region Options
+
+### Obstacles XLSX
+
+While the XML data dump contains all obstacles, some details of the source XLSX file are omitted. Unfortunately, the latter is only available for the current AIRAC cycle, therefore the XML data dump is used by default. Add `-o lf_obstacles_xlsx` to use the source XLSX file instead.
+
+## Charset
+
+The XML data dump from SIA is ISO-8859-1 encoded. Nokogiri which parses the XML converts this to UTF-8 on the fly, however, when grepping the dump on a shell, you might run into trouble:
+
+```shell
+grep "<Revetement>" XML_SIA_2021-12-02.xml | sort | uniq
+
+sort: Illegal byte sequence
+```
+
+For this to work, you have to convert the dump to UTF-8 and use this converted dump for grepping:
+
+```shell
+iconv -f ISO-8859-1 -t UTF-8 XML_SIA_2021-12-02.xml >XML_SIA_2021-12-02_UTF.xml
+grep "<Revetement>" XML_SIA_2021-12-02_UTF.xml | sort | uniq
+
+<Revetement>Aluminium</Revetement>
+<Revetement>Asphalte</Revetement>
+<Revetement>Béton ( 4t )</Revetement>
+(...)
+```
+
+## References
+
+* [SIA – AIP publisher](https://www.sia.aviation-civile.gouv.fr)
+* [SIA XML usage guide](https://www.sia.aviation-civile.gouv.fr/faqs)
+* [OpenData – public data files](https://www.data.gouv.fr)
+* [Protected Planet – protected area data files](https://www.protectedplanet.net)

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

@@ -0,0 +1,223 @@
+module AIPP
+  module LF
+
+    class Aerodromes < AIP
+
+      include AIPP::LF::Helpers::Base
+      include AIPP::LF::Helpers::UsageLimitation
+      include AIPP::LF::Helpers::Surface
+
+      APPROACH_LIGHTING_TYPES = {
+        'CAT I' => :cat_1,
+        'CAT II' => :cat_2,
+        'CAT III' => :cat_3,
+        'CAT II-III' => :cat_2_and_3
+      }.freeze
+
+      LIGHTING_POSITIONS = {
+        threshold: 'Thr',
+        touch_down_zone: 'Tdz',
+        center_line: 'Axe',
+        edge: 'Bord',
+        runway_end: 'Fin',
+        stopway_center_line: 'Swy'
+      }.freeze
+
+      LIGHTING_COLORS = {
+        'W' => :white,
+        'R' => :red,
+        'G' => :green,
+        'B' => :blue,
+        'Y' => :yellow
+      }.freeze
+
+      ICAO_LIGHTING_COLORS = {
+        center_line: :white,
+        edge: :white
+      }.freeze
+
+      def parse
+        cache.ad.css(%Q(Ad[lk^="[LF]"])).each do |ad_node|
+          # Build airport
+          next unless limitation_type = LIMITATION_TYPES.fetch(ad_node.(:AdStatut))
+          airport = AIXM.airport(
+            source: source(section: 'AD', position: ad_node.line),
+            organisation: organisation_lf,
+            id: id_from(ad_node.(:AdCode)),
+            name: ad_node.(:AdNomComplet),
+            xy: xy_from(ad_node.(:Geometrie))
+          ).tap do |airport|
+            airport.meta = ad_node.attr('pk')
+            airport.z = given(ad_node.(:AdRefAltFt)) { AIXM.z(_1.to_i, :qnh) }
+            airport.declination = ad_node.(:AdMagVar)&.to_f
+            airport.add_usage_limitation(type: limitation_type.fetch(:limitation)) do |limitation|
+              limitation.remarks = limitation_type[:remarks]
+              [
+                (:scheduled if ad_node.(:TfcRegulier?)),
+                (:not_scheduled if ad_node.(:TfcNonRegulier?)),
+                (:private if ad_node.(:TfcPrive?)),
+                (:other unless ad_node.(:TfcRegulier?) || ad_node.(:TfcNonRegulier?) || ad_node.(:TfcPrive?))
+              ].compact.each do |purpose|
+                limitation.add_condition do |condition|
+                  condition.realm = limitation_type.fetch(:realm)
+                  condition.origin = case
+                    when ad_node.(:TfcIntl?) && ad_node.(:TfcNtl?) then :any
+                    when ad_node.(:TfcIntl?) then :international
+                    when ad_node.(:TfcNtl?) then :national
+                    else :other
+                  end
+                  condition.rule = case
+                    when ad_node.(:TfcIfr?) && ad_node.(:TfcVfr?) then :ifr_and_vfr
+                    when ad_node.(:TfcIfr?) then :ifr
+                    when ad_node.(:TfcVfr?) then :vfr
+                    else
+                      warn("falling back to VFR rule for `#{airport.id}'", severe: false)
+                      :vfr
+                  end
+                  condition.purpose = purpose
+                end
+              end
+            end
+# TODO: link to VAC once supported downstream
+#           # Link to VAC
+#           airport.remarks = [
+#             airport.remarks.to_s,
+#             link_to('VAC-AD', url_for("VAC-#{airport.id}"))
+#           ].join("\n")
+            cache.rwy.css(%Q(Rwy:has(Ad[pk="#{ad_node.attr(:pk)}"]))).each do |rwy_node|
+              add_runway_to(airport, rwy_node)
+            end
+          end
+          add airport
+        end
+      end
+
+      private
+
+      def id_from(content)
+        case content
+          when /^\d{2}$/ then 'LF00' + content   # private aerodromes without official ID
+          else 'LF' + content
+        end
+      end
+
+      def add_runway_to(airport, rwy_node)
+        AIXM.runway(
+          name: rwy_node.(:Rwy)
+        ).tap do |runway|
+          rwylgt_nodes = cache.rwylgt.css(%Q(RwyLgt:has(Rwy[pk="#{rwy_node.attr(:pk)}"])))
+          airport.add_runway(runway)
+          runway.dimensions = AIXM.r(AIXM.d(rwy_node.(:Longueur)&.to_i, :m), AIXM.d(rwy_node.(:Largeur)&.to_i, :m))
+          runway.surface = surface_from(rwy_node)
+          runway.forth.geographic_bearing = given(rwy_node.(:OrientationGeo)) { AIXM.a(_1.to_f) }
+          runway.forth.xy = given(rwy_node.(:LatThr1), rwy_node.(:LongThr1)) { AIXM.xy(lat: _1.to_f, long: _2.to_f) }
+          runway.forth.displaced_threshold = given(rwy_node.(:LatDThr1), rwy_node.(:LongDThr1)) { AIXM.xy(lat: _1.to_f, long: _2.to_f) }
+          runway.forth.z = given(rwy_node.(:AltFtDThr1)) { AIXM.z(_1.to_i, :qnh) }
+          runway.forth.z ||= given(rwy_node.(:AltFtThr1)) { AIXM.z(_1.to_i, :qnh) }
+          if rwylgt_node = rwylgt_nodes[0]
+            runway.forth.vasis = vasis_from(rwylgt_node)
+            given(approach_lighting_from(rwylgt_node)) { runway.forth.add_approach_lighting(_1) }
+            LIGHTING_POSITIONS.each_key do |position|
+              given(lighting_from(rwylgt_node, position)) { runway.forth.add_lighting(_1) }
+            end
+          end
+          if rwy_node.(:Rwy).match? '/'
+            runway.back.xy = given(rwy_node.(:LatThr2), rwy_node.(:LongThr2)) { AIXM.xy(lat: _1.to_f, long: _2.to_f) }
+            runway.back.displaced_threshold = given(rwy_node.(:LatDThr2), rwy_node.(:LongDThr2)) { AIXM.xy(lat: _1.to_f, long: _2.to_f) }
+            runway.back.z = given(rwy_node.(:AltFtDThr2)) { AIXM.z(_1.to_i, :qnh) }
+            runway.back.z ||= given(rwy_node.(:AltFtThr2)) { AIXM.z(_1.to_i, :qnh) }
+            if rwylgt_node = rwylgt_nodes[1]
+              runway.back.vasis = vasis_from(rwylgt_node)
+              given(approach_lighting_from(rwylgt_node)) { runway.back.add_approach_lighting(_1) }
+              LIGHTING_POSITIONS.each_key do |position|
+                given(lighting_from(rwylgt_node, position)) { runway.back.add_lighting(_1) }
+              end
+            end
+          end
+        end
+      end
+
+      def vasis_from(rwylgt_node)
+        if rwylgt_node.(:PapiVasis)
+          AIXM.vasis.tap do |vasis|
+            vasis.type = rwylgt_node.(:PapiVasis)
+            vasis.slope_angle = AIXM.a(rwylgt_node.(:PapiVasisPente).to_f)
+            vasis.meht = AIXM.z(rwylgt_node.(:MehtFt).to_i, :qfe)
+          end
+        end
+      end
+
+      def approach_lighting_from(rwylgt_node)
+        if rwylgt_node.(:LgtApchCat)
+          AIXM.approach_lighting(
+            type: APPROACH_LIGHTING_TYPES.fetch(rwylgt_node.(:LgtApchCat) , :other)
+          ).tap do |approach_lighting|
+            approach_lighting.length = AIXM.d(rwylgt_node.(:LgtApchLongueur).to_i, :m) if rwylgt_node.(:LgtApchLongueur)
+            approach_lighting.intensity = rwylgt_node.(:LgtApchIntensite)&.first_match(/LIH/, /LIM/, /LIL/, default: :other)
+            approach_lighting.remarks = {
+              'type' => (rwylgt_node.(:LgtApchCat) if approach_lighting.type == :other),
+              'intensité/intensity' => (rwylgt_node.(:LgtApchIntensite) if approach_lighting.intensity == :other)
+            }.to_remarks
+          end
+        end
+      end
+
+      def lighting_from(rwylgt_node, position)
+        prefix = "Lgt" + LIGHTING_POSITIONS.fetch(position)
+        if rwylgt_node.(:"#{prefix}Couleur") || rwylgt_node.(:"#{prefix}Longueur")
+          AIXM.lighting(position: position).tap do |lighting|
+            couleur, intensite = rwylgt_node.(:"#{prefix}Couleur"), rwylgt_node.(:"#{prefix}Intensite")
+            lighting.intensity = if intensite
+              intensite.first_match(/LIH/, /LIM/, /LIL/, default: :other)
+            elsif couleur
+              couleur.first_match(/LIH/, /LIM/, /LIL/).tap { couleur.remove!(/LIH|LIM|LIL/) }
+            end
+            lighting.color = if couleur
+              if couleur.match? /ICAO|EASA|OACI|AESA/
+                ICAO_LIGHTING_COLORS[position]
+              else
+                couleur.remove(/[^#{LIGHTING_COLORS.keys.join}]/).compact
+                LIGHTING_COLORS.fetch(couleur, :other)
+              end
+            end
+            lighting.description = {
+              'couleur/color' => (rwylgt_node.(:"#{prefix}Couleur") if [nil, :other].include?(lighting.color)),
+              'longueur/length' =>  rwylgt_node.(:"#{prefix}Longueur"),
+              'espace/spacing' => rwylgt_node.(:"#{prefix}Espace")
+            }.to_remarks
+            lighting.remarks = rwylgt_node.(:LgtRem)
+          end
+        end
+      end
+
+      patch AIXM::Feature::Airport, :xy do |parser, object, value|
+        throw(:abort) unless coordinate = parser.fixture.dig(object.id, 'xy')
+        lat, long = coordinate.split(/\s+/)
+        AIXM.xy(lat: lat, long: long)
+      end
+
+      patch AIXM::Feature::Airport, :z do |parser, object, value|
+        throw(:abort) unless value.nil?
+        throw(:abort, 'fixture missing') unless elevation = parser.fixture.dig(object.id, 'z')
+        AIXM.z(elevation, :qnh)
+      end
+
+      patch AIXM::Component::Runway, :dimensions do |parser, object, value|
+        throw(:abort) unless value.surface.zero?
+        throw(:abort, 'fixture missing') unless dimensions = parser.fixture.dig(object.airport.id, object.name, 'dimensions')
+        length, width = dimensions.split(/\D+/)
+        length = length&.match?(/^\d+$/) ? AIXM.d(length.to_i, :m) : value.length
+        width = width&.match?(/^\d+$/) ? AIXM.d(width.to_i, :m) : value.width
+        AIXM.r(length, width).tap { |r| throw(:abort, 'fixture incomplete') if r.surface.zero? }
+      end
+
+      patch AIXM::Component::Runway::Direction, :xy do |parser, object, value|
+        throw(:abort) unless value.nil?
+        throw(:abort, 'fixture missing') unless coordinate = parser.fixture.dig(object.runway.airport.id, object.name.to_s(:runway), 'xy')
+        lat, long = coordinate.split(/\s+/)
+        AIXM.xy(lat: lat, long: long)
+      end
+
+    end
+  end
+end