ramda-ruby 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d5757dd75ba41c1a2d00617b9ac764d96f378a1
-  data.tar.gz: 379e4d2156f99f92bb273d3b85e53f3ecab52ae4
+  metadata.gz: b89810eb9aeb97f4360a2ef5cdfff495a46d2495
+  data.tar.gz: 0ef2de2a457e9b889311f4af94a1b7f52c122abf
 SHA512:
-  metadata.gz: b469dce9a379ee2b6abeb701eb8fe23aff6189a3b2075cfd7c39addda944ad205fe86fb46e6066718cb3bd819fae37efe086743b438c9b437899860ca98a5dd4
-  data.tar.gz: 3f8d3a0c7d2853db5c8be295651827f792774566791d2cc43880b4927e4001c4d0780a8e4dba1c49736e5f63e95f0df186119bd68cd5b6ded3c7a80af8c1efa3
+  metadata.gz: e7b826795f824e977f6f9c0b8d8d87bb482bc96b861f3c2ce4e0aa9d81c4c4f15efe3b5f5f0d32ee9abbb8f45342c9d0c548b0fdd9f579453508f8906edb7e12
+  data.tar.gz: cd22adad8b7b4ce649844de486c1a0f6f67daebdd9901a5a9cf9ed8f2d50fab7895b5d903ff39990fd3f1723ebb9a1ef92cc5f7f9a2544ba7615c8074d821317

data/CHANGELOG.md

@@ -1,6 +1,25 @@
 Not Released
 ---------------
 
