ramda-ruby 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 554c835670ffecb793b2f9219833f609fc7474cd
-  data.tar.gz: 58afbd319ba44b6fa58a0792ea817f342febbeba
+  metadata.gz: 5069f465457b70d73fdf3293e664aed146961a04
+  data.tar.gz: d92e10b760d7774df9ae4adfabbb4e16815a9850
 SHA512:
-  metadata.gz: d2c06c63751263ce4e45b605f11a703c54c580c7da2d1761f2de822c933f39ff607b6ee941dd09ac8d77f18f4eb805d235952de9b0d57d3f206c72d29eb31404
-  data.tar.gz: 06b141ae4b5a1022cff6883797e33791993987bc8690981bc141ae2491c53c03572f52c2f796435e3005152c29b927d4634521809285da2da2d96675b2ae181f
+  metadata.gz: 51cb3c50f9b3210f0cc362548839746481e14729f8e70b526475148fc0d7454d2be8e65a7a60b7fb8f7449a74d2efa35d85fc504039d99cc0947971754ba691c
+  data.tar.gz: 9e425cf05c7667634c5e175e46fcb645b0dd7b57ad340c4a30f93bdd9198942c4f1a140aa6a8ebf7a585211b2ff468f575135c56735b9040b5a4cd66ec3bc926

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 Not Released
 ---------------
 
+Release 0.3.0
+---------------
+
+* (pending) math_mod
+* ap
+* chain
+* complement
+* empty - uses x.class.new for defining new empty object if empty method does not exist
+* from_pairs
+* is
+* of
+* unnest
+* zip_obj
+
 Release 0.2.3
 ---------------
 

data/ROADMAP.md

@@ -4,17 +4,6 @@
 
 ### release 0.3.0
 
-* ap
-* chain
-* empty
-* from_pairs
-* is
-* length
-* math_mod
-* of
-* unnest
-* zip_obj
-
 ### release 0.4.0
 
 * construct_n

data/docs/FUNCTIONS.md

@@ -1,4 +1,5 @@
 * (pending) keys_in
+* (pending) math_mod
 * (pending) values_in
 * add
 * all
@@ -7,11 +8,14 @@
 * and
 * any
 * any_pass
+* ap
 * append
 * assoc
 * binary
+* chain
 * clone
 * comparator
+* complement
 * compose
 * concat
 * construct
@@ -25,6 +29,7 @@
 * dissoc
 * divide
 * drop
+* empty - uses x.class.new for defining new empty object if empty method does not exist
 * eq_by
 * eq_props
 * equals
@@ -36,6 +41,7 @@
 * flatten
 * flip
 * for_each
+* from_pairs
 * group_by
 * gt
 * gte
@@ -47,6 +53,7 @@
 * insert
 * intersection
 * invoker
+* is
 * is_empty
 * is_nil
 * join
@@ -68,6 +75,7 @@
 * n_ary
 * not
 * nth
+* of
 * omit
 * once
 * or
@@ -108,9 +116,11 @@
 * union_with
 * uniq
 * uniq_with - first argument is a function with 1 arity which transforms each list element and applies uniq function to results
+* unnest
 * use_with
 * values
 * where
 * xprod
 * zip
+* zip_obj
 * zip_with

data/lib/ramda.rb

@@ -17,18 +17,21 @@ module Ramda
 
   def_delegators Ramda::Function,
                  :always,
+                 :ap,
                  :binary,
                  :comparator,
                  :compose,
                  :construct,
                  :converge,
                  :curry,
+                 :empty,
                  :flip,
                  :identity,
                  :invoker,
                  :juxt,
                  :memoize,
                  :n_ary,
+                 :of,
                  :once,
                  :pipe,
                  :tap,
@@ -39,10 +42,12 @@ module Ramda
                  :all,
                  :any,
                  :append,
+                 :chain,
                  :concat,
                  :contains,
                  :drop,
                  :filter,
+                 :from_pairs,
                  :find,
                  :find_index,
                  :find_last,
@@ -77,15 +82,17 @@ module Ramda
                  :times,
                  :uniq,
                  :uniq_with,
+                 :unnest,
                  :xprod,
                  :zip,
+                 :zip_obj,
                  :zip_with
 
   def_delegators Ramda::Logic,
                  :all_pass,
                  :and,
                  :any_pass,
-                 # :complement,
+                 :complement,
                  :if_else,
                  :is_empty,
                  :not,
@@ -96,6 +103,7 @@ module Ramda
                  :dec,
                  :divide,
                  :inc,
+                 # :math_mod,
                  :modulo,
                  :multiply,
                  :product,
