ramda-ruby 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b926d96db763d6a43b3d6e114448169ebe87975
-  data.tar.gz: aa89681ca4ab9dfb72413e9f21dacbf9ed42a294
+  metadata.gz: 3be47564e590c02c9edbfe24ce475676fc9e85b3
+  data.tar.gz: e27d96aa0d83e50b482cb2ada7d09c60dbbf2152
 SHA512:
-  metadata.gz: 288ef7275478fdd4ed28044dbfafc65ab2e366d988c4e2ce212f99cb1881522c56a9d0a4f0cc233902683c66b211abd141ee8619bf8535441f3f5213eb9aa9f6
-  data.tar.gz: b85a150288793a5fa4abe9e3112b2c5f2973614933af18fba0ec272db01ffd25d500f37f6c74665d3d6da3608b54c8aebd8ba743c44a26899fd2706aa96dd314
+  metadata.gz: 610df76cc6e853a7850ff2f7ef3a886b864ad93f807fbd032353d073c7eba6e361ad6f3790c6b234ac6797bf4f87aec643ab8a908ab6058d40f8529c1662d98a
+  data.tar.gz: 726d0b3245a24232e8949218e15ad50cff16356a35a675d1b89721f31d558d35bca5048da75840b182fa156f24aa4de40625c424d792fb23690d352c8752ba47

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 Not Released
 ---------------
 
+Release 0.6.0
+
+Added:
+
+* F
+* T
+* __ - first function call should have all arguments g(___2, __)(1, 3), this means that it doesn't support g(__, 2)(1)(3), g(__, 2)(1, 3) and g(__, 2)(__, 3)(1)
+* bind
+* cond
+* prop_or
+* replace - it uses a gsub method and global replacement
+* trim
+
 Release 0.5.0
 ---------------
 
@@ -26,7 +39,8 @@ Added:
 * ap
 * chain
 * complement
-* empty - uses x.class.new for defining new empty object if empty method does not exist
+* empty - uses x.class.new for defining new empty object if empty method
+  does not exist
 * from_pairs
 * is
 * of
@@ -56,7 +70,8 @@ Added:
 * binary
 * path
 * unary
-* uniq_with - first argument is a function with 1 arity which transforms each list element and applies uniq function to results
+* uniq_with - first argument is a function with 1 arity which transforms
+  each list element and applies uniq function to results
 * (pending) keys_in
 * (pending) values_in
 

data/README.md

@@ -49,7 +49,10 @@ Ruby scpecific examples can be found in [tests](spec/ramda).
 
 ## Usage
 
+Pointless Style:
+
 ```ruby
+
   R = Ramda
 
   players = [
@@ -60,6 +63,16 @@ Ruby scpecific examples can be found in [tests](spec/ramda).
 
   best_player = R.pipe(R.sort_by(R.prop(:score)), R.reverse, R.head, R.prop(:name))
   best_player.call(players) # Ivan
+
+```
+
+Placeholder:
+
+```ruby
+
+  reset_to_default = R.merge(R.__, x: 0)
+  reset_to_default.call(x: 5, y: 2) # { x: 0, y: 2 }
+
 ```
 
 ## Development

data/ROADMAP.md

@@ -2,14 +2,6 @@
 
 * Find out suitable documentation format
 
-### release 0.6.0
-
-* __
-* bind
-* cond
-* prop_or
-* trim
-
 ### release 0.7.0
 
 * apply
@@ -18,7 +10,6 @@
 * lift
 * lift_n
 * path_eq
-* replace
 
 ### release 0.8.0
 
@@ -40,7 +31,6 @@
 * dec
 * drop_while
 * evolve
-* F
 * inc
 * init
 * insert_all
@@ -50,6 +40,5 @@
 * map_obj_indexed
 * negate
 * nth_arg
-* T
 * to_lower
 * to_upper

data/docs/FUNCTIONS.md

@@ -1,7 +1,10 @@
-* (pending) to_pairs_in
 * (pending) keys_in
 * (pending) math_mod
+* (pending) to_pairs_in
 * (pending) values_in
+* F
+* T
+* __ - first function call should have all arguments g(___2, __)(1, 3), this means that it doesn't support g(__, 2)(1)(3), g(__, 2)(1, 3) and g(__, 2)(__, 3)(1)
 * add
 * all
 * all_pass
