aixm 0.3.7 → 1.0.0

data/lib/aixm/feature/obstacle_group.rb

@@ -9,6 +9,7 @@ module AIXM
     # ===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
@@ -31,12 +32,34 @@ module AIXM
     #
     # 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!
+    # is set on the individual obstacles. On the other hand, if the obstacle
+    # group has no +source+ set, it will inherit this value from the first
+    # obstacle in the group.
     #
-    # @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 +77,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 +106,16 @@ 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|
+        builder.OgrUid({ region: (region if AIXM.ofmx?) }.compact) do |ogr_uid|
           ogr_uid.txtName(name)
           ogr_uid.geoLat(obstacles.first.xy.lat(AIXM.schema))
           ogr_uid.geoLong(obstacles.first.xy.long(AIXM.schema))
         end
       end
+      memoize :to_uid
 
       # @return [String] AIXM or OFMX markup
       def to_xml
@@ -136,7 +136,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
       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)
+          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

data/lib/aixm/feature.rb

@@ -2,24 +2,34 @@ module AIXM
 
   # @abstract
   class Feature
+    REGION_RE = /\A[A-Z]{2}\z/.freeze
+
     private_class_method :new
 
     # @return [String] reference to source of the feature data
     attr_reader :source
 
-    def initialize(source: nil)
+    # @return [String] OFMX region all features in this document belong to
+    attr_reader :region
+
+    def initialize(source: nil, region: nil)
       self.source = source
+      self.region = region || AIXM.config.region
     end
 
-    # @return [String] reference to source of the feature data
     def source=(value)
       fail(ArgumentError, "invalid source") unless value.nil? || value.is_a?(String)
       @source = value
     end
 
+    def region=(value)
+      fail(ArgumentError, "invalid region") unless value.nil? || (value.is_a?(String) && value.upcase.match?(REGION_RE))
+      @region = value&.upcase
+    end
+
     # @return [Boolean]
     def ==(other)
-      self.class === other && self.to_uid == other.to_uid
+      self.__class__ === other && self.to_uid == other.to_uid
     end
   end
 

data/lib/aixm/memoize.rb

@@ -0,0 +1,89 @@
+module AIXM
+
+  # Memoize the return value of a specific method across multiple instances for
+  # the duration of a block.
+  #
+  # The method signature is taken into account, therefore calls of the same
+  # method with different positional and/or keyword arguments are cached
+  # independently. On the other hand, when calling the method with a block,
+  # no memoization is performed at all.
+  #
+  # @example
+  #   class Either
+  #     include AIXM::Memoize
+  #
+  #     def either(argument=nil, keyword: nil, &block)
+  #       $entropy || argument || keyword || (block.call if block)
+  #     end
+  #     memoize :either
+  #   end
+  #
+  #   a, b, c = Either.new, Either.new, Either.new
+  #
+  #   # No memoization before the block
+  #   $entropy = nil
+  #   a.either(1)                 # => 1
+  #   b.either(keyword: 2)        # => 2
+  #   c.either { 3 }              # => 3
+  #   $entropy = :not_nil
+  #   a.either(1)                 # => :not_nil
+  #   b.either(keyword: 2)        # => :not_nil
+  #   c.either { 3 }              # => :not_nil
+  #
+  #   # Memoization inside the block
+  #   AIXM::Memoize.method :either do
+  #     $entropy = nil
+  #     a.either(1)                 # => 1
+  #     b.either(keyword: 2)        # => 2
+  #     c.either { 3 }              # => 3
+  #     $entropy = :not_nil
+  #     a.either(1)                 # => 1          (memoized)
+  #     b.either(keyword: 2)        # => 2          (memoized)
+  #     c.either { 3 }              # => :not_nil   (cannot be memoized)
+  #   end
+  #
+  #   # No memoization after the block
+  #   $entropy = nil
+  #   a.either(1)                 # => 1
+  #   $entropy = :not_nil
+  #   a.either(1)                 # => :not_nil
+  module Memoize
+    module ClassMethods
+      def memoize(method)
+        unmemoized_method = :"unmemoized_#{method}"
+        alias_method unmemoized_method, method
+        define_method method do |*args, **kargs, &block|
+          if block || !AIXM::Memoize.cache
+            send(unmemoized_method, *args, **kargs, &block)
+          else
+            id = object_id.hash ^ args.hash ^ kargs.hash
+            if AIXM::Memoize.cache.has_key?(id)
+              AIXM::Memoize.cache[id]
+            else
+              AIXM::Memoize.cache[id] = send(unmemoized_method, *args, **kargs, &block)
+            end
+          end
+        end
+      end
+    end
+
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+        @cache = {}
+      end
+
+      def method(method)
+        @method = method
+        @cache[@method] = {}
+        yield
+      ensure
+        @method = nil
+      end
+
+      def cache
+        (@cache[@method] ||= {}) if @method
+      end
+    end
+  end
+end

