ramda-ruby 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 551c4cf30d89de74593b3d778aa686c240a80daf
-  data.tar.gz: cf3ae825a6eec5dd22feecdf318cd49578b79416
+  metadata.gz: 87c6a7c3172da72254170f7d90c79f3837e8a74e
+  data.tar.gz: 0f57eed0c3497ed9da5725a72f7efa279e475473
 SHA512:
-  metadata.gz: e911adf71d38c300aa2852872b11d35c0bc03fb3f7d7700d8f1f7171b4c0ba18e150cf4189baf683a80bab43c3d497f46f403c52fbaa63609978608ab1ae6451
-  data.tar.gz: b5f58b29149340e02badd0ab0804e797550699ccb7df3c6cd1b00344906b1c3b69f95ba703ac1e1bacae02e07ed378b91d6507277d393a93b59ab007e0bc0007
+  metadata.gz: a89e53d9df3f0f65620cc5be1b85addb80b7940d2fa56b7866c5b9a3fb31125e8f928da57ea3f0a12bc46b8be55bd8fa47b5c5ec2a2030feeac904a3ed4ec1c7
+  data.tar.gz: 7645cde2e138e671dff744fda5c108284e7d4def28de3399770faf03d1cfc3e29cd023143d5cdef1e8b52f5268c27a6d85bbb5bd6f475e8e2ca84eac2d4a44b7

data/CHANGELOG.md

@@ -1,7 +1,28 @@
 Not Released
 ---------------
 
+Release 0.9.0
+---------------
+
+Added debug_mode which shows name, arguments and result of each function call.
+
+Small performance improvements.
+
+Added:
+
+* call
+* drop_while
+* evolve
+* init
+* insert_all
+* invert
+* invert_obj
+* map_obj_indexed
+* nth_arg
+
+
 Release 0.8.1
+---------------
 
 Added ability to change exceptions handler.
 Added benchmarks.

data/README.md

