aipp 0.1.3 → 0.2.0

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

@@ -0,0 +1,101 @@
+module AIPP
+  module LF
+
+    # ENR Navaids
+    class ENR41 < AIP
+      using AIPP::Refinements
+
+      def parse
+        load_html.css('tbody').each do |tbody|
+          tbody.css('tr').to_enum.with_index(1).each do |tr, index|
+            tds = cleanup(node: 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.remarks = remarks_from(tds[5], tds[7], tds[9])
+            navaid.send("associate_#{slave}", channel: channel_from(tds[3])) if slave
+            aixm.features << navaid
+          rescue => error
+            warn("error parsing navigational aid at ##{index}: #{error.message}", context: error)
+          end
+        end
+      end
+
+      private
+
+      def base_from(tds)
+        {
+          organisation: organisation_lf,
+          id: tds[2].text.strip,
+          name: tds[0].text.strip,
+          xy: xy_from(tds[5]),
+          z: z_from(tds[6])
+        }
+      end
+
+      def vor_from(tds)
+        {
+          type: :conventional,
+          f: frequency_from(tds[3]),
+          north: :magnetic,
+        }
+      end
+
+      def dme_from(tds)
+        {
+          channel: channel_from(tds[3])
+        }
+      end
+
+      def ndb_from(tds)
+        {
+          type: :en_route,
+          f: frequency_from(tds[3])
+        }
+      end
+
+      def tacan_from(tds)
+        {
+          channel: channel_from(tds[3])
+        }
+      end
+
+      def z_from(td)
+        parts = td.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+/)
+        AIXM.f(parts[0].to_f, parts[1]) if parts[1] =~ /hz$/i
+      end
+
+      def channel_from(td)
+        parts = td.text.strip.split(/\s+/)
+        parts.last if parts[-2].downcase == 'ch'
+      end
+
+      def timetable_from(td)
+        code = td.text.strip
+        AIXM.timetable(code: code) unless code.empty?
+      end
+
+      def remarks_from(*parts)
+        part_titles = ['RANGE', 'SITUATION', 'OBSERVATIONS']
+        [].tap do |remarks|
+          parts.each.with_index do |part, index|
+            text = if index == 0
+              part = part.text.strip.split(/\s+/)
+              part.shift(2)
+              part.join(' ').blank_to_nil
+            else
+              part.text.strip.blank_to_nil
+            end
+            remarks << "#{part_titles[index]}:\n#{text}" if text
+          end
+        end.join("\n\n").blank_to_nil
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,65 @@
+module AIPP
+  module LF
+
+    # D/P/R Zones
+    class ENR51 < AIP
+      using AIPP::Refinements
+
+      TYPES = {
+        'D' => 'D',
+        'P' => 'P',
+        'R' => 'R',
+        'ZIT' => 'P'
+      }.freeze
+
+      def parse
+        load_html.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
+              begin
+                tds = cleanup(node: tr).css('td')
+                airspace.geometry = geometry_from tds[0]
+                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.first.remarks = remarks_from(tds[2], tds[3], tds[4])
+                aixm.features << airspace
+              rescue => error
+                warn("error parsing airspace `#{airspace.name}' at ##{index}: #{error.message}", context: error)
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def airspace_from(tr)
+        spans = tr.css(:span)
+        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)
+        ).tap do |airspace|
+          airspace.source = source_for(tr)
+        end
+      end
+
+      def remarks_from(*parts)
+        part_titles = ['TIMETABLE', 'RESTRICTION', 'AUTHORITY/CONDITIONS']
+        [].tap do |remarks|
+          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}"
+              end
+            end
+          end
+        end.join("\n\n").blank_to_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+module AIPP
+  module LF
+    module Helper
+      using AIPP::Refinements
+      using AIXM::Refinements
+
+      BORDERS = {
+        'franco-allemande' => 'FRANCE_GERMANY',
+        'franco-espagnole' =>  'FRANCE_SPAIN',
+        'franco-italienne' => 'FRANCE_ITALY',
+        'franco-suisse' => 'FRANCE_SWITZERLAND',
+        'franco-luxembourgeoise' => 'FRANCE_LUXEMBOURG',
+        'franco-belge' => 'BELGIUM_FRANCE',
+        'germano-suisse' => 'GERMANY_SWITZERLAND',
+        'hispano-andorrane' => 'ANDORRA_SPAIN',
+        'la côte atlantique française' => 'FRANCE_ATLANTIC_COAST',
+        'côte méditérrannéenne' => 'FRANCE_MEDITERRANEAN_COAST',
+        'limite des eaux territoriales atlantique françaises' => 'FRANCE_ATLANTIC_TERRITORIAL_SEA',
+        'parc national des écrins' => 'FRANCE_ECRINS_NATIONAL_PARK'
+      }.freeze
+
+      INTERSECTIONS = {
+        'FRANCE_SPAIN|ANDORRA_SPAIN' => AIXM.xy(lat: 42.502720, long: 1.725965),
+        'ANDORRA_SPAIN|FRANCE_SPAIN' => AIXM.xy(lat: 42.603571, long: 1.442681),
+        'FRANCE_SWITZERLAND|FRANCE_ITALY' => AIXM.xy(lat: 45.922701, long: 7.044125),
+        'BELGIUM_FRANCE|FRANCE_LUXEMBOURG' => AIXM.xy(lat: 49.546428, long: 5.818415),
+        'FRANCE_LUXEMBOURG|FRANCE_GERMANY' => AIXM.xy(lat: 49.469438, long: 6.367516),
+        'FRANCE_GERMANY|FRANCE_SWITZERLAND' => AIXM.xy(lat: 47.589831, long: 7.589049),
+        'GERMANY_SWITZERLAND|FRANCE_GERMANY' => AIXM.xy(lat: 47.589831, long: 7.589049)
+      }
+
+      ANGLICISE_MAP = {
+        /[^A-Z0-9 .\-]/ => '',
+        / 0(\d)/ => ' \1',
+        /(\d)-(\d)/ => '\1.\2',
+        /PARTIE/ => '',
+        /DELEG\./ => 'DELEG ',
+        /FRANCAISE?/ => 'FR',
+        /ANGLAISE?/ => 'UK',
+        /BELGE/ => 'BE',
+        /LUXEMBOURGEOISE?/ => 'LU',
+        /ALLEMANDE?/ => 'DE',
+        /SUISSE/ => 'CH',
+        /ITALIEN(?:NE)?/ => 'IT',
+        /ESPAGNOLE?/ => 'ES',
+        /ANDORRANE?/ => 'AD',
+        /NORD/ => 'N',
+        /EST/ => 'E',
+        /SUD/ => 'S',
+        /OEST/ => 'W',
+        /ANGLO NORMANDES/ => 'ANGLO-NORMANDES',
+        / +/ => ' '
+      }.freeze
+
+      # Download URL
+
+      def url_for(aip_file)
+        "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                                      # ENR-5.1 or AD-2.LFMV
+        ]
+      end
+
+      # Templates
+
+      def organisation_lf
+        @organisation_lf ||= AIXM.organisation(
+          name: 'FRANCE',
+          type: 'S'
+        ).tap do |organisation|
+          organisation.id = 'LF'
+        end
+      end
+
+      # Transformations
+
+      def cleanup(node:)
+        node.tap do |root|
+          root.css('del').each { |n| n.remove }   # remove deleted entries
+        end
+      end
+
+      def anglicise(name:)
+        name.uptrans.tap do |string|
+          ANGLICISE_MAP.each do |regexp, replacement|
+            string.gsub!(regexp, replacement)
+          end
+        end
+      end
+
+      # Parsers
+
+      def source_for(element)
+        [
+          options[:region],
+          @aip.split('-').first,
+          @aip,
+          options[:airac].date.xmlschema,
+          element.line
+        ].join('|')
+      end
+
+      def xy_from(td)
+        parts = td.text.strip.split(/\s+/)
+        AIXM.xy(lat: parts[0], long: parts[1])
+      end
+
+      def z_from(limit)
+        case limit
+          when nil then nil
+          when 'SFC' then AIXM::GROUND
+          when 'UNL' then AIXM::UNLIMITED
+          when /(\d+)ftASFC/ then AIXM.z($1.to_i, :qfe)
+          when /(\d+)ftAMSL/ then AIXM.z($1.to_i, :qnh)
+          when /FL(\d+)/ then AIXM.z($1.to_i, :qne)
+          else fail "z `#{limit}' not recognized"
+        end
+      end
+
+      def layer_from(td)
+        above, below = td.text.gsub(/ /, '').split(/\n+/).select(&:blank_to_nil).split { |e| e.match? '---+' }
+        above.reverse!
+        AIXM.layer(
+          vertical_limits: AIXM.vertical_limits(
+            max_z: z_from(above[1]),
+            upper_z: z_from(above[0]),
+            lower_z: z_from(below[0]),
+            min_z: z_from(below[1])
+          )
+        )
+      end
+
+      def geometry_from(td)
+        AIXM.geometry.tap do |geometry|
+          buffer = {}
+          td.text.gsub(/\s+/, ' ').strip.split(/ - /).append('end').each do |element|
+            case element
+            when /arc (anti-)?horaire .+ sur (\S+) , (\S+)/i
+              geometry << AIXM.arc(
+                xy: buffer.delete(:xy),
+                center_xy: AIXM.xy(lat: $2, long: $3),
+                clockwise: $1.nil?
+              )
+            when /cercle de ([\d\.]+) (NM|km|m) .+ sur (\S+) , (\S+)/i
+              geometry << AIXM.circle(
+                center_xy: AIXM.xy(lat: $3, long: $4),
+                radius: AIXM.d($1.to_f, $2)
+              )
+            when /end|(\S+) , (\S+)/
+              geometry << AIXM.point(xy: buffer[:xy]) if buffer.has_key?(:xy)
+              buffer[:xy] = AIXM.xy(lat: $1, long: $2) if $1
+            when /^frontière ([\w-]+)/i, /^(\D[^(]+)/i
+              border_name = BORDERS.fetch($1.downcase.strip)
+              buffer[:xy] ||= INTERSECTIONS.fetch("#{buffer[:border_name]}|#{border_name}")
+              buffer[:border_name] = border_name
+              if border_name == 'FRANCE_SPAIN'   # specify which part of this split border
+                border_name += buffer[:xy].lat < 42.55 ? '_EAST' : '_WEST'
+              end
+              geometry << AIXM.border(
+                xy: buffer.delete(:xy),
+                name: border_name
+              )
+            else
+              fail "geometry `#{element}' not recognized"
+            end
+          end
+        end
+      end
+
+      def timetable_from(td)
+        AIXM::H24 if td.text.gsub(/\W/, '') == 'H24'
+      end
+
+    end
+  end
+end

data/lib/aipp/t_hash.rb

@@ -0,0 +1,46 @@
+module AIPP
+
+  # Topologically sortable hash for dealing with dependencies
+  #
+  # Example:
+  #   dependency_hash = THash[
+  #     dns: %i(net),
+  #     webserver: %i(dns logger),
+  #     net: [],
+  #     logger: []
+  #   ]
+  #   # Sort to resolve dependencies of the entire hash
+  #   dependency_hash.tsort         # => [:net, :dns, :logger, :webserver]
+  #   # Sort to resolve dependencies of one node only
+  #   dependency_hash.tsort(:dns)   # => [:net, :dns]
+  class THash < Hash
+    include TSort
+
+    alias_method :tsort_each_node, :each_key
+
+    def tsort_each_child(node, &block)
+     fetch(node).each(&block)
+    end
+
+    def tsort(node=nil)
+      if node
+        subhash = subhash_for node
+        super().select { |n| subhash.include? n }
+      else
+        super()
+      end
+    end
+
+    private
+
+    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) }
+      end
+    end
+
+  end
+
+end

