ramda-ruby 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a23c9651684d48d741ff366c825cc13eb8b88b03
-  data.tar.gz: f784df378ef790ed8ac918986294b983500c2c8d
+  metadata.gz: 28285eadf06563393e23d6cff7ad2f945a6b579e
+  data.tar.gz: 6efe04a0ec2340fa87d43ffcedf6b56b8c949ce8
 SHA512:
-  metadata.gz: 5578f41adcd7d4978b8c3a3be2d80e4ab2f61d9e45e0f6ac46fa1b30354a53475fef02e18c06c32816f5bf8384959b6a9a1147b6df51b67519d3179f63de678b
-  data.tar.gz: 356cfffa686a4e1853353600e72076e25073262442497695a518be6699f9b91c344dc3a898dc22c1ad14a55abd0db22be1779c29e2ad7af626b92fbd3658a265
+  metadata.gz: a8e29a9fceca691c212931de21d6c7972a17d4ff4f151ed0afb6457d3e6f4113a78498b209de824ce32ec40b46bb5f974c779a2728bcee8b86f70faaac3c4ccb
+  data.tar.gz: 7f525b162fd911a9117cbedcfcebe662af36b11345130eaa9faf15e67fbeff65c06a5297059c6cdc60a0f95e7c63f20b737053cf24f6e86c45664cfa7d802cf5

data/CHANGELOG.md

@@ -1,6 +1,27 @@
 Not Released
 ---------------
 
+Release 0.8.0
+---------------
+
+Added:
+
+* assoc_path
+* lens - composition does not work compose(lens1, lensb)
+* lens_index
+* lens_path
+* lens_prop
+* max_by
+* min_by
+* negate
+* over
+* pick_by
+* set
+* type
+* unapply
+* view
+* update
+
 Release 0.7.0
 ---------------
 
@@ -20,7 +41,7 @@ Added:
 
 * F
 * T
-* __ - first function call should have all arguments g(___2, __)(1, 3), this means that it doesn't support g(__, 2)(1)(3), g(__, 2)(1, 3) and g(__, 2)(__, 3)(1)
+* `__` - first function call should have all arguments `g(__2, __)(1, 3)`, this means that it doesn't support `g(__, 2)(1)(3)`, `g(__, 2)(1, 3)` and `g(__, 2)(__, 3)(1)`
 * bind
 * cond
 * prop_or

data/ROADMAP.md

@@ -4,16 +4,6 @@
 
 ### release 0.8.0
 
-* assoc
-* assoc_path
-* if_else
-* lens
-* max_by
-* min_by
-* pick_by
-* type
-* unapply
-
 ### release 0.9.0
 
 * all_pass

data/docs/FUNCTIONS.md

@@ -4,7 +4,7 @@
 * (pending) values_in
 * F
 * T
-* __ - first function call should have all arguments g(___2, __)(1, 3), this means that it doesn't support g(__, 2)(1)(3), g(__, 2)(1, 3) and g(__, 2)(__, 3)(1)
+* `__` - first function call should have all arguments `g(__2, __)(1, 3)`, this means that it doesn't support `g(__, 2)(1)(3)`, `g(__, 2)(1, 3)` and `g(__, 2)(__, 3)(1)`
 * add
 * all
 * all_pass
@@ -16,6 +16,7 @@
 * append
 * apply
 * assoc
+* assoc_path
 * binary
 * bind
 * chain
@@ -73,6 +74,10 @@
 * last
 * last_index_of - returns nil if index doesn't exist
 * length
+* lens - composition does not work compose(lens1, lensb)
+* lens_index
+* lens_path
+* lens_prop
 * lift
 * lift_n
 * lt
@@ -80,23 +85,28 @@
 * map
 * match
 * max
+* max_by
 * memoize
 * merge
 * min
+* min_by
 * modulo
 * multiply
 * n_ary
+* negate
 * not
 * nth
 * of
 * omit
 * once
 * or
+* over
 * partition
 * path
 * path_eq
 * pick
 * pick_all
+* pick_by
 * pipe
 * pluck
 * prepend
@@ -114,6 +124,7 @@
 * repeat
 * replace - it uses a gsub method and global replacement
 * reverse
+* set
 * slice
 * sort
 * sort_by
@@ -129,14 +140,18 @@
 * to_pairs
 * to_upper
 * trim
