ramda-ruby 0.1.0.alpha

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/codeclimate.yml

@@ -0,0 +1,6 @@
+engines:
+  rubocop:
+    enabled: true
+    channel: rubocop-0-48
+    config:
+      file: .rubocop.yml

data/docker-compose.override.yml

@@ -0,0 +1,12 @@
+app:
+  volumes:
+    - ~/.ssh/id_rsa:/root/.ssh/id_rsa
+    - ./.bashrc.docker:/root/.bashrc
+    - ./.bash_history.docker:/root/.bash_history
+    # PRY
+    - ./.pry_history.docker:/root/.pry_history
+    - ./.pryrc.docker:/root/.pryrc
+  environment:
+    - CI_REPORTS=/tmp/shippable/testresults
+    - COVERAGE_REPORTS=/tmp/shippable/codecoverage
+

data/docker-compose.yml

@@ -0,0 +1,15 @@
+app:
+  container_name: rambda_ruby_app
+  build: .
+  dockerfile: Dockerfile
+  volumes:
+    - .:/srv/app
+    - ./config/config.yml.example:/srv/app/config/config.yml
+  volumes_from:
+    - bundle_cache
+
+bundle_cache:
+  container_name: rambda_ruby_bundle_cache
+  image: busybox
+  volumes:
+    - /bundle_cache

data/docs/FUNCTIONS.md

@@ -0,0 +1,93 @@
+* add
+* all
+* all_pass
+* always
+* and
+* any
+* any_pass
+* append
+* clone
+* comparator
+* compose
+* concat
+* construct
+* contains
+* converge
+* count_by
+* curry
+* dec
+* difference
+* difference_with
+* divide
+* drop
+* eq_by
+* eq_props
+* equals
+* filter
+* find
+* flatten
+* flip
+* group_by
+* gt
+* gte
+* head
+* identity
+* if_else
+* inc
+* index_of
+* intersection
+* invoker
+* is_empty
+* join
+* keys
+* last_index_of
+* length
+* lt
+* lte
+* map
+* match
+* max
+* memoize
+* merge
+* min
+* multiply
+* n_ary
+* not
+* nth
+* omit
+* once
+* or
+* pick
+* pick_all
+* pipe
+* pluck
+* prepend
+* product
+* project
+* prop
+* prop_eq
+* props
+* range
+* reduce
+* reduce_right
+* reject
+* reverse
+* sort
+* sort_by
+* split
+* subtract
+* sum
+* tail
+* take
+* take_while
+* tap
+* to_lower
+* to_upper
+* union
+* union_with
+* uniq
+* use_with
+* values
+* xprod
+* zip
+* zip_with

data/lib/ramda.rb

@@ -0,0 +1,123 @@
+require 'forwardable'
+
+require 'ramda/version'
+require 'ramda/function'
+require 'ramda/list'
+require 'ramda/logic'
+require 'ramda/math'
+require 'ramda/object'
+require 'ramda/relation'
+require 'ramda/string'
+
+# Ramda library implementation, source: http://ramdajs.com/
+# rubocop:disable Metrics/ModuleLength
+module Ramda
+  extend SingleForwardable
+
+  def_delegators Ramda::Function,
+                 :always,
+                 :comparator,
+                 :compose,
+                 :construct,
+                 :converge,
+                 :curry,
+                 :flip,
+                 :identity,
+                 :invoker,
+                 :memoize,
+                 :n_ary,
+                 :once,
+                 :pipe,
+                 :tap,
+                 :use_with
+
+  def_delegators Ramda::List,
+                 :all,
+                 :any,
+                 :append,
+                 :concat,
+                 :contains,
+                 :drop,
+                 :filter,
+                 :find,
+                 :flatten,
+                 :group_by,
+                 :head,
+                 :index_of,
+                 :join,
+                 :last_index_of,
+                 :length,
+                 :sort,
+                 :map,
+                 :nth,
+                 :pluck,
+                 :prepend,
+                 :range,
+                 :reduce,
+                 :reduce_right,
+                 :reject,
+                 :reverse,
+                 :tail,
+                 :take,
+                 :take_while,
+                 :uniq,
+                 :xprod,
+                 :zip,
+                 :zip_with
+
+  def_delegators Ramda::Logic,
+                 :all_pass,
+                 :and,
+                 :any_pass,
+                 :if_else,
+                 :is_empty,
+                 :not,
+                 :or
+
+  def_delegators Ramda::Math,
+                 :add,
+                 :dec,
+                 :divide,
+                 :inc,
+                 :multiply,
+                 :product,
+                 :subtract,
+                 :sum
+
+  def_delegators Ramda::Object,
+                 :clone,
+                 :eq_props,
+                 :keys,
+                 :merge,
+                 :omit,
+                 :pick,
+                 :pick_all,
+                 :project,
+                 :prop,
+                 :props,
+                 :values
+
+  def_delegators Ramda::Relation,
+                 :count_by,
+                 :difference,
+                 :difference_with,
+                 :eq_by,
+                 :equals,
+                 :gt,
+                 :gte,
+                 :intersection,
+                 :lt,
+                 :lte,
+                 :max,
+                 :min,
+                 :prop_eq,
+                 :sort_by,
+                 :union,
+                 :union_with
+
+  def_delegators Ramda::String,
+                 :match,
+                 :split,
+                 :to_lower,
+                 :to_upper
+end

data/lib/ramda/function.rb

