u-case 1.0.0.rc1

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "micro/case"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

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/lib/micro/case.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'micro/attributes'
+
+require 'micro/case/version'
+require 'micro/case/error'
+require 'micro/case/result'
+require 'micro/case/base'
+require 'micro/case/safe'
+require 'micro/case/strict'
+require 'micro/case/flow/reducer'
+require 'micro/case/flow'

data/lib/micro/case/base.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Micro
+  module Case
+    class Base
+      include Micro::Attributes.without(:strict_initialize)
+
+      def self.to_proc
+        Proc.new { |arg| call(arg) }
+      end
+
+      def self.>>(use_case)
+        Flow[self, use_case]
+      end
+
+      def self.&(use_case)
+        Flow::Safe[self, use_case]
+      end
+
+      def self.call(options = {})
+        new(options).call
+      end
+
+      def self.__new__(result, arg)
+        instance = new(arg)
+        instance.__set_result__(result)
+        instance
+      end
+
+      def self.__failure_type(arg, type)
+        return type if type != :error
+
+        case arg
+        when Exception then :exception
+        when Symbol then arg
+        else type
+        end
+      end
+
+      def call!
+        raise NotImplementedError
+      end
+
+      def call
+        __call
+      end
+
+      def __set_result__(result)
+        raise Error::InvalidResultInstance unless result.is_a?(Result)
+        raise Error::ResultIsAlreadyDefined if @__result
+        @__result = result
+      end
+
+      private
+
+        def __call
+          result = call!
+          return result if result.is_a?(Result)
+          raise Error::UnexpectedResult.new(self.class)
+        end
+
+        def __get_result__
+          @__result ||= Result.new
+        end
+
+        def Success(arg = :ok)
+          value, type = block_given? ? [yield, arg] : [arg, :ok]
+          __get_result__.__set__(true, value, type, nil)
+        end
+
+        def Failure(arg = :error)
+          value = block_given? ? yield : arg
+          type = self.class.__failure_type(value, block_given? ? arg : :error)
+          __get_result__.__set__(false, value, type, self)
+        end
+    end
+  end
+end

