aixm 0.3.8 → 0.3.10

data/lib/aixm/feature/obstacle.rb

@@ -9,11 +9,12 @@ module AIXM
     # ===Cheat Sheet in Pseudo Code:
     #   obstacle = AIXM.obstacle(
     #     source: String or nil
+    #     region: String or nil
     #     name: String or nil
     #     type: TYPES
     #     xy: AIXM.xy
     #     z: AIXM.z
-    #     radius: AIXM.d
+    #     radius: AIXM.d or nil
     #   )
     #   obstacle.lighting = true or false (default for AIXM) or nil (means: unknown, default for OFMX)
     #   obstacle.lighting_remarks = String or nil
@@ -32,12 +33,15 @@ module AIXM
     # See {AIXM::Feature::ObstacleGroup} for how to define physical links
     # between two obstacles (e.g. cables between powerline towers).
     #
-    # Please note: As soon as an obstacle is added to an obstacle group, the
-    # +xy_accuracy+ and +z_accuracy+ of the obstacle group overwrite whatever
-    # is set on the individual obstacles!
+    # Please note: Accuracies (+xy_accuracy+ and +z_accuracy+) set on an
+    # obstacle group are implicitly applied to all obstacles of the group
+    # unless they have their own, different accuracies set.
     #
-    # @see https://github.com/openflightmaps/ofmx/wiki/Obstacle
+    # @see https://gitlab.com/openflightmaps/ofmx/wikis/Obstacle
     class Obstacle < Feature
+      include AIXM::Association
+      include AIXM::Memoize
+
       public_class_method :new
 
       TYPES = {
@@ -57,6 +61,10 @@ module AIXM
         OTHER: :other
       }.freeze
 
+      # @!method obstacle_group
+      #   @return [AIXM::Feature::ObstacleGroup] group this obstacle belongs to
+      belongs_to :obstacle_group
+
       # @return [String] full name
       attr_reader :name
 
@@ -108,19 +116,16 @@ module AIXM
       # @return [String, nil] free text remarks
       attr_reader :remarks
 
-      # @return [AIXM::Feature::ObstacleGroup] group this obstacle belongs to
-      attr_reader :obstacle_group
-
       # @return [Symbol, nil] another obstacle to which a physical link exists
       attr_reader :linked_to
 
       # @return [Symbol, nil] type of physical link between this and another obstacle
       attr_reader :link_type
 
-      def initialize(source: nil, name: nil, type:, xy:, z:, radius:)
-        super(source: source)
+      def initialize(source: nil, region: nil, name: nil, type:, xy:, z:, radius: nil)
+        super(source: source, region: region)
         self.name, self.type, self.xy, self.z, self.radius = name, type, xy, z, radius
-        @lighting = @marking = @height_accurate = false
+        @lighting = @marking = false
       end
 
       # @return [String]
@@ -202,12 +207,6 @@ module AIXM
         @remarks = value&.to_s
       end
 
-      def obstacle_group=(value)
-        fail(ArgumentError, "invalid obstacle group") unless value.is_a?(AIXM::Feature::ObstacleGroup)
-        @obstacle_group = value
-      end
-      private :obstacle_group=
-
       def linked_to=(value)
         fail(ArgumentError, "invalid linked to") unless value.is_a?(AIXM::Feature::Obstacle)
         @linked_to = value
@@ -219,11 +218,6 @@ module AIXM
       end
       private :link_type=
 
-      # @return [Boolean] whether part of an obstacle group
-      def grouped?
-        obstacle_group && obstacle_group.obstacles.count > 1
-      end
-
       # @return [Boolean] whether obstacle is linked to another one
       def linked?
         !!linked_to
@@ -231,30 +225,29 @@ module AIXM
 
       # @return [String] UID markup
       def to_uid(as: :ObsUid)
-        self.obstacle_group ||= singleton_obstacle_group
         builder = Builder::XmlMarkup.new(indent: 2)