+* type
+* unapply
 * unary
 * union
 * 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
+* update
 * use_with
 * values
+* view
 * where
 * xprod
 * zip

data/lib/ramda.rb

@@ -44,6 +44,7 @@ module Ramda
                  :once,
                  :pipe,
                  :tap,
+                 :unapply,
                  :unary,
                  :use_with
 
@@ -92,6 +93,7 @@ module Ramda
                  :uniq,
                  :uniq_with,
                  :unnest,
+                 :update,
                  :xprod,
                  :zip,
                  :zip_obj,
@@ -109,39 +111,49 @@ module Ramda
                  :or
 
   def_delegators Ramda::Math,
+                 # :math_mod,
                  :add,
                  :dec,
                  :divide,
                  :inc,
-                 # :math_mod,
                  :modulo,
                  :multiply,
+                 :negate,
                  :product,
                  :subtract,
                  :sum
 
   def_delegators Ramda::Object,
+                 # :keys_in,
+                 # :to_pairs_in,
+                 # :values_in,
                  :assoc,
+                 :assoc_path,
                  :clone,
                  :dissoc,
                  :eq_props,
                  :has,
                  :has_in,
                  :keys,
-                 # :keys_in,
+                 :lens,
+                 :lens_index,
+                 :lens_path,
+                 :lens_prop,
                  :merge,
                  :omit,
+                 :over,
                  :path,
                  :pick,
                  :pick_all,
+                 :pick_by,
                  :project,
                  :prop,
                  :prop_or,
                  :props,
+                 :set,
                  :to_pairs,
-                 # :to_pairs_in,
                  :values,
-                 # :values_in,
+                 :view,
                  :where
 
   def_delegators Ramda::Relation,
@@ -156,7 +168,9 @@ module Ramda
                  :lt,
                  :lte,
                  :max,
+                 :max_by,
                  :min,
+                 :min_by,
                  :path_eq,
                  :prop_eq,
                  :sort_by,
@@ -173,5 +187,6 @@ module Ramda
 
   def_delegators Ramda::Type,
                  :is,
-                 :is_nil
+                 :is_nil,
+                 :type
 end

data/lib/ramda/function.rb

@@ -337,7 +337,7 @@ module Ramda
     # (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)
     #
     curried_method(:pipe) do |*fns|
-      ->(*args) { fns.reduce(args) { |memo, fn| [fn.call(*memo)] }.first }
+      ->(*args) { fns[1..-1].reduce(fns[0].call(*args)) { |memo, fn| fn.call(memo) } }
     end
 
     # Runs the given function with the supplied object, then returns the object.
@@ -349,6 +349,22 @@ module Ramda
       x
     end
 
+    # Takes a function fn, which takes a single array argument, and returns a
+    # function which:
+    #
+    # * takes any number of positional arguments;
+    # * passes these arguments to fn as an array; and
+    # * returns the result.
+    #
+    # In other words, R.unapply derives a variadic function from a function
+    # which takes an array. R.unapply is the inverse of R.apply.
+    #
+    # ([*...] -> a) -> (*... -> a)
+    #
+    curried_method(:unapply) do |fn, x, *xs|
+      fn.call([x] + xs)
+    end
+
     # Wraps a function of any arity (including nullary) in a function that
     # accepts exactly 1 parameter. Any extraneous parameters will not be passed
     # to the supplied function.

data/lib/ramda/internal/functors.rb

@@ -0,0 +1,44 @@
+module Ramda
+  module Internals
+    module Functors
+      # `const` is a functor that effectively ignores the function given to `map`.
+      class Const
+        attr_reader :value
+
+        def self.of(x)
+          new(x)
+        end
+
+        def map(*)
+          Const.of(@value)
+        end
+
+        private
+
+        def initialize(value)
+          @value = value
+        end
+      end
+
+      # `Identity` is a functor that holds a single value, where `map` simply
+      # transforms the held value with the provided function.
+      class Identity
+        attr_reader :value
+
+        def self.of(x)
+          new(x)
+        end
+
+        def map(f)
+          Identity.of(f.call(@value))
+        end
+
+        private
+
+        def initialize(value)
+          @value = value
+        end
+      end
+    end
+  end
+end

data/lib/ramda/list.rb

