ramda-ruby 0.12.0 → 0.14.0

data/lib/ramda/object.rb

@@ -7,7 +7,7 @@ module Ramda
   module Object
     extend ::Ramda::Internal::CurriedMethod
 
-    Functors = ::Ramda::Internals::Functors
+    Functors = ::Ramda::Internal::Functors
 
     # Makes a shallow clone of an object, setting or overriding the specified
     # property with the given value. Note that this copies and flattens
@@ -429,5 +429,18 @@ module Ramda
     curried_method(:where) do |spec, test|
       spec.all? { |k, v| v.call(test[k]) }
     end
+
+    # Takes a spec object and a test object; returns true if the test satisfies
+    # the spec, false otherwise. An object satisfies the spec if, for each of
+    # the spec's own properties, accessing that property of the object gives
+    # the same value (in R.equals terms) as accessing that property of the spec.
+    #
+    # whereEq is a specialization of where.)
+    #
+    # {String: *} -> {String: *} -> Boolean
+    #
+    curried_method(:where_eq) do |spec, test|
+      spec.all? { |k, v| test[k] && test[k] == v }
+    end
   end
 end

data/lib/ramda/string.rb

@@ -1,9 +1,11 @@
 require_relative 'internal/curried_method'
+require_relative 'internal/dispatchable'
 
 module Ramda
   # String functions
   module String
     extend ::Ramda::Internal::CurriedMethod
+    extend ::Ramda::Internal::Dispatchable
 
     # Tests a regular expression against a String. Note that this function will
     # return an empty array when there are no matches. This differs from
@@ -45,17 +47,34 @@ module Ramda
       !str.match(rx).nil?
     end
 
-    # The upper case version of a string.
+    # The lower case version of a string.
     #
     # String -> String
     #
-    curried_method(:to_upper, &:upcase)
+    curried_method(:to_lower, &:downcase)
 
-    # The lower case version of a string.
+    # Returns the string representation of the given value.
+    # eval'ing the output should result in a value equivalent to the input value.
+    # Many of the built-in to_string methods do not satisfy this requirement.
+    #
+    # * -> String
+    #
+    curried_method(:to_string, &dispatchable([:inspect], []) do |x|
+      # case x
+      # when Array
+      # when TrueClass, FalseClass
+      # when DateTime
+      # when NilClass
+      # when Number
+      # when String
+      # end
+    end)
+
+    # The upper case version of a string.
     #
     # String -> String
     #
-    curried_method(:to_lower, &:downcase)
+    curried_method(:to_upper, &:upcase)
 
     # Removes (strips) whitespace from both ends of the string.
     #

data/lib/ramda/version.rb

@@ -1,3 +1,3 @@
 module Ramda
-  VERSION = '0.12.0'.freeze
+  VERSION = '0.14.0'.freeze
 end

data/spec/ramda/function_spec.rb

@@ -44,9 +44,18 @@ describe Ramda::Function do
         .to eq(['tasty pizza', 'tasty salad', 'PIZZA', 'SALAD'])
     end
 
-    xit 'with monads' do
-      res = r.ap(r.ap([R.multiply], M::Maybe(10)), M::Maybe(20))
-      expect(res).to eq(M::Maybe::Some.new(200))
+    it 'with monads' do
+      expect(Maybe.of(R.multiply).ap(Maybe.of(10)).ap(Maybe.of(20))).to eq(Maybe.of(200))
+
+      res = R.ap(R.ap(Maybe.of(R.multiply), Maybe.of(10)), Maybe.of(20))
+      expect(res).to eq(Maybe.of(200))
+    end
+
+    context 'supports gem' do
+      it 'kleisli' do
+        result = R.ap(KleisliMaybe::Some.new(R.add(5)), KleisliMaybe::Some.new(10))
+        expect(result).to eq(KleisliMaybe::Some.new(15))
+      end
     end
   end
 
@@ -325,10 +334,9 @@ describe Ramda::Function do
       ).to eq([3, 4, 5, 4, 5, 6, 5, 6, 7])
     end
 
-    xit 'with monads' do
-      addm = r.lift(R.add)
-      expect(addm.call(M::Maybe(3), M::Maybe(5))).to eq(M::Maybe(8))
-      # expect(addM.call(M::Maybe(3), M::Maybe(nil))).to eq(M::Maybe::None.new)
+    it 'with monads' do
+      add_m = r.lift(R.add)
+      expect(add_m.call(Maybe.of(3), Maybe.of(5))).to eq(Maybe.of(8))
     end
   end
 