data/lib/aipp/version.rb

@@ -1,3 +1,3 @@
 module AIPP
-  VERSION = "0.1.3".freeze
+  VERSION = "0.2.0".freeze
 end

data/spec/lib/aipp/airac_spec.rb

@@ -8,7 +8,7 @@ describe AIPP::AIRAC do
     end
   end
 
-  context "on AIRAC date" do
+  context "on AIRAC date (as Date)" do
     subject do
       AIPP::AIRAC.new(Date.parse('2018-01-04'))
     end
@@ -30,9 +30,9 @@ describe AIPP::AIRAC do
     end
   end
 
-  context "one day before AIRAC date" do
+  context "one day before AIRAC date (as String)" do
     subject do
-      AIPP::AIRAC.new(Date.parse('2018-01-03'))
+      AIPP::AIRAC.new('2018-01-03')
     end
 
     it "must calculate correct #date" do

data/spec/lib/aipp/refinements_spec.rb

@@ -4,49 +4,119 @@ using AIPP::Refinements
 
 describe AIPP::Refinements do
 
-  describe 'String#blank_to_nil' do
-    it "must convert blank to nil" do
-      "\n     \n         ".blank_to_nil.must_be :nil?
-    end
+  context String do
+    describe :blank_to_nil do
+      it "must convert blank to nil" do
+        "\n     \n         ".blank_to_nil.must_be :nil?
+      end
+
+      it "must leave non-blank untouched" do
+        "foobar".blank_to_nil.must_equal "foobar"
+      end
 