@@ -146,5 +154,6 @@ module Ramda
                  :to_upper
 
   def_delegators Ramda::Type,
+                 :is,
                  :is_nil
 end

data/lib/ramda/function.rb

@@ -6,10 +6,33 @@ module Ramda
   module Function
     extend ::Ramda::Internal::CurriedMethod
 
+    # Returns a function that always returns the given value. Note that
+    # for non-primitives the value returned is a reference to the original
+    # value.
+    # This function is known as const, constant, or K (for K combinator)
+    # in other languages and libraries.
+    #
+    # a -> (* -> a)
+    #
     curried_method(:always) do |value|
       -> { value }
     end
 
+    # ap applies a list of functions to a list of values.
+    # Dispatches to the ap method of the second argument, if present.
+    # Also treats curried functions as applicatives.
+    #
+    # [a -> b] -> [a] -> [b]
+    # Apply f => f (a -> b) -> f a -> f b
+    #
+    curried_method(:ap) do |fns, xs|
+      if xs.respond_to?(:ap)
+        xs.ap(fns)
+      else
+        fns.flat_map { |fn| xs.map(&fn) }
+      end
+    end
+
     # Wraps a function of any arity (including nullary) in a function that
     # accepts exactly 2 parameters. Any extraneous parameters will not be
     # passed to the supplied function.
@@ -81,6 +104,24 @@ module Ramda
       fn.to_proc.curry
     end
 
+    # Returns the empty value of its argument's type. Ramda defines the empty
+    # value of Array ([]), Object ({}), String ('), and Arguments.
+    # Other types are supported if they define <Type>.empty.
+    #
+    # Dispatches to the empty method of the first argument, if present.'))
+    #
+    # a -> a
+    #
+    curried_method(:empty) do |x|
+      if x.respond_to?(:empty)
+        x.empty
+      elsif x.class.respond_to?(:empty)
+        x.class.empty
+      else
+        x.class.new
+      end
+    end
+
     # Returns a new function much like the supplied one, except that the
     # first two arguments' order is reversed.
     #
@@ -137,12 +178,26 @@ module Ramda
       end.curry
     end
 
+    # Wraps a function of any arity (including nullary) in a function that
+    # accepts exactly n parameters. Any extraneous parameters will not be
+    # passed to the supplied function.
+    #
+    # Number -> (* -> a) -> (* -> a)
+    #
     curried_method(:n_ary) do |arity, fn|
       Ramda::Internal::FunctionWithArity.new.call(arity) do |*args|
         fn.call(*(args.first(arity) + Array.new(fn.arity - arity, nil)))
       end.curry
     end
 
+    # Returns a singleton array containing the value provided.
+    #
+    # a -> [a]
+    #
+    curried_method(:of) do |x|
+      [x]
+    end
+
     # Accepts a function fn and returns a function that guards invocation of fn
     # such that fn can only ever be called once, no matter how many times the
     # returned function is invoked. The first value calculated is returned

data/lib/ramda/internal/curried_method.rb

@@ -1,3 +1,5 @@
+require_relative 'function_with_arity'
+
 module Ramda
   module Internal
     # Curried Method
@@ -5,6 +7,7 @@ module Ramda
       def curried_method(name, &block)
         define_singleton_method(name) do |*args|
           curried = block.curry
+          # curried.define_singleton_method(:origin_arity) { block.arity }
 
           return curried if args.empty?
 

data/lib/ramda/internal/function_with_arity.rb

@@ -7,19 +7,19 @@ module Ramda
       # rubocop:disable Metrics/ParameterLists
       def call(arity)
         case arity
-        when 0
+        when 0, -1
           ->(*a) { yield(*a) }
-        when 1
+        when 1, -2
           ->(a, *b) { yield(a, *b) }
-        when 2
+        when 2, -3
           ->(a, b, *c) { yield(a, b, *c) }
-        when 3
+        when 3, -4
           ->(a, b, c, *d) { yield(a, b, c, *d) }
-        when 4
+        when 4, -5
           ->(a, b, c, d, *e) { yield(a, b, c, d, *e) }
-        when 5
+        when 5, -6
           ->(a, b, c, d, e, *f) { yield(a, b, c, d, e, *f) }
-        when 6
+        when 6, -7
           ->(a, b, c, d, e, f, *g) { yield(a, b, c, d, e, f, *g) }
         else
           raise ArgumentError, "Arrity #{arity} is not supported"

data/lib/ramda/list.rb

@@ -37,6 +37,24 @@ module Ramda
       xs.dup + [x]
     end
 
