aixm 0.2.3 → 0.3.0

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

@@ -1,21 +1,40 @@
+using AIXM::Refinements
+
 module AIXM
-  module Feature
-    module NavigationalAid
+  class Feature
+    class NavigationalAid
 
-      ##
-      # DME (distance measuring equipment) operate in the frequency band
-      # between 962 MHz and 1213 MHz.
+      # Distance measuring equipment (DME) is a transponder-based radio navigation
+      # technology which measures slant range distance by timing the propagation
+      # delay of VHF or UHF signals. They operate in the frequency band between
+      # 962 MHz and 1213 MHz.
+      #
+      # ===Cheat Sheet in Pseudo Code:
+      #   dme = AIXM.dme(
+      #     source: String or nil
+      #     region: String or nil (falls back to AIXM.config.region)
+      #     organisation: AIXM.organisation
+      #     id: String
+      #     name: String
+      #     xy: AIXM.xy
+      #     z: AIXM.z or nil
+      #     channel: String
+      #   )
+      #   dme.timetable = AIXM.timetable or nil
+      #   dme.remarks = String or nil
       #
-      # https://en.wikipedia.org/wiki/Distance_measuring_equipment
-      class DME < Base
-        using AIXM::Refinements
+      # @see https://github.com/openflightmaps/ofmx/wiki/Navigational-aid#dme-dme
+      class DME < NavigationalAid
+        public_class_method :new
 
-        attr_reader :channel, :vor
+        # @return [String] radio channel
+        attr_reader :channel
 
-        public_class_method :new
+        # @return [AIXM::Feature::NavigationalAid::VOR, nil] associated VOR
+        attr_reader :vor
 
-        def initialize(id:, name:, xy:, z: nil, channel:)
-          super(id: id, name: name, xy: xy, z: z)
+        def initialize(channel:, **arguments)
+          super(**arguments)
           self.channel = channel
         end
 
@@ -28,46 +47,35 @@ module AIXM
           fail(ArgumentError, "invalid VOR") unless value.is_a? VOR
           @vor = value
         end
+        private :vor=
 
-        ##
-        # Digest to identify the payload
-        def to_digest
-          [super, channel].to_digest
-        end
-
-        ##
-        # Render UID markup
-        def to_uid(*extensions)
+        # @return [String] UID markup
+        def to_uid
           builder = Builder::XmlMarkup.new(indent: 2)
-          builder.DmeUid({ mid: to_digest, newEntity: (true if extensions >> :ofm) }.compact) do |dmeuid|
-            dmeuid.codeId(id)
-            dmeuid.geoLat(xy.lat(format_for(*extensions)))
-            dmeuid.geoLong(xy.long(format_for(*extensions)))
+          builder.DmeUid({ region: (region if AIXM.ofmx?) }.compact) do |dme_uid|
+            dme_uid.codeId(id)
+            dme_uid.geoLat(xy.lat(AIXM.schema))
+            dme_uid.geoLong(xy.long(AIXM.schema))
           end
         end
 
-        ##
-        # Render AIXM markup
-        def to_aixm(*extensions)
-          builder = to_builder(*extensions)
-          builder.Dme do |dme|
-            dme << to_uid(*extensions).indent(2)
-            dme.OrgUid
-            dme << vor.to_uid(*extensions).indent(2) if vor
+        # @return [String] AIXM or OFMX markup
+        def to_xml
+          builder = to_builder
+          builder.Dme({ source: (source if AIXM.ofmx?) }.compact) do |dme|
+            dme << to_uid.indent(2)
+            dme << organisation.to_uid.indent(2)
+            dme << vor.to_uid.indent(2) if vor
             dme.txtName(name) if name
             dme.codeChannel(channel)
             dme.codeDatum('WGE')
             if z
               dme.valElev(z.alt)
-              dme.uomDistVer(z.unit.to_s)
-            end
-            if schedule
-              dme.Dtt do |dtt|
-                dtt << schedule.to_aixm(*extensions).indent(4)
-              end
+              dme.uomDistVer(z.unit.upcase.to_s)
             end
+            dme << timetable.to_xml(as: :Dtt).indent(2) if timetable
             dme.txtRmk(remarks) if remarks