data/lib/micro/case/error.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Micro
+  module Case
+    module Error
+      class UnexpectedResult < TypeError
+        MESSAGE = '#call! must return an instance of Micro::Case::Result'.freeze
+
+        def initialize(klass); super(klass.name + MESSAGE); end
+      end
+
+      ResultIsAlreadyDefined = ArgumentError.new('result is already defined'.freeze)
+
+      InvalidResultType = TypeError.new('type must be a Symbol'.freeze)
+      InvalidResultInstance = ArgumentError.new('argument must be an instance of Micro::Case::Result'.freeze)
+
+      InvalidUseCase = TypeError.new('use case must be a kind or an instance of Micro::Case::Base'.freeze)
+      InvalidUseCases = ArgumentError.new('argument must be a collection of `Micro::Case::Base` classes'.freeze)
+
+      UndefinedFlow = ArgumentError.new("This class hasn't declared its flow. Please, use the `flow()` macro to define one.".freeze)
+
+      class InvalidAccessToTheUseCaseObject < StandardError
+        MSG = 'only a failure result can access its use case object'.freeze
+
+        def initialize(message = MSG); super; end
+      end
+
+      module ByWrongUsage
+        def self.check(exception)
+          exception.is_a?(Error::UnexpectedResult) || exception.is_a?(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/lib/micro/case/flow.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Micro
+  module Case
+    module Flow
+      module ClassMethods
+        def __flow__
+          @__flow
+        end
+
+        def flow(*args)
+          @__flow= flow_reducer.build(args)
+        end
+
+        def call(options = {})
+          new(options).call
+        end
+      end
+
+      CONSTRUCTOR = <<-RUBY
+      def initialize(options)
+        @options = options
+        flow= self.class.__flow__
+        raise Error::UndefinedFlow unless flow
+      end
+      RUBY
+
+      private_constant :ClassMethods, :CONSTRUCTOR
+
+      def self.included(base)
+        def base.flow_reducer; Reducer; end
+        base.extend(ClassMethods)
+        base.class_eval(CONSTRUCTOR)
+      end
+
+      def self.[](*args)
+        Reducer.build(args)
+      end
+
+      def call
+        self.class.__flow__.call(@options)
+      end
+
+      module Safe
+        def self.included(base)
+          base.send(:include, Micro::Case::Flow)
+          def base.flow_reducer; SafeReducer; end
+        end
+
+        def self.[](*args)
+          SafeReducer.build(args)
+        end
+      end
+    end
+  end
+end

data/lib/micro/case/flow/reducer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Micro
+  module Case
+    module Flow
+      class Reducer
+        attr_reader :use_cases
+
+        def self.map_use_cases(arg)
+          return arg.use_cases if arg.is_a?(Reducer)
+          return arg.__flow__.use_cases if arg.is_a?(Class) && arg < Micro::Case::Flow
+          Array(arg)
+        end
+
+        def self.build(args)
+          use_cases = Array(args).flat_map { |arg| map_use_cases(arg) }
+
+          raise Error::InvalidUseCases if use_cases.any? { |klass| !(klass < ::Micro::Case::Base) }
+
+          new(use_cases)
+        end
+
+        def initialize(use_cases)
+          @use_cases = use_cases
+        end
+
+        def call(arg = {})
+          @use_cases.reduce(initial_result(arg)) do |result, use_case|
+            break result if result.failure?
+            use_case.__new__(result, result.value).call
+          end
+        end
+
+        def >>(arg)
+          self.class.build(use_cases + self.class.map_use_cases(arg))
+        end
+
+        def &(arg)
+          raise NoMethodError, "undefined method `&' for #{self.inspect}. Please, use the method `>>' to avoid this error."
+        end
+
+        def to_proc
+          Proc.new { |arg| call(arg) }
+        end
+
+        private
+
+          def initial_result(arg)
+            return arg.call if arg_to_call?(arg)
+            return arg if arg.is_a?(Micro::Case::Result)
+            result = Micro::Case::Result.new
+            result.__set__(true, arg, :ok, nil)
+          end
+
+          def arg_to_call?(arg)
+            return true if arg.is_a?(Micro::Case::Base) || arg.is_a?(Reducer)
+            return true if arg.is_a?(Class) && (arg < Micro::Case::Base || arg < Micro::Case::Flow)
+            return false
+          end
+      end
+
+      class SafeReducer < Reducer
+        def call(arg = {})
+          @use_cases.reduce(initial_result(arg)) do |result, use_case|
+            break result if result.failure?
+            use_case_result(use_case, result)
+          end
+        end
+
+        alias_method :&, :>>
+
+        def >>(arg)
+          raise NoMethodError, "undefined method `>>' for #{self.inspect}. Please, use the method `&' to avoid this error."
+        end
+
+        private
+
+          def use_case_result(use_case, result)
+            begin
+              instance = use_case.__new__(result, result.value)
+              instance.call
+            rescue => exception
+              raise exception if Error::ByWrongUsage.check(exception)
+              result.__set__(false, exception, :exception, instance)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/micro/case/result.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Micro
+  module Case
+    class Result
+      attr_reader :value, :type
+
+      def __set__(is_success, value, type, use_case)
+        raise Error::InvalidResultType unless type.is_a?(Symbol)
+        raise Error::InvalidUseCase if !is_success && !is_an_use_case?(use_case)
+
+        @success, @value, @type, @use_case = is_success, value, type, use_case
+
+        self
+      end
+
+      def success?
+        @success
+      end
+
+      def failure?
+        !success?
+      end
+
+      def use_case
+        return @use_case if failure?
+
+        raise Error::InvalidAccessToTheUseCaseObject
+      end
+
+      def on_success(arg = nil)
+        self.tap { yield(value) if success_type?(arg) }
+      end
+
+      def on_failure(arg = nil)
+        self.tap{ yield(value, @use_case) if failure_type?(arg) }
+      end
+
+      private
+
+        def success_type?(arg)
+          success? && (arg.nil? || arg == type)
+        end
+
+        def failure_type?(arg)
+          failure? && (arg.nil? || arg == type)
+        end
+
+        def is_an_use_case?(arg)
+          (arg.is_a?(Class) && arg < Case::Base) || arg.is_a?(Case::Base)
+        end
+    end
+  end
+end

data/lib/micro/case/safe.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Micro
+  module Case
+    class Safe < Case::Base
+      def call
+        super
+      rescue => exception
+        raise exception if Error::ByWrongUsage.check(exception)
+        Failure(exception)
+      end
+    end
+  end
+end

data/lib/micro/case/strict.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Micro
+  module Case
+    class Strict < Case::Base
+      include Micro::Attributes::Features::StrictInitialize
+
+      class Safe < Case::Safe
+        include Micro::Attributes::Features::StrictInitialize
+      end
+    end
+  end
+end

data/lib/micro/case/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Micro
+  module Case
+    VERSION = '1.0.0.rc1'.freeze
+  end
+end

data/lib/micro/case/with_validation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'micro/case'
+
+module Micro
+  module Case
+    class Base
+      include Micro::Attributes::Features::ActiveModelValidations
+
+      def call
+        return Failure(:validation_error) { self.errors } unless valid?
+
+        __call
+      end
+    end
+  end
+end

data/lib/u-case.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'micro/case'

data/lib/u-case/with_validation.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'micro/case/with_validation'

data/test.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+bundle
+
+rm Gemfile.lock
+
+source $(dirname $0)/.travis.sh
+
+rm Gemfile.lock
+
+bundle