ecoportal-api-graphql 1.3.5 → 1.3.17

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

@@ -1,242 +1,295 @@
-# rubocop:disable Naming/MethodParameterName
-module Ecoportal::API::Common::GraphQL::Model::Diffable
-  # @note this is a literal copy of ecoportal-api-v2 gem `has_diff` function.
-  # @todo the aim is to adapt it by:
-  #   1. Removing the `patch_ver` model ✅
-  #   2. Using symbol keys ✅
-  module HashDiffNesting
-    class << self
-      def included(base)
-        super
-
-        base.send :include, InstanceMethods
-      end
-    end
-
-    META_KEYS  = %i[id].freeze
-    NO_CHANGES = "%not-changed!%".freeze
-
-    module InstanceMethods
-      # The `change data` is built as follows:
-      # 1. detect changes that have occurred translate into one `api_operation` of `OP_TYPE`:
-      #   * `:update`: meaning that the object has changed (existed and has not been removed)
-      #   * `:delete`:  the object has been removed
-      #   * `:create`:     the object is new
-      # 2. at the level of the target object of the model, the object is opened for change
-      # with `id` and `api_operation` as follows:
-      #
-      #    ```json
-      #    {
-      #       "id":            "objectID",
-      #       "api_operation": "OP_TYPE",
-      #       "change_data" {
-      #         "property":      "value",
-      #          "...":          "..."
-      #       }
-      #    }
-      #    ```
-      # 3. the `change_data` property holds the specific changes of the object
-      #   - the properties that have changed
-      # @note
-      #   * there should not be difference between `null` and `""` (empty string)
-      # @param a [Hash] current hash model
-      # @param b [Hash] previous hash model
-      # @return [Hash] a `change data`
-      def change_diff(a, b, ignore: [])
-        ignore = to_a(ignore)
-
-        if b.is_a?(Hash) && !empty?(b) && empty?(a)
-          patch_delete(b)
-        elsif a.is_a?(Hash) && !empty?(a) && empty?(b)
-          patch_new(a, ignore: ignore)
-        elsif a.is_a?(Hash) && b.is_a?(Hash)
-          patch_update(a, b, ignore: ignore)
-        elsif any_array?(a, b)
-          patch_data_array(a, b, ignore: ignore)
-        else
-          a
-        end
-      end
-
-      private
-
-      # Compares `a` as carrying changes of `b`
-      # @return [Hash] change data object with only changes
-      def change_data(a, b = nil, delete: false, ignore: [])
-        {}.tap do |data_hash|
-          next if delete
-
-          a.each do |key, a_value|
-            key = key.to_sym
-
-            next if meta_keys.include?(key)
-            next if ignore.include?(key)
-
-            b_value = nil
-
-            if b&.key?(key)
-              b_value = b[key]
-              next if equal_values?(a_value, b_value)
-            end
-
-            data_hash[key] = change_diff(a_value, b_value)
-
-            data_hash.delete(key) if data_hash[key] == NO_CHANGES
-          end
-
-          return NO_CHANGES if (data_hash.keys - meta_keys).empty?
-        end
-      end
-
-      def patch_delete(b)
-        return NO_CHANGES unless b.is_a?(Hash)
-        return            unless (id = get_id(b, exception: false))
-
-        {
-          id:            id,
-          api_operation: :delete,
-          change_data:   change_data(b, delete: true)
-        }
-      end
-
-      def patch_new(a, ignore: [])
-        return NO_CHANGES unless a.is_a?(Hash)
-        return a          unless (id = get_id(a, exception: false))
-
-        {
-          id:            id,
-          api_operation: :create,
-          change_data:   change_data(a, ignore: ignore)
-        }
-      end
-
-      def patch_update(a, b, ignore: [])
-        return NO_CHANGES unless a.is_a?(Hash)
-        return a          unless (id = get_id(a, exception: false))
-
-        {
-          id:            id,
-          api_operation: :update,
-          change_data:   change_data(a, b, ignore: ignore)
-        }.tap do |update_hash|
-          return nil unless update_hash[:change_data] != NO_CHANGES
-        end
-      end
-
-      def patch_data_array(a, b, ignore: [])
-        return patch_data_nested_array(a, b, ignore: ignore) if nested_array?(a, b)
-
-        patch_data_flat_array(a, b)
-      end
-
-      def patch_data_flat_array(a, b)
-        original_b = b
-        a        ||= []
-        b        ||= []
-
-        same_elements =
-          a.length == b.length &&
-          (a & b).length == b.length
-
-        return a          unless same_elements
-        return NO_CHANGES if original_b
-
-        a
-      end
-
-      def patch_data_nested_array(a, b, ignore: [])
-        a ||= []
-        b ||= []
-
-        # array with nested elements
-        a_ids = array_ids(a)
-        b_ids = array_ids(b)
-
-        del_ids = b_ids - a_ids
-        oth_ids = b_ids & a_ids
-        new_ids = a_ids - b_ids
-
-        arr_delete = del_ids.map do |id|
-          patch_delete(array_id_item(b, id))
-        end.compact
-
-        arr_update = oth_ids.map do |id|
-          patch_update(array_id_item(a, id), array_id_item(b, id), ignore: ignore)
-        end.compact
-
-        arr_new = new_ids.map do |id|
-          patch_new(array_id_item(a, id), ignore: ignore)
-        end.compact
-
-        arr_delete.concat(arr_update).concat(arr_new).tap do |patch_array|
-          # remove data with no `id`
-          patch_array.select! {|item| item.is_a?(Hash)}
-          return NO_CHANGES if patch_array.empty?
-        end
-      end
-
-      def nested_array?(*arr)
-        if arr.length > 1
-          arr.any? {|a| nested_array?(a)}
-        elsif arr.length == 1
-          arr = arr.first || []
-          arr.any? do |item|
-            next false unless item.is_a?(Hash)
-            next true  if item.key?(:id)
-
-            false
-          end
-        else
-          false
-        end
-      end
-
-      def any_array?(a, b)
-        [a, b].any? {|item| item.is_a?(Array)}
-      end
-
-      def get_id(doc, exception: true)
-        id   = nil
-        id ||= doc.id    if doc.respond_to?(:id)
-        id ||= doc['id'] if doc.is_a?(Hash)
-        id ||= doc[:id]  if doc.is_a?(Hash)
-        id ||= doc       if doc.is_a?(String)
-
-        raise 'No ID has been given!' unless id || !exception
-
-        id
-      end
-
-      def meta_keys
-        return self::META_KEYS if respond_to?(:const_get)
-
-        self.class::META_KEYS
-      end
-
-      def equal_values?(a, b)
-        if a.is_a?(String) || b.is_a?(String)
-          a_empty = a.to_s.strip.empty?
-          b_empty = b.to_s.strip.empty?
-
-          return true if a_empty && b_empty
-        end
-
-        a == b
-      end
-
-      def empty?(a)
-        bool   = !a
-        bool ||= a.respond_to?(:empty?) && a.empty?
-        bool
-      end
-
-      def to_a(*values)
-        [values].flatten.compact.uniq
-      end
-    end
-
-    extend InstanceMethods
-  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-v2 gem `has_diff` function.
+  # @todo the aim is to adapt it by:
+  #   1. Removing the `patch_ver` model ✅
+  #   2. Using symbol keys ✅
+  module HashDiffNesting
+    class << self
+      def included(base)
+        super
+
+        base.send :include, InstanceMethods
+      end
+    end
+
+    META_KEYS  = %i[id].freeze
+    NO_CHANGES = "%not-changed!%".freeze
+
+    module InstanceMethods
+      # The `change data` is built as follows:
+      # 1. detect changes that have occurred translate into one `api_operation` of `OP_TYPE`:
+      #   * `:update`: meaning that the object has changed (existed and has not been removed)
+      #   * `:delete`:  the object has been removed
+      #   * `:create`:     the object is new
+      # 2. at the level of the target object of the model, the object is opened for change
+      # with `id` and `api_operation` as follows:
+      #
+      #    ```json
+      #    {
+      #       "id":            "objectID",
+      #       "api_operation": "OP_TYPE",
+      #       "change_data" {
+      #         "property":      "value",
+      #          "...":          "..."
+      #       }
+      #    }
+      #    ```
+      # 3. the `change_data` property holds the specific changes of the object
+      #   - the properties that have changed
+      # @note
+      #   * there should not be difference between `null` and `""` (empty string)
+      # @param a [Hash] current hash model
+      # @param b [Hash] previous hash model
+      # @return [Hash] a `change data`
+      def change_diff(a, b, ignore: [])
+        ignore = to_a(ignore)
+
+        if b.is_a?(Hash) && !empty?(b) && empty?(a)
+          patch_delete(b)
+        elsif a.is_a?(Hash) && !empty?(a) && empty?(b)
+          patch_new(a, ignore: ignore)
+        elsif a.is_a?(Hash) && b.is_a?(Hash)
+          patch_update(a, b, ignore: ignore)
+        elsif any_array?(a, b)
+          patch_data_array(a, b, ignore: ignore)
+        else
+          a
+        end
+      end
+
+      private
+
+      # Compares `a` as carrying changes of `b`
+      # @return [Hash] change data object with only changes
+      def change_data(a, b = nil, delete: false, ignore: [])
+        {}.tap do |data_hash|
+          next if delete
+
+          a.each do |key, a_value|
+            key = key.to_sym
+
+            next if meta_keys.include?(key)
+            next if ignore.include?(key)
+
+            b_value = nil
+
+            if b&.key?(key)
+              b_value = b[key]
+              next if equal_values?(a_value, b_value)
+            end
+
+            data_hash[key] = change_diff(a_value, b_value)
+
+            data_hash.delete(key) if data_hash[key] == NO_CHANGES
+          end
+
+          return NO_CHANGES if (data_hash.keys - meta_keys).empty?
+        end
+      end
+
+      def patch_delete(b)
+        return NO_CHANGES unless b.is_a?(Hash)
+        return            unless (id = get_id(b, exception: false))
+
+        {
+          id:            id,
+          api_operation: :delete,
+          change_data:   change_data(b, delete: true)
+        }
+      end
+
+      def patch_new(a, ignore: [])
+        return NO_CHANGES unless a.is_a?(Hash)
+        return a          unless (id = get_id(a, exception: false))
+
+        {
+          id:            id,
+          api_operation: :create,
+          change_data:   change_data(a, ignore: ignore)
+        }
+      end
+
+      def patch_update(a, b, ignore: [])
+        return NO_CHANGES unless a.is_a?(Hash)
+        return a          unless (id = get_id(a, exception: false))
+
+        {
+          id:            id,
+          api_operation: :update,
+          change_data:   change_data(a, b, ignore: ignore)
+        }.tap do |update_hash|
+          return nil unless update_hash[:change_data] != NO_CHANGES
+        end
+      end
+
+      def patch_data_array(a, b, ignore: [])
+        return patch_data_nested_array(a, b, ignore: ignore) if nested_array?(a, b)
+
+        patch_data_flat_array(a, b)
+      end
+
+      def patch_data_flat_array(a, b)
+        original_b = b
+        a        ||= []
+        b        ||= []
+
+        same_elements =
+          a.length == b.length &&
+          (a & b).length == b.length
+
+        return a          unless same_elements
+        return NO_CHANGES if original_b
+
+        a
+      end
+
+      def patch_data_nested_array(a, b, ignore: [])
+        a ||= []
+        b ||= []
+
+        # array with nested elements
+        a_ids = array_ids(a)
+        b_ids = array_ids(b)
+
+        del_ids = b_ids - a_ids
+        oth_ids = b_ids & a_ids
+        new_ids = a_ids - b_ids
+
+        arr_delete = del_ids.map do |id|
+          patch_delete(array_id_item(b, id))
+        end.compact
+
+        arr_update = oth_ids.map do |id|
+          patch_update(array_id_item(a, id), array_id_item(b, id), ignore: ignore)
+        end.compact
+
+        arr_new = new_ids.map do |id|
+          patch_new(array_id_item(a, id), ignore: ignore)
+        end.compact
+
+        arr_delete.concat(arr_update).concat(arr_new).tap do |patch_array|
+          # remove data with no `id`
+          patch_array.select! {|item| item.is_a?(Hash)}
+          return NO_CHANGES if patch_array.empty?
+        end
+      end
+
+      def nested_array?(*arr)
+        if arr.length > 1
+          arr.any? {|a| nested_array?(a)}
+        elsif arr.length == 1
+          arr = arr.first || []
+          arr.any? do |item|
+            next false unless item.is_a?(Hash)
+            next true  if item.key?(:id)
+
+            false
+          end
+        else
+          false
+        end
+      end
+
+      def any_array?(a, b)
+        [a, b].any?(Array)
+      end
+
+      def get_id(doc, exception: true)
+        id   = nil
+        id ||= doc.id    if doc.respond_to?(:id)
+        id ||= doc['id'] if doc.is_a?(Hash)
+        id ||= doc[:id]  if doc.is_a?(Hash)
+        id ||= doc       if doc.is_a?(String)
+
+        raise 'No ID has been given!' unless id || !exception
+
+        id
+      end
+
+      # @param arr [Array] the source Array of id-bearing items
+      # @return [Array<String>] the `id`s thereof
+      def array_ids(arr)
+        return [] if !arr.is_a?(Array) || arr.empty?
+
+        arr.map {|item| get_id(item, exception: false)}
+      end
+
+      # @param arr [Array] the source Array
+      # @return [Integer, nil] the position of the item with the given `id`
+      def array_id_index(arr, id)
+        return unless arr.is_a?(Array)
+
+        arr.index {|item| get_id(item, exception: false) == id}
+      end
+
+      # @param arr [Array] the source Array
+      # @return [Object, nil] the item with the given `id`
+      def array_id_item(arr, id)
+        return unless (idx = array_id_index(arr, id))
+
+        arr[idx]
+      end
+
+      def meta_keys
+        return self::META_KEYS if respond_to?(:const_get)
+
+        self.class::META_KEYS
+      end
+
+      def equal_values?(a, b)
+        if a.is_a?(String) || b.is_a?(String)
+          a_empty = a.to_s.strip.empty?
+          b_empty = b.to_s.strip.empty?
+
+          return true if a_empty && b_empty
+        end
+
+        a == b
+      end
+
+      def empty?(a)
+        bool   = !a
+        bool ||= a.respond_to?(:empty?) && a.empty?
+        bool
+      end
+
+      def to_a(*values)
+        [values].flatten.compact.uniq
+      end
+
+      # Hash path helpers — used by DiffService#diff_reduce to navigate
+      # and modify nested result hashes during cascaded diffing.
+
+      def dig_path?(obj, keys)
+        return false unless obj.is_a?(Hash)
+        return obj.key?(keys.first) if keys.length == 1
+        return false unless obj.key?(keys.first)
+
+        dig_path?(obj[keys.first], keys[1..])
+      end
+
+      def dig_set!(obj, keys, value)
+        if keys.length == 1
+          obj[keys.first] = value
+        else
+          dig_set!(obj[keys.first], keys[1..], value)
+        end
+      end
+
+      def dig_delete!(obj, keys)
+        if keys.length == 1
+          return unless obj.respond_to?(:delete)
+
+          obj.delete(keys.first)
+        else
+          dig_delete!(obj[keys.first], keys[1..])
+        end
+      end
+    end
+
+    extend InstanceMethods
+  end
+end
+
+# rubocop:enable Naming/MethodParameterName

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

