aixm 0.2.0 → 0.2.1

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

@@ -16,8 +16,12 @@ module AIXM
 
         def initialize(id:, name:, xy:, z: nil, f:)
           super(id: id, name: name, xy: xy, z: z)
-          @f = f
-          fail(ArgumentError, "invalid frequency") unless f.is_a?(F) && f.between?(190, 1750, :khz)
+          self.f = f
+        end
+
+        def f=(value)
+          fail(ArgumentError, "invalid f") unless value.is_a?(F) && value.between?(190, 1750, :khz)
+          @f = value
         end
 
         ##
@@ -27,15 +31,22 @@ module AIXM
         end
 
         ##
-        # Render AIXM
-        def to_xml(*extensions)
+        # Render UID markup
+        def to_uid(*extensions)
+          builder = Builder::XmlMarkup.new(indent: 2)
+          builder.NdbUid({ newEntity: (true if extensions >> :ofm) }.compact) do |ndbuid|
+            ndbuid.codeId(id)
+            ndbuid.geoLat(xy.lat(format_for(*extensions)))
+            ndbuid.geoLong(xy.long(format_for(*extensions)))
+          end
+        end
+
+        ##
+        # Render AIXM markup
+        def to_aixm(*extensions)
           builder = to_builder(*extensions)
           builder.Ndb do |ndb|
-            ndb.NdbUid({ newEntity: (true if extensions >> :ofm) }.compact) do |ndbuid|
-              ndbuid.codeId(id)
-              ndbuid.geoLat(xy.lat(format_for(*extensions)))
-              ndbuid.geoLong(xy.long(format_for(*extensions)))
-            end
+            ndb << to_uid(*extensions).indent(2)
             ndb.OrgUid
             ndb.txtName(name)
             ndb.valFreq(f.freq.trim)
@@ -45,6 +56,11 @@ module AIXM
               ndb.valElev(z.alt)
               ndb.uomDistVer(z.unit.to_s)
             end
+            if schedule
+              ndb.Ntt do |ntt|
+                ntt << schedule.to_aixm(*extensions).indent(4)
+              end
+            end
             ndb.txtRmk(remarks) if remarks
             ndb.target!   # see https://github.com/jimweirich/builder/issues/42
           end

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

@@ -3,39 +3,35 @@ module AIXM
     module NavigationalAid
 
       ##
-      # TACAN (tactical air navigation system) operate in the frequency band
-      # between 960 MHz and 1215 MHz.
+      # TACAN (tactical air navigation system) can be used as a DME by civilian
+      # aircraft and therefore operate in the frequency band between 960 MHz
+      # and 1215 MHz.
       #
       # https://en.wikipedia.org/wiki/Tactical_air_navigation_system
-      class TACAN < Base
+      class TACAN < DME
         using AIXM::Refinements
 
-        attr_reader :channel
-
         public_class_method :new
 
-        def initialize(id:, name:, xy:, z: nil, channel:)
-          super(id: id, name: name, xy: xy, z: z)
-          @channel = channel&.upcase
-        end
-
         ##
-        # Digest to identify the payload
-        def to_digest
-          [super, channel].to_digest
+        # Render UID markup
+        def to_uid(*extensions)
+          builder = Builder::XmlMarkup.new(indent: 2)
+          builder.TcnUid({ newEntity: (true if extensions >> :ofm) }.compact) do |tcnuid|
+            tcnuid.codeId(id)
+            tcnuid.geoLat(xy.lat(format_for(*extensions)))
+            tcnuid.geoLong(xy.long(format_for(*extensions)))
+          end
         end
 
         ##
-        # Render AIXM
-        def to_xml(*extensions)
+        # Render AIXM markup
+        def to_aixm(*extensions)
           builder = to_builder(*extensions)
           builder.Tcn do |tcn|
-            tcn.TcnUid({ newEntity: (true if extensions >> :ofm) }.compact) do |tcnuid|
-              tcnuid.codeId(id)
-              tcnuid.geoLat(xy.lat(format_for(*extensions)))
-              tcnuid.geoLong(xy.long(format_for(*extensions)))
-            end
+            tcn << to_uid(*extensions).indent(2)
             tcn.OrgUid
