rudash 2.17.1 → 2.17.2

data/lib/rudash/unset.rb

@@ -1,34 +1,34 @@
 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)
-
-              last_key = last.to_i
-              if last_key > 0 && last_key < last_parent.length
-                last_parent.delete_at(last_key)
-                true
-              else
-                false
-              end
-            when Hash
-              last_key = Rudash::Utils.match_number?(last) ? last.to_i : last.to_sym
-              if last_parent.key?(last_key)
-                last_parent.delete(last_key)
-                true
-              else
-                false
-              end
-            else
-              false
-            end
+  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)
+        
+        last_key = last.to_i
+        if last_key > 0 && last_key < last_parent.length
+          last_parent.delete_at(last_key)
+          true
+        else
+          false
         end
+      when Hash
+        last_key = Rudash::Utils.match_number?(last) ? last.to_i : last.to_sym
+        if last_parent.key?(last_key)
+          last_parent.delete(last_key)
+          true
+        else
+          false
+        end
+      else
+        false
+      end
     end
+  end
 end

data/lib/rudash/update.rb

@@ -1,12 +1,12 @@
 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)
-
-            current_value = self.get(object, path)
-            self.set(object, path, Rudash::DynamicArgsCount.call(updater_fn, current_value))
-            object
-        end
+  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)
+      
+      current_value = self.get(object, path)
+      self.set(object, path, Rudash::DynamicArgsCount.call(updater_fn, current_value))
+      object
     end
+  end
 end

data/lib/rudash/without.rb

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

data/lib/rudash.rb

@@ -65,58 +65,58 @@ require_relative './utils/chain_wrapper.rb'
 # New methods can use already implemented methods in the library by refering to "self"
 # in the method if and only if the method get extended into the R_ class.
 class R_
-    extend Rudash::Map
-    extend Rudash::IsNil
-    extend Rudash::Filter
-    extend Rudash::Some
-    extend Rudash::Every
-    extend Rudash::Find
-    extend Rudash::Concat
-    extend Rudash::FindLast
-    extend Rudash::Reduce
-    extend Rudash::ReduceRight
-    extend Rudash::Compact
-    extend Rudash::Head
-    extend Rudash::Last
-    extend Rudash::Tail
-    extend Rudash::Size
-    extend Rudash::Flip
-    extend Rudash::Identity
-    extend Rudash::Get
-    extend Rudash::IsArray
-    extend Rudash::IsEqual
-    extend Rudash::IsHash
-    extend Rudash::IsEmpty
-    extend Rudash::Reverse
-    extend Rudash::Curry
-    extend Rudash::IsNumber
-    extend Rudash::Keys
-    extend Rudash::Each
-    extend Rudash::Uniq
-    extend Rudash::Difference
-    extend Rudash::IsString
-    extend Rudash::Eq
-    extend Rudash::EachRight
-    extend Rudash::At
-    extend Rudash::Negate
-    extend Rudash::Capitalize
-    extend Rudash::Without
-    extend Rudash::Intersection
-    extend Rudash::Join
-    extend Rudash::Initial
-    extend Rudash::Set
-    extend Rudash::Pick
-    extend Rudash::Update
-    extend Rudash::Slice
-    extend Rudash::Remove
-    extend Rudash::Union
-    extend Rudash::Reject
-    extend Rudash::Range
-    extend Rudash::GroupBy
-    extend Rudash::Take
-    extend Rudash::DropRight
-    extend Rudash::Chain
-    extend Rudash::Flow
-    extend Rudash::FlowRight
-    extend Rudash::Unset
+  extend Rudash::Map
+  extend Rudash::IsNil
+  extend Rudash::Filter
+  extend Rudash::Some
+  extend Rudash::Every
+  extend Rudash::Find
+  extend Rudash::Concat
+  extend Rudash::FindLast
+  extend Rudash::Reduce
+  extend Rudash::ReduceRight
+  extend Rudash::Compact
+  extend Rudash::Head
+  extend Rudash::Last
+  extend Rudash::Tail
+  extend Rudash::Size
+  extend Rudash::Flip
+  extend Rudash::Identity
+  extend Rudash::Get
+  extend Rudash::IsArray
+  extend Rudash::IsEqual
+  extend Rudash::IsHash
+  extend Rudash::IsEmpty
+  extend Rudash::Reverse
+  extend Rudash::Curry
+  extend Rudash::IsNumber
+  extend Rudash::Keys
+  extend Rudash::Each
+  extend Rudash::Uniq
+  extend Rudash::Difference
+  extend Rudash::IsString
+  extend Rudash::Eq
+  extend Rudash::EachRight
+  extend Rudash::At
+  extend Rudash::Negate
+  extend Rudash::Capitalize
+  extend Rudash::Without
+  extend Rudash::Intersection
+  extend Rudash::Join
+  extend Rudash::Initial
+  extend Rudash::Set
+  extend Rudash::Pick
+  extend Rudash::Update
+  extend Rudash::Slice
+  extend Rudash::Remove
+  extend Rudash::Union
+  extend Rudash::Reject
+  extend Rudash::Range
+  extend Rudash::GroupBy
+  extend Rudash::Take
+  extend Rudash::DropRight
+  extend Rudash::Chain
+  extend Rudash::Flow
+  extend Rudash::FlowRight
+  extend Rudash::Unset
 end

