aixm 0.2.3 → 0.3.0

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

@@ -1,52 +1,70 @@
+using AIXM::Refinements
+
 module AIXM
-  module Feature
-    module NavigationalAid
+  class Feature
+    class 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+) - conventional VOR (also known as CVOR)
-      # * +:doppler_vor+ (+:DVOR+) - Doppler VOR
+      # VHF omni directional radio range (VOR) is a type of radio navigation for
+      # aircraft to determine their position and course. They operate in the
+      # frequency band between 108.00 Mhz to 117.95 MHz.
       #
-      # 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
+      # ===Cheat Sheet in Pseudo Code:
+      #   vor = AIXM.vor(
+      #     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
+      #     north: NORTHS
+      #   )
+      #   vor.timetable = AIXM.timetable or nil
+      #   vor.remarks = String or nil
+      #   vor.associate_dme(channel: String)     # turns the VOR into a VOR/DME
+      #   vor.associate_tacan(channel: String)   # turns the VOR into a VORTAC
       #
-      # https://en.wikipedia.org/wiki/VHF_omnidirectional_range
-      class VOR < Base
-        using AIXM::Refinements
+      # @see https://github.com/openflightmaps/ofmx/wiki/Navigational-aid#vor-vor
+      class VOR < NavigationalAid
+        public_class_method :new
 
         TYPES = {
           VOR: :conventional,
-          DVOR: :doppler
+          DVOR: :doppler,
+          OTHER: :other         # specify in remarks
         }.freeze
 
         NORTHS = {
           TRUE: :geographic,
-          GRID: :grid,
-          MAG: :magnetic
+          GRID: :grid,         # parallel to the north-south lines of the UTM grid
+          MAG: :magnetic,
+          OTHER: :other        # specify in remarks
         }.freeze
 
-        attr_reader :type, :f, :north, :dme, :tacan
+        # @return [Symbol] type of VOR (see {TYPES})
+        attr_reader :type
 
-        public_class_method :new
+        # @return [AIXM::F] radio requency
+        attr_reader :f
+
+        # @return [Symbol] north indication (see {NORTHS})
+        attr_reader :north
+
+        # @return [AIXM::Feature::NavigationalAid::DME, nil] associated DME
+        attr_reader :dme
+
+        # @return [AIXM::Feature::NavigationalAid::TACAN, nil] associated TACAN
+        attr_reader :tacan
 
-        def initialize(id:, name:, xy:, z: nil, type:, f:, north:)
-          super(id: id, name: name, xy: xy, z: z)
+        def initialize(type:, f:, north:, **arguments)
+          super(**arguments)
           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)
+          @type = TYPES.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid type")
         end
 
         def f=(value)
@@ -55,55 +73,39 @@ module AIXM
         end
 
         def north=(value)
-          @north = NORTHS.lookup(value&.to_sym, nil) || fail(ArgumentError, "invalid north")
-        end
-
-        def north_key
-          NORTHS.key(north)
+          @north = NORTHS.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid north")
         end
 
-        ##
-        # Associate a DME (also known as VOR/DME)
+        # Associate a DME which turns the VOR into a 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
+          @dme = AIXM.dme(organisation: organisation, id: id, name: name, xy: xy, z: z, channel: channel)
+          @dme.region, @dme.timetable, @dme.remarks = region, timetable, remarks
+          @dme.send(:vor=, self)
         end
 
-        ##
-        # Associate a TACAN (also known as VORTAC)
+        # Associate a TACAN which turns the VOR into a 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
-
-        ##
-        # Digest to identify the payload
-        def to_digest
-          [super, type, f.to_digest, north].to_digest
+          @tacan = AIXM.tacan(organisation: organisation, id: id, name: name, xy: xy, z: z, channel: channel)
+          @tacan.region, @tacan.timetable, @tacan.remarks = region, timetable, remarks
+          @tacan.send(:vor=, self)
         end
 
-        ##
-        # Render UID markup
-        def to_uid(*extensions)
+        # @return [String] UID markup
+        def to_uid
           builder = Builder::XmlMarkup.new(indent: 2)
-          builder.VorUid({ mid: to_digest, 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)))
+          builder.VorUid({ region: (region if AIXM.ofmx?) }.compact) do |vor_uid|
+            vor_uid.codeId(id)
+            vor_uid.geoLat(xy.lat(AIXM.schema))
+            vor_uid.geoLong(xy.long(AIXM.schema))
           end
         end
 
