u-case 1.1.0 → 2.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f82733e98f4f7e6d43edcd3134b4a8d8b75b6847ad21149b449111696d0b2ae
-  data.tar.gz: 5577b62e6dea66980ef4277ed219dbd440eaf0888a2c8897d55e9d2cb9e40e08
+  metadata.gz: 806dbd5686331f1a76c1dd8d972172cd3754a7cb4aa53fb74f3a9eb8497d0afd
+  data.tar.gz: 5ea6769e14d5f5fdb32bc0a43895ab2a4635bcdd2ad25bbe5f1240fff90abe71
 SHA512:
-  metadata.gz: a398f2c05a509bc35d6b8391107c21a9c0994d38bc0684895d0e0e4fc3ae25ea142ce9b11f7cf8c8e40df60623b2a5bf24a4c384803bbf504cc076f96db82105
-  data.tar.gz: f271749d8790cfc12dce63a5605f35ebfc127e0f46a411064cca6c15fd6f01e638afee5fcdf8a38a82bcf4416764793e282a82b416cd99547045312ccd22146b
+  metadata.gz: ad2316a9def217796b9aa9f8f6f49a95aa7a49fec96153ff90cec72247c8e7900ce790a6af3c7d4d6a14e39af05a864d6d9d2c967f2ebb3f9fb6f6b6dd0dd326
+  data.tar.gz: a63bf37a2d60d8f177a7105224a1e1d1d77120447c2c31ae1da70e960429e9f8ff30d41f6c803c07c74205b311c90824de8360735f8721e5bc19f3b77fbfa5e3

data/Gemfile

@@ -17,6 +17,7 @@ end
 group :test do
   gem 'minitest', activemodel_version < '4.1' ? '~> 4.2' : '~> 5.0'
   gem 'simplecov', require: false
+  gem 'minitest-reporters', require: false
 end
 
 # Specify your gem's dependencies in u-case.gemspec

data/README.md

@@ -6,13 +6,13 @@
 μ-case (Micro::Case)
 ==========================
 
-Create simple and powerful use cases as objects (aka: service objects).
+Create simple and powerful use cases as objects.
 
 The main goals of this project are:
 1. Be simple to use and easy to learn (input **>>** process/transform **>>** output).
-2. Referential transparency and data integrity.
+2. Promove referential transparency (transforming instead of modifying) and data integrity.
 3. No callbacks (before, after, around...).