data/lib/aixm/object.rb

@@ -0,0 +1,9 @@
+# This monkey patch is necessary because some classes have to introduce
+# attributes named +class+ (e.g. for airspace classes as described by
+# +AIXM::Component::Layer+) which clash with this core method. Other parts
+# such as +AIXM::Association+ need the original implementation for introspection
+# which is why this alias +Object#__class__+ makes it globally and consistently
+# available again.
+class Object
+  alias_method :__class__, :class
+end

data/lib/aixm/payload_hash.rb

@@ -0,0 +1,114 @@
+using AIXM::Refinements
+
+module AIXM
+
+  # Calculate OFMX-compliant payload hashes.
+  #
+  # @example with XML fragment string
+  #   xml = '<xml><a></a></xml>'
+  #   AIXM::PayloadHash.new(xml).to_uuid
+  #
+  # @example with Nokogiri fragment
+  #   document = File.open("file.xml") { Nokogiri::XML(_1) }
+  #   AIXM::PayloadHash.new(document).to_uuid
+  #
+  # @see https://gitlab.com/openflightmaps/ofmx/wikis/Features#mid
+  class PayloadHash
+    IGNORED_ATTRIBUTES = %w(mid source).freeze
+
+    # @param fragment [Nokogiri::XML::DocumentFragment, Nokogiri::XML::Element, String] XML fragment
+    def initialize(fragment)
+      @fragment = case fragment
+        when Nokogiri::XML::DocumentFragment then fragment
+        when Nokogiri::XML::Element, String then Nokogiri::XML.fragment(fragment)
+        else fail ArgumentError
+      end
+    end
+
+    # @return [String] UUIDv3
+    def to_uuid
+      uuid_for payload_array
+    end
+
+    private
+
+    def payload_array
+      @fragment.css('*').each_with_object([]) do |element, array|
+        array << element.name.sub(/\A(\w+Uid)\w+/, '\1')   # remove name extension
+        element.attributes.sort.each do |name, attribute|
+          array.push(name, attribute.value) unless IGNORED_ATTRIBUTES.include? name
+        end
+        array << element.child.text if element.children.one? && element.child.text?
+        array << '' if element.children.none?
+      end
+    end
+
+    def uuid_for(array)
+      ::Digest::MD5.hexdigest(array.flatten.map(&:to_s).join('|')).unpack("a8a4a4a4a12").join("-")
+    end
+
+    # Insert OFMX-compliant payload hashes as mid attributes into an XML
+    # document.
+    #
+    # Keep in mind: If you pass a Nokogiri::XML::Document, the mid attributes
+    # are added into this document. In order to leave the original document
+    # untouched, you have to `dup` it.
+    #
+    # @example with XML string
+    #   string = '<OFMX-Snapshot><Ahp><AhpUid></AhpUid></Ahp></OFMX-Snapshot>'
+    #   converter = AIXM::PayloadHash::Mid.new(string)
+    #   converter.insert_mid.to_xml   # returns XML as String
+    #
+    # @example with Nokogiri document
+    #   document = File.open("file.ofmx") { Nokogiri::XML(_1) }
+    #   converter = AIXM::PayloadHash::Mid.new(document)
+    #   converter.insert_mid.to_xml   # returns XML as String
+    #   document.to_xml               # returns XML as String as well
+    #
+    # @see https://gitlab.com/openflightmaps/ofmx/wikis/Features#mid
+    class Mid
+
+      # @param document [Nokogiri::XML::Document, String] XML document
+      def initialize(document)
+        @document = case document
+          when Nokogiri::XML::Document then document
+          when String then Nokogiri::XML(document)
+          else fail ArgumentError
+        end
+      end
+
+      # Insert or update mid attributes on all *Uid elements
+      #
+      # @return [self]
+      def insert_mid
+        uid_elements.each do |element|
+          element['mid'] = AIXM::PayloadHash.new(element).to_uuid
+        end
+        self
+      end
+
+      # Check mid attributes on all *Uid elements
+      #
+      # @return [Array<String>] array of errors found
+      def check_mid
+        uid_elements.each_with_object([]) do |element, errors|
+          unless element['mid'] == (uuid = AIXM::PayloadHash.new(element).to_uuid)
+            errors << "#{element.line}: ERROR: Element '#{element.name}': mid should be #{uuid}"
+          end
+        end
+      end
+
+      # @return [String] XML document as XML string
+      def to_xml
+        @document.to_xml
+      end
+
+      private
+
+      def uid_elements
+        @document.xpath('//*[contains(local-name(), "Uid")]')
+      end
+    end
+  end
+
+end

