j8-functional 0.1.0

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/j8-functional.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'j8/functional/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'j8-functional'
+  spec.version       = J8::Functional::VERSION
+  spec.authors       = ['John Shields']
+  spec.email         = ['john@shields.wtf']
+
+  spec.summary       = 'Java 8 inspired functional utilities'
+  spec.homepage      = 'https://john.shields.wtf'
+  spec.license       = 'MIT'
+
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'gem-release'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-doc'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rb-inotify'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop'
+end

data/lib/j8-functional.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'j8/functional'

data/lib/j8/bi_consumer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module J8
+  class BiConsumer
+    include J8::Common
+
+    def accept(o1, o2)
+      @callable.call(o1, o2)
+    end
+
+    def then(after = nil, &block)
+      callable = from_callable(after, block)
+
+      J8::BiConsumer.new(
+        lambda do |o1, o2|
+          accept(o1, o2)
+          callable.accept(o1, o2)
+        end
+      )
+    end
+  end
+end

data/lib/j8/bi_function.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module J8
+  class BiFunction
+    include J8::Common
+
+    def apply(o1, o2)
+      @callable.call(o1, o2)
+    end
+
+    def then(after = nil, &block)
+      callable = from_callable(after, block)
+
+      J8::BiFunction.new(->(o1, o2) { callable.apply(*apply(o1, o2)) })
+    end
+  end
+end

data/lib/j8/bi_predicate.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module J8
+  class BiPredicate
+    include J8::Common
+
+    def test(o1, o2)
+      @callable.call(o1, o2)
+    end
+
+    def negate
+      J8::BiPredicate.new(->(o1, o2) { !test(o1, o2) })
+    end
+
+    def and(other = nil, &block)
+      callable = from_callable(other, block)
+
+      J8::BiPredicate.new(->(o1, o2) { test(o1, o2) && callable.test(o1, o2) })
+    end
+
+    def or(other = nil, &block)
+      callable = from_callable(other, block)
+
+      J8::BiPredicate.new(->(o1, o2) { test(o1, o2) || callable.test(o1, o2) })
+    end
+  end
+end

data/lib/j8/binary_operator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module J8
+  class BinaryOperator < J8::BiFunction
+    def self.max_by(comparator = nil, &block)
+      callable = from_callable_class(comparator, block, J8::Comparator)
+
+      J8::BinaryOperator.new(->(a, b) { callable.compare(a, b) <= 0 ? a : b })
+    end
+
+    def self.min_by(comparator = nil, &block)
+      callable = from_callable_class(comparator, block, J8::Comparator)
+
+      J8::BinaryOperator.new(->(a, b) { callable.compare(a, b) >= 0 ? a : b })
+    end
+  end
+end

data/lib/j8/collector.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module J8
+  class Collector
+  end
+end

data/lib/j8/collectors.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module J8
+  class Collectors
+  end
+end

data/lib/j8/common.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module J8
+  module Common
+    module_function
+
+    def initialize(callable = nil, &block)
+      @callable = callable_from_proc(callable, block)
+    end
+
+    def lambda?(o)
+      o.is_a?(Proc) && o.lambda?
+    end
+
+    def raise_unless_lambda(o)
+      return if lambda?(o)
+
+      raise ArgumentError, "(#{o.class}) '#{o}' is not a lambda"
+    end
+
+    def from_callable(callable, block)
+      callable = callable_from_proc(callable, block)
+
+      if callable.is_a?(self.class)
+        callable
+      else
+        raise_unless_lambda(callable)
+
+        self.class.new(callable)
+      end
+    end
+
+    def from_callable_class(callable, block, klass)
+      if callable.is_a?(klass)
+        callable
+      else
+        callable = callable_from_proc(callable, block)
+        raise_unless_lambda(callable)
+
+        klass.new(callable)
+      end
+    end
+
+    def make_lambda(block)
+      Object.new.tap { |n| n.define_singleton_method(:_, block) }.method(:_).to_proc
+    end
+
+    def callable_from_proc(callable, block)
+      if block.nil?
+        raise J8::NilException if callable.nil?
+
+        raise_unless_lambda(callable)
+
+        callable
+      else
+        make_lambda(block)
+      end
+    end
+  end
+end