@@ -337,6 +345,11 @@ describe Ramda::Function do
       madd3 = r.lift_n(3, ->(*args) { R.sum(args) })
       expect(madd3.call([1, 2, 3], [1, 2, 3], [1])).to eq([3, 4, 5, 4, 5, 6, 5, 6, 7])
     end
+
+    it 'works with other functors such as "Maybe"' do
+      add_m = R.lift_n(3, ->(a, b, c) { a + b + c })
+      expect(add_m.call(Maybe.of(3), Maybe.of(5), Maybe.of(10))).to eq(Maybe.of(18))
+    end
   end
 
   context '#memoize' do

data/spec/ramda/list_spec.rb

@@ -3,6 +3,16 @@ require 'spec_helper'
 describe Ramda::List do
   let(:r) { Ramda }
 
+  context '#adjust' do
+    it 'from docs' do
+      expect(R.adjust(R.add(10), 1, [1, 2, 3])).to eq([1, 12, 3])
+    end
+
+    it 'is curried' do
+      expect(R.adjust(R.add(10)).call(1).call([1, 2, 3])).to eq([1, 12, 3])
+    end
+  end
+
   context '#all' do
     it 'test' do
       equals3 = R.equals(3)
@@ -64,26 +74,6 @@ describe Ramda::List do
       expect(r.chain(duplicate, [1, 2, 3])).to eq([1, 1, 2, 2, 3, 3])
     end
 
-    it 'monad with chain' do
-      monad = Class.new do
-        def chain(fn)
-          fn.call(10)
-        end
-      end.new
-
-      expect(r.chain(R.add(5), monad)).to eq(15)
-    end
-
-    it 'monad with bind' do
-      monad = Class.new do
-        def bind(fn)
-          fn.call(10)
-        end
-      end.new
-
-      expect(r.chain(R.add(5), monad)).to eq(15)
-    end
-
     # it 'multiple args' do
     #   expect(r.chain(R.compose(R.append, R.head)).call([1, 2, 3])).to eq([1, 2, 3, 1])
     # end
@@ -92,6 +82,23 @@ describe Ramda::List do
       times2 = ->(x) { [x * 2] }
       expect(R.chain(times2).call([1, 2, 3, 4])).to eq([2, 4, 6, 8])
     end
+
+    context 'supports gem' do
+      it 'fantasy-ruby' do
+        result = R.chain(->(x) { Maybe.of(R.add(5, x)) }, Maybe.of(10))
+        expect(result).to eq(Maybe.of(15))
+      end
+
+      it 'dry-monads', market: :dry_monads do
+        result = R.chain(->(x) { DryMaybe.pure(R.add(5, x)) }, DryMaybe.pure(10))
+        expect(result).to eq(DryMaybe.pure(15))
+      end
+
+      it 'kleisli' do
+        result = R.chain(->(x) { KleisliMaybe::Some.new(R.add(5, x)) }, KleisliMaybe::Some.new(10))
+        expect(result).to eq(KleisliMaybe::Some.new(15))
+      end
+    end
   end
 
   context '#concat' do
@@ -133,6 +140,38 @@ describe Ramda::List do
     end
   end
 
+  context '#drop_repeats' do
+    let(:x1s) { [1, 2, 3, 4, 5, 3, 2] }
+    let(:x2s) { [1, 2, 2, 2, 3, 4, 4, 5, 5, 3, 2, 2] }
+
+    it 'removes repeated elements' do
+      expect(R.drop_repeats(x2s)).to eql(x1s)
+      expect(R.drop_repeats(x1s)).to eql(x1s)
+    end
+
+    it 'returns an empty array for an empty array' do
+      expect(R.drop_repeats([])).to eq([])
+    end
+
+    it 'can act as a transducer' do
+      expect(R.into([], R.drop_repeats, x2s)).to eq(x1s)
+    end
+  end
+
+  context '#drop_repeats_with' do
+    let(:drop_repeats_with_abs) { R.drop_repeats_with(R.eq_by(:abs.to_proc)) }
+
+    it 'removes repeated elements' do
+      xs = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3]
+      expect(drop_repeats_with_abs.call(xs)).to eq([1, 3, 4, -5, 3])
+    end
+
+    it 'can act as a transducer' do
+      xs = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3]
+      expect(R.into([], drop_repeats_with_abs, xs)).to eq([1, 3, 4, -5, 3])
+    end
+  end
+
   context '#drop_while' do
     it 'from docs' do
       lte_two = ->(x) { x <= 2 }
@@ -308,6 +347,12 @@ describe Ramda::List do
     end
   end
 
+  context '#intersperse' do
+    it 'from docs' do
+      expect(R.intersperse('n', ['ba', 'a', 'a'])).to eq(['ba', 'n', 'a', 'n', 'a'])
+    end
+  end
+
   context '#into' do
     it 'transduces into arrays' do
       expect(R.into([], R.map(R.add(1)), [1, 2, 3, 4])).to eq([2, 3, 4, 5])