@@ -13,12 +16,14 @@
 * append
 * assoc
 * binary
+* bind
 * chain
 * clone
 * comparator
 * complement
 * compose
 * concat
+* cond
 * construct
 * construct_n
 * contains
@@ -93,6 +98,7 @@
 * project
 * prop
 * prop_eq
+* prop_or
 * props
 * range
 * reduce
@@ -100,6 +106,7 @@
 * reject
 * remove
 * repeat
+* replace - it uses a gsub method and global replacement
 * reverse
 * slice
 * sort
@@ -115,6 +122,7 @@
 * to_lower
 * to_pairs
 * to_upper
+* trim
 * unary
 * union
 * union_with

data/lib/ramda/function.rb

@@ -7,6 +7,38 @@ 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.
@@ -16,7 +48,7 @@ module Ramda
     # a -> (* -> a)
     #
     curried_method(:always) do |value|
-      -> { value }
+      ->(*) { value }
     end
 
     # ap applies a list of functions to a list of values.
@@ -43,6 +75,14 @@ module Ramda
       n_ary(2, fn)
     end
 
+    # Creates a function that is bound to a context.
+    #
+    # (* -> *) -> {*} -> (* -> *)
+    #
+    curried_method(:bind) do |fn, ctx|
+      fn.unbind.bind(ctx)
+    end
+
     # Makes a comparator function out of a function that reports whether
     # the first element is less than the second.
     #
@@ -116,7 +156,7 @@ module Ramda
     # (* -> a) -> (* -> a)
     #
     curried_method(:curry) do |fn|
-      fn.to_proc.curry
+      curried_method_body(fn.arity, &fn)
     end
 
     # Returns a curried equivalent of the provided function, with the
@@ -145,7 +185,7 @@ module Ramda
     # Number -> (* -> a) -> (* -> a)
     #
     curried_method(:curry_n) do |arity, fn|
-      Ramda::Internal::FunctionWithArity.new.call(arity, &fn).curry
+      curried_method_body(arity, &fn)
     end
 
     # Returns the empty value of its argument's type. Ramda defines the empty

data/lib/ramda/internal/curried_method.rb

@@ -5,6 +5,40 @@ module Ramda
     # Curried Method
     module CurriedMethod
       def curried_method(name, &block)
+        define_singleton_method(name, &curried_method_body(block.arity, &block))
+      end
+
+      def curried_method_body(arity, &block)
+        Ramda::Internal::FunctionWithArity.new.call(arity) do |*args|
+          if args.include?(Ramda.__)
+            replace_placeholder(args, &block).curry
+          else
+            args.empty? ? block : yield(*args)
+          end
+        end.curry
+      end
+
+      def replace_placeholder(basic_args)
+        Ramda::Internal::FunctionWithArity.new.call(basic_args.count(Ramda.__)) do |*new_args|
+          cloned_args = basic_args.dup
+          new_args.each { |arg| cloned_args[cloned_args.index(Ramda.__)] = arg }
+          yield(*cloned_args)
+        end
+      end
+
+      def curried_method_v2(name, &block)
+        fn = Ramda::Internal::FunctionWithArity.new.call(block.arity) do |*args|
+          if args.empty?
+            block
+          else
+            yield(*args)
+          end
+        end
+
+        define_singleton_method(name, &fn.curry)
+      end
+
+      def curried_method_v1(name, &block)
         define_singleton_method(name) do |*args|
           curried = block.curry
           # curried.define_singleton_method(:origin_arity) { block.arity }
@@ -14,6 +48,34 @@ module Ramda
           curried.call(*args)
         end
       end
+
+      if RUBY_PLATFORM == 'java'
+        # This hack resolved issue:
+        #   undefined method `__make_curry_proc__' for Ramda::Math:Module
+        #
+        # Source:
+        #   https://github.com/jruby/jruby/issues/1523
+        #
+        # rubocop:disable Metrics/MethodLength
+        def __make_curry_proc__(proc, passed, arity)
+          is_lambda = proc.lambda?
+          passed.freeze
+
+          __send__((is_lambda ? :lambda : :proc)) do |*argv, &passed_proc|
+            my_passed = passed + argv
+            # original
+            # if my_passed.length < arity
+            # changed
+            if my_passed.length < arity.abs - 1
+              warn "#{caller[0]}: given block not used" unless passed_proc.nil?
+              __make_curry_proc__(proc, my_passed, arity)
+            else
+              proc.call(*my_passed)
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
     end
   end
 end