+    # chain maps a function over a list and concatenates the results. chain is
+    # also known as flatMap in some libraries
+    #
+    # Dispatches to the chain or bind method of the second argument, if present,
+    # according to the FantasyLand Chain spec.
+    #
+    # Chain m => (a -> m b) -> m a -> m b
+    #
+    curried_method(:chain) do |fn, xs|
+      if xs.respond_to?(:chain)
+        xs.chain(fn)
+      elsif xs.respond_to?(:bind)
+        xs.bind(fn)
+      else
+        xs.flat_map(&fn)
+      end
+    end
+
     # Returns the result of concatenating the given lists or strings.
     # String -> String -> String
     #
@@ -96,6 +114,15 @@ module Ramda
       end
     end
 
+    # Creates a new object from a list key-value pairs. If a key appears in
+    # multiple pairs, the rightmost pair is included in the object.
+    #
+    # [[k,v]] -> {k: v}
+    #
+    curried_method(:from_pairs) do |xs|
+      Hash[xs]
+    end
+
     # Returns the first element of the list which matches the predicate,
     # or undefined if no element matches.
     #
@@ -440,6 +467,14 @@ module Ramda
       xs.uniq(&fn)
     end
 
+    # Shorthand for R.chain(R.identity), which removes one level of nesting from any Chain.
+    #
+    # Chain c => c (c a) -> c a
+    #
+    curried_method(:unnest) do |xs|
+      Ramda.chain(Ramda.identity, xs)
+    end
+
     # Creates a new list out of the two supplied by creating each possible pair
     # from the lists.
     #
@@ -460,6 +495,16 @@ module Ramda
       xs1.zip(xs2)
     end
 
+    # Creates a new object out of a list of keys and a list of values. Key/value
+    # pairing is truncated to the length of the shorter of the two lists. Note:
+    # zipObj is equivalent to pipe(zip_with(pair), from_pairs).
+    #
+    # [String] -> [*] -> {String: *}
+    #
+    curried_method(:zip_obj) do |xs1, xs2|
+      Hash[xs1.zip(xs2)]
+    end
+
     # Creates a new list out of the two supplied by applying the function to each
     # equally-positioned pair in the lists. The returned list is truncated to the
     # length of the shorter of the two input lists.

data/lib/ramda/math.rb

@@ -37,6 +37,12 @@ module Ramda
       a + 1
     end
 
+    curried_method(:math_mod) do |x, y|
+      #  if (!_isInteger(m)) { return NaN; }
+      #  if (!_isInteger(p) || p < 1) { return NaN; }
+      #  return ((m % p) + p) % p;
+    end
+
     # Divides the first parameter by the second and returns the remainder.
     #
     # Number -> Number -> Number

data/lib/ramda/type.rb

@@ -5,7 +5,19 @@ module Ramda
   module Type
     extend ::Ramda::Internal::CurriedMethod
 
+    # See if an object (val) is an instance of the supplied constructor.
+    # This function will check up the inheritance chain, if any.
+    #
+    # (* -> {*}) -> a -> Boolean
+    #
+    curried_method(:is) do |type, x|
+      x.is_a?(type)
+    end
+
     # Checks if the input value is nil.
+    #
+    # * -> Boolean
+    #
     curried_method(:is_nil, &:nil?)
   end
 end

data/lib/ramda/version.rb

@@ -1,3 +1,3 @@
 module Ramda
-  VERSION = '0.2.3'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/spec/ramda/function_spec.rb

@@ -15,6 +15,14 @@ describe Ramda::Function do
     end
   end
 
+  context '#ap' do
+    it 'from docs' do
+      expect(r.ap([R.multiply(2), R.add(3)], [1, 2, 3])).to eq([2, 4, 6, 4, 5, 6])
+      expect(r.ap([R.concat('tasty '), R.to_upper], ['pizza', 'salad']))
+        .to eq(['tasty pizza', 'tasty salad', 'PIZZA', 'SALAD'])
+    end
+  end
+
   context '#binary' do
     it 'from docs' do
       takes_three_args = ->(a, b, c) { [a, b, c]; }
@@ -83,6 +91,24 @@ describe Ramda::Function do
     end
   end
 
+  context '#empty' do
+    it 'from docs' do
+      expect(r.empty([1, 2, 3])).to eq([])
+      expect(r.empty('unicorns')).to eq('')
+      expect(r.empty(x: 1, y: 2)).to eq({})
+    end
+
+    it 'object has empty method' do
+      obj = Class.new do
+        def empty
+          []
+        end
+      end.new
+
+      expect(r.empty(obj)).to eq([])
+    end
+  end
+
   context '#flip' do
     def merge_tree
       ->(a, b, c) { [a, b, c] }