-            dme.target!   # see https://github.com/jimweirich/builder/issues/42
+            dme.target!
           end
         end
       end

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

@@ -1,82 +1,92 @@
+using AIXM::Refinements
+
 module AIXM
-  module Feature
-    module NavigationalAid
+  class Feature
+    class NavigationalAid
 
-      ##
-      # Marker (marker beacons) operate on 75 MHz.
+      # Marker beacons guide an aircraft on a specific route e.g. towards a
+      # runway (which is why marker beacons are often part of an ILS). Their
+      # VHF radio beacons are transmitted on 75 MHz.
+      #
+      # ===Cheat Sheet in Pseudo Code:
+      #   marker = AIXM.marker(
+      #     source: String or nil
+      #     region: String or nil (falls back to AIXM.config.region)
+      #     organisation: AIXM.organisation
+      #     id: String
+      #     name: String
+      #     xy: AIXM.xy
+      #     z: AIXM.z or nil
+      #     type: :outer or :middle or :inner or :backcourse
+      #   )
+      #   marker.timetable = AIXM.timetable or nil
+      #   marker.remarks = String or nil
       #
-      # Types:
-      # * +:outer+ (+:O+) - outer marker
-      # * +:middle+ (+:M+) - middle marker
-      # * +:inner+ (+:I+) - inner marker
-      # * +:backcourse+ (+:C+) - backcourse marker
+      # @note Marker are not fully implemented because they usually have to be
+      #   associated with an ILS which are not implemented as of now.
       #
-      # https://en.wikipedia.org/wiki/Marker_beacon
-      class Marker < Base
-        using AIXM::Refinements
+      # @see https://github.com/openflightmaps/ofmx/wiki/Navigational-aid#mkr-marker-beacon
+      class Marker < NavigationalAid
+        public_class_method :new
 
         TYPES = {
           O: :outer,
           M: :middle,
           I: :inner,
-          C: :backcourse
+          C: :backcourse,
+          OTHER: :other     # specify in remarks
         }
 
+        # @return [Symbol] type of marker (see {TYPES})
         attr_reader :type
 
-        public_class_method :new
-
-        # TODO: Marker require an associated ILS
-        def initialize(id:, name:, xy:, z: nil, type:)
-          super(id: id, name: name, xy: xy, z: z)
+        # TODO: Marker require an associated ILS (not yet implemented)
+        def initialize(type:, **arguments)
+          super(**arguments)
           self.type = type
           warn("WARNING: Maker is not fully implemented yet due to the lack of ILS")
         end
 
         def type=(value)
-          @type = TYPES.lookup(value&.to_sym, nil) || fail(ArgumentError, "invalid type")
+          @type = value.nil? ? nil : TYPES.lookup(value.to_s.to_sym, nil) || fail(ArgumentError, "invalid type")
         end
 
-        def type_key
-          TYPES.key(type)
-        end
-
-        ##
-        # Render UID markup
-        def to_uid(*extensions)
+        # @return [String] UID markup
+        def to_uid
           builder = Builder::XmlMarkup.new(indent: 2)
-          builder.MkrUid({ mid: to_digest, newEntity: (true if extensions >> :ofm) }.compact) do |mkruid|
-            mkruid.codeId(id)
-            mkruid.geoLat(xy.lat(format_for(*extensions)))
-            mkruid.geoLong(xy.long(format_for(*extensions)))
+          builder.MkrUid({ region: (region if AIXM.ofmx?) }.compact) do |mkr_uid|
+            mkr_uid.codeId(id)
+            mkr_uid.geoLat(xy.lat(AIXM.schema))
+            mkr_uid.geoLong(xy.long(AIXM.schema))
           end
         end
 
-        ##
-        # Render AIXM markup
-        def to_aixm(*extensions)
-          builder = to_builder(*extensions)
-          builder.Mkr do |mkr|
-            mkr << to_uid(*extensions).indent(2)
-            mkr.OrgUid
-            mkr.codePsnIls(type_key.to_s)
+        # @return [String] AIXM or OFMX markup
+        def to_xml
+          builder = to_builder
+          builder.Mkr({ source: (source if AIXM.ofmx?) }.compact) do |mkr|
+            mkr << to_uid.indent(2)
+            mkr << organisation.to_uid.indent(2)
+            mkr.codePsnIls(type_key.to_s) if type_key
             mkr.valFreq(75)
             mkr.uomFreq('MHZ')
             mkr.txtName(name) if name
             mkr.codeDatum('WGE')
             if z
               mkr.valElev(z.alt)