data/lib/utils/chain_wrapper.rb

@@ -1,21 +1,21 @@
 module Rudash
-    module ChainUtils
-        class ChainWrapper
-            def initialize(value, r_)
-                @value = value
-                @r_ = r_
-            end
-
-            def value
-                @value
-            end
-
-            def method_missing(method_name, *args, &block)
-                    result = @r_.public_send(method_name, @value, *args)
-                    self.class.new(result, @r_)
-            rescue NameError
-                raise NameError.new("\"#{method_name}\" doesn't exist in Rudash")
-            end
-        end
+  module ChainUtils
+    class ChainWrapper
+      def initialize(value, r_)
+        @value = value
+        @r_ = r_
+      end
+      
+      def value
+        @value
+      end
+      
+      def method_missing(method_name, *args, &block)
+        result = @r_.public_send(method_name, @value, *args)
+        self.class.new(result, @r_)
+      rescue NameError
+        raise NameError.new("\"#{method_name}\" doesn't exist in Rudash")
+      end
     end
+  end
 end

data/lib/utils/dynamic_args_count.rb

@@ -5,15 +5,15 @@
 # to the developer defined Proc and if it's failed because of ArgumentError we call it recursively with less argument until success.
 
 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
-        end
+  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
     end
+  end
 end

data/lib/utils/index.rb

@@ -1,23 +1,23 @@
 # This module will contain tiny general utilities
 
 module Rudash
-    module Utils
-        def self.match_number?(str)
-            return false if !str.is_a?(String)
-            str.match(/^(\d)+$/)
-        end
-
-        def self.is_function?(func)
-            func.is_a?(Proc) || func.is_a?(Method)
-        end
+  module Utils
+    def self.match_number?(str)
+      return false if !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
-                when Hash then collection.reverse_each.to_h
-                when String then collection.reverse
-                else []
-            end
-        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

@@ -6,30 +6,30 @@ require_relative './index.rb'
 # path ['a', 'b', 'c', 'd'] as embedded hashes. If we have some string that matches a number then we create an array.
 
 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 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
-            self.create_path_if_not_exist(
-                R_.get(object, path),
-                rest_paths
-            )
+  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 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
+      self.create_path_if_not_exist(
+        R_.get(object, path),
+        rest_paths
+      )
     end
+  end
 end

data/lib/utils/path_resolver.rb

@@ -6,22 +6,22 @@ require_relative '../rudash'
 # to the array shape in order to make the logic related only to one data structure.
 
 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
+  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
+  end
 end

data/lib/utils/subset_deep_match.rb

@@ -5,48 +5,48 @@ require_relative '../rudash'
 # See test_filter_hashes_by_deep_hash (test/filter.rb)
 
 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
-                        })
-    
-                        # 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
-                    })
+  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
+                  })
+                  
+                  # 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
+                  return false
                 end
-    
+                
                 match
-            }
-    
-            subset_matcher.curry
+              }
+              
+              subset_matcher.curry
+            end
+          end
         end
-    end
-end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Rudash
-    VERSION = '2.17.1'
+  VERSION = '2.17.2'
 end

metadata

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