@@ -258,6 +258,8 @@ module Ramda
     # Ramda provides suitable map implementations for Array and Object,
     # so this function may be applied to [1, 2, 3] or {x: 1, y: 2, z: 3}.
     #
+    # Also treats functions as functors and will compose them together.
+    #
     # Functor f => (a -> b) -> f a -> f b
     #
     curried_method(:map) do |f, functor|
@@ -267,7 +269,11 @@ module Ramda
       when ::Array
         functor.map(&f)
       else
-        type_error(functor, :map)
+        if functor.respond_to?(:map)
+          functor.map(f)
+        else
+          type_error(functor, :map)
+        end
       end
     end
 
@@ -281,8 +287,8 @@ module Ramda
       case xs
       when ::String
         xs[index] || ''
-      when ::Array
-        xs[index]
+      when ::Array, ::Hash
+        xs.fetch(index, nil)
       else
         type_error(xs, :nth)
       end
@@ -475,6 +481,15 @@ module Ramda
       Ramda.chain(Ramda.identity, xs)
     end
 
+    # Returns a new copy of the array with the element at the provided
+    # index replaced with the given value.
+    #
+    # Number -> a -> [a] -> [a]
+    #
+    curried_method(:update) do |idx, x, xs|
+      xs.dup.tap { |a| a[idx] = x }
+    end
+
     # Creates a new list out of the two supplied by creating each possible pair
     # from the lists.
     #

data/lib/ramda/math.rb

@@ -59,6 +59,12 @@ module Ramda
       a * b
     end
 
+    # Negates its argument.
+    #
+    # Number -> Number
+    #
+    curried_method(:negate, &:-@)
+
     # Multiplies together all the elements of a list.
     #
     # [Number] -> Number

data/lib/ramda/object.rb

@@ -1,10 +1,14 @@
 require_relative 'internal/curried_method'
+require_relative 'internal/functors'
 
 module Ramda
   # Math functions
+  # rubocop:disable Metrics/ModuleLength
   module Object
     extend ::Ramda::Internal::CurriedMethod
 
+    Functors = ::Ramda::Internals::Functors
+
     # Makes a shallow clone of an object, setting or overriding the specified
     # property with the given value. Note that this copies and flattens
     # prototype properties onto the new object as well. All non-primitive
@@ -16,6 +20,32 @@ module Ramda
       obj.merge(key => val)
     end
 
+    # Makes a shallow clone of an object, setting or overriding the nodes
+    # required to create the given path, and placing the specific value at
+    # the tail end of that path. Note that this copies and flattens
+    # prototype properties onto the new object as well. All non-primitive
+    # properties are copied by reference.
+    #
+    # [Idx] -> a -> {a} -> {a}
+    # Idx = String | Int
+    #
+    curried_method(:assoc_path) do |path, val, obj|
+      if path.empty?
+        val
+      else
+        cloned = clone(obj)
+        path[0...-1].reduce(cloned) do |acc, k|
+          case acc[k]
+          when Hash, Array
+            acc[k]
+          else
+            acc[k] = k.is_a?(Integer) ? [] : {}
+          end
+        end[path[-1]] = val
+        cloned
+      end
+    end
+
     # Creates a deep copy of the value which may contain (nested)
     # Arrays and Objects, Numbers, Strings, Booleans and Dates.
     # Functions are assigned by reference rather than copied
@@ -24,8 +54,14 @@ module Ramda
     #
     curried_method(:clone) do |obj|
       case obj
+      when Hash
+        obj.each_with_object(obj.dup) do |(key, value), acc|
+          acc[clone(key)] = clone(value)
+        end
       when Array
-        obj.dup.map(&method(:clone))
+        obj.map(&clone)
+      when Symbol, Integer, NilClass, TrueClass, FalseClass
+        obj
       else
         obj.dup
       end
@@ -86,6 +122,51 @@ module Ramda
         .uniq
     end
 
