aixm 0.1.3 → 0.2.0

data/lib/aixm/feature/navigational_aid/vor.rb

@@ -0,0 +1,92 @@
+module AIXM
+  module Feature
+    module NavigationalAid
+
+      ##
+      # VOR (VHF omnidirectional range) operate in the frequency band between
+      # 108.00 Mhz to 117.95 MHz. Two type of VORs exist:
+      #
+      # Types:
+      # * +:vor+ (+:VOR+) - standard VOR
+      # * +:vordme+ (+:DVOR+) - VOR/DME
+      #
+      # North types:
+      # * +:geographic+ (+:TRUE+) - VOR aligned towards geographic north
+      # * +:grid+ (+:GRID+) - VOR aligned along north-south lines of the
+      #                       universal transverse mercator grid imposed on
+      #                       topographic maps by the USA and NATO
+      # * +:magnetic+ (+:MAG+) - VOR aligned towards magnetic north
+      # * +:other+ (+:OTHER+) - other north type
+      #
+      # https://en.wikipedia.org/wiki/VHF_omnidirectional_range
+      class VOR < Base
+        using AIXM::Refinements
+
+        TYPES = {
+          VOR: :vor,
+          DVOR: :vordme
+        }.freeze
+
+        NORTHS = {
+          TRUE: :geographic,
+          GRID: :grid,
+          MAG: :magnetic,
+          OTHER: :other
+        }.freeze
+
+        attr_reader :type, :f, :north
+
+        public_class_method :new
+
+        def initialize(id:, name:, xy:, z: nil, type:, f:, north:)
+          super(id: id, name: name, xy: xy, z: z)
+          @type = TYPES.lookup(type&.to_sym, nil) || fail(ArgumentError, "invalid type")
+          @north = NORTHS.lookup(north&.to_sym, nil) || fail(ArgumentError, "invalid north")
+          @f = f
+          fail(ArgumentError, "invalid frequency") unless f.is_a?(F) && f.between?(108, 117.95, :mhz)
+        end
+
+        ##
+        # Digest to identify the payload
+        def to_digest
+          [super, type, f.to_digest, north].to_digest
+        end
+
+        ##
+        # Render AIXM
+        def to_xml(*extensions)
+          builder = to_builder(*extensions)
+          builder.Vor do |vor|
+            vor.VorUid({ newEntity: (true if extensions >> :ofm) }.compact) do |voruid|
+              voruid.codeId(id)
+              voruid.geoLat(xy.lat(format_for(*extensions)))
+              voruid.geoLong(xy.long(format_for(*extensions)))
+            end
+            vor.OrgUid
+            vor.txtName(name)
+            vor.codeType(type_key.to_s)
+            vor.valFreq(f.freq.trim)
+            vor.uomFreq(f.unit.upcase.to_s)
+            vor.codeTypeNorth(north_key.to_s)
+            vor.codeDatum('WGE')
+            if z
+              vor.valElev(z.alt)
+              vor.uomDistVer(z.unit.to_s)
+            end
+            vor.txtRmk(remarks) if remarks
+            vor.target!   # see https://github.com/jimweirich/builder/issues/42
+          end
+        end
+
+        def type_key
+          TYPES.key(type)
+        end
+
+        def north_key
+          NORTHS.key(north)
+        end
+      end
+
+    end
+  end
+end

data/lib/aixm/refinements.rb

@@ -25,8 +25,8 @@ module AIXM
       # Shortcut for +include?+
       #
       # Example:
-      #   extensions.include?(:OFM)   # => true
-      #   extensions >> :OFM          # => true
+      #   extensions.include?(:ofm)   # => true
+      #   extensions >> :ofm          # => true
       alias_method :>>, :include?
 
       ##
@@ -36,6 +36,27 @@ module AIXM
       end
     end
 
