aixm 0.2.3 → 0.3.0

data/lib/aixm.rb

@@ -1,32 +1,41 @@
 require 'builder'
+require 'ostruct'
+require 'securerandom'
 require 'nokogiri'
 require 'forwardable'
-require 'ostruct'
 require 'digest'
 require 'time'
 
 require_relative 'aixm/version'
 require_relative 'aixm/refinements'
+require_relative 'aixm/config'
+require_relative 'aixm/errors'
 
-require_relative 'aixm/base'
 require_relative 'aixm/document'
 require_relative 'aixm/xy'
 require_relative 'aixm/z'
 require_relative 'aixm/f'
 
-require_relative 'aixm/component/base'
+require_relative 'aixm/component'
+require_relative 'aixm/component/service'
+require_relative 'aixm/component/frequency'
 require_relative 'aixm/component/geometry'
 require_relative 'aixm/component/geometry/point'
 require_relative 'aixm/component/geometry/arc'
 require_relative 'aixm/component/geometry/border'
 require_relative 'aixm/component/geometry/circle'
-require_relative 'aixm/component/class_layer'
+require_relative 'aixm/component/layer'
 require_relative 'aixm/component/vertical_limits'
-require_relative 'aixm/component/schedule'
+require_relative 'aixm/component/timetable'
+require_relative 'aixm/component/runway'
+require_relative 'aixm/component/helipad'
 
-require_relative 'aixm/feature/base'
+require_relative 'aixm/feature'
+require_relative 'aixm/feature/organisation'
+require_relative 'aixm/feature/unit'
 require_relative 'aixm/feature/airspace'
-require_relative 'aixm/feature/navigational_aid/base'
+require_relative 'aixm/feature/airport'
+require_relative 'aixm/feature/navigational_aid'
 require_relative 'aixm/feature/navigational_aid/designated_point'
 require_relative 'aixm/feature/navigational_aid/dme'
 require_relative 'aixm/feature/navigational_aid/marker'

data/lib/aixm/component.rb

@@ -0,0 +1,6 @@
+module AIXM
+
+  # @abstract
+  class Component; end
+
+end

data/lib/aixm/component/frequency.rb

