aipp 0.1.3 → 0.2.0

data/lib/aipp/executable.rb

@@ -0,0 +1,82 @@
+module AIPP
+
+  # Executable instantiated by the console tools
+  class Executable
+    attr_reader :options
+
+    def initialize(**options)
+      @options = options
+      @options[:airac] = AIPP::AIRAC.new
+      @options[:storage] = Pathname(Dir.home).join('.aipp')
+      @options[:verbose] = @options[:force] = @options[:pry_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('-v', '--[no-]verbose', 'verbose process output (default: false)') { |v| @options[:verbose] = v }
+        o.on('-f', '--[no-]force', 'ignore XML schema validation (default: false)') { |v| @options[:force] = v }
+        o.on('-W', '--pry-on-warn ID', Integer, 'open pry on warn with ID (default: nil)') { |v| @options[:pry_on_warn] = v }
+        o.on('-E', '--[no-]pry-on-error', 'open pry on error (default: false)') { |v| @options[:pry_on_error] = v }
+        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 }
+        o.on('-V', '--version', 'show version and exit') { version }
+      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]
+        AIPP::Parser.new(options: options).tap do |parser|
+          parser.read_config
+          parser.read_region
+          parser.parse_aip
+          parser.validate_aixm
+          parser.write_aixm
+          parser.write_config
+        end
+      rescue => error
+        puts "ERROR: #{error.message}"
+        Pry::rescued(error) if options[:pry_on_error]
+      end
+    end
+
+    private
+
+    def about
+      puts 'Written by Sven Schwyn (bitcetera.com) and distributed under MIT license.'
+      exit
+    end
+
+    def readme
+      readme_path = Pathname($0).dirname.join('..', 'gems', "aipp-#{AIPP::VERSION}", 'README.md')
+      puts IO.read(readme_path)
+      exit
+    end
+
+    def list
+      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'
+        end.compact
+      end
+      puts hash.to_yaml.sub(/\A\W*/, '')
+      exit
+    end
+
+    def version
+      puts AIPP::VERSION
+      exit
+    end
+  end
+
+end

data/lib/aipp/parser.rb

@@ -0,0 +1,97 @@
+module AIPP
+
+  # AIP parser infrastructure
+  class Parser
+    using AIPP::Refinements
+    include AIPP::Progress
+
+    # @return [Hash] passed command line arguments
+    attr_reader :options
+
+    # @return [Hash] configuration read from config.yml
+    attr_reader :config
+
+    # @return [AIXM::Document] target document
+    attr_reader :aixm
+
+    # @return [OpenStruct] object cache
+    attr_reader :cache
+
+    def initialize(options:)
+      @options = options
+      @options[:storage] = options[:storage].join(options[:region])
+      @options[:storage].mkpath
+      @config = {}
+      @aixm = AIXM.document(region: @options[:region], effective_at: @options[:airac].date)
+      @cache = OpenStruct.new
+      @dependencies = THash.new
+    end
+
+    # Read the configuration from config.yml.
+    def read_config
+      info("Reading config.yml", force: true)
+      @config = YAML.load_file(config_file, fallback: {}).transform_keys(&:to_sym) 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]}", force: true)
+      dir = Pathname(__FILE__).dirname.join('regions', options[:region])
+      fail("unknown region `#{options[:region]}'") unless dir.exist?
+      dir.glob('*.rb').each do |file|
+        info("Requiring #{file.basename}")
+        require file
+        if (aip = file.basename('.*').to_s) == 'helper'
+          extend [:AIPP, options[:region], :Helper].constantize
+        else
+          @dependencies[aip] = [:AIPP, options[:region], aip.classify, :DEPENDS].constantize
+        end
+      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}", force: true, color: :green)
+      @dependencies.tsort(options[:aip]).each do |aip|
+        info("Parsing #{aip}", force: true)
+        [:AIPP, options[:region], aip.classify].constantize.new(
+          aip: aip,
+          parser: self
+        ).parse
+      end
+    end
+
+    # Validate the AIXM document.
+    #
+    # @raise [RuntimeError] if the document is not valid
+    def validate_aixm
+      info("Validating #{options[:schema].upcase}", force: true)
+      unless aixm.valid?
+        send(@options[:force] ? :warn : :fail, "invalid AIXM document:\n#{aixm.errors}")
+      end
+    end
+
+    # Write the AIXM document.
+    def write_aixm
+      file = "#{options[:region]}_#{options[:airac].date.xmlschema}.#{options[:schema]}"
+      info("Writing #{file}", force: true)
+      AIXM.send("#{options[:schema]}!")
+      File.write(file, aixm.to_xml)
+    end
+
+    # Write the configuration to config.yml.
+    def write_config
+      info("Writing config.yml", force: true)
+      File.write(config_file, config.to_yaml)
+    end
+
+    private
+
+    def config_file
+      options[:storage].join('config.yml')
+    end
+  end
+
+end