@@ -1,54 +1,54 @@
-module Ecoportal
-  module API
-    module Common
-      module GraphQL
-        class Model
-          module Diffable
-            require_relative 'diffable/hash_diff_nesting'
-            require_relative 'diffable/classic_diff_service'
-            require_relative 'diffable/diff_service'
-
-            DIFF_CLASS = DiffService
-
-            # INSTANCE METHODS
-
-            # @note **cascaded callbacks**
-            #   1. Can **skip** rooted objects (where `root?` is `true`).
-            #     This is because nested rooted objects are usually look-ups
-            #     (not really part of the target model).
-            #   2. Allow to redefine `as_update` on each model.
-            # @param flat [Boolean] whether it should NOT perform a cascaded callback
-            #   througout all the instance objects of the model hierarchy (nested).
-            # @param ignored [Array<String>] the keys that should be ignored, not part
-            #   of the result of `as_update`
-            # @return [nil, Hash] the patch `Hash` model including only
-            #   the changes between `original_doc` and `doc`.
-            def as_update(**kargs)
-              diff_class.new(
-                self,
-                **kargs
-              ).diff
-            end
-
-            # @note `cascaded` will be more accurate in a `GraphQL` scenario.
-            # @return [Boolean] stating if there are changes.
-            def dirty?(...)
-              au = as_update(...)
-
-              return false if au.nil?
-              return false if au == {}
-
-              true
-            end
-
-            private
-
-            def diff_class
-              self.class::DIFF_CLASS
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    module Common
+      module GraphQL
+        class Model
+          module Diffable
+            require_relative 'diffable/hash_diff_nesting'
+            require_relative 'diffable/classic_diff_service'
+            require_relative 'diffable/diff_service'
+
+            DIFF_CLASS = DiffService
+
+            # INSTANCE METHODS
+
+            # @note **cascaded callbacks**
+            #   1. Can **skip** rooted objects (where `root?` is `true`).
+            #     This is because nested rooted objects are usually look-ups
+            #     (not really part of the target model).
+            #   2. Allow to redefine `as_update` on each model.
+            # @param flat [Boolean] whether it should NOT perform a cascaded callback
+            #   througout all the instance objects of the model hierarchy (nested).
+            # @param ignored [Array<String>] the keys that should be ignored, not part
+            #   of the result of `as_update`
+            # @return [nil, Hash] the patch `Hash` model including only
+            #   the changes between `original_doc` and `doc`.
+            def as_update(**kargs)
+              diff_class.new(
+                self,
+                **kargs
+              ).diff
+            end
+
+            # @note `cascaded` will be more accurate in a `GraphQL` scenario.
+            # @return [Boolean] stating if there are changes.
+            def dirty?(...)
+              au = as_update(...)
+
+              return false if au.nil?
+              return false if au == {}
+
+              true
+            end
+
+            private
+
+            def diff_class
+              self.class::DIFF_CLASS
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,17 +1,17 @@
-module Ecoportal
-  module API
-    module Common
-      module GraphQL
-        class Model < Ecoportal::API::Common::Content::DoubleModel
-          require 'ecoportal/api/common/graphql/model/diffable'
-          require 'ecoportal/api/common/graphql/model/as_input'
-
-          include Ecoportal::API::Common::GraphQL::ClassHelpers
-
-          include Diffable
-          include AsInput
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    module Common
+      module GraphQL
+        class Model < Ecoportal::API::Common::Content::DoubleModel
+          require 'ecoportal/api/common/graphql/model/diffable'
+          require 'ecoportal/api/common/graphql/model/as_input'
+
+          include Ecoportal::API::Common::GraphQL::ClassHelpers
+
+          include Diffable
+          include AsInput
+        end
+      end
+    end
+  end
+end