-        ##
-        # Render AIXM markup
-        def to_aixm(*extensions)
-          builder = to_builder(*extensions)
-          builder.Vor do |vor|
-            vor << to_uid(*extensions).indent(2)
-            vor.OrgUid
+        # @return [String] AIXM or OFMX markup
+        def to_xml
+          builder = to_builder
+          builder.Vor({ source: (source if AIXM.ofmx?) }.compact) do |vor|
+            vor << to_uid.indent(2)
+            vor << organisation.to_uid.indent(2)
             vor.txtName(name) if name
             vor.codeType(type_key.to_s)
             vor.valFreq(f.freq.trim)
@@ -112,18 +114,24 @@ module AIXM
             vor.codeDatum('WGE')
             if z
               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
+              vor.uomDistVer(z.unit.upcase.to_s)
             end
+            vor << timetable.to_xml(as: :Vtt).indent(2) if timetable
             vor.txtRmk(remarks) if remarks
           end
-          builder << @dme.to_aixm(*extensions) if @dme
-          builder << @tacan.to_aixm(*extensions) if @tacan
-          builder.target!   # see https://github.com/jimweirich/builder/issues/42
+          builder << @dme.to_xml if @dme
+          builder << @tacan.to_xml if @tacan
+          builder.target!
+        end
+
+        # @api private
+        def type_key
+          TYPES.key(type)
+        end
+
+        # @api private
+        def north_key
+          NORTHS.key(north)
         end
       end
 

data/lib/aixm/feature/organisation.rb