+    # Returns a lens for the given getter and setter functions.
+    # The getter "gets" the value of the focus;
+    # the setter "sets" the value of the focus.
+    # The setter should not mutate the data structure.
+    #
+    # (s -> a) -> ((a, s) -> s) -> Lens s a
+    # Lens s a = Functor f => (a -> f a) -> s -> f s
+    #
+    curried_method(:lens) do |getter, setter|
+      curried_method_body(:lens, 2) do |to_functor_fn, target|
+        Ramda.map(
+          ->(focus) { setter.call(focus, target) },
+          to_functor_fn.call(getter.call(target))
+        )
+      end
+    end
+
+    # Returns a lens whose focus is the specified index.
+    #
+    # Number -> Lens s a
+    # Lens s a = Functor f => (a -> f a) -> s -> f s
+    #
+    curried_method(:lens_index) do |n|
+      lens(Ramda.nth(0), Ramda.update(n))
+    end
+
+    # Returns a lens whose focus is the specified path.
+    #
+    # [Idx] -> Lens s a
+    # Idx = String | Int
+    # 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))
+    end
+
+    # Returns a lens whose focus is the specified property.
+    #
+    # String -> Lens s a
+    # Lens s a = Functor f => (a -> f a) -> s -> f s
+    #
+    curried_method(:lens_prop) do |k|
+      lens(Ramda.prop(k), Ramda.assoc(k))
+    end
+
     # Create a new object with the own properties of the first object merged
     # with the own properties of the second object. If a key exists in both
     # objects, the value from the second object will be used.
@@ -101,18 +182,34 @@ module Ramda
     # [String] -> {String: *} -> {String: *}
     #
     curried_method(:omit) do |keys, obj|
-      obj_copy = obj.dup
+      obj_copy = clone(obj)
       keys.each(&obj_copy.method(:delete))
       obj_copy
     end
 
+    # Returns the result of "setting" the portion of the given data
+    # structure focused by the given lens to the result of applying
+    # the given function to the focused value.
+    #
+    # Lens s a -> (a -> a) -> s -> s
+    # Lens s a = Functor f => (a -> f a) -> s -> f s
+    #
+    curried_method(:over) do |lens, f, x|
+      # The value returned by the getter function is first transformed with `f`,
+      # then set as the value of an `Identity`. This is then mapped over with the
+      # setter function of the lens.
+      lens
+        .call(->(y) { Functors::Identity.of(y).map(f) }, x)
+        .value
+    end
+
     # Retrieve the value at a given path.
     #
     # [Idx] -> {a} -> a | NilClass
     # Idx = String | Int
     #
     curried_method(:path) do |keys, obj|
-      keys.reduce(obj) { |acc, key| acc.is_a?(Hash) ? acc.fetch(key, nil) : nil }
+      keys.reduce(obj) { |acc, key| acc.respond_to?(:fetch) ? acc.fetch(key, nil) : nil }
     end
 
     # Returns a partial copy of an object containing only the keys specified.
@@ -133,6 +230,15 @@ module Ramda
       Hash[keys.map { |k| [k, obj.key?(k) ? obj.fetch(k) : nil] }]
     end
 
+    # Returns a partial copy of an object containing only the keys that
+    # satisfy the supplied predicate.
+    #
+    # (v, k -> Boolean) -> {k: v} -> {k: v}
+    #
+    curried_method(:pick_by) do |fn, obj|
+      obj.select { |k, v| fn.call(v, k) }
+    end
+
     # Reasonable analog to SQL select statement.
     #
     # [k] -> [{k: v}] -> [{k: v}]
@@ -174,6 +280,16 @@ module Ramda
       keys.map(&obj.method(:[]))
     end
 
+    # Returns the result of "setting" the portion of the given data structure
+    # focused by the given lens to the given value.
+    #
+    # Lens s a -> a -> s -> s
+    # Lens s a = Functor f => (a -> f a) -> s -> f s
+    #
+    curried_method(:set) do |lens, v, x|
+      over(lens, Ramda.always(v), x)
+    end
+
     # Converts an object into an array of key, value arrays. Only the
     # object's own properties are used. Note that the order of the
     # output array is not guaranteed.
@@ -197,6 +313,21 @@ module Ramda
       keys_in(obj).map(&obj.method(:send))
     end
 
+    # Returns a "view" of the given data structure, determined
+    # by the given lens. The lens's focus determines which portion
+    # of the data structure is visible.
+    #
+    # Lens s a -> s -> a
+    # Lens s a = Functor f => (a -> f a) -> s -> f s
+    #
+    curried_method(:view) do |lens, x|
+      # Using `const` effectively ignores the setter function of the `lens`,
+      # leaving the value returned by the getter function unmodified.
+      lens
+        .call(Functors::Const.method(:of), x)
+        .value
+    end
+
     # Takes a spec object and a test object; returns true if the test satisfies
     # the spec. Each of the spec's own properties must be a predicate function.
     # Each predicate is applied to the value of the corresponding property of

