aixm 0.2.3 → 0.3.0

data/lib/aixm/feature/airspace.rb

@@ -1,126 +1,179 @@
+using AIXM::Refinements
+
 module AIXM
-  module Feature
-    class Airspace < Base
-      using AIXM::Refinements
-
-      attr_reader :name, :short_name, :type, :schedule, :remarks
-      attr_accessor :geometry, :class_layers
-
-      ##
-      # Airspace feature
-      #
-      # Options:
-      # * +name+ - full name of the airspace (will be converted to uppercase,
-      #            e.g. +LF P 81+)
-      # * +short_name+ - short name of the airspace (will be converted to
-      #                  uppercase, e.g. +LF P 81 CHERBOURG+)
-      # * +type+ - airspace type (e.g. +TMA+ or +P+)
-      def initialize(name:, short_name: nil, type:)
-        self.name, self.short_name, self.type = name, short_name, type
-        @schedule = nil
-        @geometry = AIXM.geometry
-        @class_layers = []
-      end
+  class Feature
 
-      def name=(value)
-        fail(ArgumentError, "invalid name") unless value.is_a? String
-        @name = value.uptrans
-      end
+    # Three-dimensional volume most notably defining flight zones.
+    #
+    # ===Cheat Sheet in Pseudo Code:
+    #   airspace = AIXM.airspace(
+    #     source: String or nil
+    #     region: String or nil (falls back to AIXM.config.region)
+    #     id: String
+    #     type: String or Symbol
+    #     name: String or nil
+    #     short_name: String or nil
+    #   )
+    #   airspace.geometry << AIXM.point or AIXM.arc or AIXM.border or AIXM.circle
+    #   airspace.layers << AIXM.layer
+    #
+    # @see https://github.com/openflightmaps/ofmx/wiki/Airspace#ase-airspace
+    class Airspace < Feature
+      public_class_method :new
 
-      def short_name=(value)
-        fail(ArgumentError, "invalid short name") unless value.nil? || value.is_a?(String)
-        @short_name = value&.uptrans
+      TYPES = {
+        NAS: :national_airspace_system,
+        FIR: :flight_information_region,
+        'FIR-P': :part_of_flight_information_region,
+        UIR: :upper_flight_information_region,
+        'UIR-P': :part_of_upper_flight_information_region,
+        CTA: :control_area,
+        'CTA-P': :part_of_control_area,
+        OCA: :oceanic_control_area,
+        'OCA-P': :part_of_oceanic_control_area,
+        UTA: :upper_control_area,
+        'UTA-P': :part_of_upper_control_area,
+        TMA: :terminal_control_area,
+        'TMA-P': :part_of_terminal_control_area,
+        CTR: :control_zone,
+        'CTR-P': :part_of_control_zone,
+        CLASS: :airspace_with_class,
+        OTA: :oceanic_transition_area,
+        SECTOR: :control_sector,
+        'SECTOR-C': :temporarily_consolidated_sector,
+        TSA: :temporary_segregated_area,
+        TRA: :temporary_reserved_area,
+        CBA: :cross_border_area,
+        RCA: :reduced_coordination_airspace_procedure,
+        RAS: :regulated_airspace,
+        AWY: :airway,
+        P: :prohibited_area,
+        R: :restricted_area,
+        'R-AMC': :amc_manageable_restricted_area,
+        D: :danger_area,
+        'D-AMC': :amc_manageable_danger_area,
+        'D-OTHER': :dangerous_activities_area,
+        ADIZ: :air_defense_identification_zone,
+        A: :alert_area,
+        W: :warning_area,
+        PROTECT: :protected_from_specific_air_traffic,
+        AMA: :minimum_altitude_area,
+        ASR: :altimeter_setting_region,
+        'NO-FIR': :airspace_outside_any_flight_information_region,
+        POLITICAL: :political_area,
+        PART: :part_of_airspace
+      }.freeze
+
+      # @note When assigning +nil+, a 4 byte hex derived from {#type}, {#name}
+      #   and {#short_name} is written instead.
+      # @return [String] published identifier (e.g. "LFP81")
+      attr_reader :id
+
+      # @return [Symbol] type of airspace (see {TYPES})
+      attr_reader :type
+
+      # @return [String, nil] full name (e.g. "LF P 81 CHERBOURG")
+      attr_reader :name
+
+      # @return [String, nil] short name (e.g. "LF P 81")
+      attr_reader :short_name
+
+      # @return [AIXM::Component::Geometry] horizontal geometrical shape
+      attr_accessor :geometry
+
+      # @return [Array<AIXM::Compoment::Layer>] vertical layers
+      attr_accessor :layers
+
+      def initialize(source: nil, region: nil, id: nil, type:, name: nil, short_name: nil)
+        super(source: source, region: region)
+        self.type, self.name, self.short_name = type, name, short_name
+        self.id = id
+        @geometry = AIXM.geometry
+        @layers = []
       end
 
