aixm 0.1.3 → 0.2.0

data/lib/aixm/document.rb

@@ -1,8 +1,9 @@
 module AIXM
-  class Document
-
+  class Document < Base
     using AIXM::Refinements
 
+    IGNORE_ERROR_PATTERN = %r(OrgUid)
+
     attr_reader :created_at, :effective_at
     attr_accessor :features
 
@@ -20,7 +21,7 @@ module AIXM
     ##
     # Check whether the document is complete (extensions excluded)
     def complete?
-      features.any? && features.none? { |f| !f.complete? }
+      features.any? && features.none? { |f| f.respond_to?(:complete?) && !f.complete? }
     end
 
     ##
@@ -33,14 +34,16 @@ module AIXM
     # Validate against the XSD and return an array of errors
     def errors
       xsd = Nokogiri::XML::Schema(File.open(AIXM::SCHEMA))
-      xsd.validate(Nokogiri::XML(to_xml))
+      xsd.validate(Nokogiri::XML(to_xml)).reject do |error|
+        error.message =~ IGNORE_ERROR_PATTERN
+      end
     end
 
     ##
     # Render AIXM
     #
     # Extensions:
-    # * +:OFM+ - Open Flightmaps
+    # * +:ofm+ - Open Flightmaps
     def to_xml(*extensions)
       now = Time.now.xmlschema
       meta = {
@@ -50,7 +53,7 @@ module AIXM
         created: @created_at&.xmlschema || now,
         effective: @effective_at&.xmlschema || now
       }
-      meta[:version] += ' + OFM extensions of version 0.1' if extensions >> :OFM
+      meta[:version] += ' + OFM extensions of version 0.1' if extensions >> :ofm
       builder = Builder::XmlMarkup.new(indent: 2)
       builder.instruct!
       builder.tag!('AIXM-Snapshot', meta) do |aixm_snapshot|

data/lib/aixm/f.rb

@@ -0,0 +1,41 @@
+module AIXM
+
+  ##
+  # Frequency
+  #
+  # The following units are recognized:
+  # * +:mhz+ - megahertz
+  # * +:khz+ - kilohertz
+  class F < Base
+    using AIXM::Refinements
+
+    UNITS = %i(mhz khz).freeze
+
+    attr_reader :freq, :unit
+
+    def initialize(freq, unit)
+      @freq, @unit = freq.to_f, unit&.to_sym&.downcase
+      fail(ArgumentError, "unrecognized unit `#{@unit}'") unless UNITS.include? @unit
+    end
+
+    ##
+    # Digest to identify the payload
+    def to_digest
+      [freq, unit].to_digest
+    end
+
+    ##
+    # Check whether two frequencies are identical
+    def ==(other)
+      other.is_a?(F) && freq == other.freq && unit == other.unit
+    end
+
+    ##
+    # Check whether this frequency is part of a frequency band
+    def between?(lower_freq, upper_freq, unit)
+      freq.between?(lower_freq, upper_freq) && self.unit == unit
+    end
+
+  end
+
+end

data/lib/aixm/feature/airspace.rb

@@ -1,7 +1,6 @@
 module AIXM
   module Feature
-    class Airspace
-
+    class Airspace < Base
       using AIXM::Refinements
 
       attr_reader :name, :short_name, :type
@@ -45,15 +44,12 @@ module AIXM
 
       ##
       # Render AIXM
-      #
-      # Extensions:
-      # * +:OFM+ - Open Flightmaps
       def to_xml(*extensions)
         mid = to_digest
         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.AseUid({ mid: mid, newEntity: (true if extensions >> :OFM) }.compact) do |aseuid|
+        builder.Ase({ xt_classLayersAvail: ((class_layers.count > 1) if extensions >> :ofm) }.compact) do |ase|
+          ase.AseUid({ mid: mid, newEntity: (true if extensions >> :ofm) }.compact) do |aseuid|
             aseuid.codeType(type.to_s)
             aseuid.codeId(mid)
           end
@@ -66,11 +62,11 @@ module AIXM
             end
           end
           ase.txtRmk(remarks.to_s) if remarks
-          ase.xt_selAvail(false) if extensions >> :OFM
+          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|
+            abduid.AseUid({ mid: mid, newEntity: (true if extensions >> :ofm) }.compact) do |aseuid|
               aseuid.codeType(type.to_s)
               aseuid.codeId(mid)
             end

data/lib/aixm/feature/base.rb