-        builder.tag!(as) do |tag|
-          tag << obstacle_group.to_uid.indent(2) if AIXM.ofmx?
+        builder.tag!(as, { region: (region if AIXM.ofmx?) }.compact) do |tag|
           tag.geoLat((xy.lat(AIXM.schema)))
           tag.geoLong((xy.long(AIXM.schema)))
-        end.insert_payload_hash(region: AIXM.config.mid_region)
+        end
       end
+      memoize :to_uid
 
       # @return [String] AIXM or OFMX markup
       def to_xml(delegate: true)
-        self.obstacle_group ||= singleton_obstacle_group
-        return obstacle_group.to_xml if delegate && AIXM.ofmx?
+        return obstacle_group.to_xml if delegate && obstacle_group && AIXM.ofmx?
         builder = Builder::XmlMarkup.new(indent: 2)
         builder.comment! "Obstacle: [#{type}] #{xy.to_s} #{name}".strip
         builder.Obs do |obs|
           obs << to_uid.indent(2)
+          obs << obstacle_group.to_uid.indent(2) if obstacle_group && AIXM.ofmx?
           obs.txtName(name) if name
           if AIXM.ofmx?
             obs.codeType(TYPES.key(type).to_s)
           else
             obs.txtDescrType(TYPES.key(type).to_s)
           end
-          obs.codeGroup(grouped? ? 'Y' : 'N')
+          obs.codeGroup(obstacle_group ? 'Y' : 'N') if AIXM.aixm?
           if AIXM.ofmx?
             obs.codeLgt(lighting ? 'Y' : 'N') unless lighting.nil?
             obs.codeMarking(marking ? 'Y' : 'N') unless marking.nil?
@@ -264,13 +257,14 @@ module AIXM
           obs.txtDescrLgt(lighting_remarks) if lighting_remarks
           obs.txtDescrMarking(marking_remarks) if marking_remarks
           obs.codeDatum('WGE')
-          if AIXM.aixm? && obstacle_group.xy_accuracy
-            obs.valGeoAccuracy(obstacle_group.xy_accuracy.dist.trim)
-            obs.uomGeoAccuracy(obstacle_group.xy_accuracy.unit.upcase.to_s)
+          if accuracy = (xy_accuracy || (obstacle_group&.xy_accuracy if AIXM.aixm?))
+            obs.valGeoAccuracy(accuracy.dist.trim)
+            obs.uomGeoAccuracy(accuracy.unit.upcase.to_s)
           end
           obs.valElev(z.alt)
-          if AIXM.aixm? && obstacle_group.z_accuracy
-            obs.valElevAccuracy(obstacle_group.z_accuracy.to_ft.dist.round)
+          if accuracy = (z_accuracy || (obstacle_group&.z_accuracy if AIXM.aixm?))
+            obs.valElevAccuracy(accuracy.to_ft.dist.round)
+            obs.uomElevAccuracy('FT') if AIXM.ofmx?
           end
           obs.valHgt(height.to_ft.dist.round) if height
           obs.uomDistVer('FT')
@@ -282,7 +276,7 @@ module AIXM
               obs.valRadius(radius.dist.trim)
               obs.uomRadius(radius.unit.upcase.to_s)
             end
-            if grouped? && linked?
+            if linked?
               obs << linked_to.to_uid(as: :ObsUidLink).indent(2)
               obs.codeLinkType(LINK_TYPES.key(link_type).to_s)
             end
@@ -293,14 +287,6 @@ module AIXM
         end
       end
 
-      private
-
-      # OFMX requires single, ungrouped obstacles to be the only member of a
-      # singleton obstacle group.
-      def singleton_obstacle_group
-        AIXM.obstacle_group.add_obstacle self
-      end
-
     end
   end
 end

data/lib/aixm/feature/obstacle_group.rb

@@ -6,9 +6,15 @@ module AIXM
     # Groups of obstacles which consist of either linked (e.g. power line
     # towers) or unlinked (e.g. wind turbines) members.
     #