data/lib/ramda/logic.rb

@@ -31,6 +31,22 @@ module Ramda
       end.curry
     end
 
+    # Returns a function, fn, which encapsulates if/else, if/else, ...
+    # logic. R.cond takes a list of [predicate, transformer] pairs.
+    # All of the arguments to fn are applied to each of the predicates
+    # in turn until one returns a "truthy" value, at which point fn
+    # returns the result of applying its arguments to the corresponding
+    # transformer. If none of the predicates matches, fn returns nil.
+    #
+    # [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)
+    #
+    curried_method(:cond) do |xs, x, *other_x|
+      _, then_fn = xs.find do |(when_fn, _)|
+        when_fn.call(x, *other_x)
+      end
+      then_fn.call(x, *other_x) unless then_fn.nil?
+    end
+
     # Creates a function that will process either the onTrue or the onFalse
     # function depending upon the result of the condition predicate.
     #

data/lib/ramda/object.rb

@@ -133,6 +133,21 @@ module Ramda
       obj[key]
     end
 
+    # If the given, non-null object has an own property with the specified
+    # name, returns the value of that property. Otherwise returns
+    # the provided default value.
+    #
+    # a -> String -> Object -> a
+    #
+    curried_method(:prop_or) do |val, name, obj|
+      case obj
+      when Hash
+        obj[name] || val
+      else
+        obj.respond_to?(name) || val
+      end
+    end
+
     # Acts as multiple prop: array of keys in, array of values out.
     # Preserves order.
     #

data/lib/ramda/string.rb

@@ -5,6 +5,30 @@ module Ramda
   module String
     extend ::Ramda::Internal::CurriedMethod
 
+    # Tests a regular expression against a String. Note that this function will
+    # return an empty array when there are no matches. This differs from
+    # String.prototype.match which returns null when there are no matches.
+    #
+    # RegExp -> String -> [String | NilClass]
+    #
+    curried_method(:match) do |exp, x|
+      case x
+      when ::String
+        x[exp]
+        # x.scan(exp).flatten
+      else
+        type_error(x)
+      end
+    end
+
+    # Replace a substring or regex match in a string with a replacement.
+    #
+    # RegExp|String -> String -> String -> Boolean -> String
+    #
+    curried_method(:replace) do |from, to, x|
+      x.gsub(from, to)
+    end
+
     # Splits a string into an array of strings based on the given separator.
     #
     # (String | RegExp) -> String -> [String]
@@ -25,21 +49,11 @@ module Ramda
     #
     curried_method(:to_lower, &:downcase)
 
-    # Tests a regular expression against a String. Note that this function will
-    # return an empty array when there are no matches. This differs from
-    # String.prototype.match which returns null when there are no matches.
+    # Removes (strips) whitespace from both ends of the string.
     #
-    # RegExp -> String -> [String | NilClass]
+    # String -> String
     #
-    curried_method(:match) do |exp, x|
-      case x
-      when ::String
-        x[exp]
-        # x.scan(exp).flatten
-      else
-        type_error(x)
-      end
-    end
+    curried_method(:trim, &:strip)
 
     # TODO: Extract from this module
     def self.type_error(object)

data/lib/ramda/version.rb

@@ -1,3 +1,3 @@
 module Ramda
-  VERSION = '0.5.0'.freeze
+  VERSION = '0.6.0'.freeze
 end

data/lib/ramda.rb

@@ -16,9 +16,13 @@ module Ramda
   extend SingleForwardable
 
   def_delegators Ramda::Function,
+                 :F,
+                 :T,
+                 :__,
                  :always,
                  :ap,
                  :binary,
+                 :bind,
                  :comparator,
                  :compose,
                  :construct,
@@ -95,6 +99,7 @@ module Ramda
                  :and,
                  :any_pass,
                  :complement,
+                 :cond,
                  :if_else,
                  :is_empty,
                  :not,
@@ -126,6 +131,7 @@ module Ramda
                  :pick_all,
                  :project,
                  :prop,
+                 :prop_or,
                  :props,
                  :to_pairs,
                  # :to_pairs_in,
