aixm 1.2.1 → 1.3.1

data/lib/aixm/feature/airport.rb

@@ -23,6 +23,7 @@ module AIXM
     #   airport.timetable = AIXM.timetable or nil
     #   airport.operator = String or nil
     #   airport.remarks = String or nil
+    #   airport.comment = Object or nil
     #   airport.add_runway(AIXM.runway)
     #   airport.add_fato(AIXM.fato)
     #   airport.add_helipad(AIXM.helipad)
@@ -36,8 +37,7 @@ module AIXM
     #
     # @see https://gitlab.com/openflightmaps/ofmx/wikis/Airport#ahp-airport
     class Airport < Feature
-      include AIXM::Association
-      include AIXM::Memoize
+      include AIXM::Concerns::Association
       include AIXM::Concerns::Timetable
       include AIXM::Concerns::Remarks
 
@@ -269,81 +269,78 @@ module AIXM
         @operator = value&.uptrans
       end
 
-      # @return [String] UID markup
-      def to_uid(as: :AhpUid)
-        builder = Builder::XmlMarkup.new(indent: 2)
-        builder.tag!(as, ({ region: (region if AIXM.ofmx?) }.compact)) do |tag|
+      # @!visibility private
+      def add_uid_to(builder, as: :AhpUid)
+        builder.send(as, { region: (region if AIXM.ofmx?) }.compact) do |tag|
           tag.codeId(id)
         end
       end
-      memoize :to_uid
 
-      # @return [String] UID markup
-      def to_wrapped_uid(as: :AhpUid, with:)
-        builder = Builder::XmlMarkup.new(indent: 2)
-        builder.tag!(with) do |tag|
-          tag << to_uid(as: as).indent(2)
+      # @!visibility private
+      def add_wrapped_uid_to(builder, as: :AhpUid, with:)
+        builder.send(with) do |tag|
+          add_uid_to(builder, as: as)
         end
       end
 
-      # @return [String] AIXM or OFMX markup
-      def to_xml
-        builder = Builder::XmlMarkup.new(indent: 2)
-        builder.comment! "Airport: #{id} #{name}"
+      # @!visibility private
+      def add_to(builder)
+        builder.comment "Airport: #{id} #{name}".dress
+        builder.text "\n"
         builder.Ahp({ source: (source if AIXM.ofmx?) }.compact) do |ahp|
-          ahp << to_uid.indent(2)
-          ahp << organisation.to_uid.indent(2)
+          ahp.comment(indented_comment) if comment
+          add_uid_to(ahp)
+          organisation.add_uid_to(ahp)
           ahp.txtName(name)
           ahp.codeIcao(id) if id.length == 4
           ahp.codeIata(id) if id.length == 3
           ahp.codeGps(gps) if AIXM.ofmx? && gps
-          ahp.codeType(TYPES.key(type).to_s) if type
+          ahp.codeType(TYPES.key(type)) if type
           ahp.geoLat(xy.lat(AIXM.schema))
           ahp.geoLong(xy.long(AIXM.schema))
           ahp.codeDatum('WGE')
           if z
             ahp.valElev(z.alt)
-            ahp.uomDistVer(z.unit.upcase.to_s)
+            ahp.uomDistVer(z.unit.upcase)
           end
           ahp.valMagVar(declination) if declination
           ahp.txtNameAdmin(operator) if operator
           if transition_z
             ahp.valTransitionAlt(transition_z.alt)
-            ahp.uomTransitionAlt(transition_z.unit.upcase.to_s)
+            ahp.uomTransitionAlt(transition_z.unit.upcase)
           end
-          ahp << timetable.to_xml(as: :Aht).indent(2) if timetable
+          timetable.add_to(ahp, as: :Aht) if timetable
           ahp.txtRmk(remarks) if remarks
         end
         runways.each do |runway|
-          builder << runway.to_xml
+          runway.add_to(builder)
         end
         fatos.each do |fato|
-          builder << fato.to_xml
+          fato.add_to(builder)
         end
         helipads.each do |helipad|
-          builder << helipad.to_xml
+          helipad.add_to(builder)
         end
         if usage_limitations.any?
           builder.Ahu do |ahu|
-            ahu << to_wrapped_uid(with: :AhuUid).indent(2)
+            add_wrapped_uid_to(ahu, with: :AhuUid)
             usage_limitations.each do |usage_limitation|
-              ahu << usage_limitation.to_xml.indent(2)
+              usage_limitation.add_to(ahu)
             end
           end
         end
         addresses.each.with_object({}) do |address, sequences|
           sequences[address.type] = (sequences[address.type] || 0) + 1
