jay_api 27.1.0

data/lib/jay_api/elasticsearch/tasks.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module JayAPI
+  module Elasticsearch
+    # Represents Elasticsearch tasks. Returns information about the tasks
+    # currently executing in the cluster.
+    # TODO: Add #all [JAY-593]
+    class Tasks
+      attr_reader :client
+
+      # @param [JayAPI::Elasticsearch::Client] client The Elasticsearch Client
+      #   object
+      def initialize(client:)
+        @client = client
+      end
+
+      # Retrieves info about the task with the passed +task_id+
+      # For more information on how to build the query please refer to the
+      # Elasticsearch DSL documentation:
+      # https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
+      # https://www.elastic.co/guide/en/elasticsearch/reference/current/tasks.html#tasks-api-query-params
+      # @param [String] task_id The ID of the task whose info is needed
+      # @return [Hash] A Hash that details the results of the operation defined
+      #   by +task_id+
+      # @example Returned Hash can be found in this method's unit tests
+      # @raise [Elasticsearch::Transport::Transport::ServerError] If the
+      #   query fails.
+      def by_id(task_id)
+        client.task_by_id(task_id: task_id, wait_for_completion: true).deep_symbolize_keys
+      end
+    end
+  end
+end

data/lib/jay_api/elasticsearch/time.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JayAPI
+  module Elasticsearch
+    module Time
+      # Time format accepted by elasticsearch
+      TIME_FORMAT = '%Y/%m/%d %H:%M:%S'
+
+      # Transforms a Time object to a time format that is recognized by
+      # elasticsearch
+      # @param [Time] time The time to convert
+      # @return [String] The time converter to a string, parseable by ES
+      def format_time(time)
+        time.getutc.strftime(TIME_FORMAT)
+      end
+    end
+  end
+end

data/lib/jay_api/errors/configuration_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+
+module JayAPI
+  module Errors
+    # An error to be raised when there is an issue with the configuration of
+    # one of Jay's modules.
+    class ConfigurationError < JayAPI::Errors::Error
+      attr_reader :source_string
+
+      # Creates a new instance of the class.
+      # @param [String] message The error message
+      # @param [String] source_string The string from which the configuration
+      #   was loaded.
+      def initialize(message, source_string = nil)
+        @source_string = source_string
+        super(message)
+      end
+    end
+  end
+end

data/lib/jay_api/errors/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module JayAPI
+  module Errors
+    # Error class for all the errors raised by the gem
+    class Error < StandardError; end
+  end
+end

data/lib/jay_api/git/errors/invalid_repository_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JayAPI
+  module Git
+    module Errors
+      # An error to be raised when an attempt is made to perform an action on a
+      # repository that is not yet initialized.
+      class InvalidRepositoryError < StandardError; end
+    end
+  end
+end

data/lib/jay_api/git/errors/missing_url_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../../errors/error'
+
+module JayAPI
+  module Git
+    module Errors
+      # An error to be raised when an attempt is made to execute a Git operation
+      # which requires a URL without providing one.
+      class MissingURLError < JayAPI::Errors::Error; end
+    end
+  end
+end