@@ -174,6 +200,13 @@ describe Ramda::Function do
     end
   end
 
+  context '#of' do
+    it 'from docs' do
+      expect(r.of(nil)).to eq([nil])
+      expect(r.of([42])).to eq([[42]])
+    end
+  end
+
   context '#once' do
     it 'from docs' do
       add_one_once = r.once(->(x) { x + 1 })

data/spec/ramda/internal/curried_method_spec.rb

@@ -8,6 +8,7 @@ describe Ramda::Internal::CurriedMethod do
       a + b + c
     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)

data/spec/ramda/list_spec.rb

@@ -44,6 +44,42 @@ describe Ramda::List do
     end
   end
 
+  context '#chain' do
+    it 'from docs' do
+      duplicate = ->(n) { [n, n] }
+      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(Ramda.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(Ramda.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
+
+    it 'maps a function (a -> [b]) into a (shallow) flat result' do
+      times2 = ->(x) { [x * 2] }
+      expect(R.chain(times2).call([1, 2, 3, 4])).to eq([2, 4, 6, 8])
+    end
+  end
+
   context '#concat' do
     it 'from docs' do
       expect(r.concat('ABC', 'DEF')).to eq('ABCDEF')
@@ -98,6 +134,12 @@ describe Ramda::List do
     end
   end
 
+  context '#from_pairs' do
+    it 'from docs' do
+      expect(r.from_pairs([[:a, 1], [:b, 2], [:c, 3]])).to eq(a: 1, b: 2, c: 3)
+    end
+  end
+
   context '#find' do
     it 'from docs' do
       list = [{ a: 1 }, { a: 2 }, { a: 3 }]
@@ -477,6 +519,13 @@ describe Ramda::List do
     end
   end
 
+  context '#unnest' do
+    it 'from docs' do
+      expect(r.unnest([1, [2], [[3]]])).to eq([1, 2, [3]])
+      expect(r.unnest([[1, 2], [3, 4], [5, 6]])).to eq([1, 2, 3, 4, 5, 6])
+    end
+  end
+
   context '#xprod' do
     it 'from docs' do
       expect(r.xprod([1, 2], ['a', 'b']))
@@ -491,6 +540,12 @@ describe Ramda::List do
     end
   end
 
+  context '#zip_obj' do
+    it 'from docs' do
+      expect(r.zip_obj([:a, :b, :c], [1, 2, 3])).to eq(a: 1, b: 2, c: 3)
+    end
+  end
+
   context '#zip_with' do
     it 'from docs' do
       f = ->(x, y) { Ramda.join('', [x, y]) }

data/spec/ramda/logic_spec.rb

@@ -30,13 +30,13 @@ describe Ramda::Logic do
     expect(is_black_card.call(rank: 'Q', suit: 'diamond')).to be_falsey
   end
 
-  xcontext '#complement' do
+  context '#complement' do
     it 'from docs' do
-      # is_not_nil = R.complement(R.is_nil)
-      # expect(R.is_nil(nil)).to be_truthy
-      # expect(is_not_nil(nil)).to be_falsey
-      # expect(R.is_nil(7)).to be_falsey
-      # expect(is_not_nil(7)).to be_truthy
+      is_not_nil = r.complement(R.is_nil)
+      expect(R.is_nil(nil)).to be_truthy
+      expect(is_not_nil.call(nil)).to be_falsey
+      expect(R.is_nil(7)).to be_falsey
+      expect(is_not_nil.call(7)).to be_truthy
     end
   end
 

data/spec/ramda/math_spec.rb

@@ -35,6 +35,22 @@ describe Ramda::Math do
     end
   end
 
+  xcontext '#math_mod' do
+    it 'from docs' do
+      expect(R.math_mod(-17, 5)).to eq(3)
+      expect(R.math_mod(17, 5)).to eq(2)
+      expect(R.math_mod(17, -5)).to be(nil)
+      expect(R.math_mod(17, 0)).to be(nil)
+      expect(R.math_mod(17.2, 5)).to be(nil)
+      expect(R.math_mod(17, 5.3)).to be(nil)
+
+      seventeen_mod = R.mathMod(17)
+      expect(seventeen_mod.call(3)).to eq(2)
+      expect(seventeen_mod.call(4)).to eq(1)
+      expect(seventeen_mod.call(10)).to eq(7)
+    end
+  end
+
   context '#modulo' do
     it 'from docs' do
       expect(r.modulo(0, 3)).to be(0)

data/spec/ramda/object_spec.rb

@@ -158,13 +158,13 @@ describe Ramda::Object do
   context '#where' do
     it 'from docs' do
       pred = R.where(a: R.equals('foo'),
-                     # b: R.complement(R.equals('bar')),
+                     b: R.complement(R.equals('bar')),
                      x: R.lt(10),
                      y: R.gt(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
-      # expect(pred.call(a: 'foo', b: 'bar', x: 11, y: 19)).to be_falsey
+      expect(pred.call(a: 'foo', b: 'bar', x: 11, y: 19)).to be_falsey
       expect(pred.call(a: 'foo', b: 'xxx', x: 10, y: 19)).to be_falsey
       expect(pred.call(a: 'foo', b: 'xxx', x: 11, y: 20)).to be_falsey
     end

data/spec/ramda/type_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Ramda::Type do
+  let(:r) { described_class }
+
+  context '#is' do
+    it 'from docs' do
+      expect(r.is(Hash, {})).to be_truthy
+      expect(r.is(Integer, 1)).to be_truthy
+      expect(r.is(Hash, 1)).to be_falsey
+      expect(r.is(String, 's')).to be_truthy
+      expect(r.is(String, '')).to be_truthy
+      expect(r.is(Hash, 's')).to be_falsey
+      expect(r.is(Integer, {})).to be_falsey
+    end
+  end
+
+  context '#is_nil' do
+    it 'from docs' do
+      expect(r.is_nil(nil)).to be_truthy
+      expect(r.is_nil(0)).to be_falsey
+      expect(r.is_nil([])).to be_falsey
+      expect(r.is_nil('')).to be_falsey
+    end
+  end
+end

data/spec/ramda_spec.rb

@@ -7,6 +7,9 @@ describe Ramda do
     end
   end
 
+  # r(:keys_in)
+  # r(:math_mod)
+  # r(:values_in)
   r(:add)
   r(:all)
   r(:all_pass)
@@ -14,11 +17,14 @@ describe Ramda do
   r(:and)
   r(:any)
   r(:any_pass)
+  r(:ap)
   r(:append)
   r(:assoc)
+  r(:binary)
+  r(:chain)
   r(:clone)
   r(:comparator)
-  # r(:complement)
+  r(:complement)
   r(:compose)
   r(:concat)
   r(:construct)
@@ -32,6 +38,7 @@ describe Ramda do
   r(:dissoc)
   r(:divide)
   r(:drop)
+  r(:empty)
   r(:eq_by)
   r(:eq_props)
   r(:equals)
@@ -43,6 +50,7 @@ describe Ramda do
   r(:flatten)
   r(:flip)
   r(:for_each)
+  r(:from_pairs)
   r(:group_by)
   r(:gt)
   r(:gte)
@@ -54,12 +62,12 @@ describe Ramda do
   r(:insert)
   r(:intersection)
   r(:invoker)
+  r(:is)
   r(:is_empty)
   r(:is_nil)
   r(:join)
   r(:juxt)
   r(:keys)
-  # r(:keys_in)
   r(:last)
   r(:last_index_of)
   r(:length)
@@ -76,6 +84,7 @@ describe Ramda do
   r(:n_ary)
   r(:not)
   r(:nth)
+  r(:of)
   r(:omit)
   r(:once)
   r(:or)
@@ -116,11 +125,12 @@ describe Ramda do
   r(:union_with)
   r(:uniq)
   r(:uniq_with)
+  r(:unnest)
   r(:use_with)
   r(:values)
-  # r(:values_in)
   r(:where)
   r(:xprod)
   r(:zip)
+  r(:zip_obj)
   r(:zip_with)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ramda-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Vadim Lazebny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-18 00:00:00.000000000 Z
+date: 2017-06-20 00:00:00.000000000 Z
 dependencies: []
 description: Ruby version of Ramda Js library.
 email:
@@ -47,6 +47,7 @@ files:
 - spec/ramda/object_spec.rb
 - spec/ramda/relation_spec.rb
 - spec/ramda/string_spec.rb
+- spec/ramda/type_spec.rb
 - spec/ramda_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/lazebny/ramda-ruby
@@ -79,6 +80,7 @@ test_files:
 - spec/ramda/logic_spec.rb
 - spec/ramda/string_spec.rb
 - spec/ramda/list_spec.rb
+- spec/ramda/type_spec.rb
 - spec/ramda/object_spec.rb
 - spec/ramda/function_spec.rb
 - spec/ramda/relation_spec.rb