rudash 2.9.1 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82271921675a8d420c4e1dd198c0e07f6438a323040ac28f6cb07042e776ad3c
-  data.tar.gz: 66901b07176af3319fce0a930752d03e1d761652cccc47a7f1d7be300af45676
+  metadata.gz: 9093255b12cd834ff23fa463f4c7f2c4b0916a589c973c680cd4488149c9e6db
+  data.tar.gz: 268185d416326b2e38ff02bb895e09625277a2a06c012b5af0938450886bf190
 SHA512:
-  metadata.gz: 4087dbb48f61d30663fe2f25b18866bd2b1dcd8c1878692243330fe0cdcf6708dabdddd7ab07d892f221d7084d51d78f68076a92e5450d8ba98ae7067e477050
-  data.tar.gz: d8c6597e919c2e3d9a5e3e148adbc5a2b1bcbef14cac0113f5a391e05a545d1dbd188f0b15176ee4ead8acd42e084ca03964bf3983b283925ec96b4601ac91ea
+  metadata.gz: 8d5f5e26667dccc7712a9127de99eb7a5a2fef6dc345e3e91972b3708c976b5e89f426f0766df0de4fd4ca1e94d4c4aa184e09b6610d588cdd724d3ea3caa6b3
+  data.tar.gz: be2ffa703e19ffabf205a959e622b4db8bf457fbc9a35f7630cab5eb0af8179fd3b733c7e08e062886aff775dec77e08e81191da8fc58d7a84039beac7f503e5

data/lib/rudash/capitalize.rb

@@ -1,12 +1,7 @@
 module Rudash
     module Capitalize
         def capitalize(value)
-            case value
-                when String
-                    value.capitalize
-                else
-                    value.to_s
-            end
+            value.is_a?(String) ? value.capitalize : value.to_s
         end
     end
 end

data/lib/rudash/curry.rb

@@ -1,12 +1,7 @@
 module Rudash
     module Curry
         def curry(a_proc)
-            case a_proc
-                when Proc
-                    a_proc.curry
-                else
-                    raise 'Expected a Proc'
-            end
+            a_proc.is_a?(Proc) ? a_proc.curry : (raise 'Expected a Proc')
         end
     end
 end

data/lib/rudash/filter.rb

@@ -1,38 +1,27 @@
 require_relative '../utils/index.rb'
 require_relative '../utils/subset_deep_match.rb'
+require_relative '../utils/dynamic_args_count.rb'
 
 module Rudash
     module Filter
         def filter(collection, *rest_args)
-            filter = self.head(rest_args) || self.method(:identity)
+            predicate_fn = self.head(rest_args) || self.method(:identity)
     
-            if filter.is_a?(Hash)
-                slice_matcher = Rudash::SubsetDeepMatch.subset_deep_match?.(filter)
+            if predicate_fn.is_a?(Hash)
+                slice_matcher = Rudash::SubsetDeepMatch.subset_deep_match?.(predicate_fn)
                 return self.filter(collection, slice_matcher) 
             end
 
-            return [] if !Rudash::Utils.is_function?(filter)
+            return [] if !Rudash::Utils.is_function?(predicate_fn)
     
             if collection.is_a?(Array)
-                begin
-                    return collection.select.with_index { |x, idx| filter.(x, idx) }
-                rescue ArgumentError => e
-                    begin
-                        return collection.select { |x| filter.(x) }
-                    rescue ArgumentError => e
-                        return collection.select { filter.() }
-                    end
-                end
+                return collection.select.with_index { |x, idx|
+                    Rudash::DynamicArgsCount.call(predicate_fn, x, idx)
+                }
             elsif collection.is_a?(Hash)
-                begin
-                    return collection.select { |k, v| filter.(v, k) }.values
-                rescue ArgumentError => e
-                    begin
-                        return collection.select { |k, v| filter.(v) }.values
-                    rescue ArgumentError => e
-                        return collection.select { filter.() }.values
-                    end
-                end
+                return collection.select { |k, v|
+                    Rudash::DynamicArgsCount.call(predicate_fn, v, k)
+                }.values
             else
                 return []
             end