@@ -153,9 +159,11 @@ module Ramda
 
   def_delegators Ramda::String,
                  :match,
+                 :replace,
                  :split,
                  :to_lower,
-                 :to_upper
+                 :to_upper,
+                 :trim
 
   def_delegators Ramda::Type,
                  :is,

data/spec/ramda/function_spec.rb

@@ -3,6 +3,28 @@ require 'spec_helper'
 describe Ramda::Function do
   let(:r) { described_class }
 
+  context '#F' do
+    it 'from docs' do
+      expect(r.F.call).to be_falsey
+    end
+  end
+
+  context '#T' do
+    it 'from docs' do
+      expect(r.T.call).to be_truthy
+    end
+  end
+
+  context '#__' do
+    it 'from docs' do
+      greet = R.replace('{name}', r.__, 'Hello, {name}!')
+      expect(greet.call('Alice')).to eq('Hello, Alice!')
+
+      greet = R.replace(r.__, r.__, 'Hello, {name}!')
+      expect(greet.call('{name}', 'Alice')).to eq('Hello, Alice!')
+    end
+  end
+
   context '#always' do
     it 'from docs' do
       str = 'Tee'
@@ -33,6 +55,16 @@ describe Ramda::Function do
     end
   end
 
+  context '#bind' do
+    it 'from docs' do
+      fn = r.bind(''.method(:upcase), 'abcdef')
+      expect(fn.call).to eq('ABCDEF')
+
+      fn = r.bind(100.method(:+), 1000)
+      expect(fn.call(10)).to eq(1010)
+    end
+  end
+
   context '#comparator' do
     it 'from docs' do
       sort_rule = r.comparator(->(a, b) { a < b })
@@ -105,6 +137,16 @@ describe Ramda::Function do
     it 'can receive a method' do
       expect(r.curry(method(:test_method)).call(100)).to eq(100)
     end
+
+    it 'supports placeholder' do
+      g = r.curry(->(a, b, c) { a + b + c })
+
+      expect(g.call(1, 2, 3)).to eq(6)
+      expect(g.call(R.__, 2, 3).call(1)).to eq(6)
+      expect(g.call(R.__, R.__, 3).call(1).call(2)).to eq(6)
+      expect(g.call(R.__, R.__, 3).call(1, 2)).to eq(6)
+      expect(g.call(R.__, 2, R.__).call(1, 3)).to eq(6)
+    end
   end
 
   context '#curry_n' do
@@ -118,14 +160,14 @@ describe Ramda::Function do
       expect(g.call(4)).to eq(10)
     end
 
-    xit 'with __' do
-      # 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)(_, 3)(1)
+    it 'supports placeholder' do
+      g = r.curry_n(3, ->(*args) { R.sum(args) })
+
+      expect(g.call(1, 2, 3)).to eq(6)
+      expect(g.call(R.__, 2, 3).call(1)).to eq(6)
+      expect(g.call(R.__, R.__, 3).call(1).call(2)).to eq(6)
+      expect(g.call(R.__, R.__, 3).call(1, 2)).to eq(6)
+      expect(g.call(R.__, 2, R.__).call(1, 3)).to eq(6)
     end
   end
 

data/spec/ramda/internal/curried_method_spec.rb

@@ -3,15 +3,32 @@ require 'spec_helper'
 describe Ramda::Internal::CurriedMethod do
   let(:instance) { Class.new { extend Ramda::Internal::CurriedMethod } }
 
-  it '#curried_method' do
-    instance.curried_method(:sample_method) do |a, b, c|
-      a + b + c
+  context '#curried_method' do
+    it 'without placeholder' do
+      instance.curried_method(:g) do |a, b, c|
+        a + b + c
+      end
+
+      # expect(instance.sample_method.origin_arity).to be(3)
+      expect(instance.g.call(1).call(2).call(3)).to be(6)
+      expect(instance.g(1).call(2).call(3)).to be(6)
+      expect(instance.g(1, 2).call(3)).to be(6)
+      expect(instance.g(1, 2, 3)).to be(6)
     end
 
