aixm 0.1.0 → 0.1.3

data/lib/aixm/component/geometry/arc.rb

@@ -0,0 +1,53 @@
+module AIXM
+  module Component
+    class Geometry
+
+      ##
+      # Arcs are +clockwise+ (true/false) circle sectors around +center_xy+ and
+      # starting at +xy+.
+      class Arc < Point
+        using AIXM::Refinements
+
+        attr_reader :center_xy
+
+        def initialize(xy:, center_xy:, clockwise:)
+          super(xy: xy)
+          fail(ArgumentError, "invalid center xy") unless center_xy.is_a? AIXM::XY
+          fail(ArgumentError, "clockwise must be true or false") unless [true, false].include? clockwise
+          @center_xy, @clockwise = center_xy, clockwise
+        end
+
+        ##
+        # Whether the arc is going clockwise (true) or not (false)
+        def clockwise?
+          @clockwise
+        end
+
+        ##
+        # Digest to identify the payload
+        def to_digest
+          [xy.lat, xy.long, center_xy.lat, center_xy.long, clockwise?].to_digest
+        end
+
+        ##
+        # Render AIXM
+        #
+        # Extensions:
+        # * +:OFM+ - Open Flightmaps
+        def to_xml(*extensions)
+          format = extensions >> :OFM ? :OFM : :AIXM
+          builder = Builder::XmlMarkup.new(indent: 2)
+          builder.Avx do |avx|
+            avx.codeType(clockwise? ? 'CWA' : 'CCA')
+            avx.geoLat(xy.lat(format))
+            avx.geoLong(xy.long(format))
+            avx.codeDatum('WGE')
+            avx.geoLatArc(center_xy.lat(format))
+            avx.geoLongArc(center_xy.long(format))
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/aixm/component/geometry/border.rb

@@ -0,0 +1,49 @@
+module AIXM
+  module Component
+    class Geometry
+
+      ##
+      # Borders are following natural or artifical border lines referenced by
+      # +name+ and starting at +xy+.
+      class Border < Point
+        using AIXM::Refinements
+
+        attr_reader :name
+
+        def initialize(xy:, name:)
+          super(xy: xy)
+          @name = name
+        end
+
+        ##
+        # Digest to identify the payload
+        def to_digest
+          [xy.lat, xy.long, name].to_digest
+        end
+
+        ##
+        # Render AIXM
+        #
+        # Extensions:
+        # * +:OFM+ - Open Flightmaps
+        def to_xml(*extensions)
+          format = extensions >> :OFM ? :OFM : :AIXM
+          builder = Builder::XmlMarkup.new(indent: 2)
+          builder.Avx do |avx|
+            avx.codeType('FNT')
+            avx.geoLat(xy.lat(format))
+            avx.geoLong(xy.long(format))
+            avx.codeDatum('WGE')
+            # TODO: Find examples how to do this with vanilla AIXM
+            if extensions >> :OFM
+              avx.GbrUid do |gbruid|
+                gbruid.txtName(name.to_s)
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/aixm/component/geometry/circle.rb