+            tcn << vor.to_uid(*extensions).indent(2) if vor
             tcn.txtName(name)
             tcn.codeChannel(channel)
             tcn.codeDatum('WGE')
@@ -43,6 +39,11 @@ module AIXM
               tcn.valElev(z.alt)
               tcn.uomDistVer(z.unit.to_s)
             end
+            if schedule
+              tcn.Ttt do |ttt|
+                ttt << schedule.to_aixm(*extensions).indent(4)
+              end
+            end
             tcn.txtRmk(remarks) if remarks
             tcn.target!   # see https://github.com/jimweirich/builder/issues/42
           end

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

@@ -8,7 +8,7 @@ module AIXM
       #
       # Types:
       # * +:vor+ (+:VOR+) - standard VOR
-      # * +:vordme+ (+:DVOR+) - VOR/DME
+      # * +:doppler_vor+ (+:DVOR+) - Doppler VOR
       #
       # North types:
       # * +:geographic+ (+:TRUE+) - VOR aligned towards geographic north
@@ -16,7 +16,6 @@ module AIXM
       #                       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
@@ -24,26 +23,61 @@ module AIXM
 
         TYPES = {
           VOR: :vor,
-          DVOR: :vordme
+          DVOR: :doppler_vor
         }.freeze
 
         NORTHS = {
           TRUE: :geographic,
           GRID: :grid,
-          MAG: :magnetic,
-          OTHER: :other
+          MAG: :magnetic
         }.freeze
 
-        attr_reader :type, :f, :north
+        attr_reader :type, :f, :north, :dme, :tacan
 
         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)
+          self.type, self.f, self.north = type, f, north
+        end
+
+        def type=(value)
+          @type = TYPES.lookup(value&.to_sym, nil) || fail(ArgumentError, "invalid type")
+        end
+
+        def type_key
+          TYPES.key(type)
+        end
+
+        def f=(value)
+          fail(ArgumentError, "invalid f") unless value.is_a?(F) && value.between?(108, 117.95, :mhz)
+          @f = value
+        end
+
+        def north=(value)
+          @north = NORTHS.lookup(value&.to_sym, nil) || fail(ArgumentError, "invalid north")
+        end
+
+        def north_key
+          NORTHS.key(north)
+        end
+
+        ##
+        # Associate a DME (also known as VOR/DME)
+        def associate_dme(channel:)
+          @dme = AIXM.dme(id: id, name: name, xy: xy, z: z, channel: channel)
+          @dme.schedule = schedule
+          @dme.remarks = remarks
+          @dme.vor = self
+        end
+
+        ##
+        # Associate a TACAN (also known as VORTAC)
+        def associate_tacan(channel:)
+          @tacan = AIXM.tacan(id: id, name: name, xy: xy, z: z, channel: channel)
+          @tacan.schedule = schedule
+          @tacan.remarks = remarks
+          @tacan.vor = self
         end
 
         ##
@@ -53,15 +87,22 @@ module AIXM
         end
 
         ##
-        # Render AIXM
-        def to_xml(*extensions)
+        # Render UID markup
+        def to_uid(*extensions)
+          builder = Builder::XmlMarkup.new(indent: 2)
+          builder.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
+        end
+
+        ##
+        # Render AIXM markup
+        def to_aixm(*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 << to_uid(*extensions).indent(2)
             vor.OrgUid
             vor.txtName(name)
             vor.codeType(type_key.to_s)
@@ -73,17 +114,16 @@ module AIXM
               vor.valElev(z.alt)
               vor.uomDistVer(z.unit.to_s)
             end
+            if schedule
+              vor.Vtt do |vtt|
+                vtt << schedule.to_aixm(*extensions).indent(4)
+              end
+            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)
+          builder << @dme.to_aixm(*extensions) if @dme
+          builder << @tacan.to_aixm(*extensions) if @tacan
+          builder.target!   # see https://github.com/jimweirich/builder/issues/42
         end
       end
 

data/lib/aixm/version.rb

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

data/spec/factory.rb