-    # expect(instance.sample_method.origin_arity).to be(3)
-    expect(instance.sample_method.call(1).call(2).call(3)).to be(6)
-    expect(instance.sample_method(1).call(2).call(3)).to be(6)
-    expect(instance.sample_method(1, 2).call(3)).to be(6)
-    expect(instance.sample_method(1, 2, 3)).to be(6)
+    it 'with placeholder' do
+      instance.curried_method(:g) do |a, b, c|
+        a + b + c
+      end
+
+      expect(instance.g(1, 2, 3)).to eq(6)
+      expect(instance.g(R.__, 2, 3).call(1)).to eq(6)
+      expect(instance.g(R.__, R.__, 3).call(1).call(2)).to eq(6)
+      expect(instance.g(R.__, R.__, 3).call(1, 2)).to eq(6)
+      expect(instance.g(R.__, 2, R.__).call(1, 3)).to eq(6)
+      # expect(instance.g(R.__, 2).call(1).call(3)).to eq(6)
+      # expect(instance.g(R.__, 2).call(1, 3)).to eq(6)
+      # expect(instance.g(R.__, 2).call(R.__, 3).call(1)).to eq(6)
+    end
   end
 end

data/spec/ramda/list_spec.rb

@@ -57,7 +57,7 @@ describe Ramda::List do
         end
       end.new
 
-      expect(r.chain(Ramda.add(5), monad)).to eq(15)
+      expect(r.chain(R.add(5), monad)).to eq(15)
     end
 
     it 'monad with bind' do
@@ -67,7 +67,7 @@ describe Ramda::List do
         end
       end.new
 
-      expect(r.chain(Ramda.add(5), monad)).to eq(15)
+      expect(r.chain(R.add(5), monad)).to eq(15)
     end
 
     # it 'multiple args' do
@@ -548,7 +548,7 @@ describe Ramda::List do
 
   context '#zip_with' do
     it 'from docs' do
-      f = ->(x, y) { Ramda.join('', [x, y]) }
+      f = ->(x, y) { R.join('', [x, y]) }
 
       expect(r.zip_with(f, [1, 2, 3], ['a', 'b', 'c'])).to eq(['1a', '2b', '3c'])
     end

data/spec/ramda/logic_spec.rb

@@ -40,12 +40,25 @@ describe Ramda::Logic do
     end
   end
 
+  context '#cond' do
+    it 'from docs' do
+      fn = R.cond([
+                    [R.equals(0), R.always('water freezes at 0 C')],
+                    [R.equals(100), R.always('water boils at 100 C')],
+                    [R.T, ->(temp) { "nothing special happens at #{temp} C" }]
+                  ])
+      expect(fn.call(0)).to eq('water freezes at 0 C')
+      expect(fn.call(50)).to eq('nothing special happens at 50 C')
+      expect(fn.call(100)).to eq('water boils at 100 C')
+    end
+  end
+
   context '#if_else' do
     it 'from docs' do
       inc_count = R.if_else(
-        Ramda.prop(:count),
-        Ramda.prop(:count),
-        Ramda.identity
+        R.prop(:count),
+        R.prop(:count),
+        R.identity
       )
       expect(inc_count.call({})).to eq({})
       expect(inc_count.call(count: 1)).to eq(1)

data/spec/ramda/math_spec.rb

@@ -24,6 +24,11 @@ describe Ramda::Math do
       expect(r.divide(71, 100)).to eq(0.71)
     end
 
+    it 'supports placeholder' do
+      half = r.divide(Ramda.__, 2)
+      expect(half.call(10)).to eq(5)
+    end
+
     it 'is curried' do
       expect(r.divide(1).call(4)).to eq(0.25)
     end
@@ -58,6 +63,12 @@ describe Ramda::Math do
       expect(r.modulo(21, 2)).to be(1)
       expect(r.modulo(17, 3)).to be(2)
     end
+
+    it 'supports placeholer' do
+      is_odd = R.modulo(R.__, 2)
+      expect(is_odd.call(42)).to eq(0)
+      expect(is_odd.call(21)).to eq(1)
+    end
   end
 
   context '#multipy' do
@@ -90,6 +101,12 @@ describe Ramda::Math do
       expect(complementary_angel.call(30)).to be(60)
       expect(complementary_angel.call(72)).to be(18)
     end
+
+    it 'support placeholder' do
+      minus5 = r.subtract(R.__, 5)
+      expect(minus5.call(17)).to eq(12)
+      expect(minus5.call(10)).to eq(5)
+    end
   end
 
   context '#sum' do