data/lib/ramda/relation.rb

@@ -111,6 +111,15 @@ module Ramda
       [a, b].max
     end
 
+    # Takes a function and two values, and returns whichever value produces
+    # the larger result when passed to the provided function.
+    #
+    # Ord b => (a -> b) -> a -> a -> a
+    #
+    curried_method(:max_by) do |fn, a, b|
+      [a, b].max_by(&fn)
+    end
+
     # Returns the smaller of its two arguments.
     #
     # Ord a => a -> a -> a
@@ -119,6 +128,15 @@ module Ramda
       [a, b].min
     end
 
+    # Takes a function and two values, and returns whichever value
+    # produces the smaller result when passed to the provided function.
+    #
+    # Ord b => (a -> b) -> a -> a -> a
+    #
+    curried_method(:min_by) do |fn, a, b|
+      [a, b].min_by(&fn)
+    end
+
     # Determines whether a nested path on an object has a specific value,
     # in R.equals terms. Most likely used to filter a list.
     #

data/lib/ramda/type.rb

@@ -19,5 +19,11 @@ module Ramda
     # * -> Boolean
     #
     curried_method(:is_nil, &:nil?)
+
+    # Gives a class of the (native) type of a value.
+    #
+    # (* -> {*}) -> String
+    #
+    curried_method(:type, &:class)
   end
 end

data/lib/ramda/version.rb

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

data/spec/ramda/function_spec.rb

@@ -392,6 +392,13 @@ describe Ramda::Function do
     end
   end
 
+  context '#unapply' do
+    it 'from docs' do
+      stringify = ->(args) { args.to_s }
+      expect(r.unapply(stringify).call(1, 2, 3)).to eq('[1, 2, 3]')
+    end
+  end
+
   context '#unary' do
     it 'from docs' do
       takes_two_args = ->(a, b) { [a, b] }

data/spec/ramda/list_spec.rb

@@ -309,15 +309,23 @@ describe Ramda::List do
   end
 
   context '#nth' do
-    it 'from docs' do
+    it 'with array' do
       list = ['foo', 'bar', 'baz', 'quux']
       expect(r.nth(1, list)).to eq('bar')
       expect(r.nth(-1, list)).to eq('quux')
       expect(r.nth(-99, list)).to be_nil
+    end
 
+    it 'with string' do
       expect(r.nth(2, 'abc')).to eq('c')
       expect(r.nth(3, 'abc')).to eq('')
     end
+
+    it 'with hash' do
+      list = { a: 123 }
+      expect(r.nth(:a, list)).to eq(123)
+      expect(r.nth(:b, list)).to be_nil
+    end
   end
 
   context '#partition' do
@@ -526,6 +534,19 @@ describe Ramda::List do
     end
   end
 
+  context '#update' do
+    it 'without mutation' do
+      original = [0, 1, 2]
+      updated = r.update(1, 11, original)
+      expect(updated).to eq([0, 11, 2])
+      expect(original).to eq([0, 1, 2])
+    end
+
+    it 'is curried' do
+      expect(r.update(1).call(11).call([0, 1, 2])).to eq([0, 11, 2])
+    end
+  end
+
   context '#xprod' do
     it 'from docs' do
       expect(r.xprod([1, 2], ['a', 'b']))

data/spec/ramda/math_spec.rb

@@ -84,6 +84,12 @@ describe Ramda::Math do
     end
   end
 
+  context '#negate' do
+    it 'from docs' do
+      expect(R.negate(42)).to eq(-42)
+    end
+  end
+
   context '#product' do
     it 'from docs' do
       expect(r.product([2, 4, 6, 8, 100, 1])).to be(38_400)

data/spec/ramda/object_spec.rb

@@ -9,6 +9,23 @@ describe Ramda::Object do
     end
   end
 