@@ -0,0 +1,56 @@
+module AIXM
+  module Component
+    class Geometry
+
+      ##
+      # Circles are defined by a +center_xy+ and a +radius+ in kilometers.
+      class Circle
+        using AIXM::Refinements
+
+        attr_reader :center_xy, :radius
+
+        def initialize(center_xy:, radius:)
+          fail(ArgumentError, "invalid center xy") unless center_xy.is_a? AIXM::XY
+          @center_xy, @radius = center_xy, radius
+        end
+
+        ##
+        # Digest to identify the payload
+        def to_digest
+          [center_xy.lat, center_xy.long, radius].to_digest
+        end
+
+        ##
+        # Render AIXM
+        #
+        # Extensions:
+        # * +:OFM+ - Open Flightmaps
+        def to_xml(*extensions)
+          format = extensions >> :OFM ? :OFM : :AIXM
+          builder = Builder::XmlMarkup.new(indent: 2)
+          builder.Avx do |avx|
+            avx.codeType('CWA')
+            avx.geoLat(north_xy.lat(format))
+            avx.geoLong(north_xy.long(format))
+            avx.codeDatum('WGE')
+            avx.geoLatArc(center_xy.lat(format))
+            avx.geoLongArc(center_xy.long(format))
+          end
+        end
+
+        private
+
+        ##
+        # Coordinates of the point which is both strictly north of the center
+        # and on the circumference of the circle
+        def north_xy
+          AIXM.xy(
+            lat: center_xy.lat + radius.to_f / 6371 * 180 / Math::PI,
+            long: center_xy.long
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/aixm/component/geometry/point.rb

@@ -0,0 +1,42 @@
+module AIXM
+  module Component
+    class Geometry
+
+      ##
+      # Points are defined by +xy+ coordinates.
+      class Point
+        using AIXM::Refinements
+
+        attr_reader :xy
+
+        def initialize(xy:)
+          fail(ArgumentError, "invalid xy") unless xy.is_a? AIXM::XY
+          @xy = xy
+        end
+
+        ##
+        # Digest to identify the payload
+        def to_digest
+          [xy.lat, xy.long].to_digest
+        end
+
+        ##
+        # Render AIXM
+        #
+        # Extensions:
+        # * +:OFM+ - Open Flightmaps
+        def to_xml(*extensions)
+          format = extensions >> :OFM ? :OFM : :AIXM
+          builder = Builder::XmlMarkup.new(indent: 2)
+          builder.Avx do |avx|
+            avx.codeType('GRC')
+            avx.geoLat(xy.lat(format))
+            avx.geoLong(xy.long(format))
+            avx.codeDatum('WGE')
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/aixm/component/schedule.rb

@@ -0,0 +1,45 @@
+module AIXM
+  module Component
+
+    ##
+    # Schedules define activity time windows. As of now, only predefined
+    # schedules are imlemented either by use of explicit (e.g. +:continuous+)
+    # or short codes (e.g. +:H24+) as listed by the +CODES+ constant.
+    #
+    # Shortcuts:
+    # * +AIXM::H24+ - continuous 24/7
+    class Schedule < Base
+      using AIXM::Refinements
+
+      CODES = {
+        continuous: :H24,
+        sunrise_to_sunset: :HJ,
+        sunset_to_sunrise: :HN,
+        unspecified: :HX,
+        operational_request: :HO,
+        notam: :NOTAM
+      }.freeze
+
+      attr_reader :code
+
+      def initialize(code:)
+        @code = code&.to_sym
+        @code = CODES[code] unless CODES.has_value? code
+        fail(ArgumentError, "code `#{code}' not recognized") unless @code
+      end
+
+      ##
+      # Digest to identify the payload
+      def to_digest
+        [code].to_digest
+      end
+
+      ##
+      # Render AIXM
+      def to_xml(*extensions)
+        Builder::XmlMarkup.new(indent: 2).codeWorkHr(code.to_s)
+      end
+    end
+
+  end
+end

data/lib/aixm/{vertical/limits.rb → component/vertical_limits.rb}

@@ -1,18 +1,18 @@
 module AIXM
-  module Vertical
+  module Component
 
     ##
-    # Vertical limits
-    #
-    # Normally noted as:
+    # Vertical limits define a 3D airspace vertically. They are normally noted
+    # as follows:
     #
     #   +upper z+ (or +max_z+ whichever is higher)
     #   ---------
     #   +lower_z+ (or +min_z+ whichever is lower)
     #
-    # Use +AIXM::GROUND+ as a shortcut for surface aka zero height.
-    class Limits
-
+    # Shortcuts:
+    # * +AIXM::GROUND+ - surface (aka: 0ft QFE)
+    # * +AIXM::UNLIMITED+ - no upper limit (aka: FL 999)
+    class VerticalLimits < Base
       using AIXM::Refinements
 
       TAGS = { upper: :Upper, lower: :Lower, max: :Max, min: :Mnm }.freeze
@@ -20,13 +20,7 @@ module AIXM
 
       attr_reader :upper_z, :lower_z, :max_z, :min_z
 
-      ##
-      # Defines vertical limits +upper_z+ and +lower_z+
-      #
-      # Options:
-      # * +max_z+ - alternative upper limit "whichever is higher"
-      # * +min_z+ - alternative lower limit "whichever is lower"
-      def initialize(upper_z:, lower_z:, max_z: nil, min_z: nil)
+      def initialize(max_z: nil, upper_z:, lower_z:, min_z: nil)
         fail(ArgumentError, "invalid upper_z") unless upper_z.is_a? AIXM::Z
         fail(ArgumentError, "invalid lower_z") unless lower_z.is_a? AIXM::Z
         fail(ArgumentError, "invalid max_z") unless max_z.nil? || max_z.is_a?(AIXM::Z)
@@ -55,5 +49,6 @@ module AIXM
         end.target!   # see https://github.com/jimweirich/builder/issues/42
       end
     end
+
   end
 end

data/lib/aixm/document.rb

@@ -1,29 +1,32 @@
 module AIXM
   class Document
 
-    include Enumerable
-    extend Forwardable
     using AIXM::Refinements
 
-    def_delegators :@result_array, :each, :<<
-
     attr_reader :created_at, :effective_at
+    attr_accessor :features
 
     ##
     # Define a AIXM-Snapshot document
     #
     # Options:
-    # * +created_at+ - creation date (default: now)
-    # * +effective_at+ - snapshot effective after date (default: now)
+    # * +created_at+ - creation date and time (default: now)
+    # * +effective_at+ - snapshot effective after date and time (default: now)
     def initialize(created_at: nil, effective_at: nil)
-      @created_at, @effective_at = created_at, effective_at
-      @result_array = []
+      @created_at, @effective_at = parse_time(created_at), parse_time(effective_at)
+      @features = []
     end
 
     ##
-    # Array of features defined by this document
-    def features
-      @result_array
+    # Check whether the document is complete (extensions excluded)
+    def complete?
+      features.any? && features.none? { |f| !f.complete? }
+    end
+
+    ##
+    # Validate atainst the XSD and return +true+ if no errors were found
+    def valid?
+      errors.none?
     end
 
     ##
@@ -33,12 +36,6 @@ module AIXM
       xsd.validate(Nokogiri::XML(to_xml))
     end
 
-    ##
-    # Check whether the document is valid (extensions excluded)
-    def valid?
-      any? && reduce(true) { |b, f| b && f.valid? } && errors.none?
-    end
-
     ##
     # Render AIXM
     #
@@ -53,12 +50,26 @@ module AIXM
         created: @created_at&.xmlschema || now,
         effective: @effective_at&.xmlschema || now
       }