data/lib/aipp/progress.rb

@@ -0,0 +1,40 @@
+module AIPP
+  module Progress
+
+    # Issue an informational message.
+    #
+    # @param message [String] informational message
+    # @param force [Boolean] whether to show the message only when in verbose mode
+    # @param color [Symbol] override default color
+    def info(message, force: false, color: nil)
+      case
+      when !force && options[:verbose]
+        color ||= :blue
+        puts message.send(color)
+      when force
+        color ||= :black
+        puts message.send(color)
+      end
+    end
+
+    # Issue a warning and maybe open a Pry session in the context of the error
+    # or binding passed.
+    #
+    # @example with error context
+    #   begin
+    #     (...)
+    #   rescue => error
+    #     warn("oops", context: error)
+    #   end
+    # @example with binding context
+    #   warn("oops", context: binding)
+    # @param message [String] warning message
+    # @param context [Exception, Binding, nil] error or binding object
+    def warn(message, context: nil)
+      $WARN_COUNTER = $WARN_COUNTER.to_i + 1
+      Kernel.warn "WARNING #{$WARN_COUNTER}: #{message}".red
+      Pry::rescued(context) if context && options[:pry_on_warn] == $WARN_COUNTER
+    end
+
+  end
+end

data/lib/aipp/refinements.rb

@@ -1,48 +1,111 @@
 module AIPP
   module Refinements
 
-    refine Kernel do
-      def warn(message, binding=nil)
-        super(message)
-        if $DEBUG && binding
-          require 'pry'
-          binding.pry
-        end
-      end
-    end
-
+    # @!method blank_to_nil
+    #   Convert blank strings to +nil+.
+    #
+    #   @example
+    #     "foobar".blank_to_nil   # => "foobar"
+    #     " ".blank_to_nil        # => nil
+    #     "".blank_to_nil         # => nil
+    #     nil.blank_to_nil        # => nil
+    #
+    #   @note This is a refinement for +String+ and +NilClass+
+    #   @return [String, nil] converted string
     refine String do
-      ##
-      # Convert blank strings to +nil+
       def blank_to_nil
         match?(/\A\s*\z/) ? nil : self
       end
     end
 
+    # Always returns +nil+, companion to +String#blank_to_nil+.
     refine NilClass do
-      ##
-      # Companion to String#blank_to_nil
       def blank_to_nil
-        self
+        nil
+      end
+    end
+
+    # @!method blank?
+    #   Check whether the string is blank.
+    #
+    #   @example
+    #     "foobar".blank?   # => false
+    #     " ".blank?        # => true
+    #     "".blank?         # => true
+    #     nil.blank?        # => true
+    #
+    #   @note This is a refinement for +String+ and +NilClass+
+    #   @return [Boolean] whether the string is blank or not
+    refine String do
+      def blank?
+        !blank_to_nil
       end
     end
 