+  context '#assoc_path' do
+    it 'from docs' do
+      expect(r.assoc_path([:a, :b, :c], 42, a: { b: { c: 0 } })).to eq(a: { b: { c: 42 } })
+      expect(r.assoc_path([:a, :b, :c], 42, a: 5)).to eq(a: { b: { c: 42 } })
+      expect(r.assoc_path([:a, :b, :c], 42, a: 5, d: 10)).to eq(a: { b: { c: 42 } }, d: 10)
+    end
+
+    it 'with object + array' do
+      obj = { x: [{ y: 2, z: 3 }, { y: 4, z: 5 }] }
+      expect(r.assoc_path([:x, 0, :y], 1, obj)).to eq(x: [{ y: 1, z: 3 }, { y: 4, z: 5 }])
+    end
+
+    it 'empty path replaces the the whole object' do
+      expect(r.assoc_path([], 3, a: 1, b: 2)).to eq(3)
+    end
+  end
+
   context '#clone' do
     it 'from docs' do
       objects = [{}, {}, {}]
@@ -16,6 +33,31 @@ describe Ramda::Object do
       expect(objects).not_to be(objects_clone)
       expect(objects[0]).not_to be(objects_clone[0])
     end
+
+    it 'nested arrays' do
+      obj = [1, [2, 2, [3, 3]]]
+
+      cloned = r.clone(obj)
+      cloned[1][2][0] = 100
+
+      expect(cloned).not_to eq(obj)
+      path = Ramda.path([1, 2])
+      expect(path.call(obj)).to eq([3, 3])
+      expect(path.call(cloned)).to eq([100, 3])
+    end
+
+    it 'nested objects' do
+      obj = { a: { b: { c: 10 } } }
+
+      cloned = r.clone(obj)
+      cloned[:a][:b][:c] = 100
+
+      expect(cloned).not_to eq(obj)
+
+      path = Ramda.path([:a, :b])
+      expect(path.call(obj)).to eq(c: 10)
+      expect(path.call(cloned)).to eq(c: 100)
+    end
   end
 
   context '#dissoc' do
@@ -26,7 +68,7 @@ describe Ramda::Object do
 
   context '#has' do
     it 'from docs' do
-      has_name = R.has(:name)
+      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
@@ -34,7 +76,7 @@ describe Ramda::Object do
 
     it 'with placeholder' do
       point = { x: 0, y: 0 }
-      point_has = R.has(R.__, point)
+      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
@@ -87,6 +129,124 @@ describe Ramda::Object do
     end
   end
 