-              mkr.uomDistVer(z.unit.to_s)
-            end
-            if schedule
-              mkr.Mtt do |mtt|
-                mtt << schedule.to_aixm(*extensions).indent(4)
-              end
+              mkr.uomDistVer(z.unit.upcase.to_s)
             end
+            mkr << timetable.to_xml(as: :Mtt).indent(2) if timetable
             mkr.txtRmk(remarks) if remarks
-            mkr.target!   # see https://github.com/jimweirich/builder/issues/42
+            mkr.target!
           end
         end
+
+        private
+
+        def type_key
+          TYPES.key(type)
+        end
       end
 
     end

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

@@ -1,41 +1,51 @@
+using AIXM::Refinements
+
 module AIXM
-  module Feature
-    module NavigationalAid
+  class Feature
+    class NavigationalAid
 
-      ##
-      # NDB (non-directional beacon) operate in the frequency band between
-      # 190 kHz and 1750 kHz.
+      # A non-directional radio beacon (NDB) is a radio transmitter at a known
+      # location operating in the frequency band between 190 kHz and 1750 kHz.
       #
-      # Types:
-      # * +:en_route+ (+:B+) - high powered NDB
-      # * +:locator+ (+:L+) - locator (low powered NDB)
-      # * +:marine+ (+:M+) - marine beacon
+      # ===Cheat Sheet in Pseudo Code:
+      #   ndb = AIXM.ndb(
+      #     source: String or nil
+      #     region: String or nil (falls back to AIXM.config.region)
+      #     organisation: AIXM.organisation
+      #     id: String
+      #     name: String
+      #     xy: AIXM.xy
+      #     z: AIXM.z or nil
+      #     type: TYPES
+      #     f: AIXM.f
+      #   )
+      #   ndb.timetable = AIXM.timetable or nil
+      #   ndb.remarks = String or nil
       #
-      # https://en.wikipedia.org/wiki/Non-directional_beacon
-      class NDB < Base
-        using AIXM::Refinements
+      # @see https://github.com/openflightmaps/ofmx/wiki/Navigational-aid#ndb-ndb
+      class NDB < NavigationalAid
+        public_class_method :new
 
         TYPES = {
           B: :en_route,
           L: :locator,
-          M: :marine
+          M: :marine,
+          OTHER: :other   # specify in remarks
         }.freeze
 
-        attr_reader :type, :f
+        # @return [Symbol, nil] type of NDB (see {TYPES})
+        attr_reader :type
 
-        public_class_method :new
+        # @return [AIXM::F] radio frequency
+        attr_reader :f
 
-        def initialize(id:, name:, xy:, z: nil, type:, f:)
-          super(id: id, name: name, xy: xy, z: z)
+        def initialize(type:, f:, **arguments)
+          super(**arguments)
           self.type, self.f = type, f
         end
 
         def type=(value)
-          @type = TYPES.lookup(value&.to_sym, nil) || fail(ArgumentError, "invalid type")
-        end
-
-        def type_key
-          TYPES.key(type)
+          @type = value.nil? ? nil : TYPES.lookup(value.to_s.to_sym, nil) || fail(ArgumentError, "invalid type")
         end
 
         def f=(value)
@@ -43,48 +53,42 @@ module AIXM
           @f = value
         end
 
-        ##
-        # Digest to identify the payload
-        def to_digest
-          [super, f.to_digest].to_digest
-        end
-
-        ##
-        # Render UID markup
-        def to_uid(*extensions)
+        # @return [String] UID markup
+        def to_uid
           builder = Builder::XmlMarkup.new(indent: 2)
-          builder.NdbUid({ mid: to_digest, 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)))
+          builder.NdbUid({ region: (region if AIXM.ofmx?) }.compact) do |ndb_uid|
+            ndb_uid.codeId(id)
+            ndb_uid.geoLat(xy.lat(AIXM.schema))
+            ndb_uid.geoLong(xy.long(AIXM.schema))
           end
         end
 
