ramda-ruby 0.8.1 → 0.9.0

data/lib/ramda/internal/curried_method.rb

@@ -5,17 +5,19 @@ module Ramda
     # Curried Method
     module CurriedMethod
       def curried_method(name, &block)
-        define_singleton_method(name, &curried_method_body(name, block.arity, &block))
+        define_method(name, &curried_method_body(name, block.arity, &block))
       end
 
       # rubocop:disable Metrics/MethodLength
       def curried_method_body(name, arity, &block)
-        Ramda::Internal::FunctionWithArity.new.call(arity) do |*args|
+        Ramda::Internal::FunctionWithArity.call(arity) do |*args|
           begin
-            if args.include?(Ramda.__)
+            if args.index(Ramda.__)
               replace_placeholder(args, &block).curry
             else
-              args.empty? ? block : yield(*args)
+              result = args.empty? ? block : yield(*args)
+              debug_log(name, args, result) if ::Ramda::DEBUG_MODE
+              result
             end
           rescue StandardError => e
             ::Ramda.exception_handler.call(e, name)
@@ -25,62 +27,17 @@ module Ramda
       # rubocop:enable Metrics/MethodLength
 
       def replace_placeholder(basic_args)
-        Ramda::Internal::FunctionWithArity.new.call(basic_args.count(Ramda.__)) do |*new_args|
+        Ramda::Internal::FunctionWithArity.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)
+          result = yield(*cloned_args)
+          debug_log(name, cloned_args, result) if ::Ramda::DEBUG_MODE
+          result
         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 }
-
-          return curried if args.empty?
-
-          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
+      def debug_log(name, args, result)
+        puts "-> #{name}(#{args.join(', ')}) # #{result}"
       end
     end
   end

data/lib/ramda/internal/function_with_arity.rb

@@ -1,11 +1,11 @@
 module Ramda
   module Internal
     # Curried Method
-    class FunctionWithArity
+    module FunctionWithArity
       # rubocop:disable Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/MethodLength
       # rubocop:disable Metrics/ParameterLists
-      def call(arity)
+      def self.call(arity)
         case arity
         when 0, -1
           ->(*a) { yield(*a) }

data/lib/ramda/internal/java/__make_curry_proc__.rb

@@ -0,0 +1,33 @@
+module Ramda
+  module Internal
+    module Java
+      # This hack resolved issue:
+      #   undefined method `__make_curry_proc__' for Ramda::Math:Module
+      #
+      # Source:
+      #   https://github.com/jruby/jruby/issues/1523
+      #
+      module MakeCurryProc
+        # 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/list.rb

@@ -97,6 +97,22 @@ module Ramda
       end
     end
 
+    # Returns a new list excluding the leading elements of a given list which
+    # satisfy the supplied predicate function. It passes each value to the
+    # supplied predicate function, skipping elements while the predicate
+    # function returns true. The predicate function is applied
+    # to one argument: (value).
+    #
+    # Dispatches to the dropWhile method of the second argument, if present.
+    #
+    # Acts as a transducer if a transformer is given in list position.
+    #
+    # (a -> Boolean) -> [a] -> [a]
+    #
+    curried_method(:drop_while) do |fn, xs|
+      xs.drop_while(&fn)
+    end
+
     # Takes a predicate and a Filterable, and returns a new filterable of the same
     # type containing the members of the given filterable which satisfy the given
     # predicate. Filterable objects include plain objects or any object that
@@ -210,6 +226,15 @@ module Ramda
       xs.index(x)
     end
 
+    # Returns all but the last element of the given list or string.
+    #
+    # [a] -> [a]
+    # String -> String
+    #
+    curried_method(:init) do |xs|
+      xs[0..-2]
+    end
+
     # Inserts the supplied element into the list, at the specified index.
     # Note that this is not destructive: it returns a copy of the list with
     # the changes. No lists have been harmed in the application of this function.
@@ -220,6 +245,16 @@ module Ramda
       xs.dup.insert(idx, x)
     end
 
+    # Inserts the sub-list into the list, at the specified index.
+    # Note that this is not destructive: it returns a copy of the list
+    # with the changes. No lists have been harmed in the application of this function.
+    #
+    # Number -> [a] -> [a] -> [a]
+    #
+    curried_method(:insert_all) do |index, elts, xs|
+      xs.dup.insert(index, *elts)
+    end
+
     # Returns a string made by inserting the separator between each element and
     # concatenating all the elements into a single string.
     #
@@ -301,7 +336,7 @@ module Ramda
     # Filterable f => (a -> Boolean) -> f a -> [f a, f a]
     #
     curried_method(:partition) do |fn, xs|