+  context '#lens' do
+    def x_lens
+      r.lens(R.prop(:x), R.assoc(:x))
+    end
+
+    it 'with view' do
+      expect(R.view(x_lens, x: 1, y: 2)).to eq(1)
+    end
+
+    it 'with set' do
+      expect(R.set(x_lens, 4, x: 1, y: 2)).to eq(x: 4, y: 2)
+    end
+
+    it 'with over' do
+      expect(R.over(x_lens, R.negate, x: 1, y: 2)).to eq(x: -1, y: 2)
+    end
+  end
+
+  context '#lens_index' do
+    it 'from docs' do
+      head_lens = r.lens_index(0)
+
+      expect(R.view(head_lens, ['a', 'b', 'c'])).to eq('a')
+      expect(R.set(head_lens, 'x', ['a', 'b', 'c'])).to eq(['x', 'b', 'c'])
+      expect(R.over(head_lens, R.to_upper, ['a', 'b', 'c'])).to eq(['A', 'b', 'c'])
+    end
+  end
+
+  context '#lens_path' do
+    it 'from docs' do
+      x_head_y_lens = r.lens_path([:x, 0, :y])
+
+      obj = { x: [{ y: 2, z: 3 }, { y: 4, z: 5 }] }
+
+      expect(R.view(x_head_y_lens, obj)).to eq(2)
+      expect(R.set(x_head_y_lens, 1, obj)).to eq(x: [{ y: 1, z: 3 }, { y: 4, z: 5 }])
+      expect(R.over(x_head_y_lens, R.negate, obj)).to eq(x: [{ y: -2, z: 3 }, { y: 4, z: 5 }])
+
+      expect(obj).to eq(x: [{ y: 2, z: 3 }, { y: 4, z: 5 }])
+    end
+  end
+
+  context '#lens_prop' do
+    it 'from docs' do
+      x_lens = r.lens_prop(:x)
+
+      expect(R.view(x_lens, x: 1, y: 2)).to eq(1)
+      expect(R.set(x_lens, 4, x: 1, y: 2)).to eq(x: 4, y: 2)
+      expect(R.over(x_lens, R.negate, x: 1, y: 2)).to eq(x: -1, y: 2)
+    end
+  end
+
+  context 'view, over, and set' do
+    let(:alice) do
+      {
+        name: 'Alice Jones',
+        address: ['22 Walnut St', 'San Francisco', 'CA'],
+        pets: { dog: 'joker', cat: 'batman' }
+      }
+    end
+    let(:head_lens) { R.lens_index(0) }
+
+    it 'may be applied to a lens created by `lens_path`' do
+      dog_lens = R.lens_path([:pets, :dog])
+      expect(r.view(dog_lens, alice)).to eq('joker')
+    end
+
+    it 'may be applied to a lens created by `lens_prop`' do
+      name_lens = R.lens(R.prop(:name), R.assoc(:name))
+
+      expect(r.view(name_lens, alice)).to eq('Alice Jones')
+
+      expect(r.over(name_lens, R.to_upper, alice)).to eq(
+        name: 'ALICE JONES',
+        address: ['22 Walnut St', 'San Francisco', 'CA'],
+        pets: { dog: 'joker', cat: 'batman' }
+      )
+
+      expect(r.set(name_lens, 'Alice Smith', alice)).to eq(
+        name: 'Alice Smith',
+        address: ['22 Walnut St', 'San Francisco', 'CA'],
+        pets: { dog: 'joker', cat: 'batman' }
+      )
+    end
+
+    it 'may be applied to a lens created by `lens_index`' do
+      expect(R.view(head_lens, alice.fetch(:address))).to eq('22 Walnut St')
+
+      expect(R.over(head_lens, R.to_upper, alice.fetch(:address)))
+        .to eq(['22 WALNUT ST', 'San Francisco', 'CA'])
+
+      expect(R.set(head_lens, '52 Crane Ave', alice.fetch(:address)))
+        .to eq(['52 Crane Ave', 'San Francisco', 'CA'])
+    end
+
+    xit 'may be applied to composed lenses' do
+      address_lens = R.lens_prop(:address)
+      street_lens = R.compose(address_lens, head_lens)
+      dog_lens = R.compose(R.lens_path([:pets]), R.lens_path([:dog]))
+
+      expect(R.view(dog_lens, alice)).to eq(R.view(R.lens_path([:pets, :dog]), alice))
+
+      expect(R.view(street_lens, alice)).to eq('22 Walnut St')
+
+      expect(R.over(street_lens, R.to_upper, alice)).to eq(
+        name: 'Alice Jones',
+        address: ['22 WALNUT ST', 'San Francisco', 'CA'],
+        pets: { dog: 'joker', cat: 'batman' }
+      )
+
+      expect(R.set(street_lens, '52 Crane Ave', alice)).to eq(
+        name: 'Alice Jones',
+        address: ['52 Crane Ave', 'San Francisco', 'CA'],
+        pets: { dog: 'joker', cat: 'batman' }
+      )
+    end
+  end
+
   context '#merge' do
     it 'from docs' do
       expect(r.merge({ name: 'fred', age: 10 }, age: 40))
@@ -114,6 +274,11 @@ describe Ramda::Object do
       expect(r.path([:a, :b], a: { b: 2 })).to eq(2)
       expect(r.path([:a, :b], c: { b: 2 })).to eq(nil)
     end
+
+    it 'with object + array' do
+      obj = { x: [{ y: 2, z: 3 }, { y: 4, z: 5 }] }
+      expect(r.path([:x, 0, :y], obj)).to eq(2)
+    end
   end
 
   context '#pick' do
@@ -130,6 +295,14 @@ describe Ramda::Object do
     end
   end
 
+  context '#pick_by' do
+    it 'from docs' do
+      is_upper_case = ->(_, key) { key.upcase == key }
+      expect(r.pick_by(is_upper_case, 'a' => 1, 'b' => 2, 'A' => 3, 'B' => 4))
+        .to eq('A' => 3, 'B' => 4)
+    end
+  end
+
   context '#project' do
     it 'from docs' do
       abby = { name: 'Abby', age: 7, hair: 'blond', grade: 2 }