-4. Represent complex business logic using a composition of use cases.
+4. Solve complex business logic using a composition of use cases.
 
 ## Table of Contents <!-- omit in toc -->
 - [μ-case (Micro::Case)](#%ce%bc-case-microcase)
@@ -64,7 +64,7 @@ Or install it yourself as:
 ### How to define a use case?
 
 ```ruby
-class Multiply < Micro::Case::Base
+class Multiply < Micro::Case
   # 1. Define its input as attributes
   attributes :a, :b
 
@@ -108,7 +108,7 @@ result.value # 6
 
 # Note:
 # ----
-# The result of a Micro::Case::Base.call
+# The result of a Micro::Case.call
 # is an instance of Micro::Case::Result
 ```
 
@@ -133,7 +133,7 @@ Every result has a type and these are the defaults:
 - `:error`/`:exception` when failures
 
 ```ruby
-class Divide < Micro::Case::Base
+class Divide < Micro::Case
   attributes :a, :b
 
   def call!
@@ -187,7 +187,7 @@ err_result.use_case # #<Divide:0x0000 @__attributes={"a"=>2, "b"=>0}, @a=2, @b=0
 Answer: Use a symbol as the argument of `Success()`, `Failure()` methods and declare a block to set their values.
 
 ```ruby
-class Multiply < Micro::Case::Base
+class Multiply < Micro::Case
   attributes :a, :b
 
   def call!
@@ -223,7 +223,7 @@ bad_result.failure? # true
 Answer: Yes, it is. But only for failure results!
 
 ```ruby
-class Multiply < Micro::Case::Base
+class Multiply < Micro::Case
   attributes :a, :b
 
   def call!
@@ -255,7 +255,7 @@ As mentioned earlier, the `Micro::Case::Result` has two methods to improve the f
 The examples below show how to use them:
 
 ```ruby
-class Double < Micro::Case::Base
+class Double < Micro::Case
   attributes :number
 
   def call!
@@ -307,7 +307,7 @@ Double
 Answer: The hook will be triggered if it matches the result type.
 
 ```ruby
-class Double < Micro::Case::Base
+class Double < Micro::Case
   attributes :number
 
   def call!
@@ -341,7 +341,7 @@ In this case, this will be is a **flow**, because the idea is to use/reuse use c
 
 ```ruby
 module Steps
-  class ConvertToNumbers < Micro::Case::Base
+  class ConvertToNumbers < Micro::Case
     attribute :numbers
 
     def call!
@@ -440,7 +440,7 @@ Answer: Yes, it is.
 
 ```ruby
 module Steps
-  class ConvertToNumbers < Micro::Case::Base
+  class ConvertToNumbers < Micro::Case
     attribute :numbers
 
     def call!
@@ -585,7 +585,7 @@ end
 
 module Users
   class Create
-    include Micro::Case::Flow::Safe
+    include Micro::Case::Safe::Flow
 
     flow ProcessParams, ValidateParams, Persist, SendToCRM
   end
@@ -594,7 +594,7 @@ end
 # or
 
 module Users
-  Create = Micro::Case::Flow::Safe[
+  Create = Micro::Case::Safe::Flow[
     ProcessParams,
     ValidateParams,
     Persist,
@@ -616,7 +616,7 @@ To do this your application must have the [activemodel >= 3.2](https://rubygems.
 # By default, if your application has the activemodel as a dependency,
 # any kind of use case can use it to validate their attributes.
 #
-class Multiply < Micro::Case::Base
+class Multiply < Micro::Case
   attributes :a, :b
 
   validates :a, :b, presence: true, numericality: true
@@ -640,7 +640,7 @@ gem 'u-case', require: 'u-case/with_validation'
 
 # Using this approach, you can rewrite the previous example with less code. e.g:
 
-class Multiply < Micro::Case::Base
+class Multiply < Micro::Case
   attributes :a, :b
 
   validates :a, :b, presence: true, numericality: true

data/lib/micro/case/error.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Micro
-  module Case
+  class Case
     module Error
       class UnexpectedResult < TypeError
         MESSAGE = '#call! must return an instance of Micro::Case::Result'.freeze
@@ -14,8 +14,8 @@ module Micro
       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)
+      InvalidUseCase = TypeError.new('use case must be a kind or an instance of Micro::Case'.freeze)
+      InvalidUseCases = ArgumentError.new('argument must be a collection of `Micro::Case` classes'.freeze)
 
       UndefinedFlow = ArgumentError.new("This class hasn't declared its flow. Please, use the `flow()` macro to define one.".freeze)
 

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

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
 module Micro
-  module Case
+  class 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
+          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) }
+          raise Error::InvalidUseCases if use_cases.any? { |klass| !(klass < ::Micro::Case) }
 
           new(use_cases)
         end
@@ -27,6 +28,7 @@ module Micro
         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
@@ -48,43 +50,17 @@ module Micro
           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 = ::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 true if arg.is_a?(::Micro::Case) || arg.is_a?(Reducer)
+            return true if arg.is_a?(Class) && (arg < ::Micro::Case || 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/flow.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Micro
-  module Case
+  class Case
     module Flow
       module ClassMethods
         def __flow__
@@ -20,7 +20,9 @@ module Micro
       CONSTRUCTOR = <<-RUBY
       def initialize(options)
         @options = options
+
         flow = self.class.__flow__
+
         raise Error::UndefinedFlow unless flow
       end
       RUBY
@@ -29,7 +31,9 @@ module Micro
 
       def self.included(base)
         def base.flow_reducer; Reducer; end
+
         base.extend(ClassMethods)
+
         base.class_eval(CONSTRUCTOR)
       end
 
@@ -40,17 +44,6 @@ module Micro
       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/result.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 module Micro
-  module Case
+  class 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)
+        raise Error::InvalidUseCase if !is_success && !is_a_use_case?(use_case)
 
         @success, @value, @type, @use_case = is_success, value, type, use_case
 
@@ -46,8 +46,8 @@ module Micro
           failure? && (arg.nil? || arg == type)
         end
 
-        def is_an_use_case?(arg)
-          (arg.is_a?(Class) && arg < Case::Base) || arg.is_a?(Case::Base)
+        def is_a_use_case?(arg)
+          (arg.is_a?(Class) && arg < ::Micro::Case) || arg.is_a?(::Micro::Case)
         end
     end
   end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Micro
+  class Case
+    class Safe
+      module Flow
+        def self.included(base)
+          base.send(:include, ::Micro::Case::Flow)
+
+          def base.flow_reducer; Reducer; end
+        end
+
+        def self.[](*args)
+          Reducer.build(args)
+        end
+
+        class Reducer < ::Micro::Case::Flow::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
+end

data/lib/micro/case/safe.rb

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

data/lib/micro/case/strict.rb

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

data/lib/micro/case/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Micro
-  module Case
-    VERSION = '1.1.0'.freeze
+  class Case
+    VERSION = '2.0.0.pre'.freeze
   end
 end

data/lib/micro/case/with_validation.rb

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

data/lib/micro/case.rb

@@ -1,12 +1,93 @@
 # frozen_string_literal: true
 
 require 'micro/attributes'
+# frozen_string_literal: true
+
+module Micro
+  class Case
+    require 'micro/case/version'
+    require 'micro/case/result'
+    require 'micro/case/error'
+    require 'micro/case/safe'
+    require 'micro/case/strict'
+    require 'micro/case/flow/reducer'
+    require 'micro/case/flow'
+    require 'micro/case/safe/flow'
+
+    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)
+      Safe::Flow[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)
 
-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'
+        __get_result__.__set__(false, value, type, self)
+      end
+  end
+end

data/u-case.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Rodrigo Serradura']
   spec.email         = ['rodrigo.serradura@gmail.com']
 
-  spec.summary       = %q{Create simple and powerful use cases as objects (aka: service objects).}
-  spec.description   = %q{Create simple and powerful use cases as objects (aka: service objects).}
+  spec.summary       = %q{Create simple and powerful use cases as objects.}
+  spec.description   = %q{Create simple and powerful use cases as objects.}
   spec.homepage      = 'https://github.com/serradura/u-case'
   spec.license       = 'MIT'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-case
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0.pre
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-04 00:00:00.000000000 Z
+date: 2019-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: u-attributes
@@ -52,7 +52,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-description: 'Create simple and powerful use cases as objects (aka: service objects).'
+description: Create simple and powerful use cases as objects.
 email:
 - rodrigo.serradura@gmail.com
 executables: []
@@ -71,12 +71,12 @@ files:
 - bin/console
 - bin/setup
 - lib/micro/case.rb
-- lib/micro/case/base.rb
 - lib/micro/case/error.rb
 - lib/micro/case/flow.rb
 - lib/micro/case/flow/reducer.rb
 - lib/micro/case/result.rb
 - lib/micro/case/safe.rb
+- lib/micro/case/safe/flow.rb
 - lib/micro/case/strict.rb
 - lib/micro/case/version.rb
 - lib/micro/case/with_validation.rb
@@ -99,12 +99,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: 'Create simple and powerful use cases as objects (aka: service objects).'
+summary: Create simple and powerful use cases as objects.
 test_files: []

data/lib/micro/case/base.rb

@@ -1,78 +0,0 @@
-# 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