data/lib/j8/comparator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module J8
+  class Comparator
+    include J8::Common
+
+    def self.comparing(extractor, comparator)
+      extractor = from_callable_class(extractor, nil, J8::Function)
+      comparator = from_callable_class(comparator, nil, J8::Comparator)
+
+      J8::Comparataor.new(
+        lambda do |o1, o2|
+          comparator.compare(extractor.apply(o1), extractor.apply(o2))
+        end
+      )
+    end
+
+    def compare(o1, o2)
+      raise J8::NilException if o1.nil?
+      raise J8::NilException if o2.nil?
+
+      @callable.call(o1, o2)
+    end
+  end
+end

data/lib/j8/consumer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module J8
+  class Consumer
+    include J8::Common
+
+    def accept(o)
+      @callable.call(o)
+    end
+
+    def then(after = nil, &block)
+      callable = from_callable(after, block)
+
+      J8::Consumer.new(
+        lambda do |o|
+          accept(o)
+          callable.accept(o)
+        end
+      )
+    end
+  end
+end

data/lib/j8/function.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module J8
+  class Function
+    include J8::Common
+
+    def apply(o)
+      @callable.call(o)
+    end
+
+    def compose(before = nil, &block)
+      callable = from_callable(before, block)
+
+      J8::Function.new(->(o) { apply(callable.apply(o)) })
+    end
+
+    def then(after = nil, &block)
+      callable = from_callable(after, block)
+
+      J8::Function.new(->(o) { callable.apply(apply(o)) })
+    end
+
+    def self.identity
+      J8::Function.new { |o| o }
+    end
+  end
+end

data/lib/j8/functional.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'j8/functional/version'
+require 'j8/functional/exceptions'
+require 'j8/common'
+
+require 'j8/bi_consumer'
+require 'j8/bi_function'
+require 'j8/predicate'
+require 'j8/collector'
+require 'j8/supplier'
+require 'j8/optional'
+require 'j8/function'
+require 'j8/consumer'
+require 'j8/comparator'
+require 'j8/stream'
+
+class Object
+  def j8_stream
+    if self.class.ancestors.include?(Enumerable)
+      J8::Stream.new(each)
+    else
+      J8::Stream.new([self].each)
+    end
+  end
+end

data/lib/j8/functional/exceptions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module J8
+  class NilException < StandardError; end
+
+  class NoSuchElementException < StandardError; end
+end

data/lib/j8/functional/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module J8
+  module Functional
+    VERSION = '0.1.0'
+  end
+end

data/lib/j8/optional.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module J8
+  class Optional
+    include J8::Common
+
+    def initialize(value = nil)
+      @value = value
+    end
+
+    def self.empty
+      J8::Optional.new
+    end
+
+    def self.of(value)
+      raise J8::NilException if value.nil?
+
+      J8::Optional.new(value)
+    end
+
+    def self.of_nilable(value)
+      J8::Optional.new(value)
+    end
+
+    def empty?
+      @value.nil?
+    end
+
+    def equals?(object)
+      @value == object
+    end
+    alias == equals?
+
+    def filter(predicate = nil, &block)
+      callable = from_callable_class(predicate, block, J8::Predicate)
+
+      if present? && callable.test(@value)
+        J8::Optional.new(@value)
+      else
+        J8::Optional.empty
+      end
+    end
+
+    def flat_map(function = nil, &block)
+      callable = from_callable_class(function, block, J8::Function)
+      return J8::Optional.empty unless present?
+
+      callable.apply(@value).tap do |result|
+        raise J8::NilException if result.nil?
+      end
+    end
+
+    def get
+      raise J8::NoSuchElementException unless present?
+
+      @value
+    end
+    alias value get
+
+    def if_present(consumer = nil, &block)
+      callable = from_callable_class(consumer, block, J8::Consumer)
+      return unless present?
+
+      callable.accept(@value)
+    end
+
+    def present?
+      !@value.nil?
+    end
+
+    def map(function = nil, &block)
+      callable = from_callable_class(function, block, J8::Function)
+      return J8::Optional.empty unless present?
+
+      J8::Optional.new(callable.apply(@value))
+    end
+
+    def or_else(value)
+      if present?
+        @value
+      else
+        value
+      end
+    end
+
+    def or_else_get(supplier = nil, &block)
+      callable = from_callable_class(supplier, block, J8::Supplier)
+
+      if present?
+        @value
+      else
+        callable.get.tap do |result|
+          raise J8::NilException if result.nil?
+        end
+      end
+    end
+
+    def or_else_raise(supplier = nil, &block)
+      callable = from_callable_class(supplier, block, J8::Supplier)
+      raise callable.get unless present?
+
+      @value
+    end
+  end
+end