@@ -4,6 +4,7 @@ Ramda Ruby
 This is a ruby version of [Ramda Js](http://ramdajs.com) library.
 
 [![Gem Version](https://badge.fury.io/rb/ramda-ruby.svg)](http://badge.fury.io/rb/ramda-ruby)
+[![Functions](https://img.shields.io/badge/Functions-164-green.svg)](docs/FUNCTIONS.md)
 [![Travis badge](https://travis-ci.org/lazebny/ramda-ruby.svg?branch=master)](https://travis-ci.org/lazebny/ramda-ruby)
 [![AppVeyor status](https://ci.appveyor.com/api/projects/status/ponccdax7aj4ufw2?svg=true)](https://ci.appveyor.com/project/lazebny/ramda-ruby)
 [![Coverage Status](https://coveralls.io/repos/lazebny/ramda-ruby/badge.png)](https://coveralls.io/r/lazebny/ramda-ruby)
@@ -12,11 +13,11 @@ This is a ruby version of [Ramda Js](http://ramdajs.com) library.
 [![Dependency Status](https://gemnasium.com/lazebny/ramda-ruby.svg)](https://gemnasium.com/lazebny/ramda-ruby)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](http://opensource.org/licenses/MIT)
 
-Problems
+Information
 ------------
 
-This gem is stable but i think it isn't production ready - benchmarks
-are showing a huge performance loss comparing to the plain ruby.
+This library uses some stuff like `curry` and `__` which reduces performance.
+Please review benchmarks section.
 
 
 Installation
@@ -86,7 +87,7 @@ Placeholder:
 
 ```
 
-Change Exceptions Handler:
+Change exceptions handler:
 
 ```ruby
 
@@ -102,6 +103,30 @@ Change Exceptions Handler:
 
 ```
 
+Ramda in debug mode shows calls trace.
+Notice: trace is shown only for Ramda functions and not for regular procs.
+If you want to show a whole trace you can wrap your proc in Ramda.curry function
+(pleaes see example below).
+
+Enable debug mode:
+
+```ruby
+
+  Ramda.debug_mode = true
+
+  # Example:
+
+  Ramda.filter(Ramda.curry(->(n) { n.even? }), [1, 2, 3, 4])
+
+  # -> curry(#<Proc:0x...@/srv/app/spec/ramda/list_spec.rb:130 (lambda)>) # #<Proc:0x... (lambda)>
+  # -> curry(1) # false
+  # -> curry(2) # true
+  # -> curry(3) # false
+  # -> curry(4) # true
+  # -> filter(#<Proc:0x0055ff3fad4640 (lambda)>, 1, 2, 3, 4) # [2, 4]
+
+```
+
 
 Benchmarks
 -------------

data/ROADMAP.md

@@ -1,15 +1,3 @@
-Release 0.9.0
----------------
-* call
-* drop_while
-* evolve
-* init
-* insert_all
-* invert
-* invert_obj
-* map_obj_indexed
-* nth_arg
-
 Release 0.10.0
 ---------------
 * compose_p

data/docs/FUNCTIONS.md

@@ -19,6 +19,7 @@
 * assoc_path
 * binary
 * bind
+* call
 * chain
 * clone
 * comparator
@@ -39,10 +40,12 @@
 * dissoc
 * divide
 * drop
+* drop_while
 * empty - uses x.class.new for defining new empty object if empty method does not exist
 * eq_by
 * eq_props
 * equals
+* evolve
 * filter
 * find
 * find_index - returns nil if index doesn't exist
@@ -62,8 +65,12 @@
 * if_else
 * inc
 * index_of - returns nil if index doesn't exist
+* init
 * insert
+* insert_all
 * intersection
+* invert
+* invert_obj
 * invoker
 * is
 * is_empty
@@ -83,6 +90,7 @@
 * lt
 * lte
 * map
+* map_obj_indexed
 * match
 * max
 * max_by
@@ -96,6 +104,7 @@
 * negate
 * not
 * nth
+* nth_arg
 * of
 * omit
 * once

data/docs/RESOURCES.md

@@ -0,0 +1,2 @@
+* [Funkify and Pattern-Proc: Messing with Ruby for Fun (but probably not profit)](https://spin.atomicobject.com/2014/07/23/ruby-partial-application-first-class/)
+* [Funkify](https://github.com/banister/funkify)

data/lib/ramda.rb

@@ -1,5 +1,3 @@
-require 'forwardable'
-
 require 'ramda/version'
 require 'ramda/exception_handler'
 require 'ramda/function'
@@ -10,186 +8,78 @@ require 'ramda/object'
 require 'ramda/relation'
 require 'ramda/string'
 require 'ramda/type'
+require 'ramda/internal/java/__make_curry_proc__' if RUBY_PLATFORM == 'java'
 
 # Ramda library implementation, source: http://ramdajs.com/
-# rubocop:disable Metrics/ModuleLength
 module Ramda
-  extend SingleForwardable
-
-  def_delegators Ramda::Function,
-                 :F,
-                 :T,
-                 :__,
-                 :always,
-                 :ap,
-                 :apply,
-                 :binary,
-                 :bind,
-                 :comparator,
-                 :compose,
-                 :construct,
-                 :construct_n,
-                 :converge,
-                 :curry,
-                 :curry_n,
-                 :empty,
-                 :flip,
-                 :identity,
-                 :invoker,
-                 :juxt,
-                 :lift,
-                 :lift_n,
-                 :memoize,
-                 :n_ary,
-                 :of,
-                 :once,
-                 :pipe,
-                 :tap,
-                 :unapply,
-                 :unary,
-                 :use_with
+  extend Ramda::Function
+  extend Ramda::List
+  extend Ramda::Logic
+  extend Ramda::Math
+  extend Ramda::Object
+  extend Ramda::Relation
+  extend Ramda::String
+  extend Ramda::Type
+  extend Ramda::Internal::Java::MakeCurryProc if RUBY_PLATFORM == 'java'
 
-  def_delegators Ramda::List,
-                 :all,
-                 :any,
-                 :append,
-                 :chain,
-                 :concat,
-                 :contains,
-                 :drop,
-                 :filter,
-                 :from_pairs,
-                 :find,
-                 :find_index,
-                 :find_last,
-                 :find_last_index,
-                 :flatten,
-                 :for_each,
-                 :group_by,
-                 :head,
-                 :index_of,
-                 :insert,
-                 :join,
-                 :last,
-                 :last_index_of,
-                 :length,
-                 :slice,
-                 :sort,
-                 :map,
-                 :nth,
-                 :partition,
-                 :pluck,
-                 :prepend,
-                 :range,
-                 :reduce,
-                 :reduce_right,
-                 :reject,
-                 :remove,
-                 :repeat,
-                 :reverse,
-                 :tail,
-                 :take,
-                 :take_while,
-                 :times,
-                 :uniq,
-                 :uniq_with,
-                 :unnest,
-                 :update,
-                 :xprod,
-                 :zip,
-                 :zip_obj,
-                 :zip_with
+  # Constants are faster than module variables
+  #
+  def self.const_missing(name)
+    value = {
+      DEBUG_MODE: false
+    }[name]
 
-  def_delegators Ramda::Logic,
-                 :all_pass,
-                 :and,
-                 :any_pass,
-                 :complement,
-                 :cond,
-                 :if_else,
-                 :is_empty,
-                 :not,
-                 :or
+    value.nil? ? super : const_set(name, value)
+  end
 
-  def_delegators Ramda::Math,
-                 # :math_mod,
-                 :add,
-                 :dec,
-                 :divide,
-                 :inc,
-                 :modulo,
-                 :multiply,
-                 :negate,
-                 :product,
-                 :subtract,
-                 :sum
+  # A special placeholder value used to specify "gaps" within curried
+  # functions, allowing partial application of any combination of
+  # arguments, regardless of their positions.
+  #
+  # If g is a curried ternary function and _ is R.__, the following are equivalent:
+  #
+  # g(1, 2, 3)
+  # g(_, 2, 3)(1)
+  # g(_, _, 3)(1)(2)
+  # g(_, _, 3)(1, 2)
+  # g(_, 2, _)(1, 3)
+  # g(_, 2)(1)(3)
+  # g(_, 2)(1, 3)
+  # g(_, 2)(_, 3)(1)
+  #
+  def self.__
+    :ramda_placeholder
+  end
 
-  def_delegators Ramda::Object,
-                 # :keys_in,
-                 # :to_pairs_in,
-                 # :values_in,
-                 :assoc,
-                 :assoc_path,
-                 :clone,
-                 :dissoc,
-                 :eq_props,
-                 :has,
-                 :has_in,
-                 :keys,
-                 :lens,
-                 :lens_index,
-                 :lens_path,
-                 :lens_prop,
-                 :merge,
-                 :omit,
-                 :over,
-                 :path,
-                 :pick,
-                 :pick_all,
-                 :pick_by,
-                 :project,
-                 :prop,
-                 :prop_or,
-                 :props,
-                 :set,
-                 :to_pairs,
-                 :values,
-                 :view,
-                 :where
+  # A function that always returns false. Any passed in parameters are ignored.
+  #
+  # * -> Boolean
+  #
+  # rubocop:disable Style/MethodName
+  def self.F
+    ->(*) { false }
+  end
+  # rubocop:enable Style/MethodName
 
-  def_delegators Ramda::Relation,
-                 :count_by,
-                 :difference,
-                 :difference_with,
-                 :eq_by,
-                 :equals,
-                 :gt,
-                 :gte,
-                 :intersection,
-                 :lt,
-                 :lte,
-                 :max,
-                 :max_by,
-                 :min,
-                 :min_by,
-                 :path_eq,
-                 :prop_eq,
-                 :sort_by,
-                 :union,
-                 :union_with
+  # A function that always returns true. Any passed in parameters are ignored.
+  #
+  # * -> Boolean
+  #
+  # rubocop:disable Style/MethodName
+  def self.T
+    ->(*) { true }
+  end
+  # rubocop:enable Style/MethodName
 
-  def_delegators Ramda::String,
-                 :match,
-                 :replace,
-                 :split,
-                 :to_lower,
-                 :to_upper,
-                 :trim
+  # Takes Boolean
+  def self.debug_mode=(enabled)
+    const_set('DEBUG_MODE', enabled)
+  end
 
-  def_delegators Ramda::Type,
-                 :is,
-                 :is_nil,
-                 :type
+  # Returns Boolean/NilClass
+  def self.debug_mode
+    DEBUG_MODE
+  end
 
   def self.exception_handler=(handler)
     @exception_handler = handler
@@ -199,3 +89,5 @@ module Ramda
     @exception_handler ||= ::Ramda::ExceptionHandler.method(:with_narrow)
   end
 end
+
+# Ramda.debug_mode = true

data/lib/ramda/function.rb

@@ -7,38 +7,6 @@ module Ramda
   module Function
     extend ::Ramda::Internal::CurriedMethod
 
-    # A special placeholder value used to specify "gaps" within curried
-    # functions, allowing partial application of any combination of
-    # arguments, regardless of their positions.
-    #
-    # If g is a curried ternary function and _ is R.__, the following are equivalent:
-    #
-    # g(1, 2, 3)
-    # g(_, 2, 3)(1)
-    # g(_, _, 3)(1)(2)
-    # g(_, _, 3)(1, 2)
-    # g(_, 2, _)(1, 3)
-    # g(_, 2)(1)(3)
-    # g(_, 2)(1, 3)
-    # g(_, 2)(_, 3)(1)
-    #
-
-    # rubocop:disable Style/MethodName
-    def self.F
-      ->(*) { false }
-    end
-    # rubocop:enable Style/MethodName
-
-    # rubocop:disable Style/MethodName
-    def self.T
-      ->(*) { true }
-    end
-    # rubocop:enable Style/MethodName
-
-    def self.__
-      :ramda_placeholder
-    end
-
     # Returns a function that always returns the given value. Note that
     # for non-primitives the value returned is a reference to the original
     # value.
@@ -82,7 +50,7 @@ module Ramda
     #
     #
     curried_method(:binary) do |fn|
-      n_ary(2, fn)
+      ::Ramda.n_ary(2, fn)
     end
 
     # Creates a function that is bound to a context.
@@ -93,6 +61,10 @@ module Ramda
       fn.unbind.bind(ctx)
     end
 
+    curried_method(:call) do |fn, *xs|
+      fn.call(*xs)
+    end
+
     # Makes a comparator function out of a function that reports whether
     # the first element is less than the second.
     #
@@ -115,7 +87,7 @@ module Ramda
     #
     # Note: The result of compose is not automatically curried.
     curried_method(:compose) do |*fns|
-      pipe(*fns.reverse)
+      ::Ramda.pipe(*fns.reverse)
     end
 
     # Wraps a constructor function inside a curried function that can be called
@@ -135,8 +107,7 @@ module Ramda
     # Number -> (* -> {*}) -> (* -> {*})
     #
     curried_method(:construct_n) do |arity, constructor|
-      Ramda::Internal::FunctionWithArity
-        .new
+      ::Ramda::Internal::FunctionWithArity
         .call(arity, &constructor.method(:new))
         .curry
     end
@@ -242,7 +213,7 @@ module Ramda
     # Number -> String -> (a -> b -> ... -> n -> Object -> *)
     #
     curried_method(:invoker) do |arity, method_name|
-      Ramda::Internal::FunctionWithArity.new.call(arity + 1) do |*args, object|
+      ::Ramda::Internal::FunctionWithArity.call(arity + 1) do |*args, object|
         object.public_send(method_name, *args)
       end.curry
     end
@@ -263,7 +234,7 @@ module Ramda
     # https://stackoverflow.com/questions/36558598/cant-wrap-my-head-around-lift-in-ramda-js
     curried_method(:lift) do |fn, a, *xs|
       # ([a] + xs).reduce([curry(fn)], &ap)
-      lift_n(fn.arity, fn, a, *xs)
+      ::Ramda.lift_n(fn.arity, fn, a, *xs)
     end
 
     # "lifts" a function to be the specified arity, so that it may
@@ -273,7 +244,7 @@ module Ramda
     # Number -> (*... -> *) -> ([*]... -> [*])
     #
     curried_method(:lift_n) do |arity, fn, a, *xs|
-      ([a] + xs).reduce([curry_n(arity, fn)], &ap)
+      ([a] + xs).reduce([::Ramda.curry_n(arity, fn)], &::Ramda.ap)
     end
 
     # Creates a new function that, when invoked, caches the result of calling
@@ -287,7 +258,7 @@ module Ramda
     curried_method(:memoize) do |fn|
       memo = {}
 
-      Ramda::Internal::FunctionWithArity.new.call(fn.arity) do |*args|
+      ::Ramda::Internal::FunctionWithArity.call(fn.arity) do |*args|
         memo[args] = fn.call(*args) unless memo.key?(args)
         memo[args]
       end.curry
@@ -300,11 +271,19 @@ module Ramda
     # Number -> (* -> a) -> (* -> a)
     #
     curried_method(:n_ary) do |arity, fn|
-      Ramda::Internal::FunctionWithArity.new.call(arity) do |*args|
+      ::Ramda::Internal::FunctionWithArity.call(arity) do |*args|
         fn.call(*(args.first(arity) + Array.new(fn.arity - arity, nil)))
       end.curry
     end
 
+    # Returns a function which returns its nth argument.
+    #
+    # Number -> *... -> *
+    #
+    curried_method(:nth_arg) do |index, x, *xs|
+      ([x] + xs)[index]
+    end
+
     # Returns a singleton array containing the value provided.
     #
     # a -> [a]
@@ -323,7 +302,7 @@ module Ramda
     curried_method(:once) do |fn|
       memo = {}
 
-      Ramda::Internal::FunctionWithArity.new.call(fn.arity) do |*args|
+      ::Ramda::Internal::FunctionWithArity.call(fn.arity) do |*args|
         memo[:result] = fn.call(*args) unless memo.key?(:result)
         memo[:result]
       end.curry
@@ -372,7 +351,7 @@ module Ramda
     # (* -> b) -> (a -> b)
     #
     curried_method(:unary) do |fn|
-      n_ary(1, fn)
+      ::Ramda.n_ary(1, fn)
     end
 
     # Accepts a function fn and a list of transformer functions and returns
@@ -383,7 +362,7 @@ module Ramda
     # (x1 -> x2 -> ... -> z) -> [(a -> b -> ... -> x1), ...] -> (a -> b -> ... -> z)
     #
     curried_method(:use_with) do |fn, fns|
-      Ramda::Internal::FunctionWithArity.new.call(fns.count) do |*args|
+      ::Ramda::Internal::FunctionWithArity.call(fns.count) do |*args|
         modified_args = args.each_with_index.map do |arg, index|
           fns[index].call(arg)
         end