aixm 0.3.11 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d86771a98ab156be9da1487e7e2e11615bcd63590824108717a51f07c044e241
-  data.tar.gz: b6fc6d7c2803169145153d434f1675f161be6ae731b54eb1d53b6d2fbcf4807b
+  metadata.gz: a1dc4f9cb88ab4e481f835ca4d309142c6a17910b396f4293a6d9e7d3f946ec6
+  data.tar.gz: 244adc808983bc3e810fb5847051a89dbd0893df3d2c709943d2c7231acfb434
 SHA512:
-  metadata.gz: e537adc538ba520a2f0e891da01ccb13e768a5e183c8a042fbe3bf55f63bfc9f2a66125cf6a19b1882e7d646d8c9b0f848fc551f095a24323f24216d9a8036a1
-  data.tar.gz: 5a3884e00a329f243835648bce2bc13f1cd0ae701113dc89a86f23e83ebe9a82abf4af7a5c6aa87a8f22b1d7c49bc94fd222b2752a5a9bef42276936def12e60
+  metadata.gz: ac00f735cca36dc6b1b0ec00c671dcbcbdb1e14c0d051fc8d865737e9ac1363d5648f5df69098b0daf721688c541a79188cac3603a07e01f8719fde3c8070d91
+  data.tar.gz: 59d6ffb78fcb04104838bc4fb0ba50e7f3c5d526e921410e4300d08dafa08a2aa9cd1d637d374d7e5428d05c56e5f66186377a2f32fb6bff6c14ce5539044884

data/CHANGELOG.md

@@ -1,3 +1,55 @@
+## Main
+
+Nothing so far
+
+## 1.2.0
+
+#### Additions
+* `Timesheet` to add custom schedules to `Timetable`
+* `AIXM::Schedule::(Date|Day|Time)` for custom timetables
+* Interface to allow most class instances as Hash keys
+
+#### Fixes
+* Fix typo in `GUESSED_UNIT_TYPES_MAP`
+
+## 1.1.0
+
+#### Breaking Changes
+* `AIXM::Association:Array#duplicates` now returns an array of arrays which
+  group all duplicates together.
+* `VOR#associate_dme` and `VOR#associate_tacan` no longer take the channel
+  as argument but calculate it from the (ghost) frequency of the VOR.
+* Replaced `#length`/`#width` with `#dimensions` on `Runway`, `Helipad` and `FATO`
+* Renamed `AIXM::D#dist` to `AIXM::D#dim`
+* Renamed `TLOF#helicopter_class` to `TLOF#performance_class`
+* Renamed `#geographic_orientation` and `#magnetic_orientation` to more familiar
+  `#geographic_bearing` and `#magnetic_bearing` on `Runway` and `FATO`
+* Re-implementation of `AIXM::A` without precision
+* Demoted `Address` to component
+* Fixed typo in `Service` type `:vdf_direction_finding_service`
+
+#### Additions
+* Associations from `Service` to `Airport` and `Airspace`
+* `AIXM::R` (rectangle)
+* `Runway#marking`
+* `ApproachLighting` on `Runway::Direction` and `FATO::Direction`
+* `VASIS` on `Runway::Direction` and `FATO::Direction`
+* `#meta` on every feature and component
+* `Document#regions` which is added to the root element for OFMX
+
+#### Changes
+* Nested memoization of the same method is now allowed and won't reset the
+  memoization cache anymore.
+* Remove unit "mhz" from `Address` of type `:radio_frequency`.
+
+## 1.0.0
+
+#### Breaking Changes
+* Move `Ase->txtLocalType` up into `AseUid` for OFMX
+
+#### Additions
+* Add rhumb line geometry
+
 ## 0.3.11
 
 #### Breaking Changes
@@ -11,21 +63,21 @@
 #### Additions
 * Add `f#voice?` and `AIXM.config.voice_channel_separation` to check whether a
   frequency belongs to the voice communication airband and use it to validate
-  `AIXM::Frequency`
+  `Frequency`
 
 ## 0.3.10
 
 #### Additions
 * Proper `has_many` and `has_one` associations
-* `AIXM::Association:Array#find_by|find|duplicate` on `has_many` associations
+* `AIXM::Association:Array#find_by|find|duplicates` on `has_many` associations
 * `AIXM.config.mid` now defines whether `mid` attributes are inserted or not
   provided the selected schema is OFMX
 * `AIXM::Memoize` module
 * `AIXM::PayloadHash` class
 * `mkmid` executable to insert `mid` attributes into valid OFMX file
 * `ckmid` executable to check `mid` attributes in an OFMX file