data/spec/ramda/object_spec.rb

@@ -69,8 +69,11 @@ describe Ramda::Object do
 
     it 'is curried' do
       expect(r.merge(a: 1).call(b: 2)).to eq(a: 1, b: 2)
-      # var resetToDefault = R.merge(R.__, {x: 0});
-      # resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}
+    end
+
+    it 'supports placeholder' do
+      reset_to_default = R.merge(R.__, x: 0)
+      expect(reset_to_default.call(x: 5, y: 2)).to eq(x: 0, y: 2)
     end
   end
 
@@ -119,6 +122,20 @@ describe Ramda::Object do
     end
   end
 
+  context '#prop_or' do
+    it 'from docs' do
+      alice = {
+        name: 'ALICE',
+        age: 101
+      }
+      favorite = R.prop('favoriteLibrary')
+      favorite_with_default = r.prop_or('Ramda', 'favoriteLibrary')
+
+      expect(favorite.call(alice)).to eq(nil)
+      expect(favorite_with_default.call(alice)).to eq('Ramda')
+    end
+  end
+
   context '#props' do
     it 'from docs' do
       expect(r.props([:x, :y], x: 1, y: 2)).to eq([1, 2])
@@ -174,8 +191,8 @@ describe Ramda::Object do
     it 'from docs' do
       pred = R.where(a: R.equals('foo'),
                      b: R.complement(R.equals('bar')),
-                     x: R.lt(10),
-                     y: R.gt(20))
+                     x: R.gt(R.__, 10),
+                     y: R.lt(R.__, 20))
 
       expect(pred.call(a: 'foo', b: 'xxx', x: 11, y: 19)).to be_truthy
       expect(pred.call(a: 'xxx', b: 'xxx', x: 11, y: 19)).to be_falsey

data/spec/ramda/string_spec.rb

@@ -11,6 +11,13 @@ describe Ramda::String do
     end
   end
 
+  context '#replace' do
+    it 'from docs' do
+      expect(r.replace('foo', 'bar', 'test foo foo foo')).to eq('test bar bar bar')
+      expect(r.replace(/foo/, 'bar', 'test foo foo foo')).to eq('test bar bar bar')
+    end
+  end
+
   context '#split' do
     it 'from docs' do
       path_components = r.split('/')
@@ -41,4 +48,11 @@ describe Ramda::String do
       expect(r.to_lower.call('XYZ')).to eq('xyz')
     end
   end
+
+  context '#trim' do
+    it 'from docs' do
+      expect(r.trim('   xyz  ')).to eq('xyz')
+      expect(R.map(r.trim, R.split(',', 'x, y, z'))).to eq(['x', 'y', 'z'])
+    end
+  end
 end

data/spec/ramda_spec.rb

@@ -11,6 +11,9 @@ describe Ramda do
   # r(:math_mod)
   # r(:to_pairs_in)
   # r(:values_in)
+  r(:F)
+  r(:T)
+  r(:__)
   r(:add)
   r(:all)
   r(:all_pass)
@@ -22,12 +25,14 @@ describe Ramda do
   r(:append)
   r(:assoc)
   r(:binary)
+  r(:bind)
   r(:chain)
   r(:clone)
   r(:comparator)
   r(:complement)
   r(:compose)
   r(:concat)
+  r(:cond)
   r(:construct)
   r(:construct_n)
   r(:contains)
@@ -102,6 +107,7 @@ describe Ramda do
   r(:project)
   r(:prop)
   r(:prop_eq)
+  r(:prop_or)
   r(:props)
   r(:range)
   r(:reduce)
@@ -109,6 +115,7 @@ describe Ramda do
   r(:reject)
   r(:remove)
   r(:repeat)
+  r(:replace)
   r(:reverse)
   r(:slice)
   r(:sort)
@@ -124,6 +131,7 @@ describe Ramda do
   r(:to_lower)
   r(:to_pairs)
   r(:to_upper)
+  r(:trim)
   r(:unary)
   r(:union)
   r(:union_with)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ramda-ruby
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Vadim Lazebny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-20 00:00:00.000000000 Z
+date: 2017-06-21 00:00:00.000000000 Z
 dependencies: []
 description: Ruby version of Ramda Js library.
 email: