aipp 0.2.1 → 0.2.2

data/lib/aipp/regions/LF/AD-3.1.rb-NEW

@@ -0,0 +1,11 @@
+module AIPP
+  module LF
+
+    # Helipads
+    class AD31 < AIP
+
+      include AIPP::LF::Helpers::Common
+
+    end
+  end
+end

data/lib/aipp/regions/LF/ENR-2.1.rb

@@ -3,16 +3,17 @@ module AIPP
 
     # FIR, TMA etc
     class ENR21 < AIP
-      using AIPP::Refinements
 
-      # Map source types to type and local type
+      include AIPP::LF::Helpers::Common
+
+      # Map source types to type and optional local type
       SOURCE_TYPES = {
-        'FIR' => { type: 'FIR', local_type: nil },
-        'UIR' => { type: 'UIR', local_type: nil },
-        'UTA' => { type: 'UTA', local_type: nil },
-        'CTA' => { type: 'CTA', local_type: nil },
+        'FIR' => { type: 'FIR' },
+        'UIR' => { type: 'UIR' },
+        'UTA' => { type: 'UTA' },
+        'CTA' => { type: 'CTA' },
         'LTA' => { type: 'CTA', local_type: 'LTA' },
-        'TMA' => { type: 'TMA', local_type: nil },
+        'TMA' => { type: 'TMA' },
         'SIV' => { type: 'SECTOR', local_type: 'SIV' }   # providing FIS
       }.freeze
 
@@ -26,39 +27,39 @@ module AIPP
       }.freeze
 
       def parse
-        load_html.css('tbody').each do |tbody|
+        prepare(html: read).css('tbody').each do |tbody|
           airspace = nil
           tbody.css('tr').to_enum.with_index(1).each do |tr, index|
             if tr.attr(:id).match?(/--TXT_NAME/)
               aixm.features << airspace if airspace
-              airspace = airspace_from cleanup(node: tr).css(:td).first
-              info "Parsing #{airspace.type} #{airspace.name}" unless airspace.type == :terminal_control_area
+              airspace = airspace_from tr.css(:td).first
+              debug "Parsing #{airspace.type} #{airspace.name}" unless airspace.type == :terminal_control_area
               next
             end
             begin
-              tds = cleanup(node: tr).css('td')
+              tds = tr.css('td')
               if airspace.type == :terminal_control_area && tds[0].text.blank_to_nil
                 airspace = airspace_from tds[0]
-                info "Parsing #{airspace.type} #{airspace.name}"
+                debug "Parsing #{airspace.type} #{airspace.name}"
               end
               if airspace
                 if tds[0].text.blank_to_nil
-                  airspace.geometry = geometry_from tds[0]
+                  airspace.geometry = geometry_from tds[0].text
                   fail("geometry is not closed") unless airspace.geometry.closed?
                 end
-                layer = layer_from(tds[-3])
-                layer.class = class_from(tds[1]) if tds.count == 5
+                layer = layer_from(tds[-3].text)
+                layer.class = class_from(tds[1].text) if tds.count == 5
                 layer.location_indicator = LOCATION_INDICATORS.fetch("#{airspace.type} #{airspace.name}", nil)
                 # TODO: unit, call sign and frequency from tds[-2]
-                layer.timetable = timetable_from(tds[-1])
-                layer.remarks = remarks_from(tds[-1])
+                layer.timetable = timetable_from(tds[-1].text)
+                layer.remarks = remarks_from(tds[-1].text)
                 airspace.layers << layer
               end
             rescue => error
-              warn("error parsing #{airspace.type} `#{airspace.name}' at ##{index}: #{error.message}", context: error)
+              warn("error parsing #{airspace.type} `#{airspace.name}' at ##{index}: #{error.message}", pry: error)
             end
           end
-          aixm.features << airspace if airspace
+          write airspace if airspace
         end
       end
 
@@ -73,16 +74,16 @@ module AIPP
           type: SOURCE_TYPES.dig(source_type, :type),
           local_type: SOURCE_TYPES.dig(source_type, :local_type)
         ).tap do |airspace|
-          airspace.source = source_for(td)
+          airspace.source = source(position: td.line)
         end
       end
 
-      def class_from(td)
-        td.text.strip
+      def class_from(text)
+        text.strip
       end
 
-      def remarks_from(td)
-        td.text.strip.gsub(/(\s)\s+/, '\1').blank_to_nil
+      def remarks_from(text)
+        text.strip.gsub(/(\s)\s+/, '\1').blank_to_nil
       end
     end
   end

data/lib/aipp/regions/LF/ENR-4.1.rb

@@ -3,21 +3,22 @@ module AIPP
 
     # ENR Navaids
     class ENR41 < AIP
-      using AIPP::Refinements
+
+      include AIPP::LF::Helpers::Common
 
       def parse
-        load_html.css('tbody').each do |tbody|
+        prepare(html: read).css('tbody').each do |tbody|
           tbody.css('tr').to_enum.with_index(1).each do |tr, index|
-            tds = cleanup(node: tr).css('td')
+            tds = tr.css('td')
             master, slave = tds[1].text.strip.gsub(/[^\w-]/, '').downcase.split('-')
             navaid = AIXM.send(master, base_from(tds).merge(send("#{master}_from", tds)))
-            navaid.source = source_for(tr)
-            navaid.timetable = timetable_from(tds[4])
+            navaid.source = source(position: tr.line)
+            navaid.timetable = timetable_from(tds[4].text)
             navaid.remarks = remarks_from(tds[5], tds[7], tds[9])
-            navaid.send("associate_#{slave}", channel: channel_from(tds[3])) if slave
-            aixm.features << navaid
+            navaid.send("associate_#{slave}", channel: channel_from(tds[3].text)) if slave
+            write navaid
           rescue => error
-            warn("error parsing navigational aid at ##{index}: #{error.message}", context: error)
+            warn("error parsing navigational aid at ##{index}: #{error.message}", pry: error)
           end
         end
       end
@@ -29,55 +30,55 @@ module AIPP
           organisation: organisation_lf,
           id: tds[2].text.strip,
           name: tds[0].text.strip,
-          xy: xy_from(tds[5]),
-          z: z_from(tds[6])
+          xy: xy_from(tds[5].text),
+          z: z_from(tds[6].text)
         }
       end
 
       def vor_from(tds)
         {
           type: :conventional,
-          f: frequency_from(tds[3]),
+          f: f_from(tds[3].text),
           north: :magnetic,
         }
       end
 
       def dme_from(tds)
         {
-          channel: channel_from(tds[3])
+          channel: channel_from(tds[3].text)
         }
       end
 
       def ndb_from(tds)
         {
           type: :en_route,
-          f: frequency_from(tds[3])
+          f: f_from(tds[3].text)
         }
       end
 
       def tacan_from(tds)
         {
-          channel: channel_from(tds[3])
+          channel: channel_from(tds[3].text)
         }
       end
 
-      def z_from(td)
-        parts = td.text.strip.split(/\s+/)
+      def z_from(text)
+        parts = text.strip.split(/\s+/)
         AIXM.z(parts[0].to_i, :qnh) if parts[1] == 'ft'
       end
 
-      def frequency_from(td)
-        parts = td.text.strip.split(/\s+/)
+      def f_from(text)
+        parts = text.strip.split(/\s+/)
         AIXM.f(parts[0].to_f, parts[1]) if parts[1] =~ /hz$/i
       end
 
-      def channel_from(td)
-        parts = td.text.strip.split(/\s+/)
+      def channel_from(text)
+        parts = text.strip.split(/\s+/)
         parts.last if parts[-2].downcase == 'ch'
       end
 
-      def timetable_from(td)
-        code = td.text.strip
+      def timetable_from(text)
+        code = text.strip
         AIXM.timetable(code: code) unless code.empty?
       end
 
@@ -92,7 +93,7 @@ module AIPP
             else
               part.text.strip.blank_to_nil
             end
-            remarks << "#{part_titles[index]}:\n#{text}" if text
+            remarks << "**#{part_titles[index]}**\n#{text}" if text
           end
         end.join("\n\n").blank_to_nil
       end

data/lib/aipp/regions/LF/ENR-4.3.rb

@@ -4,19 +4,21 @@ module AIPP
     # Designated Points
     class ENR43 < AIP
 
+      include AIPP::LF::Helpers::Common
+
       def parse
-        load_html.css('tbody').each do |tbody|
+        prepare(html: read).css('tbody').each do |tbody|
           tbody.css('tr').to_enum.with_index(1).each do |tr, index|
-            tds = cleanup(node: tr).css('td')
+            tds = tr.css('td')
             designated_point = AIXM.designated_point(
               type: :icao,
               id: tds[0].text.strip,
-              xy: xy_from(tds[1])
+              xy: xy_from(tds[1].text)
             )
-            designated_point.source = source_for(tr)
-            aixm.features << designated_point
+            designated_point.source = source(position: tr.line)
+            write designated_point
           rescue => error