+    # Obstacle group should contain at least two obstacles. However, if the
+    # details of each obstacle of the group are unknown, you may add only one
+    # virtual obstacle to the group and mention the number of real obstacles
+    # in it's remarks.
+    #
     # ===Cheat Sheet in Pseudo Code:
     #   obstacle_group = AIXM.obstacle_group(
     #     source: String or nil        # see remarks below
+    #     region: String or nil
     #     name: String or nil
     #   ).tap do |obstacle_group|
     #     obstacle_group.xy_accuracy = AIXM.d or nil
@@ -29,14 +35,34 @@ module AIXM
     #     link_type: LINK_TYPES
     #   )
     #
-    # Please note: As soon as an obstacle is added to an obstacle group, the
-    # +xy_accuracy+ and +z_accuracy+ of the obstacle group overwrite whatever
-    # is set on the individual obstacles!
+    # Please note: Accuracies (+xy_accuracy+ and +z_accuracy+) set on an
+    # obstacle group are implicitly applied to all obstacles of the group
+    # unless they have their own, different accuracies set.
     #
-    # @see https://github.com/openflightmaps/ofmx/wiki/Obstacle
+    # @see https://gitlab.com/openflightmaps/ofmx/wikis/Obstacle
     class ObstacleGroup < Feature
+      include AIXM::Association
+      include AIXM::Memoize
+
       public_class_method :new
 
+      # @!method obstacles
+      #   @return [Array<AIXM::Feature::Obstacle>] obstacles in this obstacle group
+      # @!method add_obstacle(obstacle, linked_to: nil, link_type: nil)
+      #   @param obstacle [AIXM::Feature::Obstacle] obstacle instance
+      #   @param linked_to [Symbol, AIXM::Feature::Obstacle, nil] Either:
+      #     * :previous - link to the obstacle last added to the obstacle group
+      #     * AIXM::Feature::Obstacle - link to this specific obstacle
+      #   @param link_type [Symbol, nil] type of link (see
+      #     {AIXM::Feature::Obstacle::LINK_TYPES})
+      #   @return [self]
+      has_many :obstacles do |obstacle, linked_to: nil, link_type: nil|
+        if linked_to
+          obstacle.send(:linked_to=, linked_to == :previous ? @obstacles.last : linked_to)
+          obstacle.send(:link_type=, (link_type || :other))
+        end
+      end
+
       # @!method source
       #   @return [String] reference to source of the feature data
       # @!method name
@@ -54,13 +80,9 @@ module AIXM
       # @return [String, nil] free text remarks
       attr_reader :remarks
 
-      # @return [Array<AIXM::Feature::Obstacle>] obstacles in this obstacle group
-      attr_reader :obstacles
-
-      def initialize(source: nil, name: nil)
-        super(source: source)
+      def initialize(source: nil, region: nil, name: nil)
+        super(source: source, region: region)
         self.name = name
-        @obstacles = []
       end
 
       # @return [String]
@@ -87,35 +109,15 @@ module AIXM
         @remarks = value&.to_s
       end
 
-      # Add an obstacle to the obstacle group and optionally link it to another
-      # obstacle from the obstacle group.
-      #
-      # @param obstacle [AIXM::Feature::Obstacle] obstacle instance
-      # @param linked_to [Symbol, AIXM::Feature::Obstacle, nil] Either:
-      #   * :previous - link to the obstacle last added to the obstacle group
-      #   * AIXM::Feature::Obstacle - link to this specific obstacle
-      # @param link_type [Symbol, nil] type of link (see
-      #   {AIXM::Feature::Obstacle::LINK_TYPES})
-      # @return [self]
-      def add_obstacle(obstacle, linked_to: nil, link_type: :other)
-        obstacle.send(:obstacle_group=, self)
-        if linked_to && link_type
-          obstacle.send(:linked_to=, linked_to == :previous ? @obstacles.last : linked_to)
-          obstacle.send(:link_type=, link_type)
-        end
-        @obstacles << obstacle
-        self
-      end
-
       # @return [String] UID markup
       def to_uid
         builder = Builder::XmlMarkup.new(indent: 2)