data/lib/jay_api/git/gerrit/gitiles_helper.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module JayAPI
+  module Git
+    module Gerrit
+      # Offers a set of utility methods to work with Gerrit's Gitiles URLs.
+      module GitilesHelper
+        GITILES_PATH = '/plugins/gitiles/'
+        GITILES_REFSPEC = '/+/%<refspec>s/'
+
+        # Returns a Gitiles URL for the given parameters
+        # @param [String] repository The URL of the git repository.
+        # @param [String] refspec The name of a branch or the SHA1 of a particular
+        #   commit.
+        # @param [String] path The path to the source file.
+        # @param [Integer, String] line_number The line number
+        # @return [String] The corresponding Gitiles URL.
+        def gitiles_url(repository:, refspec:, path:, line_number: nil)
+          # NOTE: Here File.join is being used because it takes care of cases in
+          # which both strings have slash (/) at their tips and removes the double
+          # slash, for example:
+          #
+          #   ['https://example.com/', '/path/to/file'].join('/') => https://example.com///path/to/file
+          #   File.join('https://example.com/', '/path/to/file') => https://example.com/path/to/file
+          #
+          # Do not use URL.join because it interprets a slash at the beginning
+          # of the second string as a reference to the URL's root:
+          #
+          #   URI.join('https://www.example.com/hello/world', '/again') => https://www.example.com/again
+
+          @gitiles_urls ||= {}
+          base_url = @gitiles_urls[repository] ||= translate_gerrit_url(repository)
+
+          File.join(
+            base_url,
+            format(GITILES_REFSPEC, refspec: refspec),
+            [path, line_number].compact.join('#') # If there is no line number the # will not appear in the URL
+          )
+        end
+
+        # Translates a Gerrit repository URL into a Gerrit Gitiles URL for that
+        # repository, for example:
+        #
+        # ssh://jenkins@gerrit.local:29418/tools/elite becomes
+        #   https://gerrit.local/plugins/gitiles/tools/elite
+        # @param [String] url Gerrit's repository URL
+        # @return [String] The corresponding Gitiles URL
+        def translate_gerrit_url(url)
+          uri = URI.parse(url)
+          path = uri.path.sub(%r{^/a/}, '/') # Removes the /a/ at the beginning of HTTP/S repository URLs
+          URI::HTTPS.build(host: uri.host, path: File.join(GITILES_PATH, path)).to_s
+        end
+      end
+    end
+  end
+end

