ramda-ruby 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3be47564e590c02c9edbfe24ce475676fc9e85b3
-  data.tar.gz: e27d96aa0d83e50b482cb2ada7d09c60dbbf2152
+  metadata.gz: a23c9651684d48d741ff366c825cc13eb8b88b03
+  data.tar.gz: f784df378ef790ed8ac918986294b983500c2c8d
 SHA512:
-  metadata.gz: 610df76cc6e853a7850ff2f7ef3a886b864ad93f807fbd032353d073c7eba6e361ad6f3790c6b234ac6797bf4f87aec643ab8a908ab6058d40f8529c1662d98a
-  data.tar.gz: 726d0b3245a24232e8949218e15ad50cff16356a35a675d1b89721f31d558d35bca5048da75840b182fa156f24aa4de40625c424d792fb23690d352c8752ba47
+  metadata.gz: 5578f41adcd7d4978b8c3a3be2d80e4ab2f61d9e45e0f6ac46fa1b30354a53475fef02e18c06c32816f5bf8384959b6a9a1147b6df51b67519d3179f63de678b
+  data.tar.gz: 356cfffa686a4e1853353600e72076e25073262442497695a518be6699f9b91c344dc3a898dc22c1ad14a55abd0db22be1779c29e2ad7af626b92fbd3658a265

data/CHANGELOG.md

@@ -1,7 +1,20 @@
 Not Released
 ---------------
 
+Release 0.7.0
+---------------
+
+Added:
+
+* apply
+* has
+* has_in
+* lift
+* lift_n
+* path_eq
+
 Release 0.6.0
+---------------
 
 Added:
 

data/ROADMAP.md

@@ -2,15 +2,6 @@
 
 * Find out suitable documentation format
 
-### release 0.7.0
-
-* apply
-* has
-* has_in
-* lift
-* lift_n
-* path_eq
-
 ### release 0.8.0
 
 * assoc

data/docs/FUNCTIONS.md

@@ -14,6 +14,7 @@
 * any_pass
 * ap
 * append
+* apply
 * assoc
 * binary
 * bind
@@ -53,6 +54,8 @@
 * group_by
 * gt
 * gte
+* has
+* has_in
 * head
 * identity
 * if_else
@@ -70,6 +73,8 @@
 * last
 * last_index_of - returns nil if index doesn't exist
 * length
+* lift
+* lift_n
 * lt
 * lte
 * map
@@ -89,6 +94,7 @@
 * or
 * partition
 * path
+* path_eq
 * pick
 * pick_all
 * pipe

data/lib/ramda.rb

@@ -21,6 +21,7 @@ module Ramda
                  :__,
                  :always,
                  :ap,
+                 :apply,
                  :binary,
                  :bind,
                  :comparator,
@@ -35,6 +36,8 @@ module Ramda
                  :identity,
                  :invoker,
                  :juxt,
+                 :lift,
+                 :lift_n,
                  :memoize,
                  :n_ary,
                  :of,
@@ -122,6 +125,8 @@ module Ramda
                  :clone,
                  :dissoc,
                  :eq_props,
+                 :has,
+                 :has_in,
                  :keys,
                  # :keys_in,
                  :merge,
@@ -152,6 +157,7 @@ module Ramda
                  :lte,
                  :max,
                  :min,
+                 :path_eq,
                  :prop_eq,
                  :sort_by,
                  :union,

data/lib/ramda/function.rb

@@ -58,14 +58,24 @@ module Ramda
     # [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)
+    curried_method(:ap) do |apply_f, apply_x|
+      if apply_x.respond_to?(:ap)
+        apply_x.ap(apply_f)
       else
-        fns.flat_map { |fn| xs.map(&fn) }
+        apply_f.flat_map { |fn| apply_x.map(&fn) }
       end
     end
 
+    # Applies function fn to the argument list args. This is useful
+    # for creating a fixed-arity function from a variadic function.
+    # fn should be a bound function if context is significant.
+    #
+    # (*... -> a) -> [*] -> a
+    #
+    curried_method(:apply) do |fn, xs|
+      fn.call(*xs)
+    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.
@@ -156,7 +166,7 @@ module Ramda
     # (* -> a) -> (* -> a)
     #
     curried_method(:curry) do |fn|
-      curried_method_body(fn.arity, &fn)
+      curried_method_body(:curry, fn.arity, &fn)
     end
 
     # Returns a curried equivalent of the provided function, with the
@@ -185,7 +195,7 @@ module Ramda
     # Number -> (* -> a) -> (* -> a)
     #
     curried_method(:curry_n) do |arity, fn|
-      curried_method_body(arity, &fn)
+      curried_method_body(:curry_n, arity, &fn)
     end
 
     # Returns the empty value of its argument's type. Ramda defines the empty
@@ -245,6 +255,27 @@ module Ramda
       fns.map { |fn| fn.call(a, *bs) }
     end
 