-            warn("error parsing designated point at ##{index}: #{error.message}", context: error)
+            warn("error parsing designated point at ##{index}: #{error.message}", pry: error)
           end
         end
       end

data/lib/aipp/regions/LF/ENR-5.1.rb

@@ -3,32 +3,40 @@ module AIPP
 
     # D/P/R Zones
     class ENR51 < AIP
-      using AIPP::Refinements
 
-      TYPES = {
-        'D' => 'D',
-        'P' => 'P',
-        'R' => 'R',
-        'ZIT' => 'P'
+      include AIPP::LF::Helpers::Common
+
+      # Map source types to type and optional local type
+      SOURCE_TYPES = {
+        'D' => { type: 'D' },
+        'P' => { type: 'P' },
+        'R' => { type: 'R' },
+        'ZIT' => { type: 'P', local_type: 'ZIT' }
       }.freeze
 
       def parse
-        load_html.css('tbody:has(tr[id^=mid])').each do |tbody|
+        prepare(html: read).css('tbody:has(tr[id^=mid])').each do |tbody|
           airspace = nil
           tbody.css('tr').to_enum.with_index(1).each do |tr, index|
-            if tr.attr(:class) =~ /keep-with-next-row/
-              airspace = airspace_from cleanup(node: tr)
-            else
+            tds = tr.css('td')
+            case
+            when tr.attr(:id).match?(/TXT_NAME/)   # airspace
+              airspace = airspace_from tr
+            when tds.count == 1   # big comment on separate row
+              airspace.layers.first.remarks.
+                concat("\n", tds.text.cleanup).
+                remove!(/\((\d)\)\s*\(\1\)\W*/)
+            else   # layer
               begin
-                tds = cleanup(node: tr).css('td')
-                airspace.geometry = geometry_from tds[0]
+                tds = tr.css('td')
+                airspace.geometry = geometry_from tds[0].text
                 fail("geometry is not closed") unless airspace.geometry.closed?
-                airspace.layers << layer_from(tds[1])
-                airspace.layers.first.timetable = timetable_from tds[2]
+                airspace.layers << layer_from(tds[1].text)
+                airspace.layers.first.timetable = timetable_from tds[2].text
                 airspace.layers.first.remarks = remarks_from(tds[2], tds[3], tds[4])
-                aixm.features << airspace
+                write airspace
               rescue => error
-                warn("error parsing airspace `#{airspace.name}' at ##{index}: #{error.message}", context: error)
+                warn("error parsing airspace `#{airspace.name}' at ##{index}: #{error.message}", pry: error)
               end
             end
           end
@@ -38,13 +46,15 @@ module AIPP
       private
 
       def airspace_from(tr)
-        spans = tr.css(:span)
+        spans = tr.css('span:not([class*=strong])')
+        source_type = spans[1].text.blank_to_nil
+        fail "unknown type `#{source_type}'" unless SOURCE_TYPES.has_key? source_type
         AIXM.airspace(
-          name: [spans[1], spans[2], spans[3], spans[5].text.blank_to_nil].compact.join(' '),
-          local_type: [spans[1], spans[2], spans[3]].compact.join(' '),
-          type: TYPES.fetch(spans[2].text)
+          name: spans.map { |s| s.text.strip.blank_to_nil }.compact.join(' '),
+          type: SOURCE_TYPES.dig(source_type, :type),
+          local_type: SOURCE_TYPES.dig(source_type, :local_type)
         ).tap do |airspace|
-          airspace.source = source_for(tr)
+          airspace.source = source(position: tr.line)
         end
       end
 
@@ -54,7 +64,7 @@ module AIPP
           parts.each.with_index do |part, index|
             if part = part.text.gsub(/ +/, ' ').gsub(/(\n ?)+/, "\n").strip.blank_to_nil
               unless index.zero? && part == 'H24'
-                remarks << "#{part_titles[index]}:\n#{part}"
+                remarks << "**#{part_titles[index]}**\n#{part}"
               end
             end
           end

data/lib/aipp/regions/LF/ENR-5.5.rb-NEW

@@ -0,0 +1,11 @@
+module AIPP
+  module LF
+
+    # Sporting and Recreational Activities
+    class ENR55 < AIP
+
+      include AIPP::LF::Helpers::Common
+
+    end
+  end
+end

data/lib/aipp/regions/LF/helpers/AD_radio.rb

@@ -0,0 +1,90 @@
+module AIPP
+  module LF
+    module Helpers
+      module ADRadio
+
+        # Service types to be ignored
+        IGNORED_TYPES = %w(D-ATIS).freeze
+
+        # Service types to be encoded as addresses
+        ADDRESS_TYPES = %w(A/A A/G).freeze
+
+        # Unknown service types to be encoded as units
+        SERVICE_TYPES = {
+          'CEV' => { type: :other, remarks: "CEV (centre d'essais en vol / flight test center)" },
+          'SRE' => { type: :other, remarks: "SRE (elément radar de surveillance du PAR / surveillance radar element of PAR)" }
+        }.freeze
+
+        def parts_from(tds)
+          {
+            f: AIXM.f(tds[2].css('span').first.text.to_f, tds[2].css('span').last.text),
+            callsign: tds[1].text.strip,
+            timetable: tds[3].text.strip,
+            remarks: tds[4].text.strip.sub(/Canal (8.33|25)/i, '')   # TEMP: ignore canal spacing warnings
+          }
+        end
+
+        def addresses_from(trs)
+          trs.map do |tr|
+            tds = tr.css('td')
+            type = tds[0].text.strip
+            next if IGNORED_TYPES.include? type
+            f, callsign, _, remarks = parts_from(tds).values
+            if ADDRESS_TYPES.include?(type)
+              AIXM.address(
+                source: source(position: tr.line),
+                type: :radio_frequency,
+                address: f.to_s
+              ).tap do |address|
+                address.remarks = ["#{type} - indicatif/callsign #{callsign}", remarks.blank_to_nil].compact.join("\n")
+              end
+            end
+          end.compact
+        end
+
+        def units_from(trs)
+          trs.each_with_object({}) do |tr, services|
+            tds = tr.css('td')
+            type = tds[0].text.strip
+            next if IGNORED_TYPES.include?(type) || ADDRESS_TYPES.include?(type)
+            f, callsign, timetable, remarks = parts_from(tds).values
+            if SERVICE_TYPES.include? type
+              type = SERVICE_TYPES.dig(type, :type)
+              remarks = [SERVICE_TYPES.dig(type, :remarks), remarks.blank_to_nil].compact.join("\n")
+            end
+            unless services.include? type
+              services[type] = AIXM.service(
+                source: source(position: tr.line),
+                type: type
+              )
+            end
+            code = $1 if timetable.sub!(/(#{AIXM::H_RE})\b/, '')
+            services[type].add_frequency(
+              AIXM.frequency(
+                transmission_f: f,
+                callsigns: { fr: callsign }
+              ).tap do |frequency|
+                frequency.type = :standard
+                frequency.type = :alternative if remarks.sub!(%r{fréquence supplétive/auxiliary frequency\S*}i, '')
+                frequency.timetable = AIXM.timetable(code: code) if code
+                frequency.remarks = [remarks, timetable.blank_to_nil].compact.join("\n").cleanup.blank_to_nil
+              end
+            )
+          end.values.map do |service|
+            AIXM.unit(
+              source: service.source,
+              organisation: organisation_lf,   # TODO: not yet implemented
+              type: (type = service.guessed_unit_type),
+              name: "#{@id} #{AIXM::Feature::Unit::TYPES.key(type)}",
+              class: :icao   # TODO: verify whether all units are ICAO
+            ).tap do |unit|
+              unit.airport = @airport
+              unit.add_service(service)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aipp/regions/LF/helpers/URL.rb

@@ -0,0 +1,26 @@
+module AIPP
+  module LF
+    module Helpers
+      module URL
+
+        # @param aip_file [String] e.g. ENR-5.1, AD-2.LFMV or VAC-LFMV
+        def url_for(aip_file)
+          case aip_file
+          when /^VAC\-(\w+)/
+            "https://www.sia.aviation-civile.gouv.fr/dvd/eAIP_%s/Atlas-VAC/PDF_AIPparSSection/VAC/AD/AD-2.%s.pdf" % [
+              options[:airac].date.strftime('%d_%^b_%Y'),   # 04_JAN_2018
+              $1
+            ]
+          else
+            "https://www.sia.aviation-civile.gouv.fr/dvd/eAIP_%s/FRANCE/AIRAC-%s/html/eAIP/FR-%s-fr-FR.html" % [
+              options[:airac].date.strftime('%d_%^b_%Y'),   # 04_JAN_2018
+              options[:airac].date.xmlschema,               # 2018-01-04
+              aip_file
+            ]
+          end
+        end
+
+      end
+    end
+  end
+end