rudash 2.17.3 → 2.17.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 901382a43a76e1447d05328d3a20c5099a65483fc06aaff4d2eb310c5035f46f
-  data.tar.gz: f1ec1dc4cb692cc3f8124070a3cebb28f53cc4bc973eefd3b97e5d754d886696
+  metadata.gz: 3d799e40ff80455b2ed477fc110aa72a0cac0ebf1f3523e0bcb9faebabff0e93
+  data.tar.gz: 7e3d4c6be34feb99a7791bce6482a685d9b9944f4b59b0d21f6c8af9ba376d54
 SHA512:
-  metadata.gz: 30410e5bedcf726cddcb00480288d74e9ed3ee7b91216c82cdc31ab8cf686c8f86e41592401d2150b4fc211e1f17d482e7209d29c2ea6e3fb5d30b41de90efd3
-  data.tar.gz: 606b1f87af1a9064ff240dd75e01ede1244706efcf5f19124109c7ea249f488c543a09e4bf5a54b877f9484c570e02070ae16562b824fa045f8bdd6621d1655e
+  metadata.gz: 2b58b76b34470accda8d425d539d1a90414df30fd58bd2f226b152ea73afa92cbd2116eb010b1434d7026a7f57c98f7155e9bfff98ae5046ae1d7e8854751cc7
+  data.tar.gz: b4eb8d6c1577c3ed0243066f16434e35d111aa74c00abbfb22a15ef1a1611dcb587f82f1fca571dfb3581406fc24184017c51aeb7e19d96abf33ea73bc1a00df

data/lib/rudash/at.rb

@@ -1,10 +1,10 @@
 module Rudash
   module At
     def at(object, paths)