@@ -0,0 +1,181 @@
+require_relative 'internal/curried_method'
+require_relative 'internal/function_with_arity'
+
+module Ramda
+  # Function functions
+  module Function
+    extend ::Ramda::Internal::CurriedMethod
+
+    curried_method(:always) do |value|
+      -> { value }
+    end
+
+    # Makes a comparator function out of a function that reports whether
+    # the first element is less than the second.
+    #
+    # (a, b -> Boolean) -> (a, b -> Number)
+    #
+    curried_method(:comparator) do |fn|
+      lambda do |a, b|
+        if fn.call(a, b)
+          -1
+        elsif fn.call(b, a)
+          1
+        else
+          0
+        end
+      end
+    end
+
+    # Performs right-to-left function composition. The rightmost function
+    # may have any arity; the remaining functions must be unary.
+    #
+    # Note: The result of compose is not automatically curried.
+    curried_method(:compose) do |*fns|
+      pipe(*fns.reverse)
+    end
+
+    # Wraps a constructor function inside a curried function that can be called
+    # with the same arguments and returns the same type.
+    #
+    # (* -> {*}) -> (* -> {*})
+    #
+    curried_method(:construct) do |constructor|
+      ->(*args) { constructor.new(*args) }
+    end
+
+    # Accepts a converging function and a list of branching functions and returns
+    # a new function. When invoked, this new function is applied to some arguments,
+    # each branching function is applied to those same arguments. The results of
+    # each branching function are passed as arguments to the converging function to
+    # produce the return value.
+    #
+    # (x1 -> x2 -> ... -> z) -> [(a -> b -> ... -> x1), ...] -> (a -> b -> ... -> z))]
+    #
+    curried_method(:converge) do |fn, xs, obj|
+      fn.call(*xs.map { |f| f.call(obj) })
+    end
+
+    # Returns a curried equivalent of the provided function. The curried function
+    # has two unusual capabilities. First, its arguments needn't be provided
+    # one at a time. If f is a ternary function and g is R.curry(f),
+    # the following are equivalent:
+    #
+    # g(1)(2)(3)
+    # g(1)(2, 3)
+    # g(1, 2)(3)
+    # g(1, 2, 3)
+
+    # (* -> a) -> (* -> a)
+    #
+    curried_method(:curry) do |fn|
+      fn.to_proc.curry
+    end
+
+    # Returns a new function much like the supplied one, except that the
+    # first two arguments' order is reversed.
+    #
+    # (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z))
+    #
+    curried_method(:flip) do |fn|
+      ->(a, b, *args) { fn.curry.call(b, a, *args) }.curry
+    end
+
+    # A function that does nothing but return the parameter supplied to it.
+    # Good as a default or placeholder function.
+    #
+    # a -> a
+    #
+    curried_method(:identity) do |el|
+      el
+    end
+
+    # Turns a named method with a specified arity into a function that can be
+    # called directly supplied with arguments and a target object.
+    # The returned function is curried and accepts arity + 1 parameters where
+    # the final parameter is the target object.
+    #
+    # Number -> String -> (a -> b -> ... -> n -> Object -> *)
+    #
+    curried_method(:invoker) do |arity, method_name|
+      Ramda::Internal::FunctionWithArity.new.call(arity + 1) do |*args, object|
+        object.public_send(method_name, *args)
+      end.curry
+    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
+    # additional call to fn; instead, the cached result for that set of arguments
+    # will be returned.
+    #
+    # (*... -> a) -> (*... -> a)
+    #
+    curried_method(:memoize) do |fn|
+      memo = {}
+
+      Ramda::Internal::FunctionWithArity.new.call(fn.arity) do |*args|
+        memo[args] = fn.call(*args) unless memo.key?(args)
+        memo[args]
+      end.curry
+    end
+
+    curried_method(:n_ary) do |arity, fn|
+      Ramda::Internal::FunctionWithArity.new.call(arity) do |*args|
+        fn.call(*(args.first(arity) + Array.new(fn.arity - arity, nil)))
+      end.curry
+    end
+
+    # Accepts a function fn and returns a function that guards invocation of fn
+    # such that fn can only ever be called once, no matter how many times the
+    # returned function is invoked. The first value calculated is returned
+    # in subsequent invocations.
+    #
+    # (a... -> b) -> (a... -> b)
+    #
+    curried_method(:once) do |fn|
+      memo = {}
+
+      Ramda::Internal::FunctionWithArity.new.call(fn.arity) do |*args|
+        memo[:result] = fn.call(*args) unless memo.key?(:result)
+        memo[:result]
+      end.curry
+    end
+
+    # Performs left-to-right function composition. The leftmost function may
+    # have any arity; the remaining functions must be unary.
+    # In some libraries this function is named sequence.
+    # Note: The result of pipe is not automatically curried.
+    #
+    # (((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 }
+    end
+
+    # Runs the given function with the supplied object, then returns the object.
+    #
+    # (a -> *) -> a -> a
+    #
+    curried_method(:tap) do |fn, x|
+      fn.call(x)
+      x
+    end
+
+    # Accepts a function fn and a list of transformer functions and returns
+    # a new curried function. When the new function is invoked, it calls the
+    # function fn with parameters consisting of the result of calling each
+    # supplied handler on successive arguments to the new function.
+    #
+    # (x1 -> x2 -> ... -> z) -> [(a -> b -> ... -> x1), ...] -> (a -> b -> ... -> z)
+    #
+    curried_method(:use_with) do |fn, fns|
+      Ramda::Internal::FunctionWithArity.new.call(fns.count) do |*args|
+        modified_args = args.each_with_index.map do |arg, index|
+          fns[index].call(arg)
+        end
+        fn.call(*modified_args)
+      end.curry
+    end
+  end
+end