@@ -0,0 +1,135 @@
+using AIXM::Refinements
+
+module AIXM
+  class Component
+
+    # Frequencies used by a service.
+    #
+    # By default, {#reception_f} is set to the same value as {#transmission_f}
+    # since most services rely on simplex (aka: non-duplex) two-way
+    # communication. For services with one-way communication only such as ATIS,
+    # the {#reception_f} has to be set to +nil+ explicitly!
+    #
+    # ===Cheat Sheet in Pseudo Code:
+    #   frequency = AIXM.frequency(
+    #     transmission_f: AIXM.f
+    #     callsigns: Hash
+    #   )
+    #   frequency.reception_f = AIXM.f or nil
+    #   frequency.type = TYPES or nil
+    #   frequency.timetable = AIXM.timetable or nil
+    #   frequency.remarks = String or nil
+    #
+    # @see https://github.com/openflightmaps/ofmx/wiki/Organisation#fqy-frequency
+    class Frequency
+      TYPES = {
+        STD: :standard,
+        ALT: :alternative,
+        EMRG: :emergency,
+        GUARD: :guard,
+        MIL: :military,
+        CIV: :civilian,
+        OTHER: :other   # specify in remarks
+      }.freeze
+
+      # @return [AIXM::Component::Service] service the frequency belongs to
+      attr_reader :service
+
+      # @return [AIXM::F] frequency for transmission (outgoing)
+      attr_reader :transmission_f
+
+      # @example
+      #   { en: "STRASBOURG CONTROL", fr: "STRASBOURG CONTROLE" }
+      #
+      # @return [Hash] map from languages (ISO 639-1) to callsigns
+      attr_reader :callsigns
+
+      # @note One-way services such as ATIS should set this to +nil+ and simplex
+      #  (aka: non-duplex) communication should set this to {#transmission_f}.
+      # @return [AIXM::F, nil] frequency for reception (incoming)
+      attr_reader :reception_f
+
+      # @return [Symbol, nil] type of frequency (see {TYPES})
+      attr_reader :type
+
+      # @return [AIXM::Component::Timetable, nil] operating hours
+      attr_reader :timetable
+
+      # @return [String, nil] free text remarks
+      attr_reader :remarks
+
+      def initialize(transmission_f:, callsigns:)
+        self.transmission_f, self.callsigns = transmission_f, callsigns
+        self.reception_f = transmission_f
+      end
+
+      # @return [String]
+      def inspect
+        %Q(#<#{self.class} transmission_f=#{transmission_f.inspect} callsigns=#{callsigns.inspect}>)
+      end
+
+      def service=(value)
+        fail(ArgumentError, "invalid service") unless value.is_a? AIXM::Component::Service
+        @service = value
+      end
+      private :service=
+
+      def transmission_f=(value)
+        fail(ArgumentError, "invalid transmission_f") unless value.is_a? AIXM::F
+        @transmission_f = value
+      end
+
+      def callsigns=(value)
+        fail(ArgumentError, "invalid callsigns") unless value.is_a?(Hash)
+        @callsigns = value.transform_keys { |k| k.to_sym.downcase }.transform_values { |v| v.to_s.uptrans }
+      end
+
+      def reception_f=(value)
+        fail(ArgumentError, "invalid reception_f") unless value.nil? || value.is_a?(AIXM::F)
+        @reception_f = value
+      end
+
+      def type=(value)
+        @type = value.nil? ? nil : TYPES.lookup(value.to_s.to_sym, nil) || fail(ArgumentError, "invalid type")
+      end
+
+      def timetable=(value)
+        fail(ArgumentError, "invalid timetable") unless value.nil? || value.is_a?(AIXM::Component::Timetable)
+        @timetable = value
+      end
+
+      def remarks=(value)
+        @remarks = value&.to_s
+      end
+
+      # @return [String] UID markup
+      def to_uid
+        builder = Builder::XmlMarkup.new(indent: 2)
+        builder.FqyUid do |fqy_uid|
+          fqy_uid << service.to_uid.indent(2)
+          fqy_uid.valFreqTrans(transmission_f.freq)
+        end
+      end
+
+      # @return [String] AIXM or OFMX markup
+      def to_xml
+        builder = Builder::XmlMarkup.new(indent: 2)
+        builder.Fqy do |fqy|
+          fqy << to_uid.indent(2)
+          fqy.valFreqRec(reception_f.freq) if reception_f
+          fqy.uomFreq(transmission_f.unit.upcase.to_s)
+          fqy << timetable.to_xml(as: :Ftt).indent(2) if timetable
+          fqy.txtRmk(remarks) if remarks
+          callsigns.each do |language, callsign|
+            fqy.Cdl do |cdl|
+              cdl.txtCallSign(callsign)
+              cdl.codeLang(language.upcase.to_s)
+            end
+          end
+          fqy.target!
+        end
+      end
+    end
+
+  end
+end

data/lib/aixm/component/geometry.rb

@@ -1,25 +1,36 @@
+using AIXM::Refinements
+
 module AIXM
-  module Component
+  class Component
 
-    ##
     # Geometries define a 3D airspace horizontally. It's either exactly one
     # circle or at least three points, arcs and borders (the last of which
     # has to be a point with the same coordinates as the first).
     #
-    # Example 1:
+    # For a geometry to be valid, it must be comprised of either:
+    # * exactly one circle
+    # * at least three points, arcs or borders (the last of which a point with
+    #   identical coordinates as the first)
+    #
+    # ===Cheat Sheet in Pseudo Code:
+    #   geometry = AIXM.geometry
+    #   geometry << AIXM.point or AIXM.arc or AIXM.border or AIXM.circle
+    #
+    # @example Built by passing elements to the initializer
     #   geometry = AIXM.geometry(
     #     AIXM.point(...),
     #     AIXM.point(...)
     #   )
     #
-    # Example 2:
+    # @example Built by adding elements
     #   geometry = AIXM.geometry
     #   geometry << AIXM.point(...)
     #   geometry << AIXM.point(...)
-    class Geometry < Base
+    #
+    # @see https://github.com/openflightmaps/ofmx/wiki/Airspace#avx-border-vertex
+    class Geometry
       include Enumerable
       extend Forwardable
-      using AIXM::Refinements
 
       def_delegators :@result_array, :each, :<<
 
@@ -27,28 +38,28 @@ module AIXM
         @result_array = segments
       end
 
-      ##
-      # Array of +AIXM::Component::Geometry::...+ objects
-      def segments
-        @result_array
+      # @return [String]
+      def inspect
+        %Q(#<#{self.class} segments=#{segments.count.inspect}>)
       end
 
-      ##
-      # Check whether the geometry is complete
-      def complete?
-        circle? || closed_shape?
+      # @return [Array<AIXM::Component::Geometry::Point,
+      #   AIXM::Component::Geometry::Arc,
+      #   AIXM::Component::Geometry::Border,
+      #   AIXM::Component::Geometry::Circle>] points, arcs, borders or circle
+      def segments
+        @result_array
       end
 
-      ##
-      # Digest to identify the payload
-      def to_digest
-        segments.map(&:to_digest).to_digest
+      # @return [Boolean] whether the geometry is closed
+      def closed?
+        circle? || polygon?
       end
 
-      ##
-      # Render AIXM markup
-      def to_aixm(*extensions)
-        @result_array.map { |h| h.to_aixm(*extensions) }.join
+      # @return [String] AIXM or OFMX markup
+      def to_xml
+        fail(GeometryError, "geometry is not closed") unless closed?
+        @result_array.map { |h| h.to_xml }.join
       end
 
       private
@@ -58,7 +69,7 @@ module AIXM
           @result_array.first.is_a?(AIXM::Component::Geometry::Circle)
       end
 
-      def closed_shape?
+      def polygon?
         @result_array.size >= 3 &&
           !@result_array.any? { |h| h.is_a?(AIXM::Component::Geometry::Circle) } &&
           @result_array.last.is_a?(AIXM::Component::Geometry::Point) &&

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

@@ -1,45 +1,60 @@
+using AIXM::Refinements
+
 module AIXM
-  module Component
+  class Component
     class Geometry
 
-      ##
-      # Arcs are +clockwise+ (true/false) circle sectors around +center_xy+ and
-      # starting at +xy+.
+      # Arcs are clockwise or counter clockwise circle segments around a
+      # {#center_xy} and starting at {#xy}.
+      #
+      # ===Cheat Sheet in Pseudo Code:
+      #   arc = AIXM.arc(
+      #     xy: AIXM.xy
+      #     center_xy: AIXM.xy
+      #     clockwise: true or false
+      #   )
+      #
+      # @see https://github.com/openflightmaps/ofmx/wiki/Airspace#arc
       class Arc < Point
-        using AIXM::Refinements
-
+        # @return [AIXM::XY] center point
         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
+          self.center_xy, self.clockwise = center_xy, clockwise
+        end
+
+        # @return [String]
+        def inspect
+          %Q(#<#{self.class} xy="#{xy.to_s}">)
+        end
+
+        def center_xy=(value)
+          fail(ArgumentError, "invalid center xy") unless value.is_a? AIXM::XY
+          @center_xy = value
         end
 
-        ##
-        # Whether the arc is going clockwise (true) or not (false)
+        # @!attribute [w] clockwise
+        # @return [Boolean] wheter 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
+        def clockwise=(value)
+          fail(ArgumentError, "clockwise must be true or false") unless [true, false].include? value
+          @clockwise = value
         end
 
-        ##
-        # Render AIXM markup
-        def to_aixm(*extensions)
+        # @return [String] AIXM or OFMX markup
+        def to_xml
           builder = Builder::XmlMarkup.new(indent: 2)
           builder.Avx do |avx|
             avx.codeType(clockwise? ? 'CWA' : 'CCA')
-            avx.geoLat(xy.lat(format_for(*extensions)))
-            avx.geoLong(xy.long(format_for(*extensions)))
+            avx.geoLat(xy.lat(AIXM.schema))
+            avx.geoLong(xy.long(AIXM.schema))
             avx.codeDatum('WGE')
-            avx.geoLatArc(center_xy.lat(format_for(*extensions)))
-            avx.geoLongArc(center_xy.long(format_for(*extensions)))
+            avx.geoLatArc(center_xy.lat(AIXM.schema))
+            avx.geoLongArc(center_xy.long(AIXM.schema))
           end
         end
       end

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

@@ -1,40 +1,49 @@
+using AIXM::Refinements
+
 module AIXM
-  module Component
+  class Component
     class Geometry
 
-      ##
       # Borders are following natural or artifical border lines referenced by
-      # +name+ and starting at +xy+.
+      # {#name} and starting at {#xy}.
+      #
+      # ===Cheat Sheet in Pseudo Code:
+      #   border = AIXM.border(
+      #     xy: AIXM.xy
+      #     name: String
+      #   )
+      #
+      # @see https://github.com/openflightmaps/ofmx/wiki/Airspace#frontier
       class Border < Point
-        using AIXM::Refinements
-
+        # @return [String] name of the border
         attr_reader :name
 
         def initialize(xy:, name:)
           super(xy: xy)
-          @name = name
+          self.name = name
+        end
+
+        # @return [String]
+        def inspect
+          %Q(#<#{self.class} xy="#{xy.to_s}">)
         end
 
-        ##
-        # Digest to identify the payload
-        def to_digest
-          [xy.lat, xy.long, name].to_digest
+        def name=(value)
+          fail(ArgumentError, "invalid name") unless value.is_a? String
+          @name = value
         end
 
-        ##
-        # Render AIXM markup
-        def to_aixm(*extensions)
+        # @return [String] AIXM or OFMX markup
+        def to_xml
           builder = Builder::XmlMarkup.new(indent: 2)
           builder.Avx do |avx|
+            avx.GbrUid do |gbr_uid|
+              gbr_uid.txtName(name.to_s)
+            end
             avx.codeType('FNT')
-            avx.geoLat(xy.lat(format_for(*extensions)))
-            avx.geoLong(xy.long(format_for(*extensions)))
+            avx.geoLat(xy.lat(AIXM.schema))
+            avx.geoLong(xy.long(AIXM.schema))
             avx.codeDatum('WGE')
-            if extensions >> :ofm
-              avx.GbrUid do |gbruid|
-                gbruid.txtName(name.to_s)
-              end
-            end
           end
         end
       end

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

@@ -1,47 +1,64 @@
+using AIXM::Refinements
+
 module AIXM
-  module Component
+  class Component
     class Geometry
 
-      ##
-      # Circles are defined by a +center_xy+ and a +radius+ in kilometers.
-      class Circle < Base
-        using AIXM::Refinements
+      # Circles are defined by a {#center_xy} and a {#radius} in kilometers.
+      #
+      # ===Cheat Sheet in Pseudo Code:
+      #   circle = AIXM.circle(
+      #     center_xy: AIXM.xy
+      #     radius: Numeric   # kilometers
+      #   )
+      #
+      # @see https://github.com/openflightmaps/ofmx/wiki/Airspace#circle
+      class Circle
+        # @return [AIXM::XY] center point
+        attr_reader :center_xy
 
-        attr_reader :center_xy, :radius
+        # @return [Integer] circle radius
+        attr_reader :radius
 
         def initialize(center_xy:, radius:)
-          fail(ArgumentError, "invalid center xy") unless center_xy.is_a? AIXM::XY
-          @center_xy, @radius = center_xy, radius
+          self.center_xy, self.radius = center_xy, radius
+        end
+
+        # @return [String]
+        def inspect
+          %Q(#<#{self.class} xy="#{xy.to_s}">)
+        end
+
+        def center_xy=(value)
+          fail(ArgumentError, "invalid center xy") unless value.is_a? AIXM::XY
+          @center_xy = value
         end
 
-        ##
-        # Digest to identify the payload
-        def to_digest
-          [center_xy.lat, center_xy.long, radius].to_digest
+        def radius=(value)
+          fail(ArgumentError, "invalid radius") unless value.is_a?(Numeric) && value > 0
+          @radius = value.to_f
         end
 
-        ##
-        # Render AIXM markup
-        def to_aixm(*extensions)
+        # @return [String] AIXM or OFMX markup
+        def to_xml
           builder = Builder::XmlMarkup.new(indent: 2)
           builder.Avx do |avx|
             avx.codeType('CWA')
-            avx.geoLat(north_xy.lat(format_for(*extensions)))
-            avx.geoLong(north_xy.long(format_for(*extensions)))
+            avx.geoLat(north_xy.lat(AIXM.schema))
+            avx.geoLong(north_xy.long(AIXM.schema))
             avx.codeDatum('WGE')
-            avx.geoLatArc(center_xy.lat(format_for(*extensions)))
-            avx.geoLongArc(center_xy.long(format_for(*extensions)))
+            avx.geoLatArc(center_xy.lat(AIXM.schema))
+            avx.geoLongArc(center_xy.long(AIXM.schema))
           end
         end
 
         private
 
-        ##
         # Coordinates of the point which is both strictly north of the center
-        # and on the circumference of the circle
+        # and on the circumference of the circle.
         def north_xy
           AIXM.xy(
-            lat: center_xy.lat + radius.to_f / 6371 * 180 / Math::PI,
+            lat: center_xy.lat + radius.to_f / (AIXM::XY::EARTH_RADIUS / 1000) * 180 / Math::PI,
             long: center_xy.long
           )
         end