-        builder.OgrUid do |ogr_uid|
-          ogr_uid.txtName(name)
+        builder.OgrUid({ region: (region if AIXM.ofmx?) }.compact) do |ogr_uid|
           ogr_uid.geoLat(obstacles.first.xy.lat(AIXM.schema))
           ogr_uid.geoLong(obstacles.first.xy.long(AIXM.schema))
-        end.insert_payload_hash(region: AIXM.config.mid_region)
+        end
       end
+      memoize :to_uid
 
       # @return [String] AIXM or OFMX markup
       def to_xml
@@ -124,6 +126,7 @@ module AIXM
           builder.comment! "Obstacle group: #{name}".strip
           builder.Ogr({ source: (source if AIXM.ofmx?) }.compact) do |ogr|
             ogr << to_uid.indent(2)
+            ogr.txtName(name)
             ogr.codeDatum('WGE')
             if xy_accuracy
               ogr.valGeoAccuracy(xy_accuracy.dist.trim)
@@ -136,7 +139,7 @@ module AIXM
             ogr.txtRmk(remarks) if remarks
           end
         end
-        obstacles.each { |o| builder << o.to_xml(delegate: false) }
+        obstacles.each { builder << _1.to_xml(delegate: false) }
         builder.target!
       end
     end

data/lib/aixm/feature/organisation.rb

@@ -9,14 +9,18 @@ module AIXM
     # ===Cheat Sheet in Pseudo Code:
     #   organisation = AIXM.organisation(
     #     source: String or nil
+    #     region: String or nil
     #     name: String
     #     type: TYPES
     #   )
     #   organisation.id = String or nil
     #   organisation.remarks = String or nil
     #
-    # @see https://github.com/openflightmaps/ofmx/wiki/Organisation#org-organisation
+    # @see https://gitlab.com/openflightmaps/ofmx/wikis/Organisation#org-organisation
     class Organisation < Feature
+      include AIXM::Association
+      include AIXM::Memoize
+
       public_class_method :new
 
       TYPES = {
@@ -31,6 +35,17 @@ module AIXM
         OTHER: :other                          # specify in remarks
       }.freeze
 
+      # @!method members
+      #   @return [Array<AIXM::Feature::Airport,
+      #     AIXM::Feature::Unit,
+      #     AIXM::Feature::NavigationalAid>] aiports, units or navigational aids
+      # @!method add_member(member)
+      #   @param member [AIXM::Feature::Airport,
+      #     AIXM::Feature::Unit,
+      #     AIXM::Feature::NavigationalAid]
+      #   @return [self]
+      has_many :members, accept: [:airport, :unit, 'AIXM::Feature::NavigationalAid']
+
       # @return [String] name of organisation (e.g. "FRANCE")
       attr_reader :name
 
@@ -43,8 +58,8 @@ module AIXM
       # @return [String, nil] free text remarks
       attr_reader :remarks
 
-      def initialize(source: nil, name:, type:)
-        super(source: source)
+      def initialize(source: nil, region: nil, name:, type:)
+        super(source: source, region: region)
         self.name, self.type = name, type
       end
 
@@ -74,10 +89,11 @@ module AIXM
       # @return [String] UID markup
       def to_uid
         builder = Builder::XmlMarkup.new(indent: 2)
-        builder.OrgUid do |org_uid|
+        builder.OrgUid({ region: (region if AIXM.ofmx?) }.compact) do |org_uid|
           org_uid.txtName(name)
-        end.insert_payload_hash(region: AIXM.config.mid_region)
+        end
       end
+      memoize :to_uid
 
       # @return [String] AIXM or OFMX markup
       def to_xml

data/lib/aixm/feature/unit.rb

@@ -9,6 +9,7 @@ module AIXM
     # ===Cheat Sheet in Pseudo Code:
     #   unit = AIXM.unit(
     #     source: String or nil