data/lib/jay_api/git/repository.rb

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+require 'git'
+require 'logging'
+require 'pathname'
+require 'uri'
+
+require_relative 'errors/invalid_repository_error'
+require_relative 'errors/missing_url_error'
+
+module JayAPI
+  module Git
+    # :reek:MissingSafeMethod safe method `update` is defined as alias of clone
+
+    # Represents a Git repository. Offers a set of methods to lazy clone a
+    # repository and update it when necessary. As well as a set of methods to
+    # work with the repository's branches and files.
+    class Repository
+      attr_reader :url, :clone_location, :clone_path
+
+      # Creates a new instance of the class.
+      # @param [String, nil] url The URL of the git repository. This parameter
+      #   can be +nil+ *ONLY* for repositories that already exist.
+      # @param [String] clone_location The path to the location where the
+      #   repository should be cloned. (A new folder with the Repository's name
+      #   will be created INSIDE the given directory).
+      # @param [String] clone_path The path to the directory where the
+      #   repository should be cloned. (The repository will be cloned DIRECTLY
+      #   in this directory).
+      # @param [Logging::Logger] logger The logger for the class (as well as for
+      #   the Git client).
+      def initialize(url:, clone_location: nil, clone_path: nil, logger: nil)
+        raise ArgumentError, 'Either clone_location or clone_path must be given' unless clone_location || clone_path
+        raise ArgumentError, 'Either clone_path or url must be given' unless url || clone_path
+
+        @url = url
+        @logger = logger || Logging.logger[self]
+        @clone_path = Pathname.new(clone_path || File.join(clone_location, name))
+        @clone_path = Pathname.pwd.join(@clone_path) unless @clone_path.absolute?
+        @clone_location = @clone_path.dirname
+      end
+
+      # @return [Boolean] True if the repository directory exists on the disk,
+      #   false otherwise
+      def exist?
+        clone_path.exist?
+      end
+
+      # @return [Boolean] True if the repository directory directory exists and
+      #   is a valid git repository, false otherwise.
+      def valid?
+        exist? && clone_path.directory? && git_dir.exist? && git_dir.directory?
+      end
+
+      # Clones the repository or updates it, if it already exists.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If no repository URL was
+      #   provided.
+      def clone
+        valid? ? update! : clone!
+      end
+
+      alias update clone
+
+      # Clones the repository. If the repository already exists the directory is
+      # completely removed and the repository cloned again.
+      # @raise [Git::GitExecuteError] If the repository cannot be cloned.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If no repository URL was
+      #   provided.
+      def clone!
+        clone_path.rmtree if exist?
+        clone_location.mkpath
+        clone_repo
+        self
+      end
+
+      # Updates the repository (without checking if it already exists or cloning
+      # it beforehand).
+      # @raise [ArgumentError] If the repository path doesn't exist.
+      # @raise [Git::GitExecuteError] If the repository path exists but it does
+      #   not contain a valid git repository.
+      def update!
+        open_repo
+        repository.fetch(remote = repository.remotes.first.name)
+        repository.pull(remote, repository.current_branch)
+        self
+      end
+
+      # Checks out the specified commit. If the Repository is not yet initialized, then
+      #   it will be opened or cloned depending on whether the repository exists.
+      # @param [String] commit The SHA1 representing the commit.
+      def checkout(commit)
+        open_or_clone
+        checkout!(commit)
+      end
+
+      # Checks out the specified commit.
+      # @param [String] commit The SHA1 representing the commit.
+      def checkout!(commit)
+        raise JayAPI::Git::Errors::InvalidRepositoryError unless repository
+
+        repository.checkout commit
+      end
+
+      # @return [String] The name of the directory in which the repository
+      # was/will be cloned.
+      def name
+        @name ||= url ? directory_from_url : File.basename(clone_path)
+      end
+
+      # Returns the Git object that correspond to the given reference (normally
+      # a Git::Object::Commit). If the Repository is not yet initialized then,
+      # if the repository exists it will be open if not it will be cloned.
+      # @param [String] objectish The reference to the object whose information
+      #   should be retrieved. Normally this would be a SHA1 for a specific
+      #   commit but it could also be a branch, a tag or any other valid git
+      #   reference.
+      # @raise [ArgumentError] If the Repository cannot be opened.
+      # @raise [Git::GitExecuteError] If the repository cannot be cloned, or the
+      #   given reference doesn't exist or is not a valid git object reference.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If the repository doesn't
+      #   exist yet and no repository URL was provided for the cloning.
+      def object(objectish)
+        open_or_clone
+        object!(objectish)
+      end
+
+      # Returns the Git object that correspond to the given reference (normally
+      # a Git::Object::Commit).
+      # @param [String] objectish The reference to the object whose information
+      #   should be retrieved. Normally this would be a SHA1 for a specific
+      #   commit but it could also be a branch, a tag or any other valid git
+      #   reference.
+      # @raise [JayAPI::Git::Errors::InvalidRepositoryError] If the repository
+      #   is not a valid repository (it hasn't been initialized: cloned or
+      #   open).
+      # @raise [Git::GitExecuteError] If the given reference doesn't exist or is
+      #   not a valid git object reference.
+      def object!(objectish)
+        raise JayAPI::Git::Errors::InvalidRepositoryError unless repository
+
+        repository.object(objectish)
+      end
+
+      # Returns a Git::Branches object with the collection of branches in the
+      # repository.
+      # @return [Git::Branches] The collection of branches in the repository.
+      # @raise [ArgumentError] If the Repository cannot be opened.
+      # @raise [Git::GitExecuteError] If the repository cannot be cloned.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If the repository doesn't
+      #   exist yet and no repository URL was provided for the cloning.
+      def branches
+        open_or_clone
+        branches!
+      end
+
+      # Returns a Git::Branches object with the collection of branches in the
+      # repository.
+      # @return [Git::Branches] The collection of branches in the repository.
+      # @raise [JayAPI::Git::Errors::InvalidRepositoryError] If the repository
+      #   is not a valid repository (it hasn't been initialized: cloned or
+      #   open).
+      def branches!
+        raise JayAPI::Git::Errors::InvalidRepositoryError unless repository
+
+        repository.branches
+      end
+
+      # Returns an +Array+ of objects representing the Remote Repositories
+      # linked to the repository. The array may be empty but normally it
+      # contains at least one element (origin).
+      # @return [Array<Git::Remote>] The collection of remote repositories
+      #   linked to the repository.
+      # @raise [ArgumentError] If the Repository cannot be opened.
+      # @raise [Git::GitExecuteError] If the repository cannot be cloned.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If the repository doesn't
+      #   exist yet and no repository URL was provided for the cloning.
+      def remotes
+        open_or_clone
+        remotes!
+      end
+
+      # Returns an +Array+ of objects representing the Remote Repositories
+      # linked to the repository. The array may be empty but normally it
+      # contains at least one element (origin).
+      # @return [Array<Git::Remote>] The collection of remote repositories
+      #   linked to the repository.
+      # @raise [JayAPI::Git::Errors::InvalidRepositoryError] If the repository
+      #   is not a valid repository (it hasn't been initialized: cloned or
+      #   open).
+      def remotes!
+        raise JayAPI::Git::Errors::InvalidRepositoryError unless repository
+
+        repository.remotes
+      end
+
+      # @return [String, nil] The URL of the remote repository.
+      def remote_url
+        @remote_url ||= remotes.first&.url
+      end
+
+      # Returns a Git::Log object: The collection of commits in the current
+      # branch or under the specified reference (if given).
+      # @param [String] objectish A git reference. Normally this would be a
+      #   branch's name but it could also be a tag, the SHA1 for a specific
+      #   commit or any other valid git reference.
+      # @param [Integer] count The maximum number of commits to return in the
+      #   collection, if omitted all the commits will be returned.
+      # @return [Git::Log] A Git::Log object with the collection of commits.
+      # @raise [ArgumentError] If the Repository cannot be opened.
+      # @raise [Git::GitExecuteError] If the repository cannot be cloned.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If the repository doesn't
+      #   exist yet and no repository URL was provided for the cloning.
+      def log(objectish: nil, count: nil)
+        open_or_clone
+        log!(objectish: objectish, count: count)
+      end
+
+      # Returns a Git::Log object: The collection of commits in the current
+      # branch or under the specified reference (if given).
+      # @param [String] objectish A git reference. Normally this would be a
+      #   branch's name but it could also be a tag, the SHA1 for a specific
+      #   commit or any other valid git reference.
+      # @param [Integer] count The maximum number of commits to return in the
+      #   collection, if omitted all the commits will be returned.
+      # @return [Git::Log] A Git::Log object with the collection of commits.
+      # @raise [JayAPI::Git::Errors::InvalidRepositoryError] If the repository
+      #   is not a valid repository (it hasn't been initialized: cloned or
+      #   open).
+      def log!(objectish: nil, count: nil)
+        raise JayAPI::Git::Errors::InvalidRepositoryError unless repository
+
+        objectish ? repository.gblob(objectish).log(count) : repository.log(count)
+      end
+
+      # Adds a new worktree to the repository.
+      # @param [String] path The path where the worktree should be created.
+      # @param [String] branch The branch that should be checked out in the
+      #   working tree. If no branch is provided the current HEAD will be
+      #   checked out in a new branch.
+      # @return [Git::Worktree] The object representing the newly created
+      #   worktree.
+      # @raise [ArgumentError] If the Repository cannot be opened.
+      # @raise [Git::GitExecuteError] If the repository cannot be cloned or if
+      #   the worktree cannot be created.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If the repository doesn't
+      #   exist yet and no repository URL was provided for the cloning.
+      def add_worktree(path:, branch: nil)
+        open_or_clone
+        add_worktree!(path: path, branch: branch)
+      end
+
+      # Adds a new worktree to the repository.
+      # @param [String] path The path where the worktree should be created.
+      # @param [String] branch The branch that should be checked out in the
+      #   working tree. If no branch is provided the current HEAD will be
+      #   checked out in a new branch.
+      # @return [Git::Worktree] The object representing the newly created
+      #   worktree.
+      # @raise [JayAPI::Git::Errors::InvalidRepositoryError] If the repository
+      #   is not a valid repository (it hasn't been initialized: cloned or
+      #   open).
+      # @raise [Git::GitExecuteError] If the worktree cannot be created.
+      def add_worktree!(path:, branch: nil)
+        raise JayAPI::Git::Errors::InvalidRepositoryError unless repository
+
+        repository.worktree(path, branch).add
+        repository.worktree(path)
+      end
+
+      # Returns the collection of worktrees linked to the repository.
+      # @return [Git::Worktrees] The collection of worktrees linked to the
+      #   repository.
+      # @raise [ArgumentError] If the Repository cannot be opened.
+      # @raise [Git::GitExecuteError] If the repository cannot be cloned.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If the repository doesn't
+      #   exist yet and no repository URL was provided for the cloning.
+      def worktrees
+        open_or_clone
+        worktrees!
+      end
+
+      # Returns the collection of worktrees linked to the repository.
+      # @return [Git::Worktrees] The collection of worktrees linked to the
+      #   repository.
+      # @raise [JayAPI::Git::Errors::InvalidRepositoryError] If the repository
+      #   is not a valid repository (it hasn't been initialized: cloned or
+      #   open).
+      def worktrees!
+        raise JayAPI::Git::Errors::InvalidRepositoryError unless repository
+
+        repository.worktrees
+      end
+
+      # Opens the repository if it is valid or clones it if it isn't
+      # @return [JayAPI::Git::Repository] Self.
+      # @raise [ArgumentError] If the Repository doesn't exist.
+      # @raise [Git::GitExecuteError] If the repository cannot be cloned.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If the repository doesn't
+      #   exist yet and no repository URL was provided for the cloning.
+      def open_or_clone!
+        open_or_clone
+        self
+      end
+
+      private
+
+      attr_reader :repository, :logger
+
+      # Opens the repository if it is valid or clones it if it isn't
+      # @raise [ArgumentError] If the Repository doesn't exist.
+      # @raise [Git::GitExecuteError] If the repository cannot be cloned.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If the repository doesn't
+      #   exist yet and no repository URL was provided for the cloning.
+      def open_or_clone
+        return if repository
+
+        valid? ? open_repo : clone!
+      end
+
+      # Opens the repository and returns the Git::Base object
+      # @return [Git::Base] The Git::Base object representing the repository.
+      # @raise [ArgumentError] If the Repository doesn't exist.
+      def open_repo
+        @repository = ::Git.open(clone_path.to_s, log: logger)
+      end
+
+      # Clones the repository and returns the Git::Base object
+      # @return [Git::Base] The Git::Base object representing the repository.
+      # @raise [Git::GitExecuteError] If the repository cannot be cloned.
+      # @raise [JayAPI::Git::Errors::MissingURLError] If no repository URL was
+      #   provided.
+      def clone_repo
+        raise JayAPI::Git::Errors::MissingURLError, 'A repository URL is required to perform this operation' unless url
+
+        # name needs to be passed as an empty string, otherwise the Git gem will
+        # add it again at the end of the path, and we want the repository to be
+        # cloned exactly in the path that we have designated.
+        @repository = ::Git.clone(url, '', path: clone_path.to_s, log: logger)
+      end
+
+      def git_dir
+        @git_dir ||= clone_path.join('.git')
+      end
+
+      # Derives a directory name from the Repository URL, for example:
+      #
+      #   git://git.local/tools/jay/jay_api.git -> jay_api
+      #
+      # @return [String] A directory name
+      def directory_from_url
+        path = URI.parse(url).path
+        File.basename(path).sub('.git', '')
+      end
+    end
+  end
+end