-      def type=(value)
-        fail(ArgumentError, "invalid type") unless value.is_a?(String)
-        @type = value.upcase
+      # @return [String]
+      def inspect
+        %Q(#<#{self.class} type=#{type.inspect} name=#{name.inspect}>)
       end
 
-      def schedule=(value)
-        fail(ArgumentError, "invalid schedule") unless value.nil? || value.is_a?(AIXM::Component::Schedule)
-        @schedule = value
+      def id=(value)
+        fail(ArgumentError, "invalid id") unless value.nil? || value.is_a?(String)
+        @id = value&.uptrans || [type, name, short_name].to_digest.upcase
       end
 
-      def remarks=(value)
-        fail(ArgumentError, "invalid remarks") unless value.is_a?(String)
-        @remarks = value
+      def type=(value)
+        @type = TYPES.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid type")
       end
 
-      ##
-      # Check whether the airspace is complete
-      def complete?
-        !!name && !!type && class_layers.any? && geometry.complete?
+      def name=(value)
+        fail(ArgumentError, "invalid name") unless value.nil? || value.is_a?(String)
+        @name = value&.uptrans
       end
 
-      ##
-      # Digest to identify the payload
-      def to_digest
-        [name, short_name, type, schedule&.to_digest, class_layers.map(&:to_digest), geometry.to_digest, remarks].to_digest
+      def short_name=(value)
+        fail(ArgumentError, "invalid short name") unless value.nil? || value.is_a?(String)
+        @short_name = value&.uptrans
       end
 
-      ##
-      # Render UID markup
-      def to_uid(*extensions)
-        mid = to_digest
+      # @return [String] UID markup
+      def to_uid(as: :AseUid)
         builder = Builder::XmlMarkup.new(indent: 2)
-        builder.AseUid({ mid: mid, newEntity: (true if extensions >> :ofm) }.compact) do |aseuid|
-          aseuid.codeType(type)
-          aseuid.codeId(mid)
+        builder.tag!(as, { region: (region if AIXM.ofmx?) }.compact) do |tag|
+          tag.codeType(TYPES.key(type).to_s)
+          tag.codeId(id)
         end
       end
 
-      ##
-      # Render AIXM markup
-      def to_aixm(*extensions)
-        mid = to_digest
+      # @raise [AIXM::GeometryError] if the geometry is not closed
+      # @raise [AIXM::LayerError] if no layers are defined
+      # @return [String] AIXM or OFMX markup
+      def to_xml
+        fail(LayerError, "no layers defined") unless layers.any?
         builder = Builder::XmlMarkup.new(indent: 2)
-        builder.comment! "Airspace: [#{type}] #{name}"
-        builder.Ase({ xt_classLayersAvail: ((class_layers.count > 1) if extensions >> :ofm) }.compact) do |ase|
-          ase << to_uid(*extensions).indent(2)
-          ase.txtLocalType(short_name.to_s) if short_name && short_name != name
-          ase.txtName(name.to_s)
-          ase << class_layers.first.to_aixm(*extensions).indent(2)
-          if schedule
-            ase.Att do |att|
-              att << schedule.to_aixm(*extensions).indent(4)
-            end
+        builder.comment! "Airspace: [#{TYPES.key(type)}] #{name || :UNNAMED}"
+        builder.Ase({
+          source: (source if AIXM.ofmx?),
+          classLayers: (layers.count if AIXM.ofmx? && layered?)
+        }.compact) do |ase|
+          ase << to_uid.indent(2)
+          ase.txtLocalType(short_name) if short_name && short_name != name
+          ase.txtName(name) if name
+          unless layered?
+            ase << layers.first.to_xml.indent(2)
           end
-          ase.txtRmk(remarks.to_s) if remarks
-          ase.xt_selAvail(false) if extensions >> :ofm
         end
         builder.Abd do |abd|
-          abd.AbdUid do |abduid|
-            abduid.AseUid({ mid: mid, newEntity: (true if extensions >> :ofm) }.compact) do |aseuid|
-              aseuid.codeType(type)
-              aseuid.codeId(mid)
-            end
+          abd.AbdUid do |abd_uid|
+            abd_uid << to_uid.indent(4)
           end
-          abd << geometry.to_aixm(*extensions).indent(2)
+          abd << geometry.to_xml.indent(2)
         end
-        if class_layers.count > 1
-          builder.Adg do |adg|
-            class_layers.each.with_index do |class_layer, index|
-              adg.AdgUid do |adguid|
-                adguid.AseUid(mid: "#{mid}.#{index + 1}") do |aseuid|
-                  aseuid.codeType("CLASS")
-                end
-              end
-            end
-            adg.AseUidSameExtent(mid: mid)
-          end
-          class_layers.each.with_index do |class_layer, index|
+        if layered?
+          layers.each.with_index do |layer, index|
+            layer_airspace = AIXM.airspace(region: region, type: 'CLASS', name: "#{name} LAYER #{index + 1}")
             builder.Ase do |ase|
-              ase.AseUid(mid: "#{mid}.#{index + 1}") do |aseuid|
-                aseuid.codeType("CLASS")
+              ase << layer_airspace.to_uid.indent(2)
+              ase.txtName(layer_airspace.name)
+              ase << layers[index].to_xml.indent(2)
+            end
+            builder.Adg do |adg|
+              adg.AdgUid do |adg_uid|
+                adg_uid << layer_airspace.to_uid.indent(4)
               end
-              ase.txtName(name.to_s)
-              ase << class_layers[index].to_aixm(*extensions).indent(2)
+              adg << to_uid(as: :AseUidSameExtent).indent(2)
             end
           end
         end
-        builder.target!   # see https://github.com/jimweirich/builder/issues/42
+        builder.target!
       end
+
+      private
+
+      def layered?
+        layers.count > 1
+      end
+
     end
   end
 end

data/lib/aixm/feature/navigational_aid.rb

@@ -0,0 +1,94 @@
+using AIXM::Refinements
+
+module AIXM
+  class Feature
+
+    # @abstract
+    class NavigationalAid < Feature
+      private_class_method :new
+
+      # @return [AIXM::Feature::Organisation] superior organisation
+      attr_reader :organisation
+
+      # @return [String] published identifier
+      attr_reader :id
+
+      # @return [String, nil] name of the navigational aid
+      attr_reader :name
+
+      # @return [AIXM::XY] geographic position
+      attr_reader :xy
+
+      # @return [AIXM::Z, nil] elevation in +:qnh+
+      attr_reader :z
+
+      # @return [AIXM::Component::Timetable, nil] operating hours
+      attr_reader :timetable
+
+      # @return [String, nil] free text remarks
+      attr_reader :remarks
+
+      def initialize(source: nil, region: nil, organisation:, id:, name: nil, xy:, z: nil)
+        super(source: source, region: region)
+        self.organisation, self.id, self.name, self.xy, self.z = organisation, id, name, xy, z
+      end
+
+      # @return [String]
+      def inspect
+        %Q(#<#{self.class} id=#{id.inspect} name=#{name.inspect}>)
+      end
+
+      def organisation=(value)
+        fail(ArgumentError, "invalid organisation") unless value == false || value.is_a?(AIXM::Feature::Organisation)
+        @organisation = value
+      end
+
+      def id=(value)
+        fail(ArgumentError, "invalid id") unless value.is_a? String
+        @id = value.upcase
+      end
+
+      def name=(value)
+        fail(ArgumentError, "invalid name") unless value.nil? || value.is_a?(String)
+        @name = value&.uptrans
+      end
+
+      def xy=(value)
+        fail(ArgumentError, "invalid xy") unless value.is_a? AIXM::XY
+        @xy = value
+      end
+
+      def z=(value)
+        fail(ArgumentError, "invalid z") unless value.nil? || (value.is_a?(AIXM::Z) && value.qnh?)
+        @z = value
+      end
+
+      def timetable=(value)
+        fail(ArgumentError, "invalid timetable") unless value.nil? || value.is_a?(AIXM::Component::Timetable)
+        @timetable = value
+      end
+
+      def remarks=(value)
+        @remarks = value&.to_s
+      end
+
+      # @return [String] fully descriptive combination of {#class} and {#type} key
+      def kind
+        [self.class.name.split('::').last, type_key].compact.join(':')
+      end
+
+      private
+
+      def type_key
+        nil
+      end
+
+      def to_builder
+        builder = Builder::XmlMarkup.new(indent: 2)
+        builder.comment! "NavigationalAid: [#{kind}] #{name || :UNNAMED}"
+        builder
+      end
+    end
+
+  end
+end

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

@@ -1,81 +1,77 @@
+using AIXM::Refinements
+
 module AIXM
-  module Feature
-    module NavigationalAid
+  class Feature
+    class NavigationalAid
 
-      ##
-      # Designated points are  named map coordinates
+      # Named geographical location used in defining an ATS route, aircraft
+      # flight paths or for other navigation purposes.
+      #
+      # ===Cheat Sheet in Pseudo Code:
+      #   designated_point = AIXM.designated_point(
+      #     source: String or nil
+      #     region: String or nil (falls back to AIXM.config.region)
+      #     id: String
+      #     name: String or nil
+      #     xy: AIXM.xy
+      #     type: TYPES
+      #   )
+      #   designated_point.remarks = String or nil
       #
-      # Types:
-      # * +:icao+ (+:ICAO+) - ICAO 5 letter name code designator
-      # * +:adhp+ (+:ADHP+) - aerodrome/heliport related name code designator
-      # * +:coordinates+ (+:COORD+) - point with identifier derived from its
-      #                               geographical coordinates
-      class DesignatedPoint < Base
-        using AIXM::Refinements
+      # @see https://github.com/openflightmaps/ofmx/wiki/Navigational-aid#dpn-designated-point
+      class DesignatedPoint < NavigationalAid
+        public_class_method :new
+        private :organisation=
+        private :organisation
 
         TYPES = {
-          ICAO: :icao,
-          ADHP: :adhp,
-          COORD: :coordinates
+          ICAO: :icao,           # five-letter ICAO name
+          ADHP: :adhp,           # airport related name
+          COORD: :coordinates,   # derived from geographical coordinates
+          OTHER: :other          # specify in remarks
         }.freeze
 
+        # @return [Symbol] type of designated point
         attr_reader :type
 
-        public_class_method :new
-
-        def initialize(id:, name: nil, xy:, z: nil, type:)
-          super(id: id, name: name, xy: xy, z: z)
+        def initialize(type:, **arguments)
+          super(organisation: false, z: nil, **arguments)
           self.type = type
         end
 
         def type=(value)
-          @type = TYPES.lookup(value&.to_sym, nil) || fail(ArgumentError, "invalid type")
+          @type = TYPES.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid type")
         end
 
-        def type_key
-          TYPES.key(type)
-        end
-
-        ##
-        # Digest to identify the payload
-        def to_digest
-          [super, type].to_digest
-        end
-
-        ##
-        # Render UID markup
-        def to_uid(*extensions)
+        # @return [String] UID markup
+        def to_uid
           builder = Builder::XmlMarkup.new(indent: 2)
-          builder.DpnUid({ mid: to_digest, newEntity: (true if extensions >> :ofm) }.compact) do |dpnuid|
-            dpnuid.codeId(id)
-            dpnuid.geoLat(xy.lat(format_for(*extensions)))
-            dpnuid.geoLong(xy.long(format_for(*extensions)))
+          builder.DpnUid({ region: (region if AIXM.ofmx?) }.compact) do |dpn_uid|
+            dpn_uid.codeId(id)
+            dpn_uid.geoLat(xy.lat(AIXM.schema))
+            dpn_uid.geoLong(xy.long(AIXM.schema))
           end
         end
 
-        ##
-        # Render AIXM markup
-        def to_aixm(*extensions)
-          builder = to_builder(*extensions)
-          builder.Dpn do |dpn|
-            dpn << to_uid(*extensions).indent(2)
-            dpn.OrgUid
-            dpn.txtName(name) if name
+        # @return [String] AIXM or OFMX markup
+        def to_xml
+          builder = to_builder
+          builder.Dpn({ source: (source if AIXM.ofmx?) }.compact) do |dpn|
+            dpn << to_uid.indent(2)
             dpn.codeDatum('WGE')
             dpn.codeType(type_key.to_s)
-            if z
-              dpn.valElev(z.alt)
-              dpn.uomDistVer(z.unit.to_s)
-            end
-            if schedule
-              dpn.Dtt do |dtt|
-                dtt << schedule.to_aixm(*extensions).indent(4)
-              end
-            end
+            dpn.txtName(name) if name
             dpn.txtRmk(remarks) if remarks
-            dpn.target!   # see https://github.com/jimweirich/builder/issues/42
+            dpn.target!
           end
         end
+
+        private
+
+        def type_key
+          TYPES.key(type)
+        end
+
       end
 
     end