+    refine Hash do
+      ##
+      # Fetch a value from the hash, but unlike +fetch+, if +key_or_value+ is
+      # no hash key, check whether +key_or_value+ is a hash value and if so
+      # return it.
+      #
+      # Examples:
+      #   h = { one: 1, two: 2, three: 3, four: :three }
+      #   h.lookup(:one)             # => 1
+      #   h.lookup(1)                # => 1
+      #   h.lookup(:three)           # => 3 (key has priority over value)
+      #   h.lookup(:foo)             # => KeyError
+      #   h.lookup(:foo, :default)   # => :default
+      #   h.lookup(:foo, nil)        # => nil
+      def lookup(key_or_value, default = omitted = true)
+        self[key_or_value] ||
+          (key_or_value if has_value?(key_or_value)) ||
+          (omitted ? fail(KeyError, "key or value `#{key_or_value}' not found") : default)
+      end
+    end
+
     refine String do
       ##
       # Indent every line of a string with +number+ spaces

data/lib/aixm/shortcuts.rb

@@ -2,14 +2,11 @@ module AIXM
 
   SCHEMA = Pathname(__dir__).join('schemas', '4.5', 'AIXM-Snapshot.xsd').freeze
 
-  GROUND = Z.new(alt: 0, code: :QFE).freeze
-  UNLIMITED = Z.new(alt: 999, code: :QNE).freeze
-  H24 = Component::Schedule.new(code: :H24).freeze
-
   ELEMENTS = {
     document: Document,
     xy: XY,
     z: Z,
+    f: F,
     airspace: Feature::Airspace,
     class_layer: Component::ClassLayer,
     geometry: Component::Geometry,
@@ -18,7 +15,13 @@ module AIXM
     arc: Component::Geometry::Arc,
     border: Component::Geometry::Border,
     circle: Component::Geometry::Circle,
-    point: Component::Geometry::Point
+    point: Component::Geometry::Point,
+    dme: Feature::NavigationalAid::DME,
+    designated_point: Feature::NavigationalAid::DesignatedPoint,
+    marker: Feature::NavigationalAid::Marker,
+    tacan: Feature::NavigationalAid::TACAN,
+    ndb: Feature::NavigationalAid::NDB,
+    vor: Feature::NavigationalAid::VOR
   }.freeze
 
   ELEMENTS.each do |element, klass|
@@ -27,4 +30,8 @@ module AIXM
     end
   end
 
+  GROUND = z(0, :qfe).freeze
+  UNLIMITED = z(999, :qne).freeze
+  H24 = schedule(code: :H24).freeze
+
 end

data/lib/aixm/version.rb

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

data/lib/aixm/xy.rb

@@ -6,8 +6,7 @@ module AIXM
   # The following notations for longitude and latitude are recognized:
   # * DD - examples: 12.12345678 (north or east), -12.12345678 (south or west)
   # * DMS - examples: 11°22'33.44"N, 1112233.44W
-  class XY
-
+  class XY < Base
     using AIXM::Refinements
 
     def initialize(lat:, long:)
@@ -18,20 +17,24 @@ module AIXM
 
     def lat(format=nil)
       case format
-        when :OFM then ("%.8f" % @lat.abs.round(8)) + (@lat.negative? ? 'S' : 'N')
-        when :AIXM then @lat.to_dms(2).gsub(/[^\d.]/, '') + (@lat.negative? ? 'S' : 'N')
+        when :ofm then ("%.8f" % @lat.abs.round(8)) + (@lat.negative? ? 'S' : 'N')
+        when :aixm then @lat.to_dms(2).gsub(/[^\d.]/, '') + (@lat.negative? ? 'S' : 'N')
         else @lat.round(8)
       end
     end
 
     def long(format=nil)
       case format