@@ -0,0 +1,6 @@
+module AIXM
+  module Feature
+    class Base < AIXM::Base
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module AIXM
+  module Feature
+    module NavigationalAid
+
+      ##
+      # Implements common attributes of all navigational aids
+      #
+      # Please note that the optional elevation +z+ must be in +:qnh+.
+      class Base < AIXM::Feature::Base
+        using AIXM::Refinements
+
+        attr_reader :id, :name, :xy, :z
+        attr_accessor :remarks
+
+        private_class_method :new
+
+        def initialize(id:, name:, xy:, z: nil)
+          @id, @name, @xy, @z = id&.upcase, name&.upcase, xy, z
+          fail(ArgumentError, "invalid xy") unless xy.is_a? AIXM::XY
+          fail(ArgumentError, "invalid z") unless z.nil? || (z.is_a?(AIXM::Z) && z.qnh?)
+        end
+
+        ##
+        # Return either the +type_key+ or +class+
+        def kind
+          respond_to?(:type_key) ? type_key : self.class.name.split('::').last.to_sym
+        end
+
+        ##
+        # Digest to identify the payload
+        def to_digest
+          [kind, id, name, xy.to_digest, z&.to_digest, remarks].to_digest
+        end
+
+        ##
+        # Create builder to render AIXM in subclasses
+        def to_builder(*extensions)
+          builder = Builder::XmlMarkup.new(indent: 2)
+          builder.comment! "Navigational aid: [#{kind}] #{name}"
+          builder
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module AIXM
+  module Feature
+    module NavigationalAid
+
+      ##
+      # Designated points are  named map coordinates
+      #
+      # 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
+      # * +:other+ (+:OTHER+) - other type
+      class DesignatedPoint < Base
+        using AIXM::Refinements
+
+        TYPES = {
+          ICAO: :icao,
+          ADHP: :adhp,
+          COORD: :coordinates,
+          OTHER: :other
+        }.freeze
+
+        attr_reader :type
+
+        public_class_method :new
+
+        def initialize(id:, name:, xy:, z: nil, type:)
+          super(id: id, name: name, xy: xy, z: z)
+          @type = TYPES.lookup(type&.to_sym, nil) || fail(ArgumentError, "invalid type")
+        end
+
+        ##
+        # Digest to identify the payload
+        def to_digest
+          [super, type].to_digest
+        end
+
+        ##
+        # Render AIXM
+        def to_xml(*extensions)
+          builder = to_builder(*extensions)
+          builder.Dpn do |dpn|
+            dpn.DpnUid({ 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)))
+            end
+            dpn.OrgUid
+            dpn.txtName(name)
+            dpn.codeDatum('WGE')
+            dpn.codeType(type_key.to_s)
+            if z
+              dpn.valElev(z.alt)
+              dpn.uomDistVer(z.unit.to_s)
+            end
+            dpn.txtRmk(remarks) if remarks
+            dpn.target!   # see https://github.com/jimweirich/builder/issues/42
+          end
+        end
+
+        def type_key
+          TYPES.key(type)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module AIXM
+  module Feature
+    module NavigationalAid
+
+      ##
+      # DME (distance measuring equipment) operate in the frequency band
+      # between 962 MHz and 1213 MHz.
+      #
+      # https://en.wikipedia.org/wiki/Distance_measuring_equipment
+      class DME < Base
+        using AIXM::Refinements
+
+        attr_reader :channel
+
+        public_class_method :new
+
+        def initialize(id:, name:, xy:, z: nil, channel:)
+          super(id: id, name: name, xy: xy, z: z)
+          @channel = channel&.upcase
+        end
+
+        ##
+        # Digest to identify the payload
+        def to_digest
+          [super, channel].to_digest
+        end
+
+        ##
+        # Render AIXM
+        def to_xml(*extensions)
+          builder = to_builder(*extensions)
+          builder.Dme do |dme|
+            dme.DmeUid({ newEntity: (true if extensions >> :ofm) }.compact) do |dmeuid|
+              dmeuid.codeId(id)
+              dmeuid.geoLat(xy.lat(format_for(*extensions)))
+              dmeuid.geoLong(xy.long(format_for(*extensions)))
+            end
+            dme.OrgUid
+            dme.txtName(name)
+            dme.codeChannel(channel)
+            dme.codeDatum('WGE')
+            if z
+              dme.valElev(z.alt)
+              dme.uomDistVer(z.unit.to_s)
+            end
+            dme.txtRmk(remarks) if remarks
+            dme.target!   # see https://github.com/jimweirich/builder/issues/42
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module AIXM
+  module Feature
+    module NavigationalAid
+
+      ##
+      # Marker (marker beacons) operate on 75 MHz.
+      #
+      # https://en.wikipedia.org/wiki/Marker_beacon
+      class Marker < Base
+        using AIXM::Refinements
+
+        public_class_method :new
+
+        ##
+        # Render AIXM
+        def to_xml(*extensions)
+          builder = to_builder(*extensions)
+          builder.Mkr do |mkr|
+            mkr.MkrUid({ newEntity: (true if extensions >> :ofm) }.compact) do |mkruid|
+              mkruid.codeId(id)
+              mkruid.geoLat(xy.lat(format_for(*extensions)))
+              mkruid.geoLong(xy.long(format_for(*extensions)))
+            end
+            mkr.OrgUid
+            mkr.valFreq(75)
+            mkr.uomFreq('MHZ')
+            mkr.txtName(name)
+            mkr.codeDatum('WGE')
+            if z
+              mkr.valElev(z.alt)
+              mkr.uomDistVer(z.unit.to_s)
+            end
+            mkr.txtRmk(remarks) if remarks
+            mkr.target!   # see https://github.com/jimweirich/builder/issues/42
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module AIXM
+  module Feature
+    module NavigationalAid
+
+      ##
+      # NDB (non-directional beacon) operate in the frequency band between
+      # 190 kHz and 1750 kHz.
+      #
+      # https://en.wikipedia.org/wiki/Non-directional_beacon
+      class NDB < Base
+        using AIXM::Refinements
+
+        attr_reader :f
+
+        public_class_method :new
+
+        def initialize(id:, name:, xy:, z: nil, f:)
+          super(id: id, name: name, xy: xy, z: z)
+          @f = f
+          fail(ArgumentError, "invalid frequency") unless f.is_a?(F) && f.between?(190, 1750, :khz)
+        end
+
+        ##
+        # Digest to identify the payload
+        def to_digest
+          [super, f.to_digest].to_digest
+        end
+
+        ##
+        # Render AIXM
+        def to_xml(*extensions)
+          builder = to_builder(*extensions)
+          builder.Ndb do |ndb|
+            ndb.NdbUid({ newEntity: (true if extensions >> :ofm) }.compact) do |ndbuid|
+              ndbuid.codeId(id)
+              ndbuid.geoLat(xy.lat(format_for(*extensions)))
+              ndbuid.geoLong(xy.long(format_for(*extensions)))
+            end
+            ndb.OrgUid
+            ndb.txtName(name)
+            ndb.valFreq(f.freq.trim)
+            ndb.uomFreq(f.unit.upcase.to_s)
+            ndb.codeDatum('WGE')
+            if z
+              ndb.valElev(z.alt)
+              ndb.uomDistVer(z.unit.to_s)
+            end
+            ndb.txtRmk(remarks) if remarks
+            ndb.target!   # see https://github.com/jimweirich/builder/issues/42
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module AIXM
+  module Feature
+    module NavigationalAid
+
+      ##
+      # TACAN (tactical air navigation system) operate in the frequency band
+      # between 960 MHz and 1215 MHz.
+      #
+      # https://en.wikipedia.org/wiki/Tactical_air_navigation_system
+      class TACAN < Base
+        using AIXM::Refinements
+
+        attr_reader :channel
+
+        public_class_method :new
+
+        def initialize(id:, name:, xy:, z: nil, channel:)
+          super(id: id, name: name, xy: xy, z: z)
+          @channel = channel&.upcase
+        end
+
+        ##
+        # Digest to identify the payload
+        def to_digest
+          [super, channel].to_digest
+        end
+
+        ##
+        # Render AIXM
+        def to_xml(*extensions)
+          builder = to_builder(*extensions)
+          builder.Tcn do |tcn|
+            tcn.TcnUid({ newEntity: (true if extensions >> :ofm) }.compact) do |tcnuid|
+              tcnuid.codeId(id)
+              tcnuid.geoLat(xy.lat(format_for(*extensions)))
+              tcnuid.geoLong(xy.long(format_for(*extensions)))
+            end
+            tcn.OrgUid
+            tcn.txtName(name)
+            tcn.codeChannel(channel)
+            tcn.codeDatum('WGE')
+            if z
+              tcn.valElev(z.alt)
+              tcn.uomDistVer(z.unit.to_s)
+            end
+            tcn.txtRmk(remarks) if remarks
+            tcn.target!   # see https://github.com/jimweirich/builder/issues/42
+          end
+        end
+      end
+
+    end
+  end
+end