+    #     region: String or nil
     #     organisation: AIXM.organisation
     #     name: String
     #     type: TYPES
@@ -18,8 +19,11 @@ module AIXM
     #   unit.remarks = String or nil
     #   unit.add_service(AIXM.service)
     #
-    # @see https://github.com/openflightmaps/ofmx/wiki/Organisation#uni-unit
+    # @see https://gitlab.com/openflightmaps/ofmx/wikis/Organisation#uni-unit
     class Unit < Feature
+      include AIXM::Association
+      include AIXM::Memoize
+
       public_class_method :new
 
       TYPES = {
@@ -76,8 +80,19 @@ module AIXM
         OTHER: :other   # specify in remarks
       }.freeze
 
-      # @return [AIXM::Feature::Organisation] superior organisation
-      attr_reader :organisation
+      # @!method services
+      #   @return [Array<AIXM::Component::Service>] services provided by this unit
+      # @!method add_service(service)
+      #   @param service [AIXM::Component::Service]
+      has_many :services
+
+      # @!method organisation
+      #   @return [AIXM::Feature::Organisation] superior organisation
+      belongs_to :organisation, as: :member
+
+      # @!method airport
+      #   @return [AIXM::Feature::Airport, nil] airport
+      belongs_to :airport
 
       # @return [String] name of unit (e.g. "MARSEILLE ACS")
       attr_reader :name
@@ -85,27 +100,18 @@ module AIXM
       # @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, organisation:, name:, type:, class:)
-        super(source: source)
+      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(#<#{original_class} name=#{name.inspect} type=#{type.inspect}>)
-      end
-
-      def organisation=(value)
-        fail(ArgumentError, "invalid organisation") unless value.is_a? AIXM::Feature::Organisation
-        @organisation = value
+        %Q(#<#{__class__} name=#{name.inspect} type=#{type.inspect}>)
       end
 
       def name=(value)
@@ -118,9 +124,8 @@ module AIXM
       end
 
       # @!attribute class
-      # @note Use +original_class+ to query the Ruby object class.
+      # @note Use +Object#__class__+ alias to query the Ruby object class.
       # @return [Symbol] class of unit (see {CLASSES})
-      alias_method :original_class, :class
       def class
         @klass
       end
@@ -129,58 +134,43 @@ module AIXM
         @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::Feature::Service] service instance
-      # @return [self]
-      def add_service(service)
-        fail(ArgumentError, "invalid service") unless service.is_a? AIXM::Feature::Service
-        service.send(:unit=, self)
-        @services << service
-        self
-      end
-
-      # @!attribute [r] services
-      # @return [Array<AIXM::Feature::Service>] services provided by this unit
-      def services
-        @services.sort { |a, b| a.type <=> b.type }
-      end
-
       # @return [String] UID markup
       def to_uid
         builder = Builder::XmlMarkup.new(indent: 2)
-        builder.UniUid do |uni_uid|
+        builder.UniUid({ region: (region if AIXM.ofmx?) }.compact) do |uni_uid|
           uni_uid.txtName(name)
-        end.insert_payload_hash(region: AIXM.config.mid_region)
+          uni_uid.codeType(TYPES.key(type).to_s) if AIXM.ofmx?
+        end
       end
+      memoize :to_uid
 
       # @return [String] AIXM or OFMX markup
       def to_xml
         builder = Builder::XmlMarkup.new(indent: 2)
-        builder.comment! "Unit: #{name}"
+        builder.comment! "Unit: #{name_with_type}"
         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.codeType(TYPES.key(type).to_s) unless AIXM.ofmx?
           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(sequence: sequences[service.type])
+        services.sort { |a, b| a.type <=> b.type }.each do |service|
+          builder << service.to_xml
         end
         builder.target!
       end
+
+      private
+
+      def name_with_type
+        [name, TYPES.key(type)].join(' ')
+      end
     end
 
   end