-      ::Ramda.juxt([filter, reject]).call(fn, xs)
+      ::Ramda.juxt([::Ramda.filter, ::Ramda.reject]).call(fn, xs)
     end
 
     # Returns a new list by plucking the same named property off all objects
@@ -425,7 +460,7 @@ module Ramda
     # String -> String
     #
     curried_method(:tail) do |xs|
-      drop(1, xs)
+      ::Ramda.drop(1, xs)
     end
 
     # Returns the first n elements of the given list, string.
@@ -478,7 +513,7 @@ module Ramda
     # Chain c => c (c a) -> c a
     #
     curried_method(:unnest) do |xs|
-      Ramda.chain(Ramda.identity, xs)
+      ::Ramda.chain(::Ramda.identity, xs)
     end
 
     # Returns a new copy of the array with the element at the provided

data/lib/ramda/logic.rb

@@ -26,7 +26,7 @@ module Ramda
     # (*... -> *) -> (*... -> Boolean)
     #
     curried_method(:complement) do |fn|
-      ::Ramda::Internal::FunctionWithArity.new.call(fn.arity) do |*args|
+      ::Ramda::Internal::FunctionWithArity.call(fn.arity) do |*args|
         !fn.call(*args)
       end.curry
     end

data/lib/ramda/object.rb

@@ -33,7 +33,7 @@ module Ramda
       if path.empty?
         val
       else
-        cloned = clone(obj)
+        cloned = ::Ramda.clone(obj)
         path[0...-1].reduce(cloned) do |acc, k|
           case acc[k]
           when Hash, Array
@@ -56,10 +56,10 @@ module Ramda
       case obj
       when Hash
         obj.each_with_object(obj.dup) do |(key, value), acc|
-          acc[clone(key)] = clone(value)
+          acc[::Ramda.clone(key)] = ::Ramda.clone(value)
         end
       when Array
-        obj.map(&clone)
+        obj.map(&::Ramda.clone)
       when Symbol, Integer, NilClass, TrueClass, FalseClass
         obj
       else
@@ -72,7 +72,7 @@ module Ramda
     # String -> {k: v} -> {k: v}
     #
     curried_method(:dissoc) do |prop, obj|
-      clone(obj).tap { |o| o.delete(prop) }
+      ::Ramda.clone(obj).tap { |o| o.delete(prop) }
     end
 
     # Returns whether or not an object has an own property with the specified name
@@ -101,6 +101,56 @@ module Ramda
       a[prop] == b[prop]
     end
 
+    # Creates a new object by recursively evolving a shallow copy of object,
+    # according to the transformation functions. All non-primitive properties
+    # are copied by reference.
+    #
+    # A transformation function will not be invoked if its corresponding
+    # key does not exist in the evolved object.
+    #
+    # {k: (v -> v)} -> {k: v} -> {k: v}
+    #
+    curried_method(:evolve) do |trans, obj|
+      obj.each_with_object({}) do |(key, val), acc|
+        acc[key] = case trans[key]
+                   when Hash
+                     ::Ramda.evolve(trans[key], val)
+                   when Proc
+                     trans[key].call(val)
+                   else
+                     val
+                   end
+      end
+    end
+
+    # Same as R.invertObj, however this accounts for objects with duplicate
+    # values by putting the values into an array.
+    #
+    # {s: x} -> {x: [ s, ...]}
+    #
+    curried_method(:invert) do |obj|
+      case obj
+      when Hash
+        # Ramda.map(Ramda.map(:first.to_proc), obj.group_by { |_, v| v })
+        Hash[obj.group_by { |_, v| v }.map { |k, v| [k, v.map(&:first)] }]
+      when Array
+        Hash[obj.each_with_index.group_by { |v, _| v }.map { |k, v| [k, v.map(&:last)] }]
+      else
+        {}
+      end
+    end
+
+    curried_method(:invert_obj) do |obj|
+      case obj
+      when Hash
+        obj.invert
+      when Array
+        Hash[obj.each_with_index.map { |k, v| [k, v] }]
+      else
+        {}
+      end
+    end
+
     # Returns a list containing the names of all the enumerable own properties
     # of the supplied object.
     # Note that the order of the output array is not guaranteed.
@@ -132,7 +182,7 @@ module Ramda
     #
     curried_method(:lens) do |getter, setter|
       curried_method_body(:lens, 2) do |to_functor_fn, target|