+    # "lifts" a function of arity > 1 so that it may "map over" a list,
+    # Function or other object that satisfies the FantasyLand Apply spec.
+    #
+    # (*... -> *) -> ([*]... -> [*])
+    #
+    # 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)
+    end
+
+    # "lifts" a function to be the specified arity, so that it may
+    # "map over" that many lists, Functions or other objects that
+    # satisfy the FantasyLand Apply spec.
+    #
+    # Number -> (*... -> *) -> ([*]... -> [*])
+    #
+    curried_method(:lift_n) do |arity, fn, a, *xs|
+      ([a] + xs).reduce([curry_n(arity, fn)], &ap)
+    end
+
     # Creates a new function that, when invoked, caches the result of calling
     # fn for a given argument set and returns the result. Subsequent calls to
     # the memoized fn with the same argument set will not result in an

data/lib/ramda/internal/curried_method.rb

@@ -5,18 +5,24 @@ module Ramda
     # Curried Method
     module CurriedMethod
       def curried_method(name, &block)
-        define_singleton_method(name, &curried_method_body(block.arity, &block))
+        define_singleton_method(name, &curried_method_body(name, block.arity, &block))
       end
 
-      def curried_method_body(arity, &block)
+      # rubocop:disable Metrics/MethodLength
+      def curried_method_body(name, 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)
+          begin
+            if args.include?(Ramda.__)
+              replace_placeholder(args, &block).curry
+            else
+              args.empty? ? block : yield(*args)
+            end
+          rescue StandardError => e
+            raise e, [name, e.exception].join(' -> '), e.backtrace
           end
         end.curry
       end
+      # rubocop:enable Metrics/MethodLength
 
       def replace_placeholder(basic_args)
         Ramda::Internal::FunctionWithArity.new.call(basic_args.count(Ramda.__)) do |*new_args|

data/lib/ramda/list.rb

@@ -295,7 +295,7 @@ module Ramda
     # Filterable f => (a -> Boolean) -> f a -> [f a, f a]
     #
     curried_method(:partition) do |fn, xs|
-      R.juxt([filter, reject]).call(fn, xs)
+      ::Ramda.juxt([filter, reject]).call(fn, xs)
     end
 
     # Returns a new list by plucking the same named property off all objects

data/lib/ramda/object.rb

@@ -39,6 +39,23 @@ module Ramda
       clone(obj).tap { |o| o.delete(prop) }
     end
 
+    # Returns whether or not an object has an own property with the specified name
+    #
+    # s -> {s: x} -> Boolean
+    #
+    curried_method(:has) do |key, obj|
+      obj.key?(key)
+    end
+
+    # Returns whether or not an object or its prototype chain has a property
+    # with the specified name
+    #
+    # s -> {s: x} -> Boolean
+    #
+    curried_method(:has_in) do |key, obj|
+      obj.respond_to?(key)
+    end
+
     # Reports whether two objects have the same value, in R.equals terms,
     # for the specified property. Useful as a curried predicate.
     #

data/lib/ramda/relation.rb

@@ -119,6 +119,18 @@ module Ramda
       [a, b].min
     end
 
+    # Determines whether a nested path on an object has a specific value,
+    # in R.equals terms. Most likely used to filter a list.
+    #
+    # [Idx] -> a -> {a} -> Boolean
+    # Idx = String | Int
+    #
+    curried_method(:path_eq) do |path, val, obj|
+      path.reduce(obj) do |acc, key|
+        acc.fetch(key, nil) if acc.is_a?(Hash) || acc.is_a?(Array)
+      end == val
+    end
+
     # Returns true if the specified object property is equal, in R.equals terms,
     # to the given value; false otherwise.
     #

data/lib/ramda/version.rb

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

data/spec/ramda/function_spec.rb

@@ -43,6 +43,26 @@ describe Ramda::Function do
       expect(r.ap([R.concat('tasty '), R.to_upper], ['pizza', 'salad']))
         .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))
+    end
+  end
+
+  context '#apply' do
+    def max(*args)
+      args.max
+    end
+    it 'from docs' do
+      nums = [1, 2, 3, -99, 42, 6, 7]
+      expect(r.apply(method(:max), nums)).to be(42)
+    end
+
+    it 'is curried' do
+      nums = [1, 2, 3, -99, 42, 6, 7]
+      expect(r.apply.call(method(:max)).call(nums)).to be(42)
+    end
   end
 
   context '#binary' do
@@ -235,6 +255,61 @@ describe Ramda::Function do
     end
   end
 