data/spec/ramda/relation_spec.rb

@@ -122,6 +122,17 @@ describe Ramda::Relation do
     end
   end
 
+  context '#max_by' do
+    it 'from docs' do
+      square = ->(n) { n * n; }
+
+      expect(r.max_by(square, -3, 2)).to eq(-3)
+
+      expect(R.reduce(r.max_by(square), 0, [3, -5, 4, 1, -2])).to eq(-5)
+      expect(R.reduce(r.max_by(square), 0, [])).to eq(0)
+    end
+  end
+
   context '#min' do
     it 'from docs' do
       expect(r.min(789, 123)).to be(123)
@@ -129,6 +140,17 @@ describe Ramda::Relation do
     end
   end
 
+  context '#min_by' do
+    it 'from docs' do
+      square = ->(n) { n * n; }
+
+      expect(r.min_by(square, -3, 2)).to eq(2)
+
+      expect(R.reduce(r.min_by(square), 100, [3, -5, 4, 1, -2])).to eq(1)
+      expect(R.reduce(r.min_by(square), 0, [])).to eq(0)
+    end
+  end
+
   context '#prop_eq' do
     it 'from docs' do
       abby = { name: 'Abby', age: 7, hair: 'blond' }

data/spec/ramda/type_spec.rb

@@ -23,4 +23,16 @@ describe Ramda::Type do
       expect(r.is_nil('')).to be_falsey
     end
   end
+
+  context '#type' do
+    it 'from docs' do
+      expect(r.type({})).to be(Hash)
+      expect(r.type(false)).to be(FalseClass)
+      expect(r.type('s')).to be(String)
+      expect(r.type(nil)).to be(NilClass)
+      expect(r.type([])).to be(Array)
+      expect(r.type(/[A-z]/)).to be(Regexp)
+      expect(r.type(-> {})).to be(Proc)
+    end
+  end
 end

data/spec/ramda_spec.rb

@@ -25,6 +25,7 @@ describe Ramda do
   r(:append)
   r(:apply)
   r(:assoc)
+  r(:assoc_path)
   r(:binary)
   r(:bind)
   r(:chain)
@@ -82,6 +83,10 @@ describe Ramda do
   r(:last)
   r(:last_index_of)
   r(:length)
+  r(:lens)
+  r(:lens_index)
+  r(:lens_path)
+  r(:lens_prop)
   r(:lift)
   r(:lift_n)
   r(:lt)
@@ -89,23 +94,28 @@ describe Ramda do
   r(:map)
   r(:match)
   r(:max)
+  r(:max_by)
   r(:memoize)
   r(:merge)
   r(:min)
+  r(:min_by)
   r(:modulo)
   r(:multiply)
   r(:n_ary)
+  r(:negate)
   r(:not)
   r(:nth)
   r(:of)
   r(:omit)
   r(:once)
   r(:or)
+  r(:over)
   r(:partition)
   r(:path)
   r(:path_eq)
   r(:pick)
   r(:pick_all)
+  r(:pick_by)
   r(:pipe)
   r(:pluck)
   r(:prepend)
@@ -123,6 +133,7 @@ describe Ramda do
   r(:repeat)
   r(:replace)
   r(:reverse)
+  r(:set)
   r(:slice)
   r(:sort)
   r(:sort_by)
@@ -138,14 +149,18 @@ describe Ramda do
   r(:to_pairs)
   r(:to_upper)
   r(:trim)
+  r(:type)
+  r(:unapply)
   r(:unary)
   r(:union)
   r(:union_with)
   r(:uniq)
   r(:uniq_with)
   r(:unnest)
+  r(:update)
   r(:use_with)
   r(:values)
+  r(:view)
   r(:where)
   r(:xprod)
   r(:zip)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ramda-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Vadim Lazebny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-23 00:00:00.000000000 Z
+date: 2017-06-24 00:00:00.000000000 Z
 dependencies: []
 description: Ruby version of Ramda Js library.
 email:
@@ -31,6 +31,7 @@ files:
 - lib/ramda/function.rb
 - lib/ramda/internal/curried_method.rb
 - lib/ramda/internal/function_with_arity.rb
+- lib/ramda/internal/functors.rb
 - lib/ramda/list.rb
 - lib/ramda/logic.rb
 - lib/ramda/math.rb