-          builder << address.to_xml(as: :Aha, sequence: sequences[address.type])
+          address.add_to(builder, as: :Aha, sequence: sequences[address.type])
         end
         services.each do |service|
           builder.Sah do |sah|
             sah.SahUid do |sah_uid|
-              sah_uid << to_uid.indent(4)
-              sah_uid << service.to_uid.indent(4)
+              add_uid_to(sah_uid)
+              service.add_uid_to(sah_uid)
             end
           end
         end
-        builder.target!
       end
 
       # Limitations concerning the availability of an airport for certain flight
@@ -376,7 +373,8 @@ module AIXM
       # @see AIXM::Feature::Airport#add_usage_limitation
       # @see https://gitlab.com/openflightmaps/ofmx/wikis/Airport#ahu-airport-usage
       class UsageLimitation
-        include AIXM::Association
+        include AIXM::Concerns::Association
+        include AIXM::Concerns::XMLBuilder
         include AIXM::Concerns::Timetable
         include AIXM::Concerns::Remarks
 
@@ -422,15 +420,14 @@ module AIXM
           @type = TYPES.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid type")
         end
 
-        # @return [String] AIXM or OFMX markup
-        def to_xml
-          builder = Builder::XmlMarkup.new(indent: 2)
+        # @!visibility private
+        def add_to(builder)
           builder.UsageLimitation do |usage_limitation|
-            usage_limitation.codeUsageLimitation(TYPES.key(type).to_s)
+            usage_limitation.codeUsageLimitation(TYPES.key(type))
             conditions.each do |condition|
-              usage_limitation << condition.to_xml.indent(2)
+              condition.add_to(usage_limitation)
             end
-            usage_limitation << timetable.to_xml(as: :Timetable).indent(2) if timetable
+            timetable.add_to(usage_limitation, as: :Timetable) if timetable
             usage_limitation.txtRmk(remarks) if remarks
           end
         end
@@ -441,7 +438,8 @@ module AIXM
         # @see AIXM::Feature::Airport#add_usage_limitation
         # @see https://gitlab.com/openflightmaps/ofmx/wikis/Airport#ahu-airport-usage
         class Condition