@@ -0,0 +1,97 @@
+using AIXM::Refinements
+
+module AIXM
+  class Feature
+
+    # Organisations and authorities such as ATS organisations, aircraft
+    # operating agencies, states and so forth.
+    #
+    # ===Cheat Sheet in Pseudo Code:
+    #   organisation = AIXM.organisation(
+    #     source: String or nil
+    #     region: String or nil (falls back to +AIXM.config.region+)
+    #     name: String
+    #     type: TYPES
+    #   )
+    #   organisation.id = String or nil
+    #   organisation.remarks = String or nil
+    #
+    # @see https://github.com/openflightmaps/ofmx/wiki/Organisation#org-organisation
+    class Organisation < Feature
+      public_class_method :new
+
+      TYPES = {
+        S: :state,
+        GS: :group_of_states,
+        O: :national_organisation,
+        IO: :international_organisation,
+        AOA: :aircraft_operating_agency,
+        ATS: :air_traffic_services_provider,
+        HA: :handling_authority,
+        A: :national_authority,
+        OTHER: :other                          # specify in remarks
+      }.freeze
+
+      # @return [String] name of organisation (e.g. "FRANCE")
+      attr_reader :name
+
+      # @return [Symbol] type of organisation (see {TYPES})
+      attr_reader :type
+
+      # @return [String, nil] code of the organisation (e.g. "LF")
+      attr_reader :id
+
+      # @return [String, nil] free text remarks
+      attr_reader :remarks
+
+      def initialize(source: nil, region: nil, name:, type:)
+        super(source: source, region: region)
+        self.name, self.type = name, type
+      end
+
+      # @return [String]
+      def inspect
+        %Q(#<#{self.class} name=#{name.inspect} type=#{type.inspect}>)
+      end
+
+      def name=(value)
+        fail(ArgumentError, "invalid name") unless value.is_a? String
+        @name = value.uptrans
+      end
+
+      def type=(value)
+        @type = TYPES.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid type")
+      end
+
+      def id=(value)
+        fail(ArgumentError, "invalid id") unless value.nil? || value.is_a?(String)
+        @id = value&.upcase
+      end
+
+      def remarks=(value)
+        @remarks = value&.to_s
+      end
+
+      # @return [String] UID markup
+      def to_uid
+        builder = Builder::XmlMarkup.new(indent: 2)
+        builder.OrgUid({ region: (region if AIXM.ofmx?) }.compact) do |org_uid|
+          org_uid.txtName(name)
+        end
+      end
+
+      # @return [String] AIXM or OFMX markup
+      def to_xml
+        builder = Builder::XmlMarkup.new(indent: 2)
+        builder.comment! "Organisation: #{name}"
+        builder.Org({ source: (source if AIXM.ofmx?) }.compact) do |org|
+          org << to_uid.indent(2)
+          org.codeId(id) if id
+          org.codeType(TYPES.key(type).to_s)
+          org.txtRmk(remarks) if remarks
+        end
+      end
+    end
+
+  end
+end

data/lib/aixm/feature/unit.rb

@@ -0,0 +1,152 @@
+using AIXM::Refinements
+
+module AIXM
+  class Feature
+
+    # Units providing all kind of services such as air traffic management,
+    # search and rescue, meteorological services and so forth.
+    #
+    # ===Cheat Sheet in Pseudo Code:
+    #   unit = AIXM.unit(
+    #     source: String or nil
+    #     region: String or nil (falls back to +AIXM.config.region+)
+    #     organisation: AIXM.organisation
+    #     name: String
+    #     type: TYPES
+    #     class: :icao or :other
+    #   )
+    #   unit.airport = AIXM.airport or nil
+    #   unit.remarks = String or nil
+    #   unit.add_service(AIXM.service)
+    #
+    # @see https://github.com/openflightmaps/ofmx/wiki/Organisation#uni-unit
+    class Unit < Feature
+      public_class_method :new
+
+      TYPES = {
+        ACC: :area_control_centre,
+        APP: :approach_control_office,
+        ARO: :ats_reporting_office,
+        ATSU: :air_traffic_services_unit,
+        COM: :communications_office,
+        FIC: :flight_information_centre,
+        FSS: :flight_service_station,
+        MET: :meteorological_office,
+        NOF: :international_notam_office,
+        RAD: :radar_office,
+        TWR: :aerodrome_control_tower,
+        OTHER: :other                       # specify in remarks
+      }.freeze
+
+      CLASSES = {
+        ICAO: :icao,
+        OTHER: :other   # specify in remarks
+      }.freeze
+
+      # @return [AIXM::Feature::Organisation] superior organisation
+      attr_reader :organisation
+
+      # @return [String] name of unit (e.g. "MARSEILLE ACS")
+      attr_reader :name
+
+      # @return [Symbol] type of unit (see {TYPES})
+      attr_reader :type
+
+      # @return [AIXM::Feature::Airport, nil] airport
+      attr_reader :airport
+
+      # @return [String, nil] free text remarks
+      attr_reader :remarks
+
+      def initialize(source: nil, region: nil, organisation:, name:, type:, class:)
+        super(source: source, region: region)
+        self.organisation, self.name, self.type = organisation, name, type
+        self.class = binding.local_variable_get(:class)
+        @services = []
+      end
+
+      # @return [String]
+      def inspect
+        %Q(#<#{self.class} name=#{name.inspect} type=#{type.inspect}>)
+      end
+
+      def organisation=(value)
+        fail(ArgumentError, "invalid organisation") unless value.is_a? AIXM::Feature::Organisation
+        @organisation = value
+      end
+
+      def name=(value)
+        fail(ArgumentError, "invalid name") unless value.is_a? String
+        @name = value.uptrans
+      end
+
+      def type=(value)
+        @type = TYPES.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid type")
+      end
+
+      # @!attribute class
+      # @return [Symbol] class of unit (see {CLASSES})
+      def class
+        @klass
+      end
+
+      def class=(value)
+        @klass = CLASSES.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid class")
+      end
+
+      def airport=(value)
+        fail(ArgumentError, "invalid airport") unless value.nil? || value.is_a?(AIXM::Feature::Airport)
+        @airport = value
+      end
+
+      def remarks=(value)
+        @remarks = value&.to_s
+      end
+
+      # Add a service provided by this unit.
+      #
+      # @param service [AIXM::Component::Service] service instance
+      # @return [self]
+      def add_service(service)
+        fail(ArgumentError, "invalid service") unless service.is_a? AIXM::Component::Service
+        service.send(:unit=, self)
+        @services << service
+        self
+      end
+
+      # @!attribute [r] services
+      # @return [Array<AIXM::Component::Service>] services provided by this unit
+      def services
+        @services.sort { |a, b| [a.type, a.name] <=> [b.type, b.name] }
+      end
+
+      # @return [String] UID markup
+      def to_uid
+        builder = Builder::XmlMarkup.new(indent: 2)
+        builder.UniUid({ region: (region if AIXM.ofmx?) }.compact) do |uni_uid|
+          uni_uid.txtName(name)
+        end
+      end
+
+      # @return [String] AIXM or OFMX markup
+      def to_xml
+        builder = Builder::XmlMarkup.new(indent: 2)
+        builder.comment! "Unit: #{name}"
+        builder.Uni({ source: (source if AIXM.ofmx?) }.compact) do |uni|
+          uni << to_uid.indent(2)
+          uni << organisation.to_uid.indent(2)
+          uni << airport.to_uid.indent(2) if airport
+          uni.codeType(TYPES.key(type).to_s)
+          uni.codeClass(CLASSES.key(self.class).to_s)
+          uni.txtRmk(remarks) if remarks
+        end
+        services.each.with_object({}) do |service, sequences|
+          sequences[service.type] = (sequences[service.type] || 0) + 1
+          builder << service.to_xml(sequences[service.type])
+        end
+        builder.target!
+      end
+    end
+
+  end
+end