-        Ramda.map(
+        ::Ramda.map(
           ->(focus) { setter.call(focus, target) },
           to_functor_fn.call(getter.call(target))
         )
@@ -145,7 +195,7 @@ module Ramda
     # Lens s a = Functor f => (a -> f a) -> s -> f s
     #
     curried_method(:lens_index) do |n|
-      lens(Ramda.nth(0), Ramda.update(n))
+      ::Ramda.lens(::Ramda.nth(0), ::Ramda.update(n))
     end
 
     # Returns a lens whose focus is the specified path.
@@ -155,7 +205,7 @@ module Ramda
     # Lens s a = Functor f => (a -> f a) -> s -> f s
     #
     curried_method(:lens_path) do |path|
-      lens(Ramda.path(path), Ramda.assoc_path(path))
+      ::Ramda.lens(Ramda.path(path), Ramda.assoc_path(path))
     end
 
     # Returns a lens whose focus is the specified property.
@@ -164,7 +214,17 @@ module Ramda
     # Lens s a = Functor f => (a -> f a) -> s -> f s
     #
     curried_method(:lens_prop) do |k|
-      lens(Ramda.prop(k), Ramda.assoc(k))
+      ::Ramda.lens(Ramda.prop(k), Ramda.assoc(k))
+    end
+
+    # An Object-specific version of map. The function is applied to
+    # three arguments: (value, key, obj).
+    # If only the value is significant, use map instead.
+    #
+    # ((*, String, Object) -> *) -> Object -> Object
+    #
+    curried_method(:map_obj_indexed) do |fn, obj|
+      Hash[obj.map { |(k, v)| [k, fn.call(v, k, obj)] }]
     end
 
     # Create a new object with the own properties of the first object merged
@@ -182,7 +242,7 @@ module Ramda
     # [String] -> {String: *} -> {String: *}
     #
     curried_method(:omit) do |keys, obj|
-      obj_copy = clone(obj)
+      obj_copy = ::Ramda.clone(obj)
       keys.each(&obj_copy.method(:delete))
       obj_copy
     end
@@ -244,7 +304,7 @@ module Ramda
     # [k] -> [{k: v}] -> [{k: v}]
     #
     curried_method(:project) do |keys, objs|
-      objs.map(&pick_all(keys))
+      objs.map(&::Ramda.pick_all(keys))
     end
 
     # Returns a function that when supplied an object returns the indicated
@@ -287,7 +347,7 @@ module Ramda
     # Lens s a = Functor f => (a -> f a) -> s -> f s
     #
     curried_method(:set) do |lens, v, x|
-      over(lens, Ramda.always(v), x)
+      ::Ramda.over(lens, Ramda.always(v), x)
     end
 
     # Converts an object into an array of key, value arrays. Only the

data/lib/ramda/version.rb

@@ -1,3 +1,3 @@
 module Ramda
-  VERSION = '0.8.1'.freeze
+  VERSION = '0.9.0'.freeze
 end

data/spec/ramda/function_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Ramda::Function do
-  let(:r) { described_class }
+  let(:r) { Ramda }
 
   context '#F' do
     it 'from docs' do
@@ -85,6 +85,35 @@ describe Ramda::Function do
     end
   end
 
+  context '#call' do
+    it 'from docs' do
+      indent_n = R.pipe(R.times(R.always(' ')),
+                        R.join(''),
+                        R.replace(/^(?!$)/m))
+
+      format = R.converge(R.call, [
+                            R.pipe(R.prop(:indent), indent_n),
+                            R.prop(:value)
+                          ])
+
+      expect(format.call(indent: 2, value: "foo\nbar\nbaz\n")).to eq("  foo\n  bar\n  baz\n")
+    end
+
+    it 'returns the result of calling its first argument with the remaining arguments' do
+      fn = ->(*args) { args.max }
+      expect(R.call(fn, 1, 2, 3, -99, 42, 6, 7)).to eq(42)
+    end
+
+    it 'accepts one or more arguments' do
+      fn = ->(*args) { args.length; }
+
+      expect(R.call(fn)).to eq(0)
+      expect(R.call(fn, 'x')).to eq(1)
+      expect(R.call(fn, 'x', 'y')).to eq(2)
+      expect(R.call(fn, 'x', 'y', 'z')).to eq(3)
+    end
+  end
+
   context '#comparator' do
     it 'from docs' do
       sort_rule = r.comparator(->(a, b) { a < b })
@@ -355,6 +384,14 @@ describe Ramda::Function do
     end
   end
 
+  context '#nth_arg' do
+    it 'from docs' do
+      expect(R.nth_arg(1, 'a', 'b', 'c')).to eq('b')
+      expect(R.nth_arg(1).call('a', 'b', 'c')).to eq('b')
+      expect(R.nth_arg(-1).call('a', 'b', 'c')).to eq('c')
+    end
+  end
+
   context '#of' do
     it 'from docs' do
       expect(r.of(nil)).to eq([nil])