ecoportal-api-graphql 1.3.16 → 1.3.17

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

@@ -1,105 +1,105 @@
-module Ecoportal
-  module API
-    module Common
-      module GraphQL
-        module HashHelpers
-          class << self
-            def included(base)
-              base.send(:include, InstanceMethods)
-            end
-          end
-
-          module InstanceMethods
-            def keys_to_sym_deep(value)
-              transform_keys_deep(value, &:to_sym)
-            end
-
-            def keys_to_s_deep(value)
-              transform_keys_deep(value, &:to_s)
-            end
-
-            def except_keys(value, *keys)
-              return value unless value.is_a?(Hash)
-
-              deep_dup(value).tap do |out|
-                keys.each {|key| out.delete(key)}
-              end
-            end
-
-            # Targetted removal of keys in `target` that are `nil`
-            def remove_nil_keys_deep(value, target: [])
-              remove_keys_deep_if(value, target: target, &:nil?)
-            end
-
-            # Based on Rails support.
-            def deep_dup(data)
-              case data
-              when Hash
-                data.each_with_object({}) do |(k, v), copy|
-                  if k.is_a?(::String) || k.is_a?(::Symbol)
-                    copy[k] = deep_dup(v)
-                  else
-                    copy.delete(k)
-                    copy[deep_dup(k)] = deep_dup(v)
-                  end
-                end
-              when Enumerable
-                data.map {|d| deep_dup(d)}
-              else
-                data.dup
-              end
-            end
-
-            private
-
-            # Iterator
-            # @param value [Variadic]
-            # @return [value.class]
-            def transform_keys_deep(value, &block)
-              case value
-              when Hash
-                value.dup.each_with_object({}) do |(k, v), out|
-                  k_val      = block_given?? yield(k) : k
-                  out[k_val] = transform_keys_deep(v, &block)
-                end
-              when Enumerable
-                value.map {|v| transform_keys_deep(v, &block)}
-              else
-                value
-              end
-            end
-
-            # Targetted removal of keys in `target` that meet
-            # the `block` condition.
-            # @param value [Variadic]
-            # @param target [Array<String>, Array<Symbol>] the target
-            #   `keys` to yield `block` onto.
-            # @return [value.class]
-            def remove_keys_deep_if(value, target: [], &block)
-              msg = 'Expected block. None given.'
-              raise ArgumentError, msg unless block_given?
-
-              target = [target].flatten.compact
-              return value if target.empty?
-
-              case value
-              when Hash
-                value.dup.each_with_object({}) do |(k, v), out|
-                  next if yield(v) && target.include?(k) # skip
-
-                  out[k] = remove_nil_keys_deep(v, target: target, &block)
-                end
-              when Enumerable
-                value.map {|v| remove_nil_keys_deep(v, target: target, &block)}
-              else
-                value
-              end
-            end
-          end
-
-          extend InstanceMethods
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    module Common
+      module GraphQL
+        module HashHelpers
+          class << self
+            def included(base)
+              base.send(:include, InstanceMethods)
+            end
+          end
+
+          module InstanceMethods
+            def keys_to_sym_deep(value)
+              transform_keys_deep(value, &:to_sym)
+            end
+
+            def keys_to_s_deep(value)
+              transform_keys_deep(value, &:to_s)
+            end
+
+            def except_keys(value, *keys)
+              return value unless value.is_a?(Hash)
+
+              deep_dup(value).tap do |out|
+                keys.each {|key| out.delete(key)}
+              end
+            end
+
+            # Targetted removal of keys in `target` that are `nil`
+            def remove_nil_keys_deep(value, target: [])
+              remove_keys_deep_if(value, target: target, &:nil?)
+            end
+
+            # Based on Rails support.
+            def deep_dup(data)
+              case data
+              when Hash
+                data.each_with_object({}) do |(k, v), copy|
+                  if k.is_a?(::String) || k.is_a?(::Symbol)
+                    copy[k] = deep_dup(v)
+                  else
+                    copy.delete(k)
+                    copy[deep_dup(k)] = deep_dup(v)
+                  end
+                end
+              when Enumerable
+                data.map {|d| deep_dup(d)}
+              else
+                data.dup
+              end
+            end
+
+            private
+
+            # Iterator
+            # @param value [Variadic]
+            # @return [value.class]
+            def transform_keys_deep(value, &block)
+              case value
+              when Hash
+                value.dup.each_with_object({}) do |(k, v), out|
+                  k_val      = block_given?? yield(k) : k
+                  out[k_val] = transform_keys_deep(v, &block)
+                end
+              when Enumerable
+                value.map {|v| transform_keys_deep(v, &block)}
+              else
+                value
+              end
+            end
+
+            # Targetted removal of keys in `target` that meet
+            # the `block` condition.
+            # @param value [Variadic]
+            # @param target [Array<String>, Array<Symbol>] the target
+            #   `keys` to yield `block` onto.
+            # @return [value.class]
+            def remove_keys_deep_if(value, target: [], &block)
+              msg = 'Expected block. None given.'
+              raise ArgumentError, msg unless block_given?
+
+              target = [target].flatten.compact
+              return value if target.empty?
+
+              case value
+              when Hash
+                value.dup.each_with_object({}) do |(k, v), out|
+                  next if yield(v) && target.include?(k) # skip
+
+                  out[k] = remove_nil_keys_deep(v, target: target, &block)
+                end
+              when Enumerable
+                value.map {|v| remove_nil_keys_deep(v, target: target, &block)}
+              else
+                value
+              end
+            end
+          end
+
+          extend InstanceMethods
+        end
+      end
+    end
+  end
+end

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