-        ##
-        # Render AIXM markup
-        def to_aixm(*extensions)
-          builder = to_builder(*extensions)
-          builder.Ndb do |ndb|
-            ndb << to_uid(*extensions).indent(2)
-            ndb.OrgUid
+        # @return [String] AIXM or OFMX markup
+        def to_xml
+          builder = to_builder
+          builder.Ndb({ source: (source if AIXM.ofmx?) }.compact) do |ndb|
+            ndb << to_uid.indent(2)
+            ndb << organisation.to_uid.indent(2)
             ndb.txtName(name) if name
             ndb.valFreq(f.freq.trim)
             ndb.uomFreq(f.unit.upcase.to_s)
-            ndb.codeClass(type_key.to_s)
+            ndb.codeClass(type_key.to_s) if type
             ndb.codeDatum('WGE')
             if z
               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
+              ndb.uomDistVer(z.unit.upcase.to_s)
             end
+            ndb << timetable.to_xml(as: :Ntt).indent(2) if timetable
             ndb.txtRmk(remarks) if remarks
-            ndb.target!   # see https://github.com/jimweirich/builder/issues/42
+            ndb.target!
           end
         end
+
+        private
+
+        def type_key
+          TYPES.key(type)
+        end
       end
 
     end

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

@@ -1,51 +1,58 @@
+using AIXM::Refinements
+
 module AIXM
-  module Feature
-    module NavigationalAid
+  class Feature
+    class NavigationalAid
 
-      ##
-      # 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.
+      # TACAN (tactical air navigation system) are military systems which also
+      # provide DME service to civilian aircraft and therefore operate in the
+      # frequency band between 960 MHz and 1215 MHz.
+      #
+      # ===Cheat Sheet in Pseudo Code:
+      #   tacan = AIXM.tacan(
+      #     source: String or nil
+      #     region: String or nil (to use +AIXM.config.region+)
+      #     organisation: AIXM.organisation
+      #     id: String
+      #     name: String
+      #     xy: AIXM.xy
+      #     z: AIXM.z or nil
+      #     channel: String
+      #   )
+      # tacan.timetable = AIXM.timetable or nil
+      # tacan.remarks = String or nil
       #
-      # https://en.wikipedia.org/wiki/Tactical_air_navigation_system
+      # @see https://github.com/openflightmaps/ofmx/wiki/Navigational-aid#tcn-tacan
       class TACAN < DME
-        using AIXM::Refinements
-
         public_class_method :new
 
-        ##
-        # Render UID markup
-        def to_uid(*extensions)
+        # @return [String] UID markup
+        def to_uid
           builder = Builder::XmlMarkup.new(indent: 2)
-          builder.TcnUid({ mid: to_digest, 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)))
+          builder.TcnUid({ region: (region if AIXM.ofmx?) }.compact) do |tcn_uid|
+            tcn_uid.codeId(id)
+            tcn_uid.geoLat(xy.lat(AIXM.schema))
+            tcn_uid.geoLong(xy.long(AIXM.schema))
           end
         end
 
-        ##
-        # Render AIXM markup
-        def to_aixm(*extensions)
-          builder = to_builder(*extensions)
-          builder.Tcn do |tcn|
-            tcn << to_uid(*extensions).indent(2)
-            tcn.OrgUid
-            tcn << vor.to_uid(*extensions).indent(2) if vor
+        # @return [String] AIXM or OFMX markup
+        def to_xml
+          builder = to_builder
+          builder.Tcn({ source: (source if AIXM.ofmx?) }.compact) do |tcn|
+            tcn << to_uid.indent(2)
+            tcn << organisation.to_uid.indent(2)
+            tcn << vor.to_uid.indent(2) if vor
             tcn.txtName(name) if name
             tcn.codeChannel(channel)
             tcn.codeDatum('WGE')
             if z
               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
+              tcn.uomDistVer(z.unit.upcase.to_s)
             end
+            tcn << timetable.to_xml(as: :Ttt).indent(2) if timetable
             tcn.txtRmk(remarks) if remarks
-            tcn.target!   # see https://github.com/jimweirich/builder/issues/42
+            tcn.target!
           end
         end
       end