@@ -382,6 +427,23 @@ describe Ramda::List do
 
       expect(r.map(double_fn).call([1, 2, 3])).to eq([2, 4, 6])
     end
+
+    context 'supports gem' do
+      it 'fantasy-ruby' do
+        result = R.map(R.add(5), Maybe.of(10))
+        expect(result).to eq(Maybe.of(15))
+      end
+
+      it 'dry-monads', market: :dry_monads do
+        result = R.map(R.add(5), DryMaybe.pure(10))
+        expect(result).to eq(DryMaybe.pure(15))
+      end
+
+      it 'kleisli' do
+        result = R.map(R.add(5), KleisliMaybe::Some.new(10))
+        expect(result).to eq(KleisliMaybe::Some.new(15))
+      end
+    end
   end
 
   # context '#map_accum' do
@@ -449,6 +511,10 @@ describe Ramda::List do
       expect(r.pluck(:a).call([{ a: 1 }, { a: 2 }])).to eq([1, 2])
       expect(r.pluck(0).call([[1, 2], [3, 4]])).to eq([1, 3])
     end
+
+    it 'works with functor' do
+      expect(R.pluck(:a, Maybe.of(a: 100))).to eq(Maybe.of(100))
+    end
   end
 
   context '#prepend' do

data/spec/ramda/logic_spec.rb

@@ -44,6 +44,16 @@ describe Ramda::Logic do
       expect(f.call(15)).to be_truthy
       expect(f.call(30)).to be_falsey
     end
+
+    it 'accepts fantasy-land applicative functors' do
+      some = Maybe::Some
+      none = Maybe::None
+      expect(R.both(some.new(true), some.new(true))). to eq(some.new(true))
+      expect(R.both(some.new(true), some.new(false))).to eq(some.new(false))
+      expect(R.both(some.new(true), none.new)).to eq(none.new)
+      expect(R.both(none.new, some.new(false))).to eq(none.new)
+      expect(R.both(none.new, none.new)).to eq(none.new)
+    end
   end
 
   context '#complement' do
@@ -54,6 +64,15 @@ describe Ramda::Logic do
       expect(R.is_nil(7)).to be_falsey
       expect(is_not_nil.call(7)).to be_truthy
     end
+
+    it 'accepts fantasy-land functors' do
+      some = Maybe::Some
+      none = Maybe::None
+
+      expect(R.complement(some.new(true))).to eq(some.new(false))
+      expect(R.complement(some.new(false))).to eq(some.new(true))
+      expect(R.complement(none.new)).to eq(none.new)
+    end
   end
 
   context '#cond' do
@@ -86,6 +105,17 @@ describe Ramda::Logic do
       expect(f.call(101)).to be_truthy
       expect(f.call(8)).to be_truthy
     end
+
+    it 'accepts fantasy-land applicative functors' do
+      some = Maybe::Some
+      none = Maybe::None
+      expect(R.either(some.new(true), some.new(true))).to eq(some.new(true))
+      expect(R.either(some.new(true), some.new(false))).to eq(some.new(true))
+      expect(R.either(some.new(false), some.new(false))).to eq(some.new(false))
+      expect(R.either(some.new(true), none.new)).to eq(none.new)
+      expect(R.either(none.new, some.new(false))).to eq(none.new)
+      expect(R.either(none.new, none.new)).to eq(none.new)
+    end
   end
 
   context '#if_else' do

data/spec/ramda/math_spec.rb

@@ -56,6 +56,35 @@ describe Ramda::Math do
     end
   end
 
+  context '#mean' do
+    it 'returns mean of a nonempty list' do
+      expect(R.mean([2])).to eq(2)
+      expect(R.mean([2, 7])).to eq(4.5)
+      expect(R.mean([2, 7, 9])).to eq(6)
+      expect(R.mean([2, 7, 9, 10])).to eq(7)
+    end
+
+    it 'returns Nil for an empty list' do
+      expect(R.mean([])).to be_nan
+    end
+  end
+
+  context '#median' do
+    it 'returns middle value of an odd-length list' do
+      expect(R.median([2])).to eq(2)
+      expect(R.median([2, 9, 7])).to eq(7)
+    end
+
+    it 'returns mean of two middle values of a nonempty even-length list' do
+      expect(R.median([7, 2])).to eq(4.5)
+      expect(R.median([7, 2, 10, 9])).to eq(8)
+    end
+
+    it 'returns NaN for an empty list' do
+      expect(R.median([])).to be_nan
+    end
+  end
+
   context '#modulo' do
     it 'from docs' do
       expect(r.modulo(0, 3)).to be(0)