-* `AIXM::Component::Geometry#point?|circle?|polygon?`
-* `AIXM::Component::Layer#services`
+* Geometries respond to `#point?`, `#circle?` and `#polygon?`
+* `Layer#services`
 
 #### Breaking Changes
 * Require Ruby 2.7
@@ -55,20 +107,20 @@
 ## 0.3.7
 
 #### Additions
-* `AIXM::Document#select_features`
-* `AIXM::Document#group_obstacles!`
+* `Document#select_features`
+* `Document#group_obstacles!`
 
 ## 0.3.6
 
 #### Additions
-* `AIXM::Component::FATO`
-* `AIXM::Component::Helipad#helicopter_class` and `AIXM::Component::Helipad#marking`
+* `FATO`
+* `Helipad#helicopter_class` and `Helipad#marking`
 * `AIXM::XY#seconds?` to detect possibly rounded or estimated coordinates
-* `AIXM::Features::Airport#operator`
+* `Airport#operator`
 * `AIXM::W` (weight)
 * `AIXM::P` (pressure)
-* `AIXM::Component::Lighting` for use with runways, helipads and FATOs
-* Surface details `siwl_weight`, `siwl_tire_pressure` and `auw_weight`
+* `Lighting` for use with runways, helipads and FATOs
+* Surface details `#siwl_weight`, `#siwl_tire_pressure` and `#auw_weight`
 
 #### Changes
 * Generate `Airport#id` from region and `Airport#name`
@@ -234,7 +286,7 @@
 
 #### Changes
 * `Document#created_at` and `#effective_at` accept Time, Date, String or *nil*
-* Separate `AIXM::Document#valid?` from `#complete?`
+* Separate `Document#valid?` from `#complete?`
 * Write coordinates in DD if extension `:OFM` is set
 * `Array#to_digest` returns Integer which fits in signed 32bit
 

data/README.md