-      get_mapper = -> (path) {
+      get_mapper = ->(path) {
         self.get(object, path)
       }
-      
+
       self.map(paths, get_mapper)
     end
   end

data/lib/rudash/compact.rb

@@ -1,7 +1,8 @@
 module Rudash
   module Compact
     def compact(array)
-      return [] if !array.is_a?(Array)
+      return [] unless array.is_a?(Array)
+
       array.compact
     end
   end

data/lib/rudash/concat.rb

@@ -2,11 +2,9 @@ module Rudash
   module Concat
     def concat(head, *values)
       head_arr = head.is_a?(Array) ? head : [head]
-      if values.size == 0
-        return head_arr
-      else
-        return head_arr + self.concat(*values)
-      end
+      return head_arr if values.size.zero?
+
+      head_arr + self.concat(*values)
     end
   end
 end

data/lib/rudash/difference.rb

@@ -1,13 +1,13 @@
 module Rudash
   module Difference
     def difference(*values)
-      diff_reducer = -> (acc, current) {
-        return [] if !acc.is_a?(Array)
-        return acc if !current.is_a?(Array)
-        
+      diff_reducer = ->(acc, current) {
+        return [] unless acc.is_a?(Array)
+        return acc unless current.is_a?(Array)
+
         acc - current
       }
-      
+
       self.reduce(values, diff_reducer)
     end
   end

data/lib/rudash/drop_right.rb

@@ -1,11 +1,11 @@
 module Rudash
   module DropRight
     def drop_right(array, *rest_args)
-      return [] if !self.is_array?(array)
-      
+      return [] unless self.is_array?(array)
+
       n = self.head(rest_args) || 1
       return array if n <= 0
-      
+
       self.take(array, self.size(array) - n)
     end
   end

data/lib/rudash/each.rb

@@ -4,7 +4,7 @@ module Rudash
       self.map(collection, *rest_args)
       collection
     end
-    
+
     def for_each(*args)
       self.each(*args)
     end

data/lib/rudash/each_right.rb

@@ -2,11 +2,11 @@ module Rudash
   module EachRight
     def each_right(collection, *rest_args)
       reversed_collection = Rudash::Utils.force_reverse(collection)
-      
+
       self.each(reversed_collection, *rest_args)
       collection
     end
-    
+
     def for_each_right(*args)
       self.each_right(*args)
     end

data/lib/rudash/filter.rb

@@ -2,22 +2,22 @@ module Rudash
   module Filter
     def filter(collection, *rest_args)
       predicate_fn = self.head(rest_args) || self.method(:identity)
-      
+
       if predicate_fn.is_a?(Hash)
-        slice_matcher = Rudash::SubsetDeepMatch.subset_deep_match?.(predicate_fn)
-        return self.filter(collection, slice_matcher) 
+        slice_matcher = Rudash::SubsetDeepMatch.subset_deep_match?.call(predicate_fn)
+        return self.filter(collection, slice_matcher)
       end
-      
-      return [] if !Rudash::Utils.is_function?(predicate_fn)
-      
+
+      return [] unless Rudash::Utils.is_function?(predicate_fn)
+
       if collection.is_a?(Array)
-        return collection.select.with_index { |x, idx|
+        return collection.select.with_index do |x, idx|
           Rudash::DynamicArgsCount.call(predicate_fn, x, idx)
-        }
+        end
       elsif collection.is_a?(Hash)
-        return collection.select { |k, v|
+        return collection.select do |k, v|
           Rudash::DynamicArgsCount.call(predicate_fn, v, k)
-        }.values
+        end.values
       else
         return []
       end

data/lib/rudash/find.rb

@@ -3,7 +3,7 @@ module Rudash
     def find(collection, *rest_args)
       iteratee_fn = self.head(rest_args)
       filtered_arr = self.filter(collection, iteratee_fn)
-      
+
       filtered_arr[0]
     end
   end

data/lib/rudash/find_last.rb

@@ -3,7 +3,7 @@ module Rudash
     def find_last(collection, *rest_args)
       iteratee_fn = self.head(rest_args)
       filtered_arr = self.filter(collection, iteratee_fn)
-      
+
       filtered_arr[filtered_arr.length - 1]
     end
   end

data/lib/rudash/flip.rb

@@ -1,11 +1,11 @@
 module Rudash
   module Flip
     def flip(a_proc)
-      raise 'Expected a Proc/Method' if !Rudash::Utils.is_function?(a_proc)
-      
-      flipped_proc = -> (*args) {
+      raise 'Expected a Proc/Method' unless Rudash::Utils.is_function?(a_proc)
+
+      ->(*args) {
         reveresed_args = args.reverse
-        
+
         a_proc.(*reveresed_args)
       }
     end

data/lib/rudash/flow.rb

@@ -2,12 +2,12 @@ module Rudash
   module Flow
     def flow(*funs)
       flatten_funs = funs.flatten
-      
-      flow_proc = -> (*args) {
-        self.reduce(flatten_funs, -> (acc, fn) {
+
+      ->(*args) {
+        self.reduce(flatten_funs, ->(acc, fn) {
           Rudash::DynamicArgsCount.call(fn, *self.concat(acc))
-          }, args)
-        }
-      end
+        }, args)
+      }
     end
   end
+end

data/lib/rudash/flow_right.rb

@@ -2,7 +2,7 @@ module Rudash
   module FlowRight
     def flow_right(*funs)
       flatten_funs = funs.flatten.reverse
-      
+
       self.flow(flatten_funs)
     end
   end

data/lib/rudash/get.rb

@@ -1,14 +1,14 @@
 module Rudash
   module Get
-    def get(hash, path, *rest_args)
+    def get(hash, path, *_rest_args)
       return nil if !path.is_a?(String) && !path.is_a?(Array)
       return nil if !hash.is_a?(Array) && !hash.is_a?(Hash)
-      
+
       resolved_path = Rudash::PathResolver.resolve(path)
-      
-      get_reducer = -> (acc, current) {
+
+      get_reducer = ->(acc, current) {
         return nil if acc.nil?
-        
+
         if acc.is_a?(Array) && Rudash::Utils.match_number?(current)
           acc[current.to_i]
         elsif acc.is_a?(Array) && !Rudash::Utils.match_number?(current)
@@ -19,7 +19,7 @@ module Rudash
           nil
         end
       }
-      
+
       self.reduce(resolved_path, get_reducer, hash)
     end
   end

data/lib/rudash/group_by.rb

@@ -2,19 +2,19 @@ module Rudash
   module GroupBy
     def group_by(collection, *rest_args)
       iteratee = self.head(rest_args) || self.method(:identity)
-      
-      reducer = -> (acc, current) {
+
+      reducer = ->(acc, current) {
         key = Rudash::DynamicArgsCount.call(iteratee, current)
-        
+
         if acc[key]
           acc[key] << current
         else
           acc[key] = [current]
         end
-        
+
         acc
       }
-      
+
       self.reduce(collection, reducer, {})
     end
   end

data/lib/rudash/head.rb

@@ -1,10 +1,11 @@
 module Rudash
   module Head
     def head(array)
-      return nil if !array.is_a?(Array)
+      return nil unless array.is_a?(Array)
+
       array.first
     end
-    
+
     def first(*args)
       self.head(*args)
     end

data/lib/rudash/identity.rb

@@ -1,6 +1,6 @@
 module Rudash
   module Identity
-    def identity(first_arg, *rest_args)
+    def identity(first_arg, *_rest_args)
       first_arg
     end
   end

data/lib/rudash/initial.rb

@@ -1,8 +1,9 @@
 module Rudash
   module Initial
     def initial(array)
-      return [] if !array.is_a?(Array)
-      *initial, last = array
+      return [] unless array.is_a?(Array)
+
+      *initial, _last = array
       initial
     end
   end

data/lib/rudash/intersection.rb

@@ -1,12 +1,12 @@
 module Rudash
   module Intersection
     def intersection(*values)
-      
-      intersection_reducer = -> (acc, current) {
+      intersection_reducer = ->(acc, current) {
         return [] if !current.is_a?(Array) || !acc.is_a?(Array)
+
         acc & current
       }
-      
+
       self.reduce(values, intersection_reducer, values[0])
     end
   end

data/lib/rudash/join.rb

@@ -1,9 +1,9 @@
 module Rudash
   module Join
     def join(array, separator = ',')
-      return '' if !array.is_a?(Array)
-      stringified_separator = separator.is_a?(String) ? separator : separator.to_s
-      array.join(stringified_separator)
+      return '' unless array.is_a?(Array)
+
+      array.join(separator.to_s)
     end
   end
 end

data/lib/rudash/keys.rb

@@ -3,9 +3,9 @@ module Rudash
     def keys(value)
       case value
       when Hash
-        value.map { |key, value| "#{key}" }
+        value.map { |key, _value| key.to_s }
       when Array
-        value.map.with_index { |value, index| "#{index}" }
+        value.map.with_index { |_value, index| index.to_s }
       else
         []
       end

data/lib/rudash/last.rb

@@ -1,7 +1,8 @@
 module Rudash
   module Last
     def last(array)
-      return nil if !array.is_a?(Array)
+      return nil unless array.is_a?(Array)
+
       array.last
     end
   end

data/lib/rudash/map.rb

@@ -3,17 +3,17 @@ module Rudash
     def map(collection, *rest_args)
       iteratee_fn = self.head(rest_args) || self.method(:identity)
       col = collection.is_a?(String) ? collection.split('') : collection
-      
-      return self.map(collection, -> () { nil }) if !Rudash::Utils.is_function?(iteratee_fn)
-      
+
+      return self.map(collection, ->() { nil }) unless Rudash::Utils.is_function?(iteratee_fn)
+
       if col.is_a?(Array)
         return col.map.with_index { |value, index|
           Rudash::DynamicArgsCount.call(iteratee_fn, value, index)
         }
       elsif col.is_a?(Hash)
-        return col.map { |k,v|
+        return col.map do |k, v|
           Rudash::DynamicArgsCount.call(iteratee_fn, v, k)
-        }
+        end
       else
         return []
       end

data/lib/rudash/negate.rb

@@ -1,11 +1,9 @@
 module Rudash
   module Negate
     def negate(a_proc)
-      raise 'Expected a Proc/Method' if !Rudash::Utils.is_function?(a_proc)
-      
-      negate_proc = -> (*args) {
-        !a_proc.(*args)
-      }
+      raise 'Expected a Proc/Method' unless Rudash::Utils.is_function?(a_proc)
+
+      ->(*args) { !a_proc.call(*args) }
     end
   end
 end

data/lib/rudash/pick.rb

@@ -1,18 +1,16 @@
 module Rudash
   module Pick
     def pick(hash, paths)
-      return self.pick(hash, [paths]) if !paths.is_a?(Array)
-      return {} if !hash.is_a?(Hash)
-      
+      return self.pick(hash, [paths]) unless paths.is_a?(Array)
+      return {} unless hash.is_a?(Hash)
+
       picked_hash = {}
-      
-      eacher = -> (path) {
+
+      eacher = ->(path) {
         value = self.get(hash, path)
-        if !value.nil?
-          self.set(picked_hash, path, value)
-        end
+        self.set(picked_hash, path, value) unless value.nil?
       }
-      
+
       self.each(paths, eacher)
       picked_hash
     end

data/lib/rudash/range.rb

@@ -4,7 +4,7 @@ module Rudash
       start_step = 0
       step_jump = 1
       end_step = 0
-      
+
       case args.size
       when 0
         return []
@@ -16,30 +16,32 @@ module Rudash
         start_step, end_step, step_jump = args
         step_jump_configured = true
       end
-      
+
       # step_jump direction (+/-) should be defined by start/end values
       norm_step_jump = (end_step > start_step ? step_jump.abs : -step_jump.abs)
-      
+
       # illegal behaviors
-      return [] if (norm_step_jump != step_jump && step_jump_configured)
+
+      return [] if norm_step_jump != step_jump && step_jump_configured
+
       # End illegal behavior
-      
+
       iterator = start_step
       result = []
-      
+
       # calculate loop count
       boundaries = [start_step, end_step]
       max = boundaries.max
       min = boundaries.min
-      i = (norm_step_jump == 0 ? (max - min) : ((max - min).to_f / norm_step_jump)).abs
+      i = (norm_step_jump.zero? ? (max - min) : ((max - min).to_f / norm_step_jump)).abs
       # end loop calculation
-      
+
       while i > 0
         result << iterator
         iterator += norm_step_jump
-        i-=1
+        i -= 1
       end
-      
+
       result
     end
   end

data/lib/rudash/reduce.rb

@@ -4,18 +4,18 @@ module Rudash
       reducer = rest_args[0]
       initial_state = rest_args[1]
       col = collection.is_a?(String) ? collection.split('') : collection
-      
-      return self.reduce(collection, -> () { nil }) if !Rudash::Utils.is_function?(reducer)
-      
+
+      return self.reduce(collection, -> () { nil }) unless Rudash::Utils.is_function?(reducer)
+
       case rest_args.size
       when 1
-        return col.reduce { |acc, current|
+        return col.reduce do |acc, current|
           if col.is_a?(Hash)
             Rudash::DynamicArgsCount.call(reducer, acc, current[1], current[0])
           else
             Rudash::DynamicArgsCount.call(reducer, acc, current)
           end
-        }
+        end
       when 2
         return col.reduce(initial_state) { |acc, current|
           if col.is_a?(Hash)

data/lib/rudash/reject.rb

@@ -2,10 +2,10 @@ module Rudash
   module Reject
     def reject(collection, *rest_args)
       filter = self.head(rest_args) || self.method(:identity)
-      
+
       if filter.is_a?(Hash)
-        slice_matcher = Rudash::SubsetDeepMatch.subset_deep_match?.(filter)
-        return self.filter(collection, self.negate(slice_matcher)) 
+        slice_matcher = Rudash::SubsetDeepMatch.subset_deep_match?.call(filter)
+        return self.filter(collection, self.negate(slice_matcher))
       elsif Rudash::Utils.is_function?(filter)
         return self.filter(collection, self.negate(filter))
       else

data/lib/rudash/remove.rb

@@ -1,10 +1,11 @@
 module Rudash
   module Remove
     def remove(array, *rest_args)
+      return [] unless array.is_a?(Array)
+
       predicate_fn = self.head(rest_args)
-      return [] if !array.is_a?(Array)
       removed_items = self.filter(array, predicate_fn)
-      
+
       array.replace(array - removed_items)
       removed_items
     end

data/lib/rudash/set.rb

@@ -2,19 +2,19 @@ module Rudash
   module Set
     def set(object, path, value)
       return object if !object.is_a?(Hash) && !object.is_a?(Array)
-      
+
       resolved_path = Rudash::PathResolver.resolve(path)
       Rudash::NestedPathCreator.create_path_if_not_exist(object, resolved_path)
-      
+
       *initial_path, last = resolved_path
-      
+
       last_key = Rudash::Utils.match_number?(last) ? last.to_i : last.to_sym
-      
-      if initial_path.size == 0
+
+      if initial_path.size.zero?
         object[last_key] = value
         return object
       end
-      
+
       last_parent = self.get(object, initial_path)
       last_parent[last_key] = value
       object

data/lib/rudash/size.rb

@@ -2,6 +2,7 @@ module Rudash
   module Size
     def size(something)
       return 0 if self.is_nil?(something)
+
       something.size
     end
   end

data/lib/rudash/slice.rb

@@ -2,13 +2,13 @@ module Rudash
   module Slice
     def slice(array, *rest_args)
       return self.slice(array.split(''), *rest_args) if array.is_a?(String)
-      return [] if !array.is_a?(Array)
-      
+      return [] unless array.is_a?(Array)
+
       start_point = rest_args[0] || 0
       end_point = rest_args[1] || array.size
-      
-      return [] if !end_point.is_a?(Numeric)
-      
+
+      return [] unless end_point.is_a?(Numeric)
+
       array.slice(start_point, end_point - start_point) || []
     end
   end

data/lib/rudash/some.rb

@@ -2,7 +2,7 @@ module Rudash
   module Some
     def some?(array, filter)
       filtered_arr = self.filter(array, filter)
-      filtered_arr.length != 0
+      !filtered_arr.empty?
     end
   end
 end

data/lib/rudash/tail.rb

@@ -1,7 +1,8 @@
 module Rudash
   module Tail
     def tail(array)
-      return [] if !array.is_a?(Array)
+      return [] unless array.is_a?(Array)
+
       array[1..-1] || []
     end
   end

data/lib/rudash/take.rb

@@ -1,12 +1,13 @@
 module Rudash
   module Take
     def take(array, *rest_args)
-      return [] if !self.is_array?(array)
+      return [] unless self.is_array?(array)
+
       count = self.head(rest_args) || 1
-      
+
       begin
         return array.take(count)
-      rescue
+      rescue ArgumentError
         return []
       end
     end

data/lib/rudash/union.rb

@@ -1,17 +1,18 @@
 module Rudash
   module Union
     def union(*values)
-      
-      union_reducer = -> (acc, current) {
+
+      union_reducer = ->(acc, current) {
         return acc if !current.is_a?(Array) || !acc.is_a?(Array)
+
         acc | current
       }
-      
-      is_array = -> (value) { value.is_a?(Array) }
-      
+
+      is_array = ->(value) { value.is_a?(Array) }
+
       arr_values = self.filter(values, is_array)
       head = self.head(arr_values)
-      
+
       self.reduce(arr_values, union_reducer, head) || []
     end
   end

data/lib/rudash/unset.rb

@@ -2,15 +2,15 @@ module Rudash
   module Unset
     def unset(object, path)
       return object if !object.is_a?(Hash) && !object.is_a?(Array)
-      
+
       *initial_path, last = Rudash::PathResolver.resolve(path)
-      
+
       last_parent = self.get(object, initial_path)
-      
+
       case last_parent
       when Array
-        return false if !Rudash::Utils.match_number?(last)
-        
+        return false unless Rudash::Utils.match_number?(last)
+
         last_key = last.to_i
         if last_key > 0 && last_key < last_parent.length
           last_parent.delete_at(last_key)

data/lib/rudash/update.rb

@@ -2,8 +2,8 @@ module Rudash
   module Update
     def update(object, path, *rest_args)
       updater_fn = self.head(rest_args) || self.method(:identity)
-      return object if !Rudash::Utils.is_function?(updater_fn)
-      
+      return object unless Rudash::Utils.is_function?(updater_fn)
+
       current_value = self.get(object, path)
       self.set(object, path, Rudash::DynamicArgsCount.call(updater_fn, current_value))
       object

data/lib/rudash/without.rb

@@ -1,7 +1,8 @@
 module Rudash
   module Without
     def without(array, *values)
-      return [] if !array.is_a?(Array)
+      return [] unless array.is_a?(Array)
+
       self.difference(array, values)
     end
   end

data/lib/rudash.rb

@@ -62,7 +62,7 @@ require_relative './utils/nested_path_creator.rb'
 require_relative './utils/chain_wrapper.rb'
 
 # This is the exposed Gem class that contains all Rudash methods.
-# New methods can use already implemented methods in the library by refering to "self"
+# New methods can use already implemented methods by refering to "self"
 # in the method if and only if the method get extended into the R_ class.
 class R_
   extend Rudash::Map

data/lib/utils/chain_wrapper.rb

@@ -1,16 +1,14 @@
 module Rudash
   module ChainUtils
     class ChainWrapper
+      attr_reader :value
+
       def initialize(value, r_)
         @value = value
         @r_ = r_
       end
-      
-      def value
-        @value
-      end
-      
-      def method_missing(method_name, *args, &block)
+
+      def method_missing(method_name, *args, &_block)
         result = @r_.public_send(method_name, @value, *args)
         self.class.new(result, @r_)
       rescue NameError

data/lib/utils/dynamic_args_count.rb

@@ -7,13 +7,13 @@
 module Rudash
   module DynamicArgsCount
     def self.call(func, *args)
-      begin
-        return func.(*args)
-      rescue ArgumentError => e
-        raise ArgumentError.new('Argument Error') if args.size == 0
-        *initial, last = args
-        return self.call(func, *initial)
-      end
+      func.call(*args)
+
+    rescue ArgumentError
+      raise ArgumentError.new('Argument Error') if args.size.zero?
+
+      *initial, _last = args
+      self.call(func, *initial)
     end
   end
 end

data/lib/utils/index.rb

@@ -3,14 +3,15 @@
 module Rudash
   module Utils
     def self.match_number?(str)
-      return false if !str.is_a?(String)
+      return false unless str.is_a?(String)
+
       str.match(/^(\d)+$/)
     end
-    
+
     def self.is_function?(func)
       func.is_a?(Proc) || func.is_a?(Method)
     end
-    
+
     def self.force_reverse(collection)
       case collection
       when Array then collection.reverse

data/lib/utils/nested_path_creator.rb

@@ -10,22 +10,24 @@ module Rudash
     def self.create_path_if_not_exist(object, resolved_path)
       path = R_.head(resolved_path)
       return nil if !resolved_path.is_a?(Array) || R_.is_nil?(path)
-      
+
       path_key = Utils.match_number?(path) ? path.to_i : path.to_sym
       rest_paths = R_.tail(resolved_path)
       next_path = R_.head(rest_paths)
       value = R_.get(object, path)
-      
+
       if R_.is_nil?(value) || (!value.is_a?(Hash) && !value.is_a?(Array))
-        # If the next path item is numeric (index) then we want to create an array otherwise we create a hash
+        # If the next path item is numeric (index)
+        # then we want to create an array otherwise we create a hash
         if next_path && Utils.match_number?(next_path)
           object[path_key] = []
         else
           object[path_key] = {}
         end
       end
-      
-      # Do the same recursively for next path until getting to the last path item
+
+      # Do the same recursively for next path
+      # until getting to the last path item
       self.create_path_if_not_exist(
         R_.get(object, path),
         rest_paths

data/lib/utils/path_resolver.rb

@@ -9,16 +9,16 @@ module Rudash
   module PathResolver
     def self.resolve(path)
       normalized_path = path
-      
+
       if normalized_path.is_a?(Array)
-        normalized_path = normalized_path.join('.') 
+        normalized_path = normalized_path.join('.')
       end
-      
-      filter_not_empty = -> (value) {
+
+      filter_not_empty = ->(value) {
         value != ''
       }
-      
-      splitted_hash = R_.filter(
+
+      R_.filter(
         normalized_path.split(/[.\[\]]/),
         filter_not_empty
       )

data/lib/utils/subset_deep_match.rb

@@ -7,46 +7,46 @@ require_relative '../rudash'
 module Rudash
   module SubsetDeepMatch
     def self.subset_deep_match?
-      subset_matcher = -> (slice, collection) {
+      subset_matcher = ->(slice, collection) {
         match = true
-        
+
         # If was called with two arrays then the logic will be to
         # check if every "slice" items exist somehow in the collection
         # without any order consideration.
-        if (slice.is_a?(Array) && collection.is_a?(Array))
-          return R_.every?(slice, -> (sliceVal) {
-            R_.some?(collection, -> (collectionVal) {
-              self.subset_deep_match?.(sliceVal, collectionVal)
-              })
-              })
-            end
-            
-            begin
-              R_.each(collection, -> (v) {
-                R_.each(slice, -> (value, key) {
-                  if (value.is_a?(Hash) && collection[key].is_a?(Hash))
-                    match &= self.subset_deep_match?.(value, collection[key])
-                  elsif (value.is_a?(Array) && collection[key].is_a?(Array))
-                    match &= self.subset_deep_match?.(value, collection[key])
-                  elsif (value != collection[key])
-                    match = false
-                  end
-                  })
-                  
-                  # That was done for performance manners since
-                  # R_.each don't stop when returning false from the proc
-                  # so we force it to stop by throwing an exception that we catch later
-                  # It's the same hack for JavaScript forEach function.
-                  raise if match == false
-                  })
-                rescue
-                  return false
-                end
-                
-                match
-              }
-              
-              subset_matcher.curry
-            end
-          end
+        if slice.is_a?(Array) && collection.is_a?(Array)
+          return R_.every?(slice, ->(sliceVal) {
+            R_.some?(collection, ->(collectionVal) {
+              self.subset_deep_match?.call(sliceVal, collectionVal)
+            })
+          })
+        end
+
+        begin
+          R_.each(collection, ->(_v) {
+            R_.each(slice, ->(value, key) {
+              if value.is_a?(Hash) && collection[key].is_a?(Hash)
+                match &= self.subset_deep_match?.call(value, collection[key])
+              elsif value.is_a?(Array) && collection[key].is_a?(Array)
+                match &= self.subset_deep_match?.call(value, collection[key])
+              elsif value != collection[key]
+                match = false
+              end
+            })
+
+            # That was done for performance manners since
+            # R_.each don't stop when returning false from the proc
+            # so we force it to stop by throwing an exception that we catch later
+            # It's the same hack for JavaScript forEach function.
+            raise if match == false
+          })
+        rescue
+          return false
         end
+
+        match
+      }
+
+      subset_matcher.curry
+    end
+  end
+end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Rudash
-  VERSION = '2.17.3'
+  VERSION = '2.17.4'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rudash
 version: !ruby/object:Gem::Version
-  version: 2.17.3
+  version: 2.17.4
 platform: ruby
 authors:
 - Islam Attrash