+Release 0.12.0
+---------------
+
+Added:
+
+* [aperture](http://ramdajs.com/docs/#aperture)
+* [both](http://ramdajs.com/docs/#both)
+* [either](http://ramdajs.com/docs/#either)
+* [into](http://ramdajs.com/docs/#into)
+* [none](http://ramdajs.com/docs/#none)
+* [test](http://ramdajs.com/docs/#test)
+* [transduce](http://ramdajs.com/docs/#transduce)
+
+Transducers for:
+
+* filter
+* map
+* take
+
 Release 0.11.0
 ---------------
 

data/README.md

@@ -4,7 +4,7 @@ Ramda Ruby
 This is a ruby version of [Ramda Js](http://ramdajs.com) library.
 
 [![Gem Version](https://badge.fury.io/rb/ramda-ruby.svg)](http://badge.fury.io/rb/ramda-ruby)
-[![Functions](https://img.shields.io/badge/Functions-171-green.svg)](docs/FUNCTIONS.md)
+[![Functions](https://img.shields.io/badge/Functions-178-green.svg)](docs/FUNCTIONS.md)
 [![Travis badge](https://travis-ci.org/lazebny/ramda-ruby.svg?branch=master)](https://travis-ci.org/lazebny/ramda-ruby)
 [![AppVeyor status](https://ci.appveyor.com/api/projects/status/ponccdax7aj4ufw2?svg=true)](https://ci.appveyor.com/project/lazebny/ramda-ruby)
 [![Coverage Status](https://coveralls.io/repos/lazebny/ramda-ruby/badge.png)](https://coveralls.io/r/lazebny/ramda-ruby)
@@ -47,15 +47,17 @@ require 'ramda'
 Documentation
 -------------
 
-Currently the gem doesn't have own documentation but it tries to follow specification from [Ramda Js](http://ramdajs.com/docs/)
-
-* each release includes [functions](docs/FUNCTIONS.md) from the relevant [Ramda Js](http://ramdajs.com) release
-* each release includes more functions which i found pretty useful but they are from upcoming releases
-
-You could use [Ramda Js](http://ramdajs.com/docs/) as a source of documentation.
-
-Ruby scpecific examples can be found in [tests](spec/ramda).
+* [Function](docs/FUNCTIONS.md#function)
+* [List](docs/FUNCTIONS.md#list)
+* [Logic](docs/FUNCTIONS.md#logic)
+* [Math](docs/FUNCTIONS.md#math)
+* [Object](docs/FUNCTIONS.md#object)
+* [Relation](docs/FUNCTIONS.md#relation)
+* [String](docs/FUNCTIONS.md#string)
+* [Type](docs/FUNCTIONS.md#type)
 
+You can use Ramda [docs](http://ramdajs.com/docs/) as a documentation
+or to check Ruby [examples](spec/ramda).
 
 Usage
 -------------
@@ -87,6 +89,29 @@ Placeholder:
 
 ```
 
+Transducers:
+
+```ruby
+
+  appender = R.flip(R.append)
+
+  xform = R.map(R.add(10))
+  R.transduce(xform, appender, [], [1, 2, 3, 4]) # [11, 12, 13, 14]
+
+  xform = R.filter(:odd?.to_proc)
+  R.transduce(xform, appender, [], [1, 2, 3, 4]) # [1, 3]
+
+  xform = R.compose(R.map(R.add(10)), R.take(2))
+  R.transduce(xform, appender, [], [1, 2, 3, 4]) # [11, 12]
+
+  xform = R.compose(R.filter(:odd?.to_proc), R.take(2))
+  R.transduce(xform, R.add, 100, [1, 2, 3, 4, 5]) # 104)
+  R.transduce(xform, appender, [], [1, 2, 3, 4, 5]) # [1, 3])
+  R.into([], xform, [1, 2, 3, 4, 5]) # [1, 3])
+
+
+```
+
 Change exceptions handler:
 
 ```ruby

data/ROADMAP.md

@@ -1,13 +1,3 @@
-Release 0.12.0
----------------
-* apperture
-* both
-* either
-* into
-* none
-* test
-* transduce
-
 Release 0.13.0
 ---------------
 

data/docs/FUNCTIONS.md

@@ -51,13 +51,14 @@ List
 
 * [all](http://ramdajs.com/docs/#all)
 * [any](http://ramdajs.com/docs/#any)
+* [aperture](http://ramdajs.com/docs/#aperture)
 * [append](http://ramdajs.com/docs/#append)
 * [chain](http://ramdajs.com/docs/#chain)
 * [concat](http://ramdajs.com/docs/#concat)
 * [contains](http://ramdajs.com/docs/#contains)
 * [drop](http://ramdajs.com/docs/#drop)
 * [drop_while](http://ramdajs.com/docs/#dropWhile)
-* [filter](http://ramdajs.com/docs/#filter)
+* [filter](http://ramdajs.com/docs/#filter) - transducer
 * [find](http://ramdajs.com/docs/#find)
 * [find_index](http://ramdajs.com/docs/#findIndex) - returns nil if index doesn't exist
 * [find_last](http://ramdajs.com/docs/#findLast)
@@ -71,13 +72,15 @@ List
 * [init](http://ramdajs.com/docs/#init)
 * [insert](http://ramdajs.com/docs/#insert)
 * [insert_all](http://ramdajs.com/docs/#insertAll)
+* [into](http://ramdajs.com/docs/#into)
 * [join](http://ramdajs.com/docs/#join)
 * [last](http://ramdajs.com/docs/#last)
 * [last_index_of](http://ramdajs.com/docs/#lastIndexOf) - returns nil if index doesn't exist
 * [length](http://ramdajs.com/docs/#length)
-* [map](http://ramdajs.com/docs/#map)
+* [map](http://ramdajs.com/docs/#map) - transducer
 * [map_obj_indexed](http://ramdajs.com/docs/#mapObjIndexed)
 * [merge_all](http://ramdajs.com/docs/#mergeAll)
+* [none](http://ramdajs.com/docs/#none)
 * [nth](http://ramdajs.com/docs/#nth)
 * [partition](http://ramdajs.com/docs/#partition)
 * [pluck](http://ramdajs.com/docs/#pluck)
@@ -94,9 +97,10 @@ List
 * [sort](http://ramdajs.com/docs/#sort)
 * [sort_by](http://ramdajs.com/docs/#sortBy)
 * [tail](http://ramdajs.com/docs/#tail)
-* [take](http://ramdajs.com/docs/#take)
+* [take](http://ramdajs.com/docs/#take)- transducer
 * [take_while](http://ramdajs.com/docs/#takeWhile)
 * [times](http://ramdajs.com/docs/#times)
+* [transduce](http://ramdajs.com/docs/#transduce)
 * [unfold](http://ramdajs.com/docs/#unfold)
 * [uniq](http://ramdajs.com/docs/#uniq)
 * [uniq_with](http://ramdajs.com/docs/#uniqWith) - first argument is a function with 1 arity which transforms each list element and applies uniq function to results
@@ -113,9 +117,11 @@ Logic
 * [all_pass](http://ramdajs.com/docs/#allPass)
 * [and](http://ramdajs.com/docs/#and)
 * [any_pass](http://ramdajs.com/docs/#anyPass)
+* [both](http://ramdajs.com/docs/#both)
 * [complement](http://ramdajs.com/docs/#complement)
 * [cond](http://ramdajs.com/docs/#cond)
 * [default_to](http://ramdajs.com/docs/#defaultTo)
+* [either](http://ramdajs.com/docs/#either)
 * [if_else](http://ramdajs.com/docs/#ifElse)
 * [is_empty](http://ramdajs.com/docs/#isEmpty)
 * [not](http://ramdajs.com/docs/#not)
@@ -201,6 +207,7 @@ String
 * [match](http://ramdajs.com/docs/#math)
 * [replace](http://ramdajs.com/docs/#replace) - it uses a gsub method and global replacement
 * [split](http://ramdajs.com/docs/#split)
+* [test](http://ramdajs.com/docs/#test)
 * [to_lower](http://ramdajs.com/docs/#toLower)
 * [to_upper](http://ramdajs.com/docs/#toUpper)
 * [trim](http://ramdajs.com/docs/#trim)

data/lib/ramda/function.rb

@@ -1,4 +1,5 @@
 require_relative 'internal/curried_method'
+require_relative 'internal/dispatchable'
 require_relative 'internal/function_with_arity'
 
 module Ramda
@@ -6,6 +7,7 @@ module Ramda
   # rubocop:disable Metrics/ModuleLength
   module Function
     extend ::Ramda::Internal::CurriedMethod
+    extend ::Ramda::Internal::Dispatchable
 
     # Returns a function that always returns the given value. Note that
     # for non-primitives the value returned is a reference to the original
@@ -26,13 +28,9 @@ module Ramda
     # [a -> b] -> [a] -> [b]
     # Apply f => f (a -> b) -> f a -> f b
     #
-    curried_method(:ap) do |apply_f, apply_x|
-      if apply_x.is_a?(Array)
-        apply_f.flat_map { |fn| apply_x.map(&fn) }
-      else
-        Internal::Dispatchable.call([:ap], nil, apply_f, apply_x)
-      end
-    end
+    curried(:ap, &dispatchable(:ap, ::Array) do |apply_f, apply_x|
+      apply_f.flat_map { |fn| apply_x.map(&fn) }
+    end)
 
     # Applies function fn to the argument list args. This is useful
     # for creating a fixed-arity function from a variadic function.

data/lib/ramda/internal/curried_method.rb

@@ -4,10 +4,12 @@ module Ramda
   module Internal
     # Curried Method
     module CurriedMethod
-      def curried_method(name, &block)
+      def curried(name, &block)
         define_method(name, &curried_method_body(name, block.arity, &block))
       end
 
+      alias curried_method curried
+
       # rubocop:disable Metrics/MethodLength
       def curried_method_body(name, arity, &block)
         Ramda::Internal::FunctionWithArity.call(arity) do |*args|

data/lib/ramda/internal/dispatchable.rb

@@ -1,8 +1,10 @@
 module Ramda
   module Internal
     # Dispatchable
+    # rubocop:disable Performance/CaseWhenSplat
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Style/GuardClause
     module Dispatchable
-      #
       #   Returns a function that dispatches with different strategies based on the
       #   object in list position (last argument). If it is an array, executes [fn].
       #   Otherwise, if it has a  function with [methodname], it will execute that
@@ -11,17 +13,33 @@ module Ramda
       #   default to executing [fn].
       #
       #   @private
-      #   - @param {String} methodname property to check for a custom implementation
+      #   - @param {Array[Symbol]|Symbol} method_names property to check for a custom implementation
+      #   - @param {Array[Class]|Class} described_types a list of type with default behaviour
       #   - @param {Function} xf transducer to initialize if object is transformer
       #   - @param {Function} fn default ramda implementation
       #   - @return {Function} A function that dispatches on object in list position
       #
-      def self.call(method_names, _xf, *args, xs)
-        method_name = method_names.find { |name| xs.respond_to?(name) }
+      def dispatchable(method_names, described_types, xf = nil, &fn)
+        method_names = Array(method_names)
+
+        FunctionWithArity.call(fn.arity) do |*args, xs|
+          case xs
+          when *described_types # default behaviour
+            yield(*args, xs)
+
+          when Proc # transducer behaviour
+            xf.call(*args, xs)
 
-        return xs.public_send(method_name, *args) if method_name
+          else # method dispatch behaviour
+            method_name = method_names.find { |name| xs.respond_to?(name) }
 
-        raise ArgumentError, "Unexpected type #{xs.class} in method: #{method_name}"
+            if method_name
+              xs.public_send(method_name, *args)
+            else
+              raise ArgumentError, "Unexpected type #{xs.class} in method: #{method_name}"
+            end
+          end
+        end
       end
     end
   end

data/lib/ramda/internal/transducers.rb

@@ -0,0 +1,40 @@
+module Ramda
+  module Internal
+    # Transducers
+    #
+    # Signature: (*, reducing_fn) -> Proc((acc, input) -> acc)
+    #
+    module Transducers
+      # predicate - fn with 1 arity
+      def self.filter(predicate, reducer)
+        lambda do |acc, x|
+          if predicate.call(x)
+            reducer.call(acc, x)
+          else
+            acc
+          end
+        end
+      end
+
+      # transformer - fn with 1 arity
+      def self.map(transformer, reducer)
+        lambda do |acc, x|
+          reducer.call(acc, transformer.call(x))
+        end
+      end
+
+      # limit - number
+      def self.take(limit, reducer)
+        count = 0
+        lambda do |acc, x|
+          count += 1
+          if limit >= count
+            reducer.call(acc, x)
+          else
+            acc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramda/list.rb

@@ -1,11 +1,15 @@
 require_relative 'internal/curried_method'
 require_relative 'internal/dispatchable'
+require_relative 'internal/transducers'
 
 module Ramda
   # List functions
   # rubocop:disable Metrics/ModuleLength
   module List
+    Transducer = ->(method) { ::Ramda::Internal::Transducers.method(method) }
+
     extend ::Ramda::Internal::CurriedMethod
+    extend ::Ramda::Internal::Dispatchable
 
     # Returns true if all elements of the list match the predicate,
     # false if there are any that don't.
@@ -16,13 +20,9 @@ module Ramda
     #
     # (a -> Boolean) -> [a] -> Boolean
     #
-    curried_method(:all) do |f, xs|
-      if xs.is_a?(::Array)
-        xs.all?(&f)
-      else
-        Internal::Dispatchable.call([:any], nil, f, xs)
-      end
-    end
+    curried(:all, &dispatchable(:all, ::Array) do |f, xs|
+      xs.all?(&f)
+    end)
 
     # Returns true if at least one of elements of the list match the predicate,
     # false otherwise.
@@ -33,12 +33,19 @@ module Ramda
     #
     # (a -> Boolean) -> [a] -> Boolean
     #
-    curried_method(:any) do |f, xs|
-      if xs.is_a?(::Array)
-        xs.any?(&f)
-      else
-        Internal::Dispatchable.call([:any], nil, f, xs)
-      end
+    curried(:any, &dispatchable(:any, ::Array) do |f, xs|
+      xs.any?(&f)
+    end)
+
+    # Returns a new list, composed of n-tuples of consecutive elements.
+    # If n is greater than the length of the list, an empty list is returned.
+    #
+    # Acts as a transducer if a transformer is given in list position.
+    #
+    # Number -> [a] -> [[a]]
+    #
+    curried_method(:aperture) do |n, xs|
+      xs.each_cons(n).to_a
     end
 
     # Returns a new list containing the contents of the given list,
@@ -58,35 +65,28 @@ module Ramda
     #
     # Chain m => (a -> m b) -> m a -> m b
     #
-    curried_method(:chain) do |f, xs|
-      if xs.is_a?(::Array)
-        xs.flat_map(&f)
-      else
-        Internal::Dispatchable.call([:chain, :bind], nil, f, xs)
-      end
-    end
+    curried(:chain, &dispatchable([:chain, :bind], ::Array) do |f, xs|
+      xs.flat_map(&f)
+    end)
 
     # Returns the result of concatenating the given lists or strings.
-    # String -> String -> String
     #
+    # Dispatches to the concat method of the first argument, if present.
+    #
+    # String -> String -> String
     # List -> List -> List
     #
-    curried_method(:concat) do |list_a, list_b|
-      case list_b
-      when ::String, ::Symbol
-        [list_a, list_b].join('')
-      when ::Array
-        list_a.dup + list_b
+    curried(:concat, &dispatchable(:concat, [::Array, ::String, ::Symbol]) do |list_a, list_b|
+      if list_b.is_a?(::Array)
+        list_a + list_b
       else
-        Internal::Dispatchable.call([:concat], nil, list_a, list_b)
+        [list_a, list_b].join('')
       end
-    end
+    end)
 
     # Returns true if the specified value is equal, in R.equals terms,
     # to at least one element of the given list; false otherwise.
     #
-    # Dispatches to the concat method of the first argument, if present.
-    #
     # a -> [a] -> Boolean
     #
     curried_method(:contains) do |x, xs|
@@ -101,16 +101,9 @@ module Ramda
     # Number -> [a] -> [a]
     # Number -> String -> String
     #
-    curried_method(:drop) do |num, xs|
-      case xs
-      when ::String
-        xs[num..-1] || ''
-      when ::Array
-        xs[num..-1] || []
-      else
-        Internal::Dispatchable.call([:drop], nil, num, xs)
-      end
-    end
+    curried(:drop, &dispatchable(:drop, [::Array, ::String]) do |num, xs|
+      xs[num..-1] || xs.class.new
+    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
@@ -124,13 +117,9 @@ module Ramda
     #
     # (a -> Boolean) -> [a] -> [a]
     #
-    curried_method(:drop_while) do |f, xs|
-      if xs.is_a?(::Array)
-        xs.drop_while(&f)
-      else
-        Internal::Dispatchable.call([:drop_while], nil, f, xs)
-      end
-    end
+    curried(:drop_while, &dispatchable(:drop_while, ::Array) do |f, xs|
+      xs.drop_while(&f)
+    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
@@ -141,16 +130,13 @@ module Ramda
     #
     # Filterable f => (a -> Boolean) -> f a -> f a
     #
-    curried_method(:filter) do |f, xs|
-      case xs
-      when ::Hash
+    curried(:filter, &dispatchable(:filter, [::Array, ::Hash], Transducer[:filter]) do |f, xs|
+      if xs.is_a?(Hash)
         xs.select { |_, value| f.call(value) }
-      when ::Array
-        xs.select(&f)
       else
-        Internal::Dispatchable.call([:filter], nil, f, xs)
+        xs.select(&f)
       end
-    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.
@@ -168,13 +154,9 @@ module Ramda
     #
     # (a -> Boolean) -> [a] -> a | NilClass
     #
-    curried_method(:find) do |f, xs|
-      if xs.is_a?(::Array)
-        xs.find(&f)
-      else
-        Internal::Dispatchable.call([:find], nil, f, xs)
-      end
-    end
+    curried(:find, &dispatchable(:find, ::Array) do |f, xs|
+      xs.find(&f)
+    end)
 
     # Returns the index of the first element of the list which matches the predicate,
     # or nil if no element matches.
@@ -218,13 +200,9 @@ module Ramda
     #
     # (a -> *) -> [a] -> [a]
     #
-    curried_method(:for_each) do |f, xs|
-      if xs.is_a?(::Array)
-        xs.each(&f)
-      else
-        Internal::Dispatchable.call([:for_each], nil, f, xs)
-      end
-    end
+    curried(:for_each, &dispatchable(:for_each, ::Array) do |f, xs|
+      xs.each(&f)
+    end)
 
     # Splits a list into sub-lists stored in an object, based on the result of
     # calling a String-returning function on each element, and grouping the
@@ -235,13 +213,9 @@ module Ramda
     #
     # (a -> String) -> [a] -> {String: [a]}
     #
-    curried_method(:group_by) do |f, xs|
-      if xs.is_a?(::Array)
-        xs.group_by(&f)
-      else
-        Internal::Dispatchable.call([:group_by], nil, f, xs)
-      end
-    end
+    curried(:group_by, &dispatchable(:group_by, ::Array) do |f, xs|
+      xs.group_by(&f)
+    end)
 
     # Returns the first element of the given list or string. In some libraries
     # this function is named first.
@@ -296,6 +270,43 @@ module Ramda
       xs.dup.insert(index, *elts)
     end
 
+    # Transforms the items of the list with the transducer and appends
+    # the transformed items to the accumulator using an appropriate iterator
+    # function based on the accumulator type.
+    #
+    # The accumulator can be an array, string, object or a transformer.
+    # Iterated items will be appended to arrays and concatenated to strings.
+    # Objects will be merged directly.
+    #
+    # The accumulator can also be a transformer object that provides a 2-arity
+    # reducing iterator function, step, 0-arity initial value function,
+    # init, and 1-arity result extraction function result.
+    # The step function is used as the iterator function in reduce. The result
+    # function is used to convert the final accumulator into the return type
+    # and in most cases is R.identity. The init function is used to provide
+    # the initial accumulator.
+    #
+    # The iteration is performed with R.reduce after initializing the transducer.
+    #
+    # a -> (b -> b) -> [c] -> a
+    #
+    curried_method(:into) do |acc, xf, xs|
+      rx = case acc
+           when ::Array
+             lambda { |arr, x|
+               arr.push(x)
+               arr
+             }
+           when ::String
+             ->(str, x) { "#{str}#{x}" }
+           when ::Object
+             ->(obj, x) { obj.merge(x) }
+           else
+             raise ArgumetError, "Cannot create transformer for #{acc}"
+           end
+      xs.reduce(acc, &xf.call(rx))
+    end
+
     # Returns a string made by inserting the separator between each element and
     # concatenating all the elements into a single string.
     #
@@ -338,16 +349,14 @@ module Ramda
     #
     # Functor f => (a -> b) -> f a -> f b
     #
-    curried_method(:map) do |f, xs|
+    curried(:map, &dispatchable(:map, [::Hash, ::Array], Transducer[:map]) do |f, xs|
       case xs
       when ::Hash
         Hash[xs.map { |k, v| [k, f.call(v)] }]
       when ::Array
         xs.map(&f)
-      else
-        Internal::Dispatchable.call([:map], nil, f, xs)
       end
-    end
+    end)
 
     # The mapAccum function behaves like a combination of map and reduce;
     # it applies a function to each element of a list, passing
@@ -371,6 +380,16 @@ module Ramda
       xs.reduce(&:merge)
     end
 
+    # Returns true if no elements of the list match the predicate, false otherwise.
+    #
+    # Dispatches to the none? method of the second argument, if present.
+    #
+    # (a -> Boolean) -> [a] -> Boolean
+    #
+    curried_method(:none) do |f, xs|
+      xs.none?(&f)
+    end
+
     # Returns the nth element of the given list or string. If n is negative
     # the element at index length + n is returned.
     #
@@ -507,14 +526,9 @@ module Ramda
     # Number -> Number -> [a] -> [a]
     # Number -> Number -> String -> String
     #
-    curried_method(:slice) do |from, to, xs|
-      case xs
-      when ::Array, ::String
-        xs[from...to]
-      else
-        Internal::Dispatchable.call([:slice], nil, from, to, xs)
-      end
-    end
+    curried(:slice, &dispatchable(:slice, [::Array, ::String]) do |from, to, xs|
+      xs[from...to]
+    end)
 
     # Returns a copy of the list, sorted according to the comparator function,
     # which should accept two values at a time and return a negative number
@@ -543,14 +557,9 @@ module Ramda
     # Number -> [a] -> [a]
     # Number -> String -> String
     #
-    curried_method(:take) do |num, xs|
-      case xs
-      when ::Array, ::String
-        xs[0, num]
-      else
-        Internal::Dispatchable.call([:take], nil, num, xs)
-      end
-    end
+    curried(:take, &dispatchable(:take, [::Array, ::String], Transducer[:take]) do |num, xs|
+      xs[0, num]
+    end)
 
     # Returns a new list containing the first n elements of a given list,
     # passing each value to the supplied predicate function, and terminating
@@ -560,13 +569,9 @@ module Ramda
     #
     # (a -> Boolean) -> [a] -> [a]
     #
-    curried_method(:take_while) do |f, xs|
-      if xs.is_a?(::Array)
-        xs[0, xs.index { |x| !f.call(x) } || xs.size]
-      else
-        Internal::Dispatchable.call([:take_while], nil, f, xs)
-      end
-    end
+    curried(:take_while, &dispatchable(:take_while, ::Array) do |f, xs|
+      xs[0, xs.index { |x| !f.call(x) } || xs.size]
+    end)
 
     # Calls an input function n times, returning an array containing the results
     # of those function calls.
@@ -579,6 +584,26 @@ module Ramda
       n.times.to_a.map(&f)
     end
 
+    # Returns a single item by iterating through the list, successively
+    # calling the iterator function and passing it an accumulator value
+    # and the current value from the array, and then passing the result
+    # to the next call.
+    #
+    # The iterator function receives two values: (acc, value).
+    # It may use R.reduced to shortcut the iteration.
+    #
+    # The arguments' order of reduceRight's iterator function is (value, acc).
+    #
+    # Dispatches to the reduce method of the third argument, if present.
+    # When doing so, it is up to the user to handle the R.reduced shortcuting,
+    # as this is not implemented by reduce.
+    #
+    # ((a, b) -> a) -> a -> [b] -> a
+    #
+    curried_method(:transduce) do |xf, rx, acc, xs|
+      xs.reduce(acc, &xf.call(rx))
+    end
+
     # Builds a list from a seed value. Accepts an iterator function, which
     # returns either false to stop iteration or an array of length 2
     # containing the value to add to the resulting list and the seed

data/lib/ramda/logic.rb

@@ -5,18 +5,55 @@ module Ramda
   module Logic
     extend ::Ramda::Internal::CurriedMethod
 
+    # Takes a list of predicates and returns a predicate that returns
+    # true for a given list of arguments if every one of the provided
+    # predicates is satisfied by those arguments.
+    #
+    # The function returned is a curried function whose arity matches
+    # that of the highest-arity predicate.
+    #
+    # [(*... -> Boolean)] -> (*... -> Boolean)
+    #
     curried_method(:all_pass) do |predicates, obj|
       predicates.all? { |predicate| predicate.call(obj) }
     end
 
+    # Returns true if both arguments are true; false otherwise.
+    #
+    # a -> b -> a | b
+    #
     curried_method(:and) do |a, b|
       a && b
     end
 
+    # Takes a list of predicates and returns a predicate that returns
+    # true for a given list of arguments if at least one of the
+    # provided predicates is satisfied by those arguments.
+    #
+    # The function returned is a curried function whose arity matches
+    # that of the highest-arity predicate.
+    #
+    # [(*... -> Boolean)] -> (*... -> Boolean)
+    #
     curried_method(:any_pass) do |predicates, obj|
       predicates.any? { |predicate| predicate.call(obj) }
     end
 
+    # A function which calls the two provided functions and returns
+    # the && of the results. It returns the result of the first function
+    # if it is false-y and the result of the second function otherwise.
+    # Note that this is short-circuited, meaning that the second function
+    # will not be invoked if the first returns a false-y value.
+    #
+    # In addition to functions, R.both also accepts any fantasy-land
+    # compatible applicative functor.
+    #
+    # (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
+    #
+    curried_method(:both) do |fa, fb|
+      ->(*args) { fa.call(*args) && fb.call(*args) }
+    end
+
     # Takes a function f and returns a function g such that if called with
     # the same arguments when f returns a "truthy" value, g returns false
     # and when f returns a "falsy" value g returns true.
@@ -56,6 +93,21 @@ module Ramda
       b || a
     end
 
+    # A function wrapping calls to the two functions in an || operation,
+    # returning the result of the first function if it is truth-y and
+    # the result of the second function otherwise.
+    # Note that this is short-circuited, meaning that the second
+    # function will not be invoked if the first returns a truth-y value.
+    #
+    # In addition to functions, R.either also accepts any fantasy-land
+    # compatible applicative functor.
+    #
+    # (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean))
+    #
+    curried_method(:either) do |fa, fb|
+      ->(*args) { fa.call(*args) || fb.call(*args) }
+    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/string.rb

@@ -37,6 +37,14 @@ module Ramda
       x.split(sep)
     end
 
+    # Determines whether a given string matches a given regular expression.
+    #
+    # RegExp -> String -> Boolean
+    #
+    curried_method(:test) do |rx, str|
+      !str.match(rx).nil?
+    end
+
     # The upper case version of a string.
     #
     # String -> String

data/lib/ramda/version.rb

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

data/spec/ramda/list_spec.rb

@@ -32,6 +32,14 @@ describe Ramda::List do
     end
   end
 
+  context '#aperture' do
+    it 'from docs' do
+      expect(R.aperture(2, [1, 2, 3, 4, 5])).to eq([[1, 2], [2, 3], [3, 4], [4, 5]])
+      expect(R.aperture(3, [1, 2, 3, 4, 5])).to eq([[1, 2, 3], [2, 3, 4], [3, 4, 5]])
+      expect(R.aperture(7, [1, 2, 3, 4, 5])).to eq([])
+    end
+  end
+
   context '#append' do
     it 'from docs' do
       expect(r.append('tests', ['write', 'more'])).to eq(['write', 'more', 'tests'])
@@ -300,6 +308,32 @@ describe Ramda::List do
     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])
+      expect(R.into([], R.filter(:odd?.to_proc), [1, 2, 3, 4])).to eq([1, 3])
+      expect(R.into([], R.compose(R.map(R.add(1)), R.take(2)), [1, 2, 3, 4])).to eq([2, 3])
+    end
+
+    it 'transduces into strings' do
+      expect(R.into('', R.map(R.add(1)), [1, 2, 3, 4])).to eq('2345')
+      expect(R.into('', R.filter(:odd?.to_proc), [1, 2, 3, 4])).to eq('13')
+      expect(R.into('', R.compose(R.map(R.add(1)), R.take(2)), [1, 2, 3, 4])).to eq('23')
+    end
+
+    it 'transduces into objects' do
+      # expect(R.into({}, R.identity, [[:a, 1], [:b, 2]])).to eq(a: 1, b: 2)
+      expect(R.into({}, R.identity, [{ a: 1 }, { b: 2, c: 3 }])).to eq(a: 1, b: 2, c: 3)
+    end
+
+    it 'is curried' do
+      into_array = R.into([])
+      add2 = R.map(R.add(2))
+      result = into_array.call(add2)
+      expect(result.call([1, 2, 3, 4])).to eq([3, 4, 5, 6])
+    end
+  end
+
   context '#join' do
     it 'from docs' do
       expect(r.join('|', [1, 2, 3])).to eq('1|2|3')
@@ -370,6 +404,16 @@ describe Ramda::List do
     end
   end
 
+  context '#none' do
+    it 'from docs' do
+      is_even = :even?.to_proc
+      is_odd = :odd?.to_proc
+
+      expect(R.none(is_even, [1, 3, 5, 7, 9, 11])).to be_truthy
+      expect(R.none(is_odd, [1, 3, 5, 7, 9, 11])).to be_falsey
+    end
+  end
+
   context '#nth' do
     it 'with array' do
       list = ['foo', 'bar', 'baz', 'quux']
@@ -594,6 +638,58 @@ describe Ramda::List do
     end
   end
 
+  context '#transduce' do
+    context 'transduces into arrays' do
+      let(:append) { R.flip(R.append) }
+
+      it 'different cases' do
+        xform = R.map(R.add(10))
+        expect(R.transduce(xform, append, [], [1, 2, 3, 4])).to eq([11, 12, 13, 14])
+
+        xform = R.filter(:odd?.to_proc)
+        expect(R.transduce(xform, append, [], [1, 2, 3, 4])).to eq([1, 3])
+
+        xform = R.compose(R.map(R.add(10)), R.take(2))
+        expect(R.transduce(xform, append, [], [1, 2, 3, 4])).to eq([11, 12])
+
+        xform = R.compose(R.filter(:odd?.to_proc), R.take(2))
+        expect(R.transduce(xform, append, [], [1, 2, 3, 4, 5])).to eq([1, 3])
+        expect(R.transduce(xform, R.add, 100, [1, 2, 3, 4, 5])).to eq(104)
+      end
+    end
+
+    context '#transducers into strings' do
+      let(:add) { ->(acc, x) { [acc, x].join } }
+
+      it 'different cases' do
+        xform = R.map(R.inc)
+        expect(R.transduce(xform, add, '', [1, 2, 3, 4])).to eq('2345')
+
+        xform = R.filter(:odd?.to_proc)
+        expect(R.transduce(xform, add, '', [1, 2, 3, 4])).to eq('13')
+
+        xform = R.compose(R.map(R.add(1)), R.take(2))
+        expect(R.transduce(xform, add, '', [1, 2, 3, 4])).to eq('23')
+      end
+    end
+
+    context 'transduces into objects' do
+      it 'different cases' do
+        xform = R.map(R.identity)
+        expect(R.transduce(xform, R.merge, {}, [{ a: 1 }, { b: 2, c: 3 }])).to eq(a: 1, b: 2, c: 3)
+      end
+    end
+
+    it 'returns the accumulator for an empty collection' do
+      reducer = ->(acc, x) { acc + x }
+
+      xform = R.map(R.identity)
+      expect(R.transduce(xform, reducer, 0, [])).to be(0)
+      expect(R.transduce(xform, reducer, 1, [])).to be(1)
+      expect(R.transduce(xform, reducer, [], [])).to eql([])
+    end
+  end
+
   context '#unfold' do
     it 'from docs' do
       f = ->(n) { n > 50 ? false : [-n, n + 10] }

data/spec/ramda/logic_spec.rb

@@ -3,31 +3,47 @@ require 'spec_helper'
 describe Ramda::Logic do
   let(:r) { Ramda }
 
-  it '#all_pass' do
-    is_queen = R.prop_eq(:rank, 'Queen')
-    is_spade = R.prop_eq(:suit, 'Spade')
+  context '#all_pass' do
+    it 'from docs' do
+      is_queen = R.prop_eq(:rank, 'Queen')
+      is_spade = R.prop_eq(:suit, 'Spade')
 
-    is_queen_of_spades = r.all_pass([is_queen, is_spade])
+      is_queen_of_spades = r.all_pass([is_queen, is_spade])
 
-    expect(is_queen_of_spades.call(rank: 'King', suit: 'Spade')).to be_falsey
-    expect(is_queen_of_spades.call(rank: 'Queen', suit: 'Spade')).to be_truthy
+      expect(is_queen_of_spades.call(rank: 'King', suit: 'Spade')).to be_falsey
+      expect(is_queen_of_spades.call(rank: 'Queen', suit: 'Spade')).to be_truthy
+    end
   end
 
-  it '#and' do
-    expect(r.and(true, true)).to be_truthy
-    expect(r.and(true, false)).to be_falsey
-    expect(r.and(false, true)).to be_falsey
-    expect(r.and(false, false)).to be_falsey
+  context '#and' do
+    it 'from docs' do
+      expect(r.and(true, true)).to be_truthy
+      expect(r.and(true, false)).to be_falsey
+      expect(r.and(false, true)).to be_falsey
+      expect(r.and(false, false)).to be_falsey
+    end
   end
 
-  it '#any_pass' do
-    is_club = R.prop_eq(:suit, 'club')
-    is_spade = R.prop_eq(:suit, 'spade')
-    is_black_card = r.any_pass([is_club, is_spade])
+  context '#any_pass' do
+    it 'from docs' do
+      is_club = R.prop_eq(:suit, 'club')
+      is_spade = R.prop_eq(:suit, 'spade')
+      is_black_card = r.any_pass([is_club, is_spade])
+
+      expect(is_black_card.call(rank: '10', suit: 'club')).to be_truthy
+      expect(is_black_card.call(rank: 'Q', suit: 'spade')).to be_truthy
+      expect(is_black_card.call(rank: 'Q', suit: 'diamond')).to be_falsey
+    end
+  end
 
-    expect(is_black_card.call(rank: '10', suit: 'club')).to be_truthy
-    expect(is_black_card.call(rank: 'Q', suit: 'spade')).to be_truthy
-    expect(is_black_card.call(rank: 'Q', suit: 'diamond')).to be_falsey
+  context '#both' do
+    it 'from docs' do
+      gt10 = R.gt(R.__, 10)
+      lt20 = R.lt(R.__, 20)
+      f = R.both(gt10, lt20)
+      expect(f.call(15)).to be_truthy
+      expect(f.call(30)).to be_falsey
+    end
   end
 
   context '#complement' do
@@ -62,6 +78,16 @@ describe Ramda::Logic do
     end
   end
 
+  context '#either' do
+    it 'from docs' do
+      gt10 = ->(x) { x > 10 }
+      even = :even?.to_proc
+      f = R.either(gt10, even)
+      expect(f.call(101)).to be_truthy
+      expect(f.call(8)).to be_truthy
+    end
+  end
+
   context '#if_else' do
     it 'from docs' do
       inc_count = R.if_else(

data/spec/ramda/string_spec.rb

@@ -29,6 +29,13 @@ describe Ramda::String do
     end
   end
 
+  context '#test' do
+    it 'from docs' do
+      expect(R.test(/^x/, 'xyz')).to be_truthy
+      expect(R.test(/^y/, 'xyz')).to be_falsey
+    end
+  end
+
   context '#to_upper' do
     it 'from docs' do
       expect(r.to_upper('abc')).to eq('ABC')

data/spec/ramda_spec.rb

@@ -24,12 +24,14 @@ describe Ramda do
   r(:any)
   r(:any_pass)
   r(:ap)
+  r(:aperture)
   r(:append)
   r(:apply)
   r(:assoc)
   r(:assoc_path)
   r(:binary)
   r(:bind)
+  r(:both)
   r(:call)
   r(:chain)
   r(:clone)
@@ -55,6 +57,7 @@ describe Ramda do
   r(:drop)
   r(:drop_while)
   r(:empty)
+  r(:either)
   r(:eq_by)
   r(:eq_props)
   r(:equals)
@@ -82,6 +85,7 @@ describe Ramda do
   r(:insert)
   r(:insert_all)
   r(:intersection)
+  r(:into)
   r(:invert)
   r(:invert_obj)
   r(:invoker)
@@ -116,6 +120,7 @@ describe Ramda do
   r(:multiply)
   r(:n_ary)
   r(:negate)
+  r(:none)
   r(:not)
   r(:nth)
   r(:nth_arg)
@@ -161,10 +166,12 @@ describe Ramda do
   r(:take)
   r(:take_while)
   r(:tap)
+  r(:test)
   r(:times)
   r(:to_lower)
   r(:to_pairs)
   r(:to_upper)
+  r(:transduce)
   r(:trim)
   r(:type)
   r(:unapply)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ramda-ruby
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Vadim Lazebny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-06 00:00:00.000000000 Z
+date: 2017-07-09 00:00:00.000000000 Z
 dependencies: []
 description: Ruby version of Ramda Js library.
 email:
@@ -37,6 +37,7 @@ files:
 - lib/ramda/internal/function_with_arity.rb
 - lib/ramda/internal/functors.rb
 - lib/ramda/internal/java/__make_curry_proc__.rb
+- lib/ramda/internal/transducers.rb
 - lib/ramda/list.rb
 - lib/ramda/logic.rb
 - lib/ramda/math.rb