@@ -11,7 +11,7 @@ For now, only the parts needed to automize the AIP import of [open flightmaps](h
 
 * [Homepage](https://github.com/svoop/aixm)
 * [API](https://www.rubydoc.info/gems/aixm)
-* Author: [Sven Schwyn - Bitcetera](http://www.bitcetera.com)
+* Author: [Sven Schwyn - Bitcetera](https://bitcetera.com)
 
 ## Install
 
@@ -47,7 +47,7 @@ gem install aixm --trust-policy MediumSecurity
 
 ## Usage
 
-Here's how to build a document object, populate it with a simple feature and then render it as AIXM:
+Here's how to build a document object, populate it with a simple feature and then render it as AIXM or OFMX:
 
 ```ruby
 document = AIXM.document(
@@ -139,17 +139,16 @@ AIXM.config.ignored_errors = /invalid date/i
 
 ### Fundamentals
 * [Document](https://www.rubydoc.info/gems/aixm/AIXM/Document.html)
+* [A (angle)](https://www.rubydoc.info/gems/aixm/AIXM/A.html)
+* [D (dimension, distance or length)](https://www.rubydoc.info/gems/aixm/AIXM/D.html)
+* [F (frequency)](https://www.rubydoc.info/gems/aixm/AIXM/F.html)
+* [P (pressure)](https://www.rubydoc.info/gems/aixm/AIXM/P.html)
+* [R (rectangle)](https://www.rubydoc.info/gems/aixm/AIXM/R.html)
 * [XY (longitude and latitude)](https://www.rubydoc.info/gems/aixm/AIXM/XY.html)
 * [Z (height, elevation or altitude)](https://www.rubydoc.info/gems/aixm/AIXM/Z.html)
-* [D (distance or length)](https://www.rubydoc.info/gems/aixm/AIXM/D.html)
-* [F (frequency)](https://www.rubydoc.info/gems/aixm/AIXM/F.html)
-* [A (angle)](https://www.rubydoc.info/gems/aixm/AIXM/A.html)
 
 ### Features
 * [Address](https://www.rubydoc.info/gems/aixm/AIXM/Feature/Address.html)
-* [Organisation](https://www.rubydoc.info/gems/aixm/AIXM/Feature/Organisation.html)
-* [Unit](https://www.rubydoc.info/gems/aixm/AIXM/Feature/Unit.html)
-* [Service](https://www.rubydoc.info/gems/aixm/AIXM/Component/Service.html)
 * [Airport](https://www.rubydoc.info/gems/aixm/AIXM/Feature/Airport.html)
 * [Airspace](https://www.rubydoc.info/gems/aixm/AIXM/Feature/Airspace.html)
 * [Navigational aid](https://www.rubydoc.info/gems/aixm/AIXM/NavigationalAid.html)
@@ -159,22 +158,33 @@ AIXM.config.ignored_errors = /invalid date/i
   * [NDB](https://www.rubydoc.info/gems/aixm/AIXM/Feature/NDB.html)
   * [TACAN](https://www.rubydoc.info/gems/aixm/AIXM/Feature/TACAN.html)
   * [VOR](https://www.rubydoc.info/gems/aixm/AIXM/Feature/VOR.html)
-* [Obstacle and obstacle group](https://www.rubydoc.info/gems/aixm/AIXM/Feature/Obstacle.html)
+* [Obstacle](https://www.rubydoc.info/gems/aixm/AIXM/Feature/Obstacle.html)
+* [Obstacle group](https://www.rubydoc.info/gems/aixm/AIXM/Feature/ObstacleGroup.html)
+* [Organisation](https://www.rubydoc.info/gems/aixm/AIXM/Feature/Organisation.html)
+* [Service](https://www.rubydoc.info/gems/aixm/AIXM/Component/Service.html)
+* [Unit](https://www.rubydoc.info/gems/aixm/AIXM/Feature/Unit.html)
 
 ### Components
+
+* [ApproachLighting](https://www.rubydoc.info/gems/aixm/AIXM/Component/ApproachLighting.html)
+* [FATO](https://www.rubydoc.info/gems/aixm/AIXM/Component/FATO.html)
 * [Frequency](https://www.rubydoc.info/gems/aixm/AIXM/Component/Frequency.html)
 * [Geometry](https://www.rubydoc.info/gems/aixm/AIXM/Component/Geometry.html)
-  * [Point](https://www.rubydoc.info/gems/aixm/AIXM/Component/Point.html)
   * [Arc](https://www.rubydoc.info/gems/aixm/AIXM/Component/Arc.html)
   * [Border](https://www.rubydoc.info/gems/aixm/AIXM/Component/Border.html)
   * [Circle](https://www.rubydoc.info/gems/aixm/AIXM/Component/Circle.html)
-* [Runway](https://www.rubydoc.info/gems/aixm/AIXM/Component/Runway.html)
+  * [Point](https://www.rubydoc.info/gems/aixm/AIXM/Component/Point.html)
+  * [RhumbLine](https://www.rubydoc.info/gems/aixm/AIXM/Component/RhumbLine.html)
 * [Helipad](https://www.rubydoc.info/gems/aixm/AIXM/Component/Helipad.html)
-* [FATO](https://www.rubydoc.info/gems/aixm/AIXM/Component/FATO.html)
-* [Surface](https://www.rubydoc.info/gems/aixm/AIXM/Component/Surface.html)
 * [Layer](https://www.rubydoc.info/gems/aixm/AIXM/Component/Layer.html)
-* [Vertical limit](https://www.rubydoc.info/gems/aixm/AIXM/Component/VerticalLimit.html)
+* [Lighting](https://www.rubydoc.info/gems/aixm/AIXM/Component/Lighting.html)
+* [Runway](https://www.rubydoc.info/gems/aixm/AIXM/Component/Runway.html)
+* [Service](https://www.rubydoc.info/gems/aixm/AIXM/Component/Service.html)
+* [Surface](https://www.rubydoc.info/gems/aixm/AIXM/Component/Surface.html)
 * [Timetable](https://www.rubydoc.info/gems/aixm/AIXM/Component/Timetable.html)
+* [Timesheet](https://www.rubydoc.info/gems/aixm/AIXM/Component/Timesheet.html)
+* [VASIS](https://www.rubydoc.info/gems/aixm/AIXM/Component/VASIS.html)
+* [Vertical limit](https://www.rubydoc.info/gems/aixm/AIXM/Component/VerticalLimit.html)
 
 ## Associations
 
@@ -204,6 +214,14 @@ document.features.find(airport)   # => [#<AIXM::Feature::Airport>]
 
 This may seem redundant at first, but keep in mind that two instances of +AIXM::CLASSES+ which implement `#to_uid` are considered equal if they are instances of the same class and both their UIDs as calculated by `#to_uid` are equal. Attributes which are not part of the `#to_uid` calculation are irrelevant!
 
+### meta
+
+You can write arbitrary meta information to any feature or component. It won't be used when building the AIXM or OFMX document, in fact, it is not used by this gem at all. But you can store e.g. foreign keys and then later use them to find a feature or component like so:
+
+```ruby
+document.features.find_by(:airport, meta: 1234)   # 1234 is the foreign key
+```
+
 ### duplicates
 
 Equally on `has_many` associations, use `duplicates` to find identical or equal associations:
@@ -257,6 +275,7 @@ ckmid --help
 ### AIXM
 * [AIXM](http://aixm.aero)
 * [AICM 4.5 documentation](https://openflightmaps.gitlab.io/ofmx/aixm/4.5/manual/aicm/)
+* [AICM 4.5 manual](https://www.aixm.aero/sites/aixm.aero/files/imce/library/aicm_manual_4-5.pdf)
 * [AIXM 4.5 specification](http://aixm.aero/document/aixm-45-specification)
 
 ### OFMX
@@ -282,13 +301,7 @@ bundle exec rake    # run tests once
 bundle exec guard   # run tests whenever files are modified
 ```
 
-Please submit issues on:
-
-https://github.com/svoop/aixm/issues
-
-To contribute code, fork the project on Github, add your code and submit a pull request:
-
-https://help.github.com/articles/fork-a-repo
+You're welcome to [submit issues](https://github.com/svoop/aixm/issues) and contribute code by [forking the project and submitting pull requests](https://docs.github.com/en/get-started/quickstart/fork-a-repo).
 
 ## License
 

data/lib/aixm/a.rb

@@ -2,53 +2,61 @@ using AIXM::Refinements
 
 module AIXM
 
-  # Angle from 0 to 359 degrees with an optional suffix used for azimuths,
-  # bearings, headings, courses etc.
+  # Angle in the range of -360 < angle < 360 degrees (used for azimuths or
+  # courses) and with an optional one-letter suffix (used for runways).
   #
-  # @example Initialized with Numeric
-  #   a = AIXM.a(12)   # 12 degrees, 1 degree precision, no suffix
-  #   a.precision      # => 3 (three digits = steps of 1 degree)
-  #   a.to_s           # => "012"
-  #   a.suffix         # => nil
-  #   a.deg            # => 12
-  #   a.deg += 7       # => 19
-  #   a.deg += 341     # => 0     - deg is always within (0..359)
-  #   a.to_s           # => "000" - to_s is always within ("000".."359")
+  # @example Initialization
+  #   AIXM.a(-36.9)   # => #<AIXM::A -36.9° "32">
+  #   AIXM.a(12)      # => #<AIXM::A 12° "01">
+  #   AIXM.a("12L")   # => #<AIXM::A 120° "12L">
+  #   AIXM.a(360)     # => #<AIXM::A 0° "36">
+  #   AIXM.a(-400)    # => #<AIXM::A -40° "32">
   #
-  # @example Initialized with String
-  #   a = AIXM.a('06L')   # 60 degrees, 10 degree precision, suffix :L
-  #   a.precision         # => 2 (two digits = steps of 10 degrees)
-  #   a.to_s              # => "06L"
-  #   a.suffix            # => :L
-  #   a.deg               # => 60
-  #   a.deg += 7          # => 70
-  #   a.deg += 190        # => 0     - deg is always within (0..359)
-  #   a.to_s              # => "36L" - to_s converts to ("01".."36")
+  # @example Calculations
+  #   a = AIXM.a("02L")
+  #   a += 5               # => #<AIXM::A 25° "03L">
+  #   a -= AIXM.a(342.8)   # => #<AIXM::A -317.8° "04L">
+  #   a.to_s               # => "-317.8°"
+  #   a.to_s(:runway)      # => "04L"
+  #   a.to_s(:bearing)     # => "042.2000"
+  #   a.to_f               # => 42.2
+  #   a.to_i               # => 42
+  #   a.invert             # => #<AIXM::A -137.8° "22R">
+  #   a.to_s(:runway)      # => "22R"
   class A
+    include AIXM::Concerns::HashEquality
+
     SUFFIX_INVERSIONS = {
       R: :L,
       L: :R
     }.freeze
 
-    # @return [Integer] angle
-    attr_reader :deg
+    RUNWAY_RE = /\A(0[1-9]|[12]\d|3[0-6])([A-Z])?\z/
 
-    # @return [Integer] precision: +2+ (10 degree steps) or +3+ (1 degree steps)
-    attr_reader :precision
+    # Angle in the range of -360 < angle < 360.
+    #
+    # @overload deg
+    #   @return [Integer]
+    # @overload deg=(value)
+    #   @param value [Integer]
+    attr_reader :deg
 
-    # @return [Symbol, nil] suffix
+    # One-letter suffix.
+    #
+    # @overload suffix
+    #   @return [Symbol, nil]
+    # @overload suffix=(value)
+    #   @param value [Symbol, nil]
     attr_reader :suffix
 
-    def initialize(deg_and_suffix)
-      case deg_and_suffix
-      when Numeric
-        self.deg, @precision = deg_and_suffix, 3
+    # See the {overview}[AIXM::A] for examples.
+    def initialize(value)
+      case value
       when String
-        fail(ArgumentError, "invalid angle") unless deg_and_suffix.to_s =~ /\A(\d+)([A-Z]+)?\z/
-        self.deg, @precision, self.suffix = $1.to_i * 10, 2, $2
-      when Symbol   # used only by private build method
-        fail(ArgumentError, "invalid precision") unless %i(2 3).include? deg_and_suffix
-        @deg, @precision = 0, deg_and_suffix.to_s.to_i
+        fail(ArgumentError, "invalid angle") unless value =~ RUNWAY_RE
+        self.deg, self.suffix = $1.to_i * 10, $2
+      when Numeric
+        self.deg = value
       else
         fail(ArgumentError, "invalid angle")
       end
@@ -56,42 +64,69 @@ module AIXM
 
     # @return [String]
     def inspect
-      %Q(#<#{self.class}[precision=#{precision}] #{to_s}>)
+      %Q(#<#{self.class} #{to_s} #{to_s(:runway).inspect}>)
     end
 
-    # @return [String] human readable representation according to precision
-    def to_s
-      if precision == 2
-        [('%02d' % ((deg / 10 + 35) % 36 + 1)), suffix].map(&:to_s).join
-      else
-        ('%03d' % deg)
+    # Degrees in the range of 0..359
+    #
+    # @return [Integer]
+    def to_i
+      (deg.round + 360) % 360
+    end
+
+    # Degrees in the range of 0.0...360.0
+    #
+    # @return [Float]
+    def to_f
+      ((deg + 360) % 360).to_f
+    end
+
+    # Degrees as formatted string
+    #
+    # Types are:
+    # * :human - degrees within -359.9~..359.9~ as D.D° (default)
+    # * :bearing - degrees within 0.0..359.9~ as DDD.DDDD
+    # * :runway - degrees within "01".."36" plus optional suffix
+    #
+    # @param type [Symbol, nil] either :runway, :bearing or nil
+    # @param unit [String] unit to postfix
+    # @return [String]
+    def to_s(type=:human)
+      return '' unless deg
+      case type
+        when :runway then [('%02d' % (((deg / 10).round + 35) % 36 + 1)), suffix].join
+        when :bearing then '%08.4f' % to_f.round(4)
+        when :human then [deg.to_s('F').sub(/\.0$/, ''), '°'].join
+        else fail ArgumentError
       end
     end
 
     def deg=(value)
-      fail(ArgumentError, "invalid deg `#{value}'") unless value.is_a?(Numeric) && value.round.between?(0, 360)
-      @deg = (precision == 2 ? (value.to_f / 10).round * 10 : value.round) % 360
+      fail(ArgumentError, "invalid deg `#{value}'") unless value.is_a? Numeric
+      normalized_value = value.abs % 360
+      sign = '-' if value.negative? && normalized_value.nonzero?
+      @deg = BigDecimal("#{sign}#{normalized_value}")
     end
 
     def suffix=(value)
-      fail(RuntimeError, "suffix only allowed when precision is 2") unless value.nil? || precision == 2
-      fail(ArgumentError, "invalid suffix") unless value.nil? || value.to_s =~ /\A[A-Z]+\z/
+      fail(ArgumentError, "invalid suffix") unless value.nil? || value.to_s =~ /\A[A-Z]\z/
       @suffix = value&.to_s&.to_sym
     end
 
-    # Invert an angle by 180 degrees
+    # Invert an angle by 180 degrees.
     #
     # @example
-    #   AIXM.a(120).invert     # => AIXM.a(300)
-    #   AIXM.a("34L").invert   # => AIXM.a("16R")
-    #   AIXM.a("33X").invert   # => AIXM.a("33X")
+    #   AIXM.a(120).invert     # (300°)
+    #   AIXM.a("34L").invert   # (160° suffix "R")
     #
-    # @return [AIXM::A] inverted angle
+    # @return [AIXM::A]
     def invert
-      build(precision: precision, deg: (deg + 180) % 360, suffix: SUFFIX_INVERSIONS.fetch(suffix, suffix))
+      self.class.new(deg.negative? ? deg - 180 : deg + 180).tap do |angle|
+        angle.suffix = SUFFIX_INVERSIONS.fetch(suffix, suffix)
+      end
     end
 
-    # Check whether +other+ angle is the inverse
+    # Whether other angle is the inverse.
     #
     # @example
     #   AIXM.a(120).inverse_of? AIXM.a(300)       # => true
@@ -99,52 +134,49 @@ module AIXM
     #   AIXM.a("33X").inverse_of? AIXM.a("33X")   # => true
     #   AIXM.a("16R").inverse_of? AIXM.a("16L")   # => false
     #
-    # @return [Boolean] whether the inverted angle or not
+    # @return [Boolean]
     def inverse_of?(other)
       invert == other
     end
 
-    # Add degrees
+    # Negate degrees.
     #
     # @return [AIXM::A]
-    def +(numeric_or_angle)
-      fail ArgumentError unless numeric_or_angle.respond_to? :round
-      build(precision: precision, deg: (deg + numeric_or_angle.round) % 360, suffix: suffix)
+    def -@
+      deg.zero? ? self : self.class.new(-deg).tap { _1.suffix = suffix }
     end
 
-    # Subtract degrees
+    # Add degrees.
     #
+    # @param value [Numeric, AIXM::A]
     # @return [AIXM::A]
-    def -(numeric_or_angle)
-      fail ArgumentError unless numeric_or_angle.respond_to? :round
-      build(precision: precision, deg: (deg - numeric_or_angle.round + 360) % 360, suffix: suffix)
+    def +(value)
+      case value
+      when Numeric
+        value.zero? ? self : self.class.new(deg + value).tap { _1.suffix = suffix }
+      when AIXM::A
+        value.deg.zero? ? self : self.class.new(deg + value.deg).tap { _1.suffix = suffix }
+      else
+        fail ArgumentError
+      end
     end
 
-    # @private
-    def round
-      deg
+    # Subtract degrees.
+    #
+    # @param value [Numeric, AIXM::A]
+    # @return [AIXM::A]
+    def -(value)
+      self + -value
     end
 
     # @see Object#==
-    # @return [Boolean]
     def ==(other)
-      self.class === other  && deg == other.deg && precision == other.precision && suffix == other.suffix
+      self.class === other  && deg == other.deg && suffix == other.suffix
     end
-    alias_method :eql?, :==
 
     # @see Object#hash
-    # @return [Integer]
     def hash
-      to_s.hash
-    end
-
-    private
-
-    def build(precision:, deg:, suffix: nil)
-      self.class.new(precision.to_s.to_sym).tap do |a|
-        a.deg = deg
-        a.suffix = suffix
-      end
+      [self.class, deg, suffix].join.hash
     end
   end
 

data/lib/aixm/association.rb

@@ -23,18 +23,18 @@ module AIXM
   #   end
   #   blog, post = Blog.new, Post.new
   #   # --either--
-  #   blog.add_post(post)
+  #   blog.add_post(post)        # => Blog
   #   blog.posts.count           # => 1
   #   blog.posts.first == post   # => true
   #   post.blog == blog          # => true
-  #   blog.remove_post(post)
+  #   blog.remove_post(post)     # => Blog
   #   blog.posts.count           # => 0
   #   # --or--
-  #   post.blog = blog
+  #   post.blog = blog           # => Blog
   #   blog.posts.count           # => 1
   #   blog.posts.first == post   # => true
   #   post.blog == blog          # => true
-  #   post.blog = nil
+  #   post.blog = nil            # => nil
   #   blog.posts.count           # => 0
   #   # --or--
   #   post_2 = Post.new
@@ -53,19 +53,21 @@ module AIXM
   #   end
   #   blog, post = Blog.new, Post.new
   #   # --either--
-  #   blog.post = post
-  #   blog.post == post   # => true
-  #   post.blog == blog   # => true
-  #   blog.post = nil
-  #   blog.post           # => nil
-  #   post.blog           # => nil
+  #   blog.post = post      # => Post (standard assignment)
+  #   blog.add_post(post)   # => Blog (alternative for chaining)
+  #   blog.post == post     # => true
+  #   post.blog == blog     # => true
+  #   blog.post = nil       # => nil
+  #   blog.post             # => nil
+  #   post.blog             # => nil
   #   # --or--
-  #   post.blog = blog
-  #   post.blog == blog   # => true
-  #   blog.post == post   # => true
-  #   post.blog = nil
-  #   post.blog           # => nil
-  #   blog.post           # => nil
+  #   post.blog = blog      # => Blog (standard assignment)
+  #   post.add_blog(blog)   # => Post (alternative for chaining)
+  #   post.blog == blog     # => true
+  #   blog.post == post     # => true
+  #   post.blog = nil       # => nil
+  #   post.blog             # => nil
+  #   blog.post             # => nil
   #
   # @example Association with readonly +belongs_to+ (idem for +has_one+)
   #   class Blog
@@ -177,7 +179,7 @@ module AIXM
         (@has_many_attributes ||= []) << attribute
         # features
         define_method(attribute) do
-          instance_eval("@#{attribute} ||= AIXM::Association::Array.new")
+          instance_variable_get(:"@#{attribute}") || AIXM::Association::Array.new
         end
         # add_feature
         define_method(:"add_#{association}") do |object=nil, **options, &add_block|
@@ -188,6 +190,7 @@ module AIXM
           end
           instance_exec(object, **options, &association_block) if association_block
           fail(ArgumentError, "#{object.__class__} not allowed") unless class_names.any? { |c| object.is_a?(c.to_class) }
+          instance_eval("@#{attribute} ||= AIXM::Association::Array.new")
           send(attribute).send(:push, object)
           object.instance_variable_set(:"@#{inversion}", self)
           self
@@ -218,14 +221,19 @@ module AIXM
         (@has_one_attributes ||= []) << attribute
         # feature
         attr_reader attribute
-        # feature= / add_feature
+        # feature=
         define_method(:"#{association}=") do |object|
           fail(ArgumentError, "#{object.__class__} not allowed") unless class_names.any? { |c| object.is_a?(c.to_class) }
           instance_variable_get(:"@#{attribute}")&.instance_variable_set(:"@#{inversion}", nil)
           instance_variable_set(:"@#{attribute}", object)
           object&.instance_variable_set(:"@#{inversion}", self)
+          object
+        end
+        # add_feature
+        define_method(:"add_#{association}") do |object|
+          send("#{association}=", object)
+          self
         end
-        alias_method(:"add_#{association}", :"#{association}=")
         # remove_feature
         define_method(:"remove_#{association}") do |_|
           send(:"#{association}=", nil)
@@ -239,11 +247,17 @@ module AIXM
         (@belongs_to_attributes ||= []) << attribute
         # feature
         attr_reader attribute
-        # feature=
         unless readonly
+          # feature=
           define_method(:"#{attribute}=") do |object|
             instance_variable_get(:"@#{attribute}")&.send(:"remove_#{inversion}", self)
             object&.send(:"add_#{inversion}", self)
+            object
+          end
+          # add_feature
+          define_method(:"add_#{attribute}") do |object|
+            send("#{attribute}=", object)
+            self
           end
         end
       end
@@ -349,17 +363,14 @@ module AIXM
       #     belongs_to :blog
       #   end
       #   blog, post = Blog.new, Post.new
-      #   blog.add_posts([post, post])
-      #   blog.posts.duplicates   # => [post]
+      #   duplicate_post = post.dup
+      #   blog.add_posts([post, duplicate_post])
+      #   blog.posts.duplicates   # => [[post, duplicate_post]]
       #
-      # @return [AIXM::Association::Array]
+      # @return [Array<Array<AIXM::Feature>>]
       def duplicates
         AIXM::Memoize.method :to_uid do
-          self.class.new(
-            select.with_index do |element, index|
-              index != self.index(element)
-            end
-          )
+          group_by(&:to_uid).select { |_, a| a.count > 1 }.map(&:last)
         end
       end
     end