+  context '#lift' do
+    def madd3
+      r.lift(->(a, b, c) { a + b + c })
+    end
+
+    def madd4
+      r.lift(->(a, b, c, d) { a + b + c + d })
+    end
+
+    def madd5
+      r.lift(->(a, b, c, d, e) { a + b + c + d + e })
+    end
+
+    it 'from docs' do
+      expect(madd3.call([1, 2, 3], [1, 2, 3], [1])).to eq([3, 4, 5, 4, 5, 6, 5, 6, 7])
+      expect(madd5.call([1, 2], [3], [4, 5], [6], [7, 8])).to eq([21, 22, 22, 23, 22, 23, 23, 24])
+    end
+
+    it 'can lift functions with any arity' do
+      expect(madd3.call([1, 10], [2], [3])).to eq([6, 15])
+      expect(madd4.call([1, 10], [2], [3], [40])).to eq([46, 55])
+      expect(madd5.call([1, 10], [2], [3], [40], [500, 1000])).to eq([546, 1046, 555, 1055])
+    end
+
+    it 'example with ap' do
+      madd3 = ->(a, b, c) { a + b + c }
+
+      expect(
+        R.ap(
+          R.ap(
+            R.ap(
+              [R.curry(madd3)],
+              [1, 2, 3]
+            ),
+            [1, 2, 3]
+          ),
+          [1]
+        )
+      ).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)
+    end
+  end
+
+  context '#lift_n' do
+    it 'from docs' 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
+  end
+
   context '#memoize' do
     it 'from docs' do
       count = 0

data/spec/ramda/internal/curried_method_spec.rb

@@ -30,5 +30,14 @@ describe Ramda::Internal::CurriedMethod do
       # 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
+
+    it 'exception handler' do
+      instance.curried_method(:g) do |a, b, c|
+        a + b + c
+      end
+
+      expect { instance.g(1, '', 2) }
+        .to raise_error(/g -> String can't be coerced/)
+    end
   end
 end

data/spec/ramda/object_spec.rb

@@ -24,6 +24,32 @@ describe Ramda::Object do
     end
   end
 
+  context '#has' do
+    it 'from docs' do
+      has_name = R.has(:name)
+      expect(has_name.call(name: 'alice')).to be_truthy
+      expect(has_name.call(name: 'bob')).to be_truthy
+      expect(has_name.call({})).to be_falsey
+    end
+
+    it 'with placeholder' do
+      point = { x: 0, y: 0 }
+      point_has = R.has(R.__, point)
+      expect(point_has.call(:x)).to be_truthy
+      expect(point_has.call(:y)).to be_truthy
+      expect(point_has.call(:z)).to be_falsey
+    end
+  end
+
+  context '#has_in' do
+    it 'from docs' do
+      square = Struct.new(:width, :area).new(2, 2)
+      expect(r.has_in(:width, square)).to be_truthy
+      expect(r.has_in(:area, square)).to be_truthy
+      expect(r.has_in(:duration, square)).to be_falsey
+    end
+  end
+
   context '#eq_props' do
     it 'from docs' do
       o1 = { a: 1, b: 2, c: 3, d: 4 }

data/spec/ramda/relation_spec.rb

@@ -141,6 +141,26 @@ describe Ramda::Relation do
     end
   end
 
+  context '#path_eq' do
+    it 'with hash' do
+      user1 = { address: { zipCode: 90_210 } }
+      user2 = { address: { zipCode: 55_555 } }
+      user3 = { name: 'Bob' }
+      users = [user1, user2, user3]
+      is_famous = R.path_eq([:address, :zipCode], 90_210)
+      expect(R.filter(is_famous, users)).to eq([user1])
+    end
+
+    it 'with array' do
+      col1 = [[11_111], [22_222], [33_333]]
+      col2 = [[44_444], [55_555], [66_666]]
+      col3 = [[77_777], [88_888], [99_999]]
+      cols = [col1, col2, col3]
+      predicate = R.path_eq([1, 0], 55_555)
+      expect(R.filter(predicate, cols)).to eq([col2])
+    end
+  end
+
   context '#sort_by' do
     it 'from docs 1' do
       sort_by_first_item = r.sort_by(R.prop(0))

data/spec/ramda_spec.rb

@@ -23,6 +23,7 @@ describe Ramda do
   r(:any_pass)
   r(:ap)
   r(:append)
+  r(:apply)
   r(:assoc)
   r(:binary)
   r(:bind)
@@ -62,6 +63,8 @@ describe Ramda do
   r(:group_by)
   r(:gt)
   r(:gte)
+  r(:has)
+  r(:has_in)
   r(:head)
   r(:identity)
   r(:if_else)
@@ -79,6 +82,8 @@ describe Ramda do
   r(:last)
   r(:last_index_of)
   r(:length)
+  r(:lift)
+  r(:lift_n)
   r(:lt)
   r(:lte)
   r(:map)
@@ -98,6 +103,7 @@ describe Ramda do
   r(:or)
   r(:partition)
   r(:path)
+  r(:path_eq)
   r(:pick)
   r(:pick_all)
   r(:pipe)

metadata

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