-        when :OFM then ("%.8f" % @long.abs.round(8)) + (@long.negative? ? 'W' : 'E')
-        when :AIXM then @long.to_dms(3).gsub(/[^\d.]/, '') + (@long.negative? ? 'W' : 'E')
+        when :ofm then ("%.8f" % @long.abs.round(8)) + (@long.negative? ? 'W' : 'E')
+        when :aixm then @long.to_dms(3).gsub(/[^\d.]/, '') + (@long.negative? ? 'W' : 'E')
         else @long.round(8)
       end
     end
 
+    def to_digest
+      [lat, long].to_digest
+    end
+
     def ==(other)
       other.is_a?(XY) && lat == other.lat && long == other.long
     end

data/lib/aixm/z.rb

@@ -4,34 +4,45 @@ module AIXM
   # Elevation or altitude
   #
   # The following Q codes are recognized:
-  # * QFE - height in feet
-  # * QNH - altitude in feet
-  # * QNE - altitude as flight level
-  class Z
+  # * +:qfe+ - height in feet
+  # * +:qnh+ - altitude in feet
+  # * +:qne+ - altitude as flight level
+  class Z < Base
+    using AIXM::Refinements
 
-    CODES = %i(QFE QNH QNE).freeze
+    CODES = %i(qfe qnh qne).freeze
 
     attr_reader :alt, :code
 
-    def initialize(alt:, code:)
-      fail(ArgumentError, "unrecognized Q code `#{code}'") unless CODES.include? code
-      @alt, @code = alt, code
+    def initialize(alt, code)
+      @alt, @code = alt, code&.to_sym&.downcase
+      fail(ArgumentError, "unrecognized Q code `#{code}'") unless CODES.include? @code
+    end
+
+    ##
+    # Digest to identify the payload
+    def to_digest
+      [alt, code].to_digest
     end
 
     def ==(other)
       other.is_a?(Z) && alt == other.alt && code == other.code
     end
 
+    CODES.each do |code|
+      define_method(:"#{code}?") { @code == code }
+    end
+
     def ground?
-      @code == :QFE && @alt == 0
+      qfe? && @alt == 0
     end
 
     def base
-      @code == :QFE ? :ASFC : :AMSL
+      qfe? ? :ASFC : :AMSL
     end
 
     def unit
-      @code == :QNE ? :FL : :FT
+      qne? ? :FL : :FT
     end
 
   end

data/spec/factory.rb

@@ -2,12 +2,16 @@ module AIXM
   class Factory
     class << self
 
+      def xy
+        AIXM.xy(lat: 10, long: 20)
+      end
+
       def vertical_limits
         AIXM.vertical_limits(
-          upper_z: AIXM.z(alt: 65, code: :QNE),
-          lower_z: AIXM.z(alt: 45, code: :QNE),
-          max_z: AIXM.z(alt: 6000, code: :QNH),
-          min_z: AIXM.z(alt: 3000, code: :QFE)
+          upper_z: AIXM.z(65, :qne),
+          lower_z: AIXM.z(45, :qne),
+          max_z: AIXM.z(6000, :qnh),
+          min_z: AIXM.z(3000, :qfe)
         )
       end
 
@@ -70,11 +74,90 @@ module AIXM
         end
       end
 
