is-deep 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 411c8b523f176b63dfbbf1ead02fd233d797a2e2ef7e647c2ced7a2d990ddcea
+  data.tar.gz: d1b89698808ec204702acbc174e6f9c564b9e09a5688f98921a5200f1c939b99
+SHA512:
+  metadata.gz: 205257ce4619b3762c9035af0477a37658a890d8d0eb2c501b00cd3235ec556c0f0ca75810208437bf545a1a00d67183938db8153b0a42be06ddc40a78827ccc
+  data.tar.gz: 8146ed7638cf40cb3f07902bc17d1b6bb21e8317c5c49857d4d68c9250e8c4bd3e3519ba26c25eb45c6a9a226b47828e7ebc1714d7a9308da752496afaaa45a8

data/LICENSE

@@ -0,0 +1,166 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+

data/README.md

@@ -0,0 +1,181 @@
+# is-deep
+
+[![GitHub License](https://img.shields.io/github/license/inat-get/is-deep)](LICENSE)
+[![Gem Version](https://badge.fury.io/rb/is-deep.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/is-deep)
+[![Ruby](https://github.com/inat-get/is-deep/actions/workflows/ruby.yml/badge.svg)](https://github.com/inat-get/is-deep/actions/workflows/ruby.yml) 
+![Coverage](coverage-badge.svg)
+
+Deep merge implementation for Ruby with configurable array strategies and circular reference protection.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'is-deep'
+```
+
+Or install directly:
+
+```bash
+gem install is-deep
+```
+
+## Usage
+
+### Basic Deep Merge
+
+```ruby
+require 'is-deep'
+
+# Hash merging
+base = { a: 1, nested: { x: 1, y: 2 } }
+other = { b: 2, nested: { y: 3, z: 4 } }
+
+base.deep_merge(other)
+# => { a: 1, b: 2, nested: { x: 1, y: 3, z: 4 } }
+
+# Non-destructive (returns new hash)
+result = base.deep_merge(other)
+base # unchanged
+
+# Destructive (modifies receiver)
+base.deep_merge!(other)
+```
+
+### Array Merge Strategies
+
+By default, arrays are concatenated:
+
+```ruby
+{ items: [1, 2] }.deep_merge({ items: [3, 4] })
+# => { items: [1, 2, 3, 4] }
+```
+
+Configure globally:
+
+```ruby
+# Replace arrays entirely
+IS::Deep.array_strategy = IS::Deep::ArrayStrategies::REPLACE
+{ items: [1] }.deep_merge({ items: [2] }) # => { items: [2] }
+
+# Union (remove duplicates)
+IS::Deep.array_strategy = IS::Deep::ArrayStrategies::UNION
+{ items: [1, 2] }.deep_merge({ items: [2, 3] }) # => { items: [1, 2, 3] }
+```
+
+Or per-call:
+
+```ruby
+{ items: [1] }.deep_merge({ items: [2] }, array_strategy: IS::Deep::ArrayStrategies::REPLACE)
+```
+
+### Key-Based Array Merging
+
+For arrays of hashes, merge by matching keys:
+
+```ruby
+base = {
+  services: [
+    { name: 'web', port: 80, env: { DEBUG: '0' } },
+    { name: 'db', port: 5432 }
+  ]
+}
+
+other = {
+  services: [
+    { name: 'web', port: 8080, env: { DEBUG: '1', API_KEY: 'secret' } },
+    { name: 'cache', port: 6379 }
+  ]
+}
+
+strategy = IS::Deep::ArrayStrategies::KeyBased.new(:name)
+base.deep_merge(other, array_strategy: strategy)
+
+# Result:
+# {
+#   services: [
+#     { name: 'web', port: 8080, env: { DEBUG: '1', API_KEY: 'secret' } },
+#     { name: 'db', port: 5432 },
+#     { name: 'cache', port: 6379 }
+#   ]
+# }
+```
+
+Auto-detect key from common candidates (`:id`, `:name`, `:key`, `:env`, `:host`):
+
+```ruby
+strategy = IS::Deep::ArrayStrategies::KeyBased.new
+# or use predefined
+strategy = IS::Deep::ArrayStrategies::KEY_BASED[:id]
+```
+
+### Deep Duplication
+
+Create independent copies with circular reference protection:
+
+```ruby
+original = { a: { b: 1 } }
+copy = original.deep_dup
+
+copy[:a][:b] = 2
+original[:a][:b] # => 1 (unchanged)
+
+# Circular references are handled safely
+circular = { name: 'root' }
+circular[:self] = circular
+
+copy = circular.deep_dup
+copy[:self] # => points to copy itself, not original
+```
+
+### Thread Safety
+
+Global strategy is thread-local by default:
+
+```ruby
+IS::Deep.array_strategy = IS::Deep::ArrayStrategies::REPLACE
+
+Thread.new do
+  # This thread has its own setting
+  IS::Deep.array_strategy = IS::Deep::ArrayStrategies::CONCAT
+end.join
+
+# Main thread still has REPLACE
+```
+
+### Custom Strategies
+
+Implement any callable (lambda or class with `#call`):
+
+```ruby
+# Lambda
+IS::Deep.array_strategy = ->(base, other) { other.reverse + base }
+
+# Class
+class AppendUnique
+  def call(base, other)
+    (base + other).uniq
+  end
+end
+
+IS::Deep.array_strategy = AppendUnique.new
+```
+
+## API Reference
+
+See [YARD documentation](https://rubydoc.info/gems/is-deep) for complete API.
+
+Key classes:
+- `IS::Deep` — configuration and core module
+- `IS::Deep::ArrayStrategies` — built-in strategies
+- `Hash#deep_merge`, `Hash#deep_merge!`, `Hash#deep_dup`
+- `Array#deep_merge`, `Array#deep_merge!`, `Array#deep_dup`
+
+## Requirements
+
+- Ruby >= 3.4
+
+## License
+
+LGPL-3.0-only. See LICENSE file.

data/coverage-badge.svg

@@ -0,0 +1,6 @@
+<?xml version="1.0"?><svg xmlns="http://www.w3.org/2000/svg" width="100" height="20">
+<rect width="100" height="20" fill="#555"/>
+<rect x="63" width="37" height="20" fill="green"/>
+<text x="8" y="14" fill="#fff" font-family="Verdana" font-size="11">coverage</text>
+<text x="66" y="14" fill="#fff" font-family="Verdana" font-size="11">94%</text>
+</svg>

data/lib/is-deep/core.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module IS; end
+
+# Deep merge functionality for Ruby collections.
+#
+# This module provides deep merge, deep duplication, and configurable
+# array merge strategies for Hash and Array classes.
+#
+# @example Basic usage
+#   { a: 1 }.deep_merge({ b: 2 }) # => { a: 1, b: 2 }
+#   { x: [1] }.deep_merge({ x: [2] }) # => { x: [1, 2] } (with concat strategy)
+#
+# @example Custom array strategy
+#   IS::Deep.array_strategy = IS::Deep::ArrayStrategies::REPLACE
+#   { x: [1] }.deep_merge({ x: [2] }) # => { x: [2] }
+#
+module IS::Deep
+
+  class << self
+
+    # @!attribute [rw] array_strategy
+    # The current array merge strategy.
+    #
+    # The strategy is thread-local. If not set for current thread,
+    # falls back to global default.
+    #
+    # @return [#call] Callable object accepting (base, other) arguments
+    # @see ArrayStrategies
+    def array_strategy
+      Thread.current[:is_deep_array_strategy] || @default_array_strategy
+    end
+
+    def array_strategy= strategy
+      @default_array_strategy ||= strategy
+      Thread.current[:is_deep_array_strategy] = strategy
+    end
+
+  end
+
+  # Стратегия по умолчанию — concat
+  self.array_strategy = lambda { |base, other| base + other }
+
+  # Performs deep merge on a duplicate of the receiver.
+  #
+  # Creates a deep copy of self, then merges other into it.
+  # Non-destructive operation — original receiver is not modified.
+  #
+  # @param other [Object] Object to merge into self
+  # @param array_strategy [#call, nil] Optional override for array merge strategy
+  # @return [IS::Deep] New object containing merged data
+  # @example
+  #   base = { a: { b: 1 } }
+  #   base.deep_merge({ a: { c: 2 } }) # => { a: { b: 1, c: 2 } }
+  #   base # => { a: { b: 1 } } (unchanged)
+  def deep_merge other, array_strategy: nil
+    base = if self.respond_to?(:deep_dup)
+        self.deep_dup
+      elsif self.respond_to?(:dup)
+        self.dup
+      else
+        self
+      end
+    if base.respond_to?(:deep_merge!)
+      base.deep_merge! other, array_strategy: array_strategy
+    elsif base.respond_to?(:merge)
+      base.merge other
+    elsif base.respond_to?(:merge!)
+      base.merge! other
+    else
+      raise NoMethodError, "No merge methods in receiver (#{base.class})", caller_locations
+    end
+  end
+
+  private
+
+  def visited_data
+    Thread::current[:deep_merge_visited_data] ||= { data: {}, level: 0 }
+  end
+
+  def reset_visited_data!
+    Thread::current[:deep_merge_visited_data] = nil
+  end
+
+  protected
+
+  # @private
+  def visited_wrap
+    raise ArgumentError, "Block is required", caller_locations unless block_given?
+    data = visited_data
+    data[:level] += 1
+    yield data[:data]
+  ensure
+    data[:level] -= 1
+    if data[:level] == 0
+      reset_visited_data!
+    end
+  end
+
+end

data/lib/is-deep/info.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module IS
+  module Deep; end
+end
+
+# @api private
+module IS::Deep::Info
+  NAME     = 'is-deep'
+  VERSION  = '0.8.0'
+  SUMMARY  = 'Deep merge implementation'
+  AUTHOR   = 'Ivan Shikhalev'
+  LICENSE  = 'LGPL-3.0-only'
+  HOMEPAGE = 'https://github.com/inat-get/is-deep'
+end

data/lib/is-deep/strategies.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative 'core'
+
+# Namespace for array merge strategies.
+#
+# Strategies are callable objects (lambdas or class instances with #call)
+# that determine how two arrays should be merged.
+#
+# @example Using built-in strategies
+#   IS::Deep.array_strategy = IS::Deep::ArrayStrategies::REPLACE
+#   IS::Deep.array_strategy = IS::Deep::ArrayStrategies::UNION
+#
+# @example Using KeyBased strategy
+#   strategy = IS::Deep::ArrayStrategies::KeyBased.new(:id)
+#   data.deep_merge(other, array_strategy: strategy)
+#
+module IS::Deep::ArrayStrategies
+
+  # Replace strategy: other array replaces base entirely.
+  #
+  REPLACE = lambda { |_, other| other }
+
+  # Concat strategy: append other to base (default).
+  #
+  # Preserves duplicates and order.
+  #
+  CONCAT = lambda { |base, other| base + other }
+
+  # Union strategy: combine arrays removing duplicates.
+  #
+  # Uses == for equality comparison. Order is preserved from base,
+  # then unique elements from other are appended.
+  #
+  UNION = lambda { |base, other| base | other }
+
+  # Key-based merge strategy for arrays of hashes.
+  #
+  # Matches elements by specified or auto-detected key, then deep merges
+  # matching elements. Unmatched elements are appended.
+  #
+  # @example Auto-detect key from common candidates (:id, :name, :key, :env, :host)
+  #   strategy = IS::Deep::ArrayStrategies::KeyBased.new
+  #   [{ id: 1, val: 1 }].deep_merge([{ id: 1, val: 2 }], array_strategy: strategy)
+  #   # => [{ id: 1, val: 2 }]
+  #
+  # @example Explicit key
+  #   strategy = IS::Deep::ArrayStrategies::KeyBased.new(:service_name)
+  #
+  class KeyBased
+
+    # @private
+    DEFAULT_KEY_CANDIDATES = [:id, :name, :key, :env, :host].freeze
+
+    # Initialize with optional explicit key.
+    #
+    # @param key [Symbol, String, nil] Key for matching elements.
+    #   If nil, attempts auto-detection from first element.
+    def initialize key = nil
+      @key = key
+    end
+
+    # Execute merge strategy.
+    #
+    # @param base [Array] Original array
+    # @param other [Array] Array to merge into base
+    # @return [Array] Merged result
+    # @note Falls back to CONCAT behavior if key cannot be determined
+    def call base, other
+      effective_key = @key || detect_key(base)
+
+      unless effective_key
+        # Fallback к concat если не можем определить ключ
+        return base + other
+      end
+
+      indexed = index_by_key(base, effective_key)
+      merge_indexed base.dup, other, indexed, effective_key
+    end
+
+    private
+
+    def detect_key base
+      return nil if base.empty?
+      return nil unless base.first.is_a?(Hash)
+
+      DEFAULT_KEY_CANDIDATES.find { |k| base.first.key?(k) }
+    end
+
+    def index_by_key array, key
+      indexed = {}
+      array.each do |elem|
+        next unless elem.is_a?(Hash)
+        k = elem[key]
+        indexed[k] = elem unless k.nil?
+      end
+      indexed
+    end
+
+    def merge_indexed result, other, indexed, key
+      other.each do |elem|
+        unless elem.is_a?(Hash)
+          result << elem
+          next
+        end
+
+        k = elem[key]
+        if k && indexed.key?(k) && indexed[k].respond_to?(:deep_merge)
+          idx = result.index(indexed[k])
+          result[idx] = indexed[k].deep_merge(elem)
+        else
+          result << elem
+        end
+      end
+
+      result
+    end
+  end
+
+  # Predefined KeyBased instances for common keys.
+  KEY_BASED = {
+    detect: KeyBased::new(nil),
+    id: KeyBased::new(:id),
+    name: KeyBased::new(:name),
+    key: KeyBased::new(:key),
+    host: KeyBased::new(:host),
+  }
+
+end

data/lib/is-deep.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative 'is-deep/core'
+require_relative 'is-deep/strategies'
+
+class Hash
+  include IS::Deep
+
+  # Creates deep copy of hash with all nested structures.
+  #
+  # Handles circular references correctly. Preserves default values
+  # and default_proc if present.
+  #
+  # @return [Hash] Deep copy of self
+  # @example
+  #   h = { a: { b: 1 } }
+  #   copy = h.deep_dup
+  #   copy[:a][:b] = 2
+  #   h[:a][:b] # => 1 (unchanged)
+  def deep_dup
+    visited_wrap do |visited|
+      self_id = self.object_id
+      return visited[self_id] if visited.has_key?(self_id)
+      result = {}
+      visited[self_id] = result
+      if self.default_proc != nil
+        result.default_proc = self.default_proc
+      elsif self.default != nil
+        result.default = self.default
+      end
+      self.each do |key, value|
+        id = value.object_id
+        result[key] = if visited.has_key?(id)
+          visited[id]
+        elsif value.respond_to?(:deep_dup)
+          visited[id] = value.deep_dup
+        elsif value.respond_to?(:dup)
+          visited[id] = value.dup
+        else
+          visited[id] = value
+        end
+      end
+      result
+    end
+  end
+
+  # Deep merges other hash into self, modifying receiver.
+  #
+  # Recursively merges nested hashes. For conflicting values where
+  # old value responds to #can_merge? and returns true, attempts
+  # recursive merge. Otherwise replaces with new value.
+  #
+  # @param other [Hash, #to_hash] Hash or hash-like object to merge
+  # @param array_strategy [#call, nil] Override array merge strategy
+  # @return [self] Modified receiver
+  # @example
+  #   h = { a: { b: 1 } }
+  #   h.deep_merge!({ a: { c: 2 } })
+  #   h # => { a: { b: 1, c: 2 } }
+  def deep_merge! other, array_strategy: nil
+    visited_wrap do |visited|
+      id = self.object_id
+      return self if visited.has_key?(id)
+      visited[id] = self
+      source = if other.is_a?(Hash)
+        other
+      elsif other.respond_to?(:to_hash)
+        other.to_hash
+      else
+        raise ArgumentError, "Unsupported type of source: (#{ other.class })", caller_locations
+      end
+      source.each do |key, value|
+        if self.has_key?(key)
+          old = self[key]
+          if old.respond_to?(:can_merge?) && old.can_merge?(value)
+            old.deep_merge! value, array_strategy: array_strategy
+          else
+            self[key] = value
+          end
+        else
+          self[key] = value
+        end
+      end
+      self
+    end
+  end
+
+  # Checks if other can be merged with this hash.
+  #
+  # @param other [Object] Object to check
+  # @return [Boolean] True if other is hash-like
+  def can_merge?(other)
+    other.is_a?(Hash) || other.respond_to?(:to_hash)
+  end
+
+end
+
+class Array
+  include IS::Deep
+
+  # Creates deep copy of array with all nested structures.
+  #
+  # Handles circular references correctly.
+  #
+  # @return [Array] Deep copy of self
+  def deep_dup
+    visited_wrap do |visited|
+      self_id = self.object_id
+      return visited[self_id] if visited.has_key?(self_id)
+      result = []
+      visited[self_id] = result
+      self.each do |item|
+        id = item.object_id
+        value = if visited.has_key?(id)
+            visited[id]
+          elsif item.respond_to?(:deep_dup)
+            visited[id] = item.deep_dup
+          elsif item.respond_to?(:dup)
+            visited[id] = item.dup
+          else
+            visited[id] = item
+          end
+        result << value
+      end
+      result
+    end
+  end
+
+  # Deep merges other array into self, modifying receiver.
+  #
+  # Uses configured or provided array_strategy to determine
+  # merge semantics. Strategy receives (base, other) and returns
+  # result array.
+  #
+  # @param other [Array, #to_ary] Array or array-like object to merge
+  # @param array_strategy [#call, nil] Override array merge strategy
+  # @return [self] Modified receiver
+  def deep_merge! other, array_strategy: nil
+    visited_wrap do |visited|
+      id = self.object_id
+      return self if visited.has_key?(id)
+      visited[id] = self
+      source = if other.is_a?(Array)
+          other
+        elsif other.respond_to?(:to_ary)
+          other.to_ary
+        else
+          raise ArgumentError, "Unsupported type of source: (#{other.class})", caller_locations
+        end
+
+      strategy = array_strategy || IS::Deep.array_strategy
+      result = strategy.call(self, source)
+
+      self.clear
+      result.each { |item| self << item }
+
+      self
+    end
+  end
+
+  # Checks if other can be merged with this array.
+  #
+  # @param other [Object] Object to check
+  # @return [Boolean] True if other is array-like
+  def can_merge? other
+    other.is_a?(Array) || other.respond_to?(:to_ary)
+  end
+
+end
+

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: is-deep
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Ivan Shikhalev
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- coverage-badge.svg
+- lib/is-deep.rb
+- lib/is-deep/core.rb
+- lib/is-deep/info.rb
+- lib/is-deep/strategies.rb
+homepage: https://github.com/inat-get/is-deep
+licenses:
+- LGPL-3.0-only
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Deep merge implementation
+test_files: []