data/spec/ramda/object_spec.rb

@@ -546,4 +546,15 @@ describe Ramda::Object do
       expect(pred.call(a: 'foo', b: 'xxx', x: 11, y: 20)).to be_falsey
     end
   end
+
+  context '#where_eq' do
+    it 'from docs' do
+      pred = R.where_eq(a: 1, b: 2)
+
+      expect(pred.call(a: 1)).to be_falsey
+      expect(pred.call(a: 1, b: 2)).to be_truthy
+      expect(pred.call(a: 1, b: 2, c: 3)).to be_truthy
+      expect(pred.call(a: 1, b: 1)).to be_falsey
+    end
+  end
 end

data/spec/ramda/string_spec.rb

@@ -36,6 +36,49 @@ describe Ramda::String do
     end
   end
 
+  context '#to_string' do
+    it 'returns the string representation of null' do
+      expect(R.to_string(nil)).to eq('nil')
+    end
+
+    it 'returns the string representation of a Boolean primitive' do
+      expect(R.to_string(true)).to eq('true')
+      expect(R.to_string(false)).to eq('false')
+    end
+
+    it 'returns the string representation of a number primitive' do
+      expect(R.to_string(0)).to eq('0')
+      expect(R.to_string(1.23)).to eq('1.23')
+      expect(R.to_string(-1.23)).to eq('-1.23')
+    end
+
+    it 'returns the string representation of a string primitive' do
+      expect(R.to_string('abc')).to eq('"abc"')
+      expect(R.to_string('x "y" z')).to eq('"x \\"y\\" z"')
+      expect(R.to_string("' '")).to eq('"\' \'"')
+      expect(R.to_string('" "')).to eq('"\\" \\""')
+      expect(R.to_string('\b \b')).to eq('"\\\\b \\\\b"')
+      expect(R.to_string('\f \f')).to eq('"\\\\f \\\\f"')
+      expect(R.to_string('\n \n')).to eq('"\\\\n \\\\n"')
+      expect(R.to_string('\r \r')).to eq('"\\\\r \\\\r"')
+      expect(R.to_string('\t \t')).to eq('"\\\\t \\\\t"')
+      expect(R.to_string('\v \v')).to eq('"\\\\v \\\\v"')
+      expect(R.to_string('\0 \0')).to eq('"\\\\0 \\\\0"')
+      expect(R.to_string('\\ \\')).to eq('"\\\\ \\\\"')
+    end
+
+    # it 'returns the string representation of a Date object' do
+    #   expect(R.to_string(DateTime.parse('2001-02-03T04:05:06.000Z')))
+    #     .to eq('DateTime.parse("2001-02-03T04:05:06.000Z")');
+    #   expect(R.to_string(DateTime.parse('XXX'))).to eq('new Date(NaN)');
+    # end
+
+    it 'returns the string representation of a RegExp object' do
+      expect(R.to_string(/(?:)/)).to eq('/(?:)/')
+      expect(R.to_string(%r{/}i)).to eq('/\\//i')
+    end
+  end
+
   context '#to_upper' do
     it 'from docs' do
       expect(r.to_upper('abc')).to eq('ABC')

data/spec/ramda_spec.rb

@@ -17,6 +17,7 @@ describe Ramda do
   r(:T)
   r(:__)
   r(:add)
+  r(:adjust)
   r(:all)
   r(:all_pass)
   r(:always)
@@ -55,6 +56,8 @@ describe Ramda do
   r(:dissoc_path)
   r(:divide)
   r(:drop)
+  r(:drop_repeats)
+  r(:drop_repeats_with)
   r(:drop_while)
   r(:empty)
   r(:either)
@@ -85,6 +88,7 @@ describe Ramda do
   r(:insert)
   r(:insert_all)
   r(:intersection)
+  r(:intersperse)
   r(:into)
   r(:invert)
   r(:invert_obj)
@@ -111,6 +115,8 @@ describe Ramda do
   r(:match)
   r(:max)
   r(:max_by)
+  r(:mean)
+  r(:median)
   r(:memoize)
   r(:merge)
   r(:merge_all)
@@ -170,6 +176,7 @@ describe Ramda do
   r(:times)
   r(:to_lower)
   r(:to_pairs)
+  r(:to_string)
   r(:to_upper)
   r(:transduce)
   r(:trim)
@@ -187,6 +194,7 @@ describe Ramda do
   r(:values)
   r(:view)
   r(:where)
+  r(:where_eq)
   r(:xprod)
   r(:zip)
   r(:zip_obj)