data/lib/rudash/find.rb

@@ -1,8 +1,8 @@
 module Rudash
     module Find
         def find(collection, *rest_args)
-            filter_proc = self.head(rest_args) || self.method(:identity)
-            filtered_arr = self.filter(collection, filter_proc)
+            iteratee_fn = self.head(rest_args)
+            filtered_arr = self.filter(collection, iteratee_fn)
             
             filtered_arr[0]
         end

data/lib/rudash/find_last.rb

@@ -1,8 +1,8 @@
 module Rudash
     module FindLast
         def find_last(collection, *rest_args)
-            filter_proc = self.head(rest_args) || self.method(:identity)
-            filtered_arr = self.filter(collection, filter_proc)
+            iteratee_fn = self.head(rest_args)
+            filtered_arr = self.filter(collection, iteratee_fn)
             
             filtered_arr[filtered_arr.length - 1]
         end

data/lib/rudash/is_string.rb

@@ -1,12 +1,7 @@
 module Rudash
     module IsString
         def is_string?(object)
-            case object
-                when String
-                    true
-                else
-                    false
-            end
+            object.is_a?(String)
         end
     end
 end

data/lib/rudash/map.rb

@@ -1,33 +1,22 @@
 require_relative '../utils/index.rb'
+require_relative '../utils/dynamic_args_count.rb'
 
 module Rudash
     module Map
         def map(collection, *rest_args)
-            mapper_proc = self.head(rest_args) || self.method(:identity)
+            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?(mapper_proc)
+            return self.map(collection, -> () { nil }) if !Rudash::Utils.is_function?(iteratee_fn)
     
             if col.is_a?(Array)
-                begin
-                    return col.map.with_index { |value, index| mapper_proc.(value, index) }
-                rescue ArgumentError => e
-                    begin
-                        return col.map { |value| mapper_proc.(value) }
-                    rescue ArgumentError => e
-                        return col.map { mapper_proc.() }
-                    end
-                end
+                return col.map.with_index { |value, index|
+                    Rudash::DynamicArgsCount.call(iteratee_fn, value, index)
+                }
             elsif col.is_a?(Hash)
-                begin
-                    return col.map { |k,v| mapper_proc.(v, k) }
-                rescue ArgumentError => e
-                    begin
-                        return col.map { |k,v| mapper_proc.(v) }
-                    rescue ArgumentError => e
-                        return col.map { mapper_proc.() }
-                    end
-                end
+                return col.map { |k,v|
+                    Rudash::DynamicArgsCount.call(iteratee_fn, v, k)
+                }
             else
                 return []
             end

data/lib/rudash/range.rb

@@ -0,0 +1,46 @@
+module Rudash
+    module Range
+        def range(*args)
+            start_step = 0
+            step_jump = 1
+            end_step = 0
+
+            case args.size
+                when 0
+                    return []
+                when 1
+                    end_step = args[0]
+                when 2
+                    start_step, end_step = args
+                else
+                    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)
+            # 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
+            # end loop calculation
+
+            while i > 0
+                result << iterator
+                iterator += norm_step_jump
+                i-=1
+            end
+
+            result
+        end
+    end
+end

data/lib/rudash/reduce.rb

@@ -1,4 +1,5 @@
 require_relative '../utils/index.rb'
+require_relative '../utils/dynamic_args_count.rb'
 
 module Rudash
     module Reduce
@@ -7,31 +8,23 @@ module Rudash
             initial_state = rest_args[1]
             col = collection.is_a?(String) ? collection.split('') : collection
 
