rudash 2.8.0 → 2.8.1

data/lib/utils/index.rb

@@ -1,15 +1,17 @@
-module Utils
-    def self.match_number?(str)
-        return false if !str.is_a?(String)
-        str.match(/^(\d)+$/)
-    end
-
-    def self.force_reverse(collection)
-        case collection
-            when Array then collection.reverse
-            when Hash then collection.reverse_each.to_h
-            when String then collection.reverse
-            else []
+module Rudash
+    module Utils
+        def self.match_number?(str)
+            return false if !str.is_a?(String)
+            str.match(/^(\d)+$/)
+        end
+    
+        def self.force_reverse(collection)
+            case collection
+                when Array then collection.reverse
+                when Hash then collection.reverse_each.to_h
+                when String then collection.reverse
+                else []
+            end
         end
     end
 end

data/lib/utils/nested_path_creator.rb

@@ -1,27 +1,29 @@
 require_relative '../rudash'
 require_relative './index.rb'
 
-module NestedPathCreator
-    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 next_path && Utils.match_number?(next_path)
-                object[path_key] = []
-            else
-                object[path_key] = {}
+module Rudash
+    module NestedPathCreator
+        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 next_path && Utils.match_number?(next_path)
+                    object[path_key] = []
+                else
+                    object[path_key] = {}
+                end
             end
+    
+            self.create_path_if_not_exist(
+                R_.get(object, path),
+                rest_paths
+            )
         end
-
-        self.create_path_if_not_exist(
-            R_.get(object, path),
-            rest_paths
-        )
     end
 end

data/lib/utils/path_resolver.rb

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

data/lib/utils/subset_deep_match.rb

@@ -4,47 +4,49 @@ require_relative '../rudash'
 # in order to give filter, some?, every? and find the ability to deep match with complex hash queries.
 # See test_filter_hashes_by_deep_hash (test/filter.rb)
 
-module SubsetDeepMatch
-    def self.subset_deep_match?
-        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)
+module Rudash
+    module SubsetDeepMatch
+        def self.subset_deep_match?
+            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
+                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
                     })
-
-                    # 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
+                rescue
+                    return false
+                end
+    
+                match
+            }
+    
+            subset_matcher.curry
+        end
     end
 end

metadata

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