data/lib/jay_api/id_builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/string'
+require 'digest'
+require 'securerandom'
+
+module JayAPI
+  # Provides methods to calculate special identifiers for Test Case for Jay.
+  class IDBuilder
+    attr_reader :test_case_id, :project, :software_version, :result
+
+    def initialize(test_case_id: nil, project: nil, software_version: nil, result: nil)
+      @test_case_id = test_case_id
+      @project = project
+      @software_version = software_version
+      @result = result
+    end
+
+    # @return [String] The Sort ID for the Test Case (composed from the
+    #   Project's name and a clean version of the full Test Case Identifier)
+    # noinspection RubyNilAnalysis
+    def short_id
+      unless test_case_id && project
+        raise ArgumentError,
+              "The Test Case ID (test_case_id) and the Project's name " \
+              '(project) are required to calculate the Short ID'
+      end
+
+      clean_id = test_case_id.downcase.gsub(/[^a-z0-9-]/, '')
+      "#{project.underscore}_#{Digest::SHA1.new.update(clean_id).hexdigest[0...12]}"
+    end
+
+    # @return [Array] An array with two elements:
+    #  - The secure Seed (A Version 4 UUID)
+    #  - The secure Hash composed by concatenating the Software Version, the
+    #    secure Seed and the result of the Test Case.
+    #  This Secure ID is meant for end-to-end verification of the test results.
+    def secure_id
+      unless software_version && result
+        raise ArgumentError,
+              'The Software Version (software_version) and the Result ' \
+              '(result) are required to calculate the Secure ID'
+      end
+
+      [
+        uuid = SecureRandom.uuid,
+        Digest::MD5.hexdigest("#{software_version}:#{uuid}:#{result}")
+      ]
+    end
+  end
+end