-            return self.reduce(collection, -> (acc, current) { nil }) if !Rudash::Utils.is_function?(reducer)
+            return self.reduce(collection, -> () { nil }) if !Rudash::Utils.is_function?(reducer)
     
             case rest_args.size
                 when 1
                     return col.reduce { |acc, current|
                         if col.is_a?(Hash)
-                            begin
-                                reducer.(acc, current[1], current[0])
-                            rescue ArgumentError => e
-                                reducer.(acc, current[1])
-                            end
+                            Rudash::DynamicArgsCount.call(reducer, acc, current[1], current[0])
                         else
-                            reducer.(acc, current)
+                            Rudash::DynamicArgsCount.call(reducer, acc, current)
                         end
                     }
                 when 2
                     return col.reduce(initial_state) { |acc, current|
                         if col.is_a?(Hash)
-                            begin
-                                reducer.(acc, current[1], current[0])
-                            rescue ArgumentError => e
-                                reducer.(acc, current[1])
-                            end
+                            Rudash::DynamicArgsCount.call(reducer, acc, current[1], current[0])
                         else
-                            reducer.(acc, current)
+                            Rudash::DynamicArgsCount.call(reducer, acc, current)
                         end
                     }
                 else

data/lib/rudash/remove.rb

@@ -1,9 +1,9 @@
 module Rudash
     module Remove
         def remove(array, *rest_args)
-            predicate = self.head(rest_args) || self.method(:identity)
+            predicate_fn = self.head(rest_args)
             return [] if !array.is_a?(Array)
-            removed_items = self.filter(array, predicate)
+            removed_items = self.filter(array, predicate_fn)
     
             array.replace(array - removed_items)
             removed_items

data/lib/rudash/update.rb

@@ -1,13 +1,14 @@
 require_relative '../utils/index.rb'
+require_relative '../utils/dynamic_args_count.rb'
 
 module Rudash
     module Update
         def update(object, path, *rest_args)
-            updater = self.head(rest_args) || self.method(:identity)
-            return object if !Rudash::Utils.is_function?(updater)
+            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, updater.(current_value))
+            self.set(object, path, Rudash::DynamicArgsCount.call(updater_fn, current_value))
             object
         end
     end

data/lib/rudash.rb

@@ -44,6 +44,7 @@ require_relative './rudash/slice.rb'
 require_relative './rudash/remove.rb'
 require_relative './rudash/union.rb'
 require_relative './rudash/reject.rb'
+require_relative './rudash/range.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"
@@ -95,4 +96,5 @@ class R_
     extend Rudash::Remove
     extend Rudash::Union
     extend Rudash::Reject
+    extend Rudash::Range
 end

data/lib/utils/dynamic_args_count.rb

@@ -0,0 +1,19 @@
+# This module was written in order to give the predicate functions for R_.filter, R_.map, R_.each, etc..
+# to be called with any dynamic arguments as it can. What differante JavaScript from Ruby is that once you configured a function
+# with a specific set of arguments then you must call it with that set or else you will get an exception.
+# That is so useful for predicate functions that developer define out of the library scope. We send all the arguments
+# 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 'Argument Error' if args.size == 0
+                *initial, last = args
+                return self.call(func, *initial)
+            end
+        end
+    end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rudash
 version: !ruby/object:Gem::Version
-  version: 2.9.1
+  version: 2.10.0
 platform: ruby
 authors:
 - Islam Attrash
@@ -49,6 +49,7 @@ files:
 - lib/rudash/map.rb
 - lib/rudash/negate.rb
 - lib/rudash/pick.rb
+- lib/rudash/range.rb
 - lib/rudash/reduce.rb
 - lib/rudash/reduce_right.rb
 - lib/rudash/reject.rb
@@ -63,6 +64,7 @@ files:
 - lib/rudash/uniq.rb
 - lib/rudash/update.rb
 - lib/rudash/without.rb
+- lib/utils/dynamic_args_count.rb
 - lib/utils/index.rb
 - lib/utils/nested_path_creator.rb
 - lib/utils/path_resolver.rb