data/lib/aixm/refinements.rb

@@ -30,22 +30,6 @@ module AIXM
       end
     end
 
-    # @!method to_uuid
-    #   Builds a UUID version 3 digest from the Array payload.
-    #
-    #   @example
-    #     ['foo', :bar, nil, [123]].to_uuid
-    #     # => "a68e9aae-81ef-c6f1-d954-2eefe2820c50"
-    #
-    #   @note This is a refinement for +Array+
-    #   @return [String] UUID version 3
-    refine Array do
-      def to_uuid
-        ::Digest::MD5.hexdigest(flatten.map(&:to_s).join('|')).unpack("a8a4a4a4a12").join("-")
-      end
-    end
-
-
     # @!method to_dms(padding=3)
     #   Convert DD angle to DMS with the degrees zero padded to +padding+
     #   length.
@@ -138,8 +122,8 @@ module AIXM
     #   Same as +Object#then+ but only applied if the condition is true.
     #
     #   @example
-    #     "foobar".then_if(false) { |s| s.gsub(/o/, 'i') }   # => "foobar"
-    #     "foobar".then_if(true) { |s| s.gsub(/o/, 'i') }    # => "fiibar"
+    #     "foobar".then_if(false) { _1.gsub(/o/, 'i') }   # => "foobar"
+    #     "foobar".then_if(true) { _1.gsub(/o/, 'i') }    # => "fiibar"
     #
     #   @note This is a refinement for +Object+
     #   @return [Object]
@@ -162,6 +146,38 @@ module AIXM
       end
     end
 
+    # @!method to_class
+    #   Convert string to class
+    #
+    #   @example
+    #     "AIXM::Feature::NavigationalAid".to_class
+    #     # => AIXM::Feature::NavigationalAid
+    #
+    #   @note This is a refinement for +String+
+    refine String do
+      def to_class
+        Object.const_get(self)
+      end
+    end
+
+    # @!method inflect
+    #   Apply inflections from the +dry-inflector+ gem
+    #
+    #   @example
+    #     s = "AIXM::Feature::NavigationalAid"
+    #     s.inflect(:demodulize, :tableize, :pluralize)
+    #     # => "navigational_aids"
+    #
+    #   @see https://www.rubydoc.info/gems/dry-inflector
+    #   @note This is a refinement for +String+
+    refine String do
+      def inflect(*inflections)
+        inflections.inject(self) do |memo, inflection|
+          AIXM.config.inflector.send(inflection, memo)
+        end
+      end
+    end
+
     # @!method indent(number)
     #   Indent every line of a string with +number+ spaces.
     #
@@ -179,38 +195,6 @@ module AIXM
       end
     end
 
-    # @!method payload_hash(region:, element:)
-    #   Calculate the UUIDv3 hash of an OFMX XML string.
-    #
-    #   A word of warning: This is a minimalistic implementation for the AIXM
-    #   gem and won't work unless the following conditions are met:
-    #   * the XML string must be OFMX
-    #   * the XML string must be valid
-    #   * the XML string must be pretty-printed
-    #
-    #   @example from https://github.com/openflightmaps/ofmx/wiki/Functions
-    #     xml.payload_hash(region: 'LF', element: 'Ser')
-    #     # => "269b1f18-cabe-3c9e-1d71-48a7414a4cb9"
-    #
-    #   @note This is a refinement for +String+
-    #   @param region [String] OFMX region (e.g. "LF")
-    #   @param element [String] tag to calculate the payload hash for
-    #   @return [String] UUID version 3
-    refine String do
-      def payload_hash(region:, element:)
-        gsub(%r(mid="[^"]*"), '').   # remove existing mid attributes
-          sub(%r(\A.*?(?=<#{element}))m, '').   # remove everything before first <element>
-          sub(%r(</#{element}>.*\z)m, '').   # remove everything after first </element>
-          scan(%r(<([\w-]+)([^>]*)>([^<]*))).each_with_object([region]) do |(e, a, t), m|
-            m << e << a.scan(%r(([\w-]+)="([^"]*)")).sort.flatten << t
-          end.
-          flatten.
-          keep_if { |s| s.match?(/[^[:space:]]/m) }.
-          compact.
-          to_uuid
-      end
-    end
-
     # @!method to_dd
     #   Convert DMS angle to DD or +nil+ if the notation is not recognized.
     #