aipp 0.2.1 → 0.2.2

data/lib/aipp/progress.rb

@@ -1,40 +0,0 @@
-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,114 +0,0 @@
-module AIPP
-  module Refinements
-
-    # @!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
-      def blank_to_nil
-        match?(/\A\s*\z/) ? nil : self
-      end
-    end
-
-    # Always returns +nil+, companion to +String#blank_to_nil+.
-    refine NilClass do
-      def blank_to_nil
-        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
-      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|
-          while index = slice((start ||= 0)...length).find_index(*args, &block)
-            array << slice(start...start+index)
-            start += index + 1
-          end
-          array << slice(start..-1) if start < length
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,177 +0,0 @@
-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/spec/lib/aipp/refinements_spec.rb

@@ -1,123 +0,0 @@
-require_relative '../../spec_helper'
-
-using AIPP::Refinements
-
-describe AIPP::Refinements do
-
-  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 with whitespace untouched" do
-        "\nfoo bar\n".blank_to_nil.must_equal "\nfoo bar\n"
-      end
-    end
-
-    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
-
-    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
-
-  context NilClass do
-    describe :blank_to_nil do
-      it "must return self" do
-        nil.blank_to_nil.must_be :nil?
-      end
-    end
-
-    describe :blank? do
-      it "must return true" do
-        nil.blank?.must_equal true
-      end
-    end
-  end
-
-  context Array do
-    describe :constantize do
-      it "must convert to constant" do
-        %w(AIPP Refinements).constantize.must_equal AIPP::Refinements
-      end
-
-      it "fails to convert to inexistant constant" do
-        -> { %w(Foo Bar).constantize }.must_raise NameError
-      end
-    end
-  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 "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
-
-end