ecoportal-api-graphql 2.0.0 → 2.2.0

data/lib/ecoportal/api/common/graphql/model/diffable/diff_service.rb

@@ -1,188 +1,188 @@
-module Ecoportal::API::Common::GraphQL::Model::Diffable
-  class DiffService < ClassicDiffService
-    include Ecoportal::API::Common::GraphQL::Model::Diffable::HashDiffNesting
-    include Ecoportal::API::Common::GraphQL::HashHelpers
-
-    def initialize(subject, flat: false, ignore: [])
-      super(subject, ignore: ignore)
-
-      @flat = flat
-    end
-
-    def flat?
-      @flat
-    end
-
-    # @param flat [Boolean] whethere it should skip nested models.
-    # @param cascaded [Boolean] whether it should cascade the calls through
-    #   the nested models.
-    #   - When `flat` is `true` will only cascade the 1st level of nested models.
-    #   - When `flat` is `false` will do a full cascade.
-    def diff(flat: flat?, ignore: [])
-      classic_diff(
-        flat:   true,
-        ignore: ignore
-      ).then do |value|
-        next value if flat
-
-        diff_reduce(
-          value,
-          ignore: ignore
-        )
-      end
-    end
-
-    protected
-
-    # Override: GraphQL mutations expect flat changed-prop values, not patch-op wrappers.
-    # Returns { id: ..., changed_field: new_value, ... } or nil when nothing changed.
-    def classic_diff(flat: flat?, ignore: [])
-      curr = keys_to_sym_deep(curr_doc(flat: flat) || {})
-      prev = keys_to_sym_deep(prev_doc(flat: flat) || {})
-
-      data = change_data(curr, prev, ignore: to_a(ignored, ignore))
-      return nil if data == NO_CHANGES
-
-      id = get_id(curr, exception: false)
-      id ? { id: id }.merge(data) : data
-    end
-
-    # @note it calls `as_update` for nested / cascaded attributes, which in turn
-    #   will use this `DiffService`. Therefore, we aim for a first flat classic diff,
-    #   onto `self`, and cascaded callbacks for the nested attributes.
-    #     - This will translate into `key_path` being lost on each jump between
-    #       `#as_update` and `DiffService#diff`.
-    #     - The `result` object regards, therefore, to the **current level** alone.
-    #       With the aim of building it up (accumulating through the call chain).
-    def diff_reduce(init, ignore: [])
-      subject.cascaded_reduce(init, recurs: false) do |result, obj, _key, key_path, _trace|
-        next result if key_path.empty?
-        next result if obj == subject
-
-        sym_path = key_path.map(&:to_sym)
-
-        # Remove any flat-diff placeholder for this key before deciding its fate.
-        dig_delete!(result, sym_path) if result && dig_path?(result, sym_path)
-
-        # Discard root-class objects — they are independent entities, not mutation payload.
-        next result if root?(obj)
-        # Only cascade-diff GraphQL model objects; ecoportal-api-v2 DoubleModel
-        # subclasses (ArrayModel, etc.) have a different as_update signature.
-        next result unless obj.is_a?(Ecoportal::API::Common::GraphQL::Model)
-
-        value = obj.as_update(ignore: ignore)
-        next result if value.nil?
-
-        result      ||= {}
-        result[:id] ||= get_id(keys_to_sym_deep(curr_doc(flat: true) || {}), exception: false)
-        dig_set!(result, sym_path, value)
-        result
-      end
-    end
-
-    # PROBLEM: trace can't be used with knowing if it's the root of the call!
-    # see `#cascaded_reduce` (when calling `_cascaded_attributes_trace`).
-    def diff_reduce_with_as_update_and_trace(init = {}, ignore: [], trace: {})
-      subject.cascaded_reduce(init, recurs: false, trace: trace) do |result, obj, _key, key_path, _trace|
-        next result if key_path.empty? # first iteration already done
-        next result if obj == subject  # first call had done it
-
-        dig_delete!(result, key_path) if dig_path?(result, key_path)
-
-        # discard rooted (i.e. read_only) objects from the diff.
-        next result if root?(obj)
-        next result unless dig_path?(result, key_path)
-        next result unless obj.respond_to?(:as_update)
-
-        value = obj.as_update(ignore: ignore)
-
-        dig_set!(
-          result,
-          key_path,
-          value
-        )
-
-        result
-      end
-    end
-
-    # FAILS to CALL #as_update on each object!!!
-    def diff_reduce_preserve_keys(init, flat: flat?, ignore: [])
-      subject.cascaded_reduce(init, recurs: !flat) do |result, obj, _key, key_path, _trace|
-        # discard rooted (i.e. read_only) objects from the diff.
-        if root?(obj)
-          dig_delete!(result, key_path)
-        else
-          value = classic_diff(
-            obj,
-            flat:   true,
-            ignore: ignore
-          )
-
-          dig_set!(result, key_path, value)
-        end
-
-        result
-      end
-    end
-
-    def cascaded_diff(flat: flat?, ignore: [])
-      subject.cascaded_callback(
-        method: :as_update,
-        kargs:  {
-          ignore: to_a(ignored, ignore),
-          flat:   flat
-        },
-        recurs: !flat
-      ) do |result, value, key_path, obj|
-        result.tap do
-          # on first call key_path is empty
-          next result if key_path.empty? # this condition isn't met, first call doesn't yield.
-
-          # discard rooted (i.e. read_only) objects from the diff.
-          if root?(obj)
-            dig_delete!(result, key_path)
-          else
-            dig_set!(result, key_path, value)
-          end
-        end
-      end
-    end
-
-    private
-
-    attr_reader :ignored
-
-    def root?(obj)
-      # root? is a CLASS method (via Rootable::ClassMethods). The instance root?
-      # is protected and checks parent position, not the class declaration.
-      # Check the ancestor chain for any class that declared root!.
-      obj.class.ancestors.any? { |k| k.respond_to?(:root?) && k.root? }
-    end
-
-    def curr_doc(target = subject, flat: flat?)
-      may_use_flat_diff(flat) { super(target) }
-    end
-
-    def prev_doc(target = subject, flat: flat?)
-      may_use_flat_diff(flat) { super(target) }
-    end
-
-    # Remove nested attributes
-    def may_use_flat_diff(flat = flat?)
-      yield.then do |json|
-        next json unless flat
-
-        doc_with_non_cascaded_attributes(json)
-      end
-    end
-
-    # Remove from `json` doc all the nested properties.
-    def doc_with_non_cascaded_attributes(json)
-      return json unless subject.class.respond_to?(:_cascaded_doc_keys)
-      return json if (excluded = subject.class._cascaded_doc_keys).empty?
-
-      except_keys(json, *excluded)
-    end
-  end
-end
+module Ecoportal::API::Common::GraphQL::Model::Diffable
+  class DiffService < ClassicDiffService
+    include Ecoportal::API::Common::GraphQL::Model::Diffable::HashDiffNesting
+    include Ecoportal::API::Common::GraphQL::HashHelpers
+
+    def initialize(subject, flat: false, ignore: [])
+      super(subject, ignore: ignore)
+
+      @flat = flat
+    end
+
+    def flat?
+      @flat
+    end
+
+    # @param flat [Boolean] whethere it should skip nested models.
+    # @param cascaded [Boolean] whether it should cascade the calls through
+    #   the nested models.
+    #   - When `flat` is `true` will only cascade the 1st level of nested models.
+    #   - When `flat` is `false` will do a full cascade.
+    def diff(flat: flat?, ignore: [])
+      classic_diff(
+        flat:   true,
+        ignore: ignore
+      ).then do |value|
+        next value if flat
+
+        diff_reduce(
+          value,
+          ignore: ignore
+        )
+      end
+    end
+
+    protected
+
+    # Override: GraphQL mutations expect flat changed-prop values, not patch-op wrappers.
+    # Returns { id: ..., changed_field: new_value, ... } or nil when nothing changed.
+    def classic_diff(flat: flat?, ignore: [])
+      curr = keys_to_sym_deep(curr_doc(flat: flat) || {})
+      prev = keys_to_sym_deep(prev_doc(flat: flat) || {})
+
+      data = change_data(curr, prev, ignore: to_a(ignored, ignore))
+      return nil if data == NO_CHANGES
+
+      id = get_id(curr, exception: false)
+      id ? { id: id }.merge(data) : data
+    end
+
+    # @note it calls `as_update` for nested / cascaded attributes, which in turn
+    #   will use this `DiffService`. Therefore, we aim for a first flat classic diff,
+    #   onto `self`, and cascaded callbacks for the nested attributes.
+    #     - This will translate into `key_path` being lost on each jump between
+    #       `#as_update` and `DiffService#diff`.
+    #     - The `result` object regards, therefore, to the **current level** alone.
+    #       With the aim of building it up (accumulating through the call chain).
+    def diff_reduce(init, ignore: [])
+      subject.cascaded_reduce(init, recurs: false) do |result, obj, _key, key_path, _trace|
+        next result if key_path.empty?
+        next result if obj == subject
+
+        sym_path = key_path.map(&:to_sym)
+
+        # Remove any flat-diff placeholder for this key before deciding its fate.
+        dig_delete!(result, sym_path) if result && dig_path?(result, sym_path)
+
+        # Discard root-class objects — they are independent entities, not mutation payload.
+        next result if root?(obj)
+        # Only cascade-diff GraphQL model objects; ecoportal-api-v2 DoubleModel
+        # subclasses (ArrayModel, etc.) have a different as_update signature.
+        next result unless obj.is_a?(Ecoportal::API::Common::GraphQL::Model)
+
+        value = obj.as_update(ignore: ignore)
+        next result if value.nil?
+
+        result      ||= {}
+        result[:id] ||= get_id(keys_to_sym_deep(curr_doc(flat: true) || {}), exception: false)
+        dig_set!(result, sym_path, value)
+        result
+      end
+    end
+
+    # PROBLEM: trace can't be used with knowing if it's the root of the call!
+    # see `#cascaded_reduce` (when calling `_cascaded_attributes_trace`).
+    def diff_reduce_with_as_update_and_trace(init = {}, ignore: [], trace: {})
+      subject.cascaded_reduce(init, recurs: false, trace: trace) do |result, obj, _key, key_path, _trace|
+        next result if key_path.empty? # first iteration already done
+        next result if obj == subject  # first call had done it
+
+        dig_delete!(result, key_path) if dig_path?(result, key_path)
+
+        # discard rooted (i.e. read_only) objects from the diff.
+        next result if root?(obj)
+        next result unless dig_path?(result, key_path)
+        next result unless obj.respond_to?(:as_update)
+
+        value = obj.as_update(ignore: ignore)
+
+        dig_set!(
+          result,
+          key_path,
+          value
+        )
+
+        result
+      end
+    end
+
+    # FAILS to CALL #as_update on each object!!!
+    def diff_reduce_preserve_keys(init, flat: flat?, ignore: [])
+      subject.cascaded_reduce(init, recurs: !flat) do |result, obj, _key, key_path, _trace|
+        # discard rooted (i.e. read_only) objects from the diff.
+        if root?(obj)
+          dig_delete!(result, key_path)
+        else
+          value = classic_diff(
+            obj,
+            flat:   true,
+            ignore: ignore
+          )
+
+          dig_set!(result, key_path, value)
+        end
+
+        result
+      end
+    end
+
+    def cascaded_diff(flat: flat?, ignore: [])
+      subject.cascaded_callback(
+        method: :as_update,
+        kargs:  {
+          ignore: to_a(ignored, ignore),
+          flat:   flat
+        },
+        recurs: !flat
+      ) do |result, value, key_path, obj|
+        result.tap do
+          # on first call key_path is empty
+          next result if key_path.empty? # this condition isn't met, first call doesn't yield.
+
+          # discard rooted (i.e. read_only) objects from the diff.
+          if root?(obj)
+            dig_delete!(result, key_path)
+          else
+            dig_set!(result, key_path, value)
+          end
+        end
+      end
+    end
+
+    private
+
+    attr_reader :ignored
+
+    def root?(obj)
+      # root? is a CLASS method (via Rootable::ClassMethods). The instance root?
+      # is protected and checks parent position, not the class declaration.
+      # Check the ancestor chain for any class that declared root!.
+      obj.class.ancestors.any? { |k| k.respond_to?(:root?) && k.root? }
+    end
+
+    def curr_doc(target = subject, flat: flat?)
+      may_use_flat_diff(flat) { super(target) }
+    end
+
+    def prev_doc(target = subject, flat: flat?)
+      may_use_flat_diff(flat) { super(target) }
+    end
+
+    # Remove nested attributes
+    def may_use_flat_diff(flat = flat?)
+      yield.then do |json|
+        next json unless flat
+
+        doc_with_non_cascaded_attributes(json)
+      end
+    end
+
+    # Remove from `json` doc all the nested properties.
+    def doc_with_non_cascaded_attributes(json)
+      return json unless subject.class.respond_to?(:_cascaded_doc_keys)
+      return json if (excluded = subject.class._cascaded_doc_keys).empty?
+
+      except_keys(json, *excluded)
+    end
+  end
+end