data/lib/jay_api/mergeables/merge_selector/configuration.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'merger'
+require_relative '../../configuration'
+
+module JayAPI
+  module Mergeables
+    module MergeSelector
+      # A child class of Configuration, that contains the functionality that
+      # allows the Configuration objects 'merge' with each other.
+      class Configuration < JayAPI::Configuration
+        public_class_method :from_hash
+
+        # @param [JayAPI::Configuration, Hash] other The element with which the
+        #   'self' object will be 'merged'.
+        # @return [JayAPI::Mergeables::MergeSelector::Configuration] The result of the 'merge' between 'self'
+        #   and 'other'.
+        def merge_select(other)
+          self.class.from_hash(
+            Merger.new(
+              with_indifferent_access,
+              other.with_indifferent_access
+            ).to_h
+          )
+        end
+      end
+    end
+  end
+end

data/lib/jay_api/mergeables/merge_selector/merger.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module JayAPI
+  module Mergeables
+    module MergeSelector
+      # This class is responsible for merging two hashes together into a new one.
+      # The merge behaviour here differs from the standard Hash merging, and can be
+      # summarized with the following rules:
+      # (Let A be a 'mergee' Hash and B a 'merger' Hash. This would be equivalent to
+      # A.merge(B))
+      # * All nodes in Hash B will completely overwrite nodes in Hash A.
+      # * All nodes in Hash A that are not found in Hash B will be ignored in the result.
+      # * If a node value is 'nil' in Hash B and the node matches a node in Hash A then
+      #   the matching node in Hash A will be 'selected' to be in the result.
+      # @see documentation/unit tests for details and examples.
+      class Merger
+        attr_reader :mergee, :merger
+
+        # @param [HashWithIndifferentAccess] merger
+        # @param [HashWithIndifferentAccess] mergee
+        def initialize(mergee, merger)
+          @merger = merger
+          @mergee = mergee
+        end
+
+        # @return [HashWithIndifferentAccess] The merged result.
+        def to_h
+          {}.with_indifferent_access.tap { |hash| deep_merge(merger, hash) }
+        end
+
+        private
+
+        # Recursively merges 'merger' and 'mergee' into the 'new_hash'.
+        # @param [HashWithIndifferentAccess] merger The Hash 'B' in class documentation.
+        # @param [HashWithIndifferentAccess] new_hash The placeholder Hash that is being
+        #   constructed and will be eventually returned as part of the merge result.
+        # @param [Array<String>] path A succession of keys leading to some value of the
+        #   mergee hash (to be used in #dig).
+        # This method smells like :reek:FeatureEnvy
+        def deep_merge(merger, new_hash, *path)
+          merger.each do |key, value|
+            case value
+            when NilClass
+              new_hash[key] = mergee.dig(*path, key)
+            when Hash
+              deep_merge(value, new_hash[key] = {}.with_indifferent_access, *path, key)
+            else
+              new_hash[key] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end