+    # Always returns +true+, companion to +String#blank?+.
+    refine NilClass do
+      def blank?
+        true
+      end
+    end
+
+    # @!method classify
+    #   Convert file name to class name.
+    #
+    #   @example
+    #     "ENR-5.1".classify   # => "ENR51"
+    #     "helper".classify    # => "Helper"
+    #     "foo_bar".classify   # => "FooBar"
+    #
+    #   @note This is a refinement for +String+
+    #   @return [String] converted string
+    refine String do
+      def classify
+        gsub(/\W/, '').gsub(/(?:^|_)(\w)/) { $1.upcase }
+      end
+    end
+
+    # @!method constantize
+    #   Get constant for array containing the lookup path.
+    #
+    #   @example
+    #     %w(AIPP AIRAC).constantize   # => AIPP::AIRAC
+    #
+    #   @note This is a refinement for +Array+
+    #   @return [Class] converted array
     refine Array do
-      ##
-      # Split an array into nested arrays at the pattern (similar to +String#split+)
-      def split(pattern)
+      def constantize
+        Kernel.const_get(self.join('::'))
+      end
+    end
+
+    # @!method split(object=nil, &block)
+    #   Divides an enumerable into sub-enumerables based on a delimiter,
+    #   returning an array of these sub-enumerables.
+    #
+    #   It takes the same arguments as +Enumerable#find_index+ and suppresses
+    #   trailing zero-length sub-enumerator as does +String#split+.
+    #
+    #   @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]]
+    #
+    #   @note This is a refinement for +Enumerable+
+    #   @param object [Object] element at which to split
+    #   @yield [Object] element to analyze
+    #   @yieldreturn [Boolean] whether to split at this element or not
+    #   @return [Array]
+    refine Enumerable do
+      def split(*args, &block)
         [].tap do |array|
-          nested_array = []
-          each do |element|
-            if pattern === element
-              array << nested_array
-              nested_array = []
-            else
-              nested_array << element
-            end
+          while index = slice((start ||= 0)...length).find_index(*args, &block)
+            array << slice(start...start+index)
+            start += index + 1
           end
-          array << nested_array
-          array.pop while array.last == []
+          array << slice(start..-1) if start < length
         end
       end
     end

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

@@ -0,0 +1,89 @@
+module AIPP
+  module LF
+
+    # FIR, TMA etc
+    class ENR21 < AIP
+      using AIPP::Refinements
+
+      # Map source types to type and 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 },
+        'LTA' => { type: 'CTA', local_type: 'LTA' },
+        'TMA' => { type: 'TMA', local_type: nil },
+        'SIV' => { type: 'SECTOR', local_type: 'SIV' }   # providing FIS
+      }.freeze
+
+      # Map airspace "<type> <name>" to location indicator
+      LOCATION_INDICATORS = {
+        'FIR BORDEAUX' => 'LFBB',
+        'FIR BREST' => 'LFRR',
+        'FIR MARSEILLE' => 'LFMM',
+        'FIR PARIS' => 'LFFF',
+        'FIR REIMS' => 'LFRR'
+      }.freeze
+
+      def parse
+        load_html.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
+              next
+            end
+            begin
+              tds = cleanup(node: 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}"
+              end
+              if airspace
+                if tds[0].text.blank_to_nil
+                  airspace.geometry = geometry_from tds[0]
+                  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.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])
+                airspace.layers << layer
+              end
+            rescue => error
+              warn("error parsing #{airspace.type} `#{airspace.name}' at ##{index}: #{error.message}", context: error)
+            end
+          end
+          aixm.features << airspace if airspace
+        end
+      end
+
+      private
+
+      def airspace_from(td)
+        spans = td.children.split { |e| e.name == 'br' }.first.css(:span).drop_while { |e| e.text.match? '\s' }
+        source_type = spans[0].text.blank_to_nil
+        fail "unknown type `#{source_type}'" unless SOURCE_TYPES.has_key? source_type
+        AIXM.airspace(
+          name: anglicise(name: spans[1..-1].join(' ')),
+          type: SOURCE_TYPES.dig(source_type, :type),
+          local_type: SOURCE_TYPES.dig(source_type, :local_type)
+        ).tap do |airspace|
+          airspace.source = source_for(td)
+        end
+      end
+
+      def class_from(td)
+        td.text.strip
+      end
+
+      def remarks_from(td)
+        td.text.strip.gsub(/(\s)\s+/, '\1').blank_to_nil
+      end
+    end
+  end
+end