@@ -48,26 +48,26 @@ module AIXM
         end
       end
 
-      def polygon_airspace(short_name: 'POLYGON', schedule: :H24)
+      def polygon_airspace
         AIXM.airspace(
           name: 'POLYGON AIRSPACE',
-          short_name: short_name,
+          short_name: 'POLYGON',
           type: 'D'
         ).tap do |airspace|
-          airspace.schedule = AIXM.schedule(code: schedule) if schedule
+          airspace.schedule = AIXM::H24
           airspace.class_layers << class_layer
           airspace.geometry = polygon_geometry
           airspace.remarks = 'polygon airspace'
         end
       end
 
-      def circle_airspace(short_name: 'CIRCLE', schedule: :H24)
+      def circle_airspace
         AIXM.airspace(
           name: 'CIRCLE AIRSPACE',
-          short_name: short_name,
+          short_name: 'CIRCLE',
           type: 'D'
         ).tap do |airspace|
-          airspace.schedule = AIXM.schedule(code: schedule) if schedule
+          airspace.schedule = AIXM::H24
           airspace.class_layers << class_layer
           airspace.geometry = circle_geometry
           airspace.remarks = 'circle airspace'
@@ -76,24 +76,26 @@ module AIXM
 
       def designated_point
         AIXM.designated_point(
-          id: 'DPN',
+          id: 'DDD',
           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.schedule = AIXM::H24
           designated_point.remarks = 'designated point navaid'
         end
       end
 
       def dme
         AIXM.dme(
-          id: 'DME',
+          id: 'MMM',
           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.schedule = AIXM::H24
           dme.remarks = 'dme navaid'
         end
       end
@@ -105,48 +107,99 @@ module AIXM
           xy: AIXM.xy(lat: %q(47°51'33"N), long: %q(007°33'36"E)),
           z: AIXM.z(500, :qnh)
         ).tap do |marker|
+          marker.schedule = AIXM::H24
           marker.remarks = 'marker navaid'
         end
       end
 
       def ndb
         AIXM.ndb(
-          id: 'NDB',
+          id: 'NNN',
           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.schedule = AIXM::H24
           ndb.remarks = 'ndb navaid'
         end
       end
 
       def tacan
         AIXM.tacan(
-          id: 'TCN',
+          id: 'TTT',
           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.schedule = AIXM::H24
           tacan.remarks = 'tacan navaid'
         end
       end
 
       def vor
         AIXM.vor(
-          id: 'VOR',
+          id: 'VVV',
           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,
+          type: :vor,
           f: AIXM.f(111, :mhz),
           north: :geographic
         ).tap do |vor|
+          vor.schedule = AIXM::H24
           vor.remarks = 'vor navaid'
         end
       end
 
+      def dvor
+        AIXM.vor(
+          id: 'DVV',
+          name: 'DOPPLER-VOR NAVAID',
+          xy: AIXM.xy(lat: %q(47°51'33"N), long: %q(007°33'36"E)),
+          z: AIXM.z(500, :qnh),
+          type: :doppler_vor,
+          f: AIXM.f(111, :mhz),
+          north: :geographic
+        ).tap do |doppler_vor|
+          doppler_vor.schedule = AIXM::H24
+          doppler_vor.remarks = 'doppler-vor navaid'
+        end
+      end
+
+      def vordme
+        AIXM.vor(
+          id: 'VDD',
+          name: 'VOR/DME 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 |vordme|
+          vordme.schedule = AIXM::H24
+          vordme.remarks = 'vor/dme navaid'
+          vordme.associate_dme(channel: '95X')
+        end
+      end
+
+      def vortac
+        AIXM.vor(
+          id: 'VTT',
+          name: 'VORTAC 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 |vortac|
+          vortac.schedule = AIXM::H24
+          vortac.remarks = 'vortac navaid'
+          vortac.associate_tacan(channel: '29X')
+        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|
@@ -156,8 +209,11 @@ module AIXM
           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
+          document.features << AIXM::Factory.vor
+          document.features << AIXM::Factory.dvor
+          document.features << AIXM::Factory.vordme
+          document.features << AIXM::Factory.vortac
         end
       end