@@ -1,54 +1,54 @@
-module Ecoportal
-  module API
-    module Common
-      module GraphQL
-        class Model
-          # @todo
-          #   1. `#as_input` vs `#to_input` **or** named argument `klass`
-          #     One gets the `input` to be already used in a mutation query.
-          #     The other gets the `Input` class object out of the `Base/Model`.
-          #     - To figure out when `as_update` should be called.
-          #   2. Each Base/Model should have its `Input` class counterpart.
-          #     This could be auto-inflected (via namespace constant lookup)
-          #     at some point.
-          #   3. Think if a service class can be used to this purpose
-          #     (i.e. decorator of DiffService).
-          module AsInput
-            class << self
-              def included(base)
-                super
-
-                base.send(:include, Model::Diffable)
-                base.extend ClassMethods
-              end
-            end
-
-            module ClassMethods
-              def as_input(hash, clientMutationId: '')
-                hash_input = Ecoportal::API::Common::GraphQL::HashHelpers.
-                  keys_to_sym_deep(hash)
-
-                hash_input.merge!(clientMutationId: clientMutationId)
-
-                Ecoportal::API::Common::GraphQL::HashHelpers.
-                  remove_nil_keys_deep(hash_input, target: :id)
-              end
-            end
-
-            # INSTANCE METHODS
-
-            def as_input(target_class: nil, clientMutationId: '')
-              return target_class.from_model(self, client_mutation_id: clientMutationId) if target_class
-
-              diff = as_update
-              return nil if diff.nil?
-
-              diff[:patchVer] = patchVer if respond_to?(:patchVer) && !patchVer.nil?
-              self.class.as_input(diff, clientMutationId: clientMutationId)
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    module Common
+      module GraphQL
+        class Model
+          # @todo
+          #   1. `#as_input` vs `#to_input` **or** named argument `klass`
+          #     One gets the `input` to be already used in a mutation query.
+          #     The other gets the `Input` class object out of the `Base/Model`.
+          #     - To figure out when `as_update` should be called.
+          #   2. Each Base/Model should have its `Input` class counterpart.
+          #     This could be auto-inflected (via namespace constant lookup)
+          #     at some point.
+          #   3. Think if a service class can be used to this purpose
+          #     (i.e. decorator of DiffService).
+          module AsInput
+            class << self
+              def included(base)
+                super
+
+                base.send(:include, Model::Diffable)
+                base.extend ClassMethods
+              end
+            end
+
+            module ClassMethods
+              def as_input(hash, clientMutationId: '')
+                hash_input = Ecoportal::API::Common::GraphQL::HashHelpers.
+                  keys_to_sym_deep(hash)
+
+                hash_input.merge!(clientMutationId: clientMutationId)
+
+                Ecoportal::API::Common::GraphQL::HashHelpers.
+                  remove_nil_keys_deep(hash_input, target: :id)
+              end
+            end
+
+            # INSTANCE METHODS
+
+            def as_input(target_class: nil, clientMutationId: '')
+              return target_class.from_model(self, client_mutation_id: clientMutationId) if target_class
+
+              diff = as_update
+              return nil if diff.nil?
+
+              diff[:patchVer] = patchVer if respond_to?(:patchVer) && !patchVer.nil?
+              self.class.as_input(diff, clientMutationId: clientMutationId)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,49 +1,49 @@
-module Ecoportal::API::Common::GraphQL::Model::Diffable
-  class ClassicDiffService
-    include Ecoportal::API::Common::GraphQL::Model::Diffable::HashDiffNesting
-
-    attr_reader :subject
-
-    def initialize(subject, ignore: [])
-      msg  = 'Expecting Ecoportal::API::Common::Content::DoubleModel. '
-      msg << "Given: #{subject.class}"
-      raise ArgumentError, msg unless subject.is_a?(Ecoportal::API::Common::Content::DoubleModel)
-
-      @subject  = subject
-      @ignored  = to_a(ignore)
-    end
-
-    def diff(ignore: [])
-      classic_diff(ignore: ignore)
-    end
-
-    protected
-
-    def classic_diff(ignore: [])
-      change_diff(
-        curr_doc,
-        prev_doc,
-        ignore: to_a(ignored, ignore)
-      )
-    end
-
-    private
-
-    attr_reader :ignored
-
-    def curr_doc(target = subject)
-      return target.as_json if target.respond_to?(:as_json)
-      return target.doc     if target.respond_to?(:doc)
-
-      raise "Can't fetch underlying document for instance of #{target.class}."
-    end
-
-    def prev_doc(target = subject)
-      return target.original_doc if target.respond_to?(:original_doc)
-
-      raise "Can't fetch original underlying model for instance of #{target.class}."
-    rescue NoMethodError
-      nil
-    end
-  end
-end
+module Ecoportal::API::Common::GraphQL::Model::Diffable
+  class ClassicDiffService
+    include Ecoportal::API::Common::GraphQL::Model::Diffable::HashDiffNesting
+
+    attr_reader :subject
+
+    def initialize(subject, ignore: [])
+      msg  = 'Expecting Ecoportal::API::Common::Content::DoubleModel. '
+      msg << "Given: #{subject.class}"
+      raise ArgumentError, msg unless subject.is_a?(Ecoportal::API::Common::Content::DoubleModel)
+
+      @subject  = subject
+      @ignored  = to_a(ignore)
+    end
+
+    def diff(ignore: [])
+      classic_diff(ignore: ignore)
+    end
+
+    protected
+
+    def classic_diff(ignore: [])
+      change_diff(
+        curr_doc,
+        prev_doc,
+        ignore: to_a(ignored, ignore)
+      )
+    end
+
+    private
+
+    attr_reader :ignored
+
+    def curr_doc(target = subject)
+      return target.as_json if target.respond_to?(:as_json)
+      return target.doc     if target.respond_to?(:doc)
+
+      raise "Can't fetch underlying document for instance of #{target.class}."
+    end
+
+    def prev_doc(target = subject)
+      return target.original_doc if target.respond_to?(:original_doc)
+
+      raise "Can't fetch original underlying model for instance of #{target.class}."
+    rescue NoMethodError
+      nil
+    end
+  end
+end