-    it "must leave non-blank untouched" do
-      "foobar".blank_to_nil.must_equal "foobar"
+      it "must leave non-blank with whitespace untouched" do
+        "\nfoo bar\n".blank_to_nil.must_equal "\nfoo bar\n"
+      end
     end
 
-    it "must leave non-blank with whitespace untouched" do
-      "\nfoo bar\n".blank_to_nil.must_equal "\nfoo bar\n"
+    describe :blank? do
+      it "all whitespace must return true" do
+        "\n     \n         ".blank?.must_equal true
+      end
+
+      it "not all whitespace must return false" do
+        "\nfoo bar\n".blank?.must_equal false
+      end
     end
-  end
 
-  describe 'NilClass#blank_to_nil' do
-    it "must return self" do
-      nil.blank_to_nil.must_be :nil?
+    describe :classify do
+      it "must convert file name to class name" do
+        "ENR-5.1".classify.must_equal "ENR51"
+        "helper".classify.must_equal "Helper"
+        "foo_bar".classify.must_equal "FooBar"
+      end
     end
   end
 
-  describe 'Array#split' do
-    it "must split at pattern" do
-      [1, 2, '---', 3, 4].split(/-+/).must_equal [[1, 2], [3, 4]]
+  context NilClass do
+    describe :blank_to_nil do
+      it "must return self" do
+        nil.blank_to_nil.must_be :nil?
+      end
     end
 