-          include AIXM::Association
+          include AIXM::Concerns::Association
+          include AIXM::Concerns::XMLBuilder
 
           AIRCRAFT = {
             L: :landplane,
@@ -557,21 +555,20 @@ module AIXM
             @purpose = value.nil? ? nil : PURPOSES.lookup(value.to_s.to_sym, nil) || fail(ArgumentError, "invalid purpose")
           end
 
-          # @return [String] AIXM or OFMX markup
-          def to_xml
-            builder = Builder::XmlMarkup.new(indent: 2)
+          # @!visibility private
+          def add_to(builder)
             builder.UsageCondition do |usage_condition|
               if aircraft
                 usage_condition.AircraftClass do |aircraft_class|
-                  aircraft_class.codeType(AIRCRAFT.key(aircraft).to_s)
+                  aircraft_class.codeType(AIRCRAFT.key(aircraft))
                 end
               end
               if rule || realm || origin || purpose
                 usage_condition.FlightClass do |flight_class|
-                  flight_class.codeRule(RULES.key(rule).to_s) if rule
-                  flight_class.codeMil(REALMS.key(realm).to_s) if realm
-                  flight_class.codeOrigin(ORIGINS.key(origin).to_s) if origin
-                  flight_class.codePurpose(PURPOSES.key(purpose).to_s) if purpose
+                  flight_class.codeRule(RULES.key(rule)) if rule
+                  flight_class.codeMil(REALMS.key(realm)) if realm
+                  flight_class.codeOrigin(ORIGINS.key(origin)) if origin
+                  flight_class.codePurpose(PURPOSES.key(purpose)) if purpose
                 end
               end
             end

data/lib/aixm/feature/airspace.rb

@@ -14,9 +14,12 @@ module AIXM
     #     local_type: String or nil
     #     name: String or nil
     #   )
+    #   airspace.comment = Object or nil
     #   airspace.add_layer(AIXM.layer)
     #   airspace.geometry.add_segment(AIXM.point or AIXM.arc or AIXM.border or AIXM.circle)
     #
+    # Timetables and remarks have to be set on the layer!
+    #
     # The +id+ is mandatory, however, you may omit it when initializing a new
     # airspace or assign +nil+ to an existing airspace which will generate a 8
     # character digest from +type+, +local_type+ and +name+.
@@ -30,8 +33,7 @@ module AIXM
     #
     # @see https://gitlab.com/openflightmaps/ofmx/wikis/Airspace#ase-airspace
     class Airspace < Feature
-      include AIXM::Association
-      include AIXM::Memoize
+      include AIXM::Concerns::Association
 
       public_class_method :new
 
@@ -165,61 +167,55 @@ module AIXM
         @name = value&.uptrans
       end
 
-      # @return [String] UID markup
-      def to_uid(as: :AseUid)
-        builder = Builder::XmlMarkup.new(indent: 2)
-        builder.tag!(as, ({ region: (region if AIXM.ofmx?) }.compact)) do |tag|
-          tag.codeType(TYPES.key(type).to_s)
+      # @!visibility private
+      def add_uid_to(builder, as: :AseUid)
+        builder.send(as, ({ region: (region if AIXM.ofmx?) }.compact)) do |tag|
+          tag.codeType(TYPES.key(type))
           tag.codeId(id)
           tag.txtLocalType(local_type) if AIXM.ofmx? && local_type && local_type != name
         end
       end
-      memoize :to_uid
 
-      # @return [String] UID markup
-      def to_wrapped_uid(as: :AseUid, with:)
-        builder = Builder::XmlMarkup.new(indent: 2)
-        builder.tag!(with) do |tag|
-          tag << to_uid(as: as).indent(2)
+      # @!visibility private
+      def add_wrapped_uid_to(builder, as: :AseUid, with:)
+        builder.send(with) do |tag|
+          add_uid_to(tag, as: as)
         end
       end
 
-      # @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
+      # @!visibility private
+      def add_to(builder)
         fail(LayerError.new("no layers defined", self)) unless layers.any?
-        builder = Builder::XmlMarkup.new(indent: 2)
-        builder.comment! "Airspace: [#{TYPES.key(type)}] #{name || :UNNAMED}"
+        builder.comment "Airspace: [#{TYPES.key(type)}] #{name || :UNNAMED}".dress
+        builder.text "\n"
         builder.Ase({ source: (source if AIXM.ofmx?) }.compact) do |ase|
-          ase << to_uid.indent(2)
+          ase.comment(indented_comment) if comment
+          add_uid_to(ase)
           ase.txtLocalType(local_type) if AIXM.aixm? && local_type && local_type != name
           ase.txtName(name) if name
-          unless layered?
-            ase << layers.first.to_xml.indent(2)
-          end
+          layers.first.add_to(ase) unless layered?
         end
         builder.Abd do |abd|
-          abd << to_wrapped_uid(with: :AbdUid).indent(2)
-          abd << geometry.to_xml.indent(2)
+          add_wrapped_uid_to(abd, with: :AbdUid)
+          geometry.add_to(abd)
         end
         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 << layer_airspace.to_uid.indent(2)
+              layer_airspace.add_uid_to(ase)
               ase.txtName(layer_airspace.name)
-              ase << layers[index].to_xml.indent(2)
+              layers[index].add_to(ase)
             end
             builder.Adg do |adg|
-              adg << layer_airspace.to_wrapped_uid(with: :AdgUid).indent(2)
-              adg << to_uid(as: :AseUidSameExtent).indent(2)
+              layer_airspace.add_wrapped_uid_to(adg, with: :AdgUid)
+              add_uid_to(adg, as: :AseUidSameExtent)
             end
             layer.services.each do |service|
               builder.Sae do |sae|
                 sae.SaeUid do |sae_uid|
-                  sae_uid << service.to_uid.indent(4)
-                  sae_uid << layer_airspace.to_uid.indent(4)
+                  service.add_uid_to(sae_uid)
+                  layer_airspace.add_uid_to(sae_uid)
                 end
               end
             end
@@ -228,13 +224,12 @@ module AIXM
           layers.first.services.each do |service|
             builder.Sae do |sae|
               sae.SaeUid do |sae_uid|
-                sae_uid << service.to_uid.indent(4)
-                sae_uid << to_uid.indent(4)
+                service.add_uid_to(sae_uid)
+                add_uid_to(sae_uid)
               end
             end
           end
         end
-        builder.target!
       end
 
       private

data/lib/aixm/feature/generic.rb

@@ -0,0 +1,67 @@
+using AIXM::Refinements
+
+module AIXM
+  class Feature
+
+    # Generic feature represented as XML document fragment.
+    #
+    # ===Cheat Sheet in Pseudo Code:
+    #   generic = AIXM.generic(
+    #     fragment: Nokogiri::XML::DocumentFragment or String
+    #   )
+    class Generic < Feature
+      public_class_method :new
+
+      # XML document fragment
+      #
+      # @overload fragment
+      #   @return [Nokogiri::XML::DocumentFragment]
+      # @overload fragment=(value)
+      #   @param value [Nokogiri::XML::DocumentFragment, Object] XML document
+      #     fragment or object which is converted to string and then parsed
+      attr_reader :fragment
+
+      # See the {cheat sheet}[AIXM::Feature::Generic] for examples on how to
+      # create instances of this class.
+      def initialize(source: nil, region: nil, fragment:)
+        super(source: source, region: region)
+        self.fragment = fragment
+      end
+
+      # @return [String]
+      def inspect
+        %Q(#<#{self.class} #{fragment.elements.first.name}>)
+      end
+
+      def fragment=(value)
+        @fragment = case value
+          when Nokogiri::XML::DocumentFragment then value
+          else Nokogiri::XML::DocumentFragment.parse(value.to_s)
+        end
+      end
+
+      # @return [Integer] pseudo UID fragment
+      def to_uid
+        fragment.to_xml.hash
+      end
+
+      # @!visibility private
+      def add_to(builder)
+        builder.comment "Generic".dress
+        builder.text "\n"
+        if comment
+          builder.comment(indented_comment)
+          builder.text "\n"
+        end
+        decorated_fragment = fragment.dup
+        if AIXM.ofmx?
+          decorated_fragment.css('*').each do |element|
+            element['region'] ||= region if element.name.match?(/Uid$/)
+          end
+        end
+        builder << decorated_fragment.to_xml
+      end
+    end
+
+  end
+end

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

@@ -18,11 +18,11 @@ module AIXM
       #   )
       #   designated_point.airport = AIXM.airport or nil
       #   designated_point.remarks = String or nil
+      #   designated_point.comment = Object or nil
       #
       # @see https://gitlab.com/openflightmaps/ofmx/wikis/Navigational-aid#dpn-designated-point
       class DesignatedPoint < NavigationalAid
-        include AIXM::Association
-        include AIXM::Memoize
+        include AIXM::Concerns::Association
 
         public_class_method :new
 
@@ -60,28 +60,26 @@ module AIXM
           @type = TYPES.lookup(value&.to_s&.to_sym, nil) || fail(ArgumentError, "invalid type")
         end
 
-        # @return [String] UID markup
-        def to_uid
-          builder = Builder::XmlMarkup.new(indent: 2)
+        # @!visibility private
+        def add_uid_to(builder)
           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
-        memoize :to_uid
 
-        # @return [String] AIXM or OFMX markup
-        def to_xml
-          builder = to_builder
+        # @!visibility private
+        def add_to(builder)
+          super
           builder.Dpn({ source: (source if AIXM.ofmx?) }.compact) do |dpn|
-            dpn << to_uid.indent(2)
-            dpn << airport.to_uid(as: :AhpUidAssoc).indent(2) if airport
+            dpn.comment(indented_comment) if comment
+            add_uid_to(dpn)
+            airport.add_uid_to(dpn, as: :AhpUidAssoc) if airport
             dpn.codeDatum('WGE')
-            dpn.codeType(AIXM.aixm? && type_key =~ /^VFR/ ? 'OTHER' : type_key.to_s)
+            dpn.codeType(AIXM.aixm? && type_key =~ /^VFR/ ? 'OTHER' : type_key)
             dpn.txtName(name) if name
             dpn.txtRmk(remarks) if remarks
-            dpn.target!
           end
         end
 

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

@@ -23,11 +23,10 @@ module AIXM
       #   )
       #   dme.timetable = AIXM.timetable or nil
       #   dme.remarks = String or nil
+      #   dme.comment = Object or nil
       #
       # @see https://gitlab.com/openflightmaps/ofmx/wikis/Navigational-aid#dme-dme
       class DME < NavigationalAid
-        include AIXM::Memoize
-
         public_class_method :new
 
         CHANNEL_RE = /\A([1-9]|[1-9]\d|1[0-1]\d|12[0-6])[XY]\z/.freeze
@@ -93,24 +92,23 @@ module AIXM
           end
         end
 
-        # @return [String] UID markup
-        def to_uid
-          builder = Builder::XmlMarkup.new(indent: 2)
+        # @!visibility private
+        def add_uid_to(builder)
           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
-        memoize :to_uid
 
-        # @return [String] AIXM or OFMX markup
-        def to_xml
-          builder = to_builder
+        # @!visibility private
+        def add_to(builder)
+          super
           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.comment(indented_comment) if comment
+            add_uid_to(dme)
+            organisation.add_uid_to(dme)
+            vor.add_uid_to(dme) if vor
             dme.txtName(name) if name
             dme.codeChannel(channel)
             unless vor
@@ -120,11 +118,10 @@ module AIXM
             dme.codeDatum('WGE')
             if z
               dme.valElev(z.alt)
-              dme.uomDistVer(z.unit.upcase.to_s)
+              dme.uomDistVer(z.unit.upcase)
             end
-            dme << timetable.to_xml(as: :Dtt).indent(2) if timetable
+            timetable.add_to(dme, as: :Dtt) if timetable
             dme.txtRmk(remarks) if remarks
-            dme.target!
           end
         end
       end

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

@@ -21,14 +21,13 @@ module AIXM
       #   )
       #   marker.timetable = AIXM.timetable or nil
       #   marker.remarks = String or nil
+      #   marker.comment = Object or nil
       #
       # @note Marker are not fully implemented because they usually have to be
       #   associated with an ILS which are not implemented as of now.
       #
       # @see https://gitlab.com/openflightmaps/ofmx/wikis/Navigational-aid#mkr-marker-beacon
       class Marker < NavigationalAid
-        include AIXM::Memoize
-
         public_class_method :new
 
         TYPES = {
@@ -60,35 +59,33 @@ module AIXM
           @type = value.nil? ? nil : TYPES.lookup(value.to_s.to_sym, nil) || fail(ArgumentError, "invalid type")
         end
 
-        # @return [String] UID markup
-        def to_uid
-          builder = Builder::XmlMarkup.new(indent: 2)
+        # @!visibility private
+        def add_uid_to(builder)
           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
-        memoize :to_uid
 
-        # @return [String] AIXM or OFMX markup
-        def to_xml
-          builder = to_builder
+        # @!visibility private
+        def add_to(builder)
+          super
           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.comment(indented_comment) if comment
+            add_uid_to(mkr)
+            organisation.add_uid_to(mkr)
+            mkr.codePsnIls(type_key) 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.upcase.to_s)
+              mkr.uomDistVer(z.unit.upcase)
             end
-            mkr << timetable.to_xml(as: :Mtt).indent(2) if timetable
+            timetable.add_to(mkr, as: :Mtt) if timetable
             mkr.txtRmk(remarks) if remarks
-            mkr.target!
           end
         end
 

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

@@ -21,11 +21,10 @@ module AIXM
       #   )
       #   ndb.timetable = AIXM.timetable or nil
       #   ndb.remarks = String or nil
+      #   ndb.comment = Object or nil
       #
       # @see https://gitlab.com/openflightmaps/ofmx/wikis/Navigational-aid#ndb-ndb
       class NDB < NavigationalAid
-        include AIXM::Memoize
-
         public_class_method :new
 
         TYPES = {
@@ -67,35 +66,33 @@ module AIXM
           @f = value
         end
 
-        # @return [String] UID markup
-        def to_uid
-          builder = Builder::XmlMarkup.new(indent: 2)
+        # @!visibility private
+        def add_uid_to(builder)
           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
-        memoize :to_uid
 
-        # @return [String] AIXM or OFMX markup
-        def to_xml
-          builder = to_builder
+        # @!visibility private
+        def add_to(builder)
+          super
           builder.Ndb({ source: (source if AIXM.ofmx?) }.compact) do |ndb|
-            ndb << to_uid.indent(2)
-            ndb << organisation.to_uid.indent(2)
+            ndb.comment(indented_comment) if comment
+            add_uid_to(ndb)
+            organisation.add_uid_to(ndb)
             ndb.txtName(name) if name
             ndb.valFreq(f.freq.trim)
-            ndb.uomFreq(f.unit.upcase.to_s)
-            ndb.codeClass(type_key.to_s) if type
+            ndb.uomFreq(f.unit.upcase)
+            ndb.codeClass(type_key) if type
             ndb.codeDatum('WGE')
             if z
               ndb.valElev(z.alt)
-              ndb.uomDistVer(z.unit.upcase.to_s)
+              ndb.uomDistVer(z.unit.upcase)
             end
-            ndb << timetable.to_xml(as: :Ntt).indent(2) if timetable
+            timetable.add_to(ndb, as: :Ntt) if timetable
             ndb.txtRmk(remarks) if remarks
-            ndb.target!
           end
         end