+      def designated_point
+        AIXM.designated_point(
+          id: 'DPN',
+          name: 'DESIGNATED POINT NAVAID',
+          xy: AIXM.xy(lat: %q(47°51'33"N), long: %q(007°33'36"E)),
+          z: AIXM.z(500, :qnh),
+          type: :ICAO
+        ).tap do |designated_point|
+          designated_point.remarks = 'designated point navaid'
+        end
+      end
+
+      def dme
+        AIXM.dme(
+          id: 'DME',
+          name: 'DME NAVAID',
+          xy: AIXM.xy(lat: %q(47°51'33"N), long: %q(007°33'36"E)),
+          z: AIXM.z(500, :qnh),
+          channel: '95X'
+        ).tap do |dme|
+          dme.remarks = 'dme navaid'
+        end
+      end
+
+      def marker
+        AIXM.marker(
+          id: '---',
+          name: 'MARKER NAVAID',
+          xy: AIXM.xy(lat: %q(47°51'33"N), long: %q(007°33'36"E)),
+          z: AIXM.z(500, :qnh)
+        ).tap do |marker|
+          marker.remarks = 'marker navaid'
+        end
+      end
+
+      def ndb
+        AIXM.ndb(
+          id: 'NDB',
+          name: 'NDB NAVAID',
+          xy: AIXM.xy(lat: %q(47°51'33"N), long: %q(007°33'36"E)),
+          z: AIXM.z(500, :qnh),
+          f: AIXM.f(555, :khz)
+        ).tap do |ndb|
+          ndb.remarks = 'ndb navaid'
+        end
+      end
+
+      def tacan
+        AIXM.tacan(
+          id: 'TCN',
+          name: 'TACAN NAVAID',
+          xy: AIXM.xy(lat: %q(47°51'33"N), long: %q(007°33'36"E)),
+          z: AIXM.z(500, :qnh),
+          channel: '29X'
+        ).tap do |tacan|
+          tacan.remarks = 'tacan navaid'
+        end
+      end
+
+      def vor
+        AIXM.vor(
+          id: 'VOR',
+          name: 'VOR NAVAID',
+          xy: AIXM.xy(lat: %q(47°51'33"N), long: %q(007°33'36"E)),
+          z: AIXM.z(500, :qnh),
+          type: :VOR,
+          f: AIXM.f(111, :mhz),
+          north: :geographic
+        ).tap do |vor|
+          vor.remarks = 'vor navaid'
+        end
+      end
+
       def document
         time = Time.parse('2018-01-18 12:00:00 +0100')
         AIXM.document(created_at: time, effective_at: time).tap do |document|
           document.features << AIXM::Factory.polygon_airspace
           document.features << AIXM::Factory.circle_airspace
+          document.features << AIXM::Factory.designated_point
+          document.features << AIXM::Factory.dme
+          document.features << AIXM::Factory.marker
+          document.features << AIXM::Factory.ndb
+          document.features << AIXM::Factory.vor
+          document.features << AIXM::Factory.tacan
         end
       end
 

data/spec/lib/aixm/component/class_layer_spec.rb

@@ -3,19 +3,19 @@ require_relative '../../../spec_helper'
 describe AIXM::Component::ClassLayer do
   describe :initialize do
     it "won't accept invalid arguments" do
-      -> { AIXM::Component::ClassLayer.new(class: 'X', vertical_limits: AIXM::Factory.vertical_limits ) }.must_raise ArgumentError
-      -> { AIXM::Component::ClassLayer.new(class: 'A', vertical_limits: 'foobar') }.must_raise ArgumentError
+      -> { AIXM.class_layer(class: 'X', vertical_limits: AIXM::Factory.vertical_limits ) }.must_raise ArgumentError
+      -> { AIXM.class_layer(class: 'A', vertical_limits: 'foobar') }.must_raise ArgumentError
     end
   end
 
   context "with class" do
     subject do
-      AIXM::Component::ClassLayer.new(class: :C, vertical_limits: AIXM::Factory.vertical_limits)
+      AIXM.class_layer(class: :C, vertical_limits: AIXM::Factory.vertical_limits)
     end
 
     describe :to_digest do
       it "must return digest of payload" do
-        subject.to_digest.must_equal 612555203
+        subject.to_digest.must_equal 385936206
       end
     end
 
@@ -42,12 +42,12 @@ describe AIXM::Component::ClassLayer do
 
   context "without class" do
     subject do
-      AIXM::Component::ClassLayer.new(vertical_limits: AIXM::Factory.vertical_limits)
+      AIXM.class_layer(vertical_limits: AIXM::Factory.vertical_limits)
     end
 
     describe :to_digest do
       it "must return digest of payload" do
-        subject.to_digest.must_equal 486148039
+        subject.to_digest.must_equal 5930767
       end
     end
 

data/spec/lib/aixm/component/geometry/arc_spec.rb

@@ -3,26 +3,26 @@ require_relative '../../../../spec_helper'
 describe AIXM::Component::Geometry::Arc do
   describe :initialize do
     it "won't accept invalid arguments" do
-      xy = AIXM::XY.new(lat: 11.1, long: 22.2)
-      -> { AIXM::Component::Geometry::Arc.new(xy: 0, center_xy: xy, clockwise: true) }.must_raise ArgumentError
-      -> { AIXM::Component::Geometry::Arc.new(xy: xy, center_xy: 0, clockwise: true) }.must_raise ArgumentError
-      -> { AIXM::Component::Geometry::Arc.new(xy: xy, center_xy: xy, clockwise: 0) }.must_raise ArgumentError
+      xy = AIXM.xy(lat: 11.1, long: 22.2)
+      -> { AIXM.arc(xy: 0, center_xy: xy, clockwise: true) }.must_raise ArgumentError
+      -> { AIXM.arc(xy: xy, center_xy: 0, clockwise: true) }.must_raise ArgumentError
+      -> { AIXM.arc(xy: xy, center_xy: xy, clockwise: 0) }.must_raise ArgumentError
     end
   end
 
   describe :clockwise? do
     it "must return true or false" do
-      xy = AIXM::XY.new(lat: 11.1, long: 22.2)
-      AIXM::Component::Geometry::Arc.new(xy: xy, center_xy: xy, clockwise: true).must_be :clockwise?
-      AIXM::Component::Geometry::Arc.new(xy: xy, center_xy: xy, clockwise: false).wont_be :clockwise?
+      xy = AIXM.xy(lat: 11.1, long: 22.2)
+      AIXM.arc(xy: xy, center_xy: xy, clockwise: true).must_be :clockwise?
+      AIXM.arc(xy: xy, center_xy: xy, clockwise: false).wont_be :clockwise?
     end
   end
 
   describe :to_digest do
     it "must return digest of payload" do
-      subject = AIXM::Component::Geometry::Arc.new(
-        xy: AIXM::XY.new(lat: 11.1, long: 33.3),
-        center_xy: AIXM::XY.new(lat: 22.2, long: 33.3),
+      subject = AIXM.arc(
+        xy: AIXM.xy(lat: 11.1, long: 33.3),
+        center_xy: AIXM.xy(lat: 22.2, long: 33.3),
         clockwise: true
       )
       subject.to_digest.must_equal 712900173
@@ -31,9 +31,9 @@ describe AIXM::Component::Geometry::Arc do
 
   describe :to_xml do
     it "must build correct XML for clockwise arcs" do
-      subject = AIXM::Component::Geometry::Arc.new(
-        xy: AIXM::XY.new(lat: 11.1, long: 33.3),
-        center_xy: AIXM::XY.new(lat: 22.2, long: 33.3),
+      subject = AIXM.arc(
+        xy: AIXM.xy(lat: 11.1, long: 33.3),
+        center_xy: AIXM.xy(lat: 22.2, long: 33.3),
         clockwise: true
       )
       subject.to_xml.must_equal <<~END
@@ -49,9 +49,9 @@ describe AIXM::Component::Geometry::Arc do
     end
 
     it "must build correct XML for counter-clockwise arcs" do
-      subject = AIXM::Component::Geometry::Arc.new(
-        xy: AIXM::XY.new(lat: 11.1, long: 33.3),
-        center_xy: AIXM::XY.new(lat: 22.2, long: 33.3),
+      subject = AIXM.arc(
+        xy: AIXM.xy(lat: 11.1, long: 33.3),
+        center_xy: AIXM.xy(lat: 22.2, long: 33.3),
         clockwise: false
       )
       subject.to_xml.must_equal <<~END