-    it "won't split arrays with no pattern matches" do
-      [1, 2, 3].split(/-+/).must_equal [[1, 2, 3]]
+    describe :blank? do
+      it "must return true" do
+        nil.blank?.must_equal true
+      end
     end
+  end
 
-    it "must keep leading empty subarrays" do
-      ['---', 1, 2, '---', 3, 4].split(/-+/).must_equal [[], [1, 2], [3, 4]]
-    end
+  context Array do
+    describe :constantize do
+      it "must convert to constant" do
+        %w(AIPP Refinements).constantize.must_equal AIPP::Refinements
+      end
 
-    it "must keep empty subarrays in the middle" do
-      [1, 2, '---', '---', 3, 4].split(/-+/).must_equal [[1, 2], [], [3, 4]]
+      it "fails to convert to inexistant constant" do
+        -> { %w(Foo Bar).constantize }.must_raise NameError
+      end
     end
+  end
 
-    it "must drop trailing empty subarrays" do
-      [1, 2, '---', 3, 4, '---'].split(/-+/).must_equal [[1, 2], [3, 4]]
-    end
+  context Enumerable do
+    describe :split do
+      context "by object" do
+        it "must split at matching element" do
+          [1, 2, 0, 3, 4].split(0).must_equal [[1, 2], [3, 4]]
+        end
+
+        it "won't split when no element matches" do
+          [1, 2, 3].split(0).must_equal [[1, 2, 3]]
+        end
+
+        it "won't split zero length enumerable" do
+          [].split(0).must_equal []
+        end
+
+        it "must keep leading empty subarrays" do
+          [0, 1, 2, 0, 3, 4].split(0).must_equal [[], [1, 2], [3, 4]]
+        end
+
+        it "must keep empty subarrays in the middle" do
+          [1, 2, 0, 0, 3, 4].split(0).must_equal [[1, 2], [], [3, 4]]
+        end
+
+        it "must drop trailing empty subarrays" do
+          [1, 2, 0, 3, 4, 0].split(0).must_equal [[1, 2], [3, 4]]
+        end
+      end
+
+      context "by block" do
+        it "must split at matching element" do
+          [1, 2, 0, 3, 4].split { |e| e.zero? }.must_equal [[1, 2], [3, 4]]
+        end
+
+        it "won't split when no element matches" do
+          [1, 2, 3].split { |e| e.zero? }.must_equal [[1, 2, 3]]
+        end
+
+        it "won't split zero length enumerable" do
+          [].split { |e| e.zero? }.must_equal []
+        end
+
+        it "must keep leading empty subarrays" do
+          [0, 1, 2, 0, 3, 4].split { |e| e.zero? }.must_equal [[], [1, 2], [3, 4]]
+        end
+
+        it "must keep empty subarrays in the middle" do
+          [1, 2, 0, 0, 3, 4].split { |e| e.zero? }.must_equal [[1, 2], [], [3, 4]]
+        end
 
-    it "won't alter empty arrays" do
-      [].split(/-+/).must_equal []
+        it "must drop trailing empty subarrays" do
+          [1, 2, 0, 3, 4, 0].split { |e| e.zero? }.must_equal [[1, 2], [3, 4]]
+        end
+      end
     end
   end