-      meta[:version] += ' + OFM extensions of version 0.1' if extensions.include?(: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|
-        aixm_snapshot << @result_array.map { |f| f.to_xml(extensions) }.join.indent(2)
+        aixm_snapshot << features.map { |f| f.to_xml(*extensions) }.join.indent(2)
+      end
+    end
+
+    private
+
+    def parse_time(value)
+      case value
+        when String then Time.parse(value)
+        when Date then value.to_time
+        when Time then value
+        when nil then nil
+        else fail ArgumentError
       end
+    rescue ArgumentError
+      raise(ArgumentError, "`#{value}' is not a valid date and time")
     end
 
   end

data/lib/aixm/feature/airspace.rb

@@ -4,38 +4,43 @@ module AIXM
 
       using AIXM::Refinements
 
-      attr_reader :name, :type
-      attr_reader :vertical_limits
-      attr_accessor :geometry, :remarks
+      attr_reader :name, :short_name, :type
+      attr_reader :schedule
+      attr_accessor :geometry, :class_layers, :remarks
 
       ##
       # Airspace feature
       #
       # Options:
-      # * +name+ - name of the airspace (will be converted to uppercase)
+      # * +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:, type:)
-        @geometry = AIXM::Geometry.new
-        @name, @type = name.upcase, type
+      def initialize(name:, short_name: nil, type:)
+        @name, @short_name, @type = name.uptrans, short_name&.uptrans, type
+        @schedule = nil
+        @geometry = AIXM.geometry
+        @class_layers = []
       end
 
       ##
-      # Assign a +Vertical::Limits+ object
-      def vertical_limits=(value)
-        fail(ArgumentError, "invalid vertical limit") unless value.is_a?(AIXM::Vertical::Limits)
-        @vertical_limits = value
+      # Assign a +Schedule+ object or +nil+
+      def schedule=(value)
+        fail(ArgumentError, "invalid schedule") unless value.nil? || value.is_a?(AIXM::Component::Schedule)
+        @schedule = value
       end
 
       ##
-      # Check whether the airspace is valid
-      def valid?
-        name && type && vertical_limits && geometry.valid?
+      # Check whether the airspace is complete
+      def complete?
+        !!name && !!type && class_layers.any? && geometry.complete?
       end
 
       ##
       # Digest to identify the payload
       def to_digest
-        [name, type, vertical_limits.to_digest, geometry.to_digest, remarks].to_digest
+        [name, short_name, type, schedule&.to_digest, class_layers.map(&:to_digest), geometry.to_digest, remarks].to_digest
       end
 
       ##
@@ -46,28 +51,54 @@ module AIXM
       def to_xml(*extensions)
         mid = to_digest
         builder = Builder::XmlMarkup.new(indent: 2)
-        builder.Ase(extensions.include?(:OFM) ? { xt_classLayersAvail: false } : {}) do |ase|
-          ase.AseUid(extensions.include?(:OFM) ? { mid: mid, newEntity: true } : { mid: mid }) do |aseuid|
-            aseuid.codeType(type)
-            aseuid.codeId(mid)   # TODO: verify
+        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|
+            aseuid.codeType(type.to_s)
+            aseuid.codeId(mid)
           end
-          ase.txtName(name)
-          ase << vertical_limits.to_xml(extensions).indent(2)
-          ase.txtRmk(remarks) if remarks
-          if extensions.include?(:OFM)
-            ase.xt_txtRmk(remarks)
-            ase.xt_selAvail(false)
+          ase.txtLocalType(short_name.to_s) if short_name && short_name != name
+          ase.txtName(name.to_s)
+          ase << class_layers.first.to_xml(*extensions).indent(2)
+          if schedule
+            ase.Att do |att|
+              att << schedule.to_xml(*extensions).indent(4)
+            end
           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(extensions.include?(:OFM) ? { mid: mid, newEntity: true } : { mid: mid }) do |aseuid|
-              aseuid.codeType(type)
-              aseuid.codeId(mid)   # TODO: verify
+            abduid.AseUid({ mid: mid, newEntity: (true if extensions >> :OFM) }.compact) do |aseuid|
+              aseuid.codeType(type.to_s)
+              aseuid.codeId(mid)
+            end
+          end
+          abd << geometry.to_xml(*extensions).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|
+            builder.Ase do |ase|
+              ase.AseUid(mid: "#{mid}.#{index + 1}") do |aseuid|
+                aseuid.codeType("CLASS")
+              end
+              ase.txtName(name.to_s)
+              ase << class_layers[index].to_xml(*extensions).indent(2)
             end
           end
-          abd << geometry.to_xml(extensions).indent(2)
         end
+        builder.target!   # see https://github.com/jimweirich/builder/issues/42
       end
     end
   end