data/lib/ecoportal/api/common/graphql/model/diffable/hash_diff.rb

@@ -1,55 +1,55 @@
-# rubocop:disable Naming/MethodParameterName
-module Ecoportal::API::Common::GraphQL::Model::Diffable
-  # @note this is a literal copy of ecoportal-api gem diff function.
-  #   ecoportal-api-graphql uses APIv2 DoubleModel inheritance chain,
-  #   and should rather adapt `HashDiffPatch`
-  module HashDiff
-    ID_KEYS = %w[id].freeze
-
-    class << self
-      def included(base)
-        super
-
-        base.send :include, InstanceMethods
-      end
-    end
-
-    module InstanceMethods
-      # @todo: refactor to only reach the current level
-      # @note the aim is to delegate `hash_diff` to the specific classes
-      #   of the model... bulding the payload/input_base in a cascaded
-      #   way (rather than in a one-off way from the top alone).
-      def diff(a, b, ignore: [])
-        case a
-        when Hash
-          {}.tap do |diffed|
-            a.each do |key, a_value|
-              b_value    = b[key] if b
-              no_changes = (a_value == b_value) || ignore.include?(key)
-              next if !ID_KEYS.include?(key) && no_changes
-
-              diffed[key] = diff(a_value, b_value, ignore: ignore)
-              diffed.delete(key) if diffed[key] == {}
-            end
-
-            # All keys are IDs, so it's actually blank
-            return {} if (diffed.keys - ID_KEYS).empty?
-          end
-        when Array
-          return a unless b.is_a?(Array) && a.length == b.length
-
-          a.map.with_index do |a_value, idx|
-            b_value = b[idx]
-            diff(a_value, b_value, ignore: ignore)
-          end.reject do |el|
-            el == {}
-          end
-        else
-          a
-        end
-      end
-    end
-  end
-end
-
-# rubocop:enable Naming/MethodParameterName
+# rubocop:disable Naming/MethodParameterName
+module Ecoportal::API::Common::GraphQL::Model::Diffable
+  # @note this is a literal copy of ecoportal-api gem diff function.
+  #   ecoportal-api-graphql uses APIv2 DoubleModel inheritance chain,
+  #   and should rather adapt `HashDiffPatch`
+  module HashDiff
+    ID_KEYS = %w[id].freeze
+
+    class << self
+      def included(base)
+        super
+
+        base.send :include, InstanceMethods
+      end
+    end
+
+    module InstanceMethods
+      # @todo: refactor to only reach the current level
+      # @note the aim is to delegate `hash_diff` to the specific classes
+      #   of the model... bulding the payload/input_base in a cascaded
+      #   way (rather than in a one-off way from the top alone).
+      def diff(a, b, ignore: [])
+        case a
+        when Hash
+          {}.tap do |diffed|
+            a.each do |key, a_value|
+              b_value    = b[key] if b
+              no_changes = (a_value == b_value) || ignore.include?(key)
+              next if !ID_KEYS.include?(key) && no_changes
+
+              diffed[key] = diff(a_value, b_value, ignore: ignore)
+              diffed.delete(key) if diffed[key] == {}
+            end
+
+            # All keys are IDs, so it's actually blank
+            return {} if (diffed.keys - ID_KEYS).empty?
+          end
+        when Array
+          return a unless b.is_a?(Array) && a.length == b.length
+
+          a.map.with_index do |a_value, idx|
+            b_value = b[idx]
+            diff(a_value, b_value, ignore: ignore)
+          end.reject do |el|
+            el == {}
+          end
+        else
+          a
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodParameterName