caze 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd3f2bd379e5397dfb287a553635b1f3101efd2c
-  data.tar.gz: 4cdce993f41b9eb4b9b7f9c8e3fc8dcc2a8c7edc
+  metadata.gz: 57f420be075d3ee1de9347c5635e710ff4efd795
+  data.tar.gz: e2de97c3f2916ecdf8711c947ee651692a532c58
 SHA512:
-  metadata.gz: 4b64fbf7ccfe57fe993fef8b2169a6deac157c0f1bb9159e8095139f710170ccc5d57cb0c56dd1ffc31fcb4350209b3abd62c9e54b7308a7ea0ac40b5be143d0
-  data.tar.gz: 6c1edbdedb4422cceb0ffe1f1401d214eba45cf7b7d3790625c24c98cf9884b70b2159ac2fb9fc89a8d5f62e4edc93c1dd870df9ee581fc5483f603082edc50b
+  metadata.gz: 8320bc671bc0d8608ae61539c21cbd04a67f925747d541682ceb27b9843937a5d6ef4118b21c9f73f71317d5cfd566712a2ac54cd0cbec7bcf16202f026a2d0b
+  data.tar.gz: dbde77a1170fb8689e8d7f17f67eaeb89b4e4359efc538b6ea8ea2514e240d1ade7dee316adbf15cd0437def582e4ad2a90c505c7007246d7005965cbee8226f

data/README.md

@@ -1,74 +1,116 @@
 # Caze
 
-This is a simple DSL to work with use case definitions.
-The main propose is to avoid the verbose declarations of
-use cases entry points inside the main project file.
+This is a simple DSL to declare use cases as entry points of a module.
+The purpose is to avoid the verbose declarations.
 
 ## Usage
 
-Require the `Caze` in your project entry point,
-and include it in your main module "class".
+Instead of doing this:
 
 ```ruby
-# Entry point file
+module Project
+  def self.sum(x, y)
+    UseCases::Sum.execute(x, y)
+  end
+
+  def self.subtract(x, y)
+    UseCases::Subtract.execute(x, y)
+  end
+end
+```
+
+You can do this:
 
-require 'project/version'
+```ruby
 require 'caze'
-require 'project/use_cases/foo'
 
 module Project
   include Caze
 
-  define_use_cases foo: UseCases::Foo
+  has_use_case sum:      UseCases::Sum,
+  has_use_case subtract: UseCases::Subtract
 end
 ```
 
-You `Foo` use case should looks like:
+## Using transactions
+
+You can use transactions in your use cases by providing a `transaction_handler`
+in your module. The only method that transaction handler should
+respond is `#transaction`.
+
+```ruby
+Project.transaction_handler = ActiveRecord::Base
+```
+
+While declaring which use cases your app has, you can set the option
+`transactional` to `true`.
+
+```ruby
+  has_use_case wow: UseCases::Wow, transactional: true
+```
+
+Note that the transaction handler must implement `#transaction` and
+return the value inside the block. It will also be responsible for handle errors
+and rollback if necessary.
+
+## Exporting instance methods as class methods
+
+Inside the use case classes you can use the `.export` method, so in the `UseCases::Sum` instead of this:
 
 ```ruby
 module Project
   module UseCases
-    class Foo
-      include Caze
+    class Sum
+      def self.execute(x ,y)
+        new(x,y).foo
+      end
 
-      define_entry_point :foo
+      def initialize(x, y)
+        @x = x
+        @y = y
+      end
 
-      def foo
-        puts "bar"
+      def sum
+        x + y
       end
     end
   end
 end
 ```
 
-The usage is like was before:
+You can define a class method based on an instance method with `export`:
 
 ```ruby
-Project.foo # This will call foo inside the use case `Foo`
-```
+module Project
+  module UseCases
+    class Foo
+      include Caze
 
-## Using transactions
+      export :sum, as: :execute
 
-You can use transactions in your use cases by providing a `transaction_handler`
-in your project entry point. The only method that transaction handler should
-respond is `#transaction`.
+      def initialize(x, y)
+        @x = x
+        @y = y
+      end
 
-```ruby
-Project.transaction_handler = ActiveRecord::Base
+      def sum
+        x + y
+      end
+    end
+  end
+end
 ```
 
-Inside your use case, you need to define the entry point with the flag
-`use_transaction` set to `true`.
+The `as` param, tells how the class method must be named,
+if it is not passed the class method will have the of the instance method.
+
+
+With this you can call your project use cases without the need to know its internals:
 
 ```ruby
-define_entry_point :foo, use_transaction: true
+Project.sum(4, 2) # This will call sum inside the use case `UseCases::Sum`
 ```
 
-Note that the transaction handler should implement `#transaction` and
-return the value inside the block. It will also be responsible for handle errors
-and rollback if necessary.
-
-# License
+# Apache License 2.0
 
-Apache License 2.0
 Check LICENSE.txt

data/caze.gemspec

@@ -6,7 +6,7 @@ require 'caze/version'
 Gem::Specification.new do |spec|
   spec.name          = "caze"
   spec.version       = Caze::VERSION
-  spec.authors       = ["Magnetis team"]
+  spec.authors       = ["Philip Sampaio", "Fabiano Beselga"]
   spec.email         = ["philip@magnetis.com.br", "fabiano@magnetis.com.br"]
   spec.summary       = %q{A DSL to define use cases}
   spec.description   = %q{With Caze it's easy to define use cases and entry points.}

data/lib/caze.rb

@@ -10,36 +10,28 @@ module Caze
   module ClassMethods
     attr_accessor :transaction_handler
 
-    def define_use_cases(use_cases)
-      use_cases.each_pair do |use_case_name, use_case_class|
-        main_module = self
+    def has_use_case(use_case_name, use_case_class, options = {})
+      transactional  = options.fetch(:transactional) { false }
 
-        # Define a reference to the parent module
-        # in order to be able to use the transaction handler.
-        use_case_class.define_singleton_method(:parent_module, ->() { main_module })
+      define_singleton_method(use_case_name, Proc.new { |*args|
+        if transactional
+          handler = self.transaction_handler
 
-        define_singleton_method(use_case_name, Proc.new { |*args|
+          raise NoTransactionMethodError, "This action should be executed inside a transaction. But no transaction handler was configured." unless handler
+
+          handler.transaction { use_case_object.send(method_name) }
+        else
           use_case_class.send(use_case_name, *args)
-        })
-      end
+        end
+      })
     end
 
-    def define_entry_point(method_name, options = {})
+    def export(method_name, options = {})
       method_to_define = options.fetch(:as) { method_name }
-      use_transaction  = options.fetch(:use_transaction) { false }
 
       define_singleton_method(method_to_define, Proc.new { |*args|
         use_case_object = args.empty? ? new : new(*args)
-
-        if use_transaction
-          handler = parent_module.transaction_handler
-
-          raise NoTransactionMethodError, "This action should be executed inside a transaction. But no transaction handler was configured." unless handler
-
-          handler.transaction { use_case_object.send(method_name) }
-        else
-          use_case_object.send(method_name)
-        end
+        use_case_object.send(method_name)
       })
     end
   end

data/lib/caze/version.rb

@@ -1,3 +1,3 @@
 module Caze
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/caze_spec.rb

@@ -12,7 +12,7 @@ describe Caze do
     class DummyUseCase
       include Caze
 
-      define_entry_point :the_answer
+      export :the_answer
 
       def the_answer
         42
@@ -22,7 +22,7 @@ describe Caze do
     class DummyUseCaseWithParam
       include Caze
 
-      define_entry_point :the_answer_for
+      export :the_answer_for
 
       def initialize(question, priority: :low)
         @priority = priority
@@ -36,15 +36,16 @@ describe Caze do
     module Dummy
       include Caze
 
-      define_use_cases the_answer: DummyUseCase,
-                       the_answer_for: DummyUseCaseWithParam
+      has_use_case :the_answer, DummyUseCase
+      has_use_case :the_answer_for, DummyUseCaseWithParam
+      has_use_case :the_transactional_answer, DummyUseCase, transactional: true
     end
   end
 
   let(:use_case) { DummyUseCase }
   let(:app) { Dummy }
 
-  describe '.define_use_cases' do
+  describe '.has_use_case' do
     it 'delegates the use case message to the use case' do
       allow(use_case).to receive(:the_answer)
       app.the_answer
@@ -55,56 +56,44 @@ describe Caze do
         expect(app.the_answer_for('the meaning of life', priority: :high)).to eql([:high, 42])
       end
     end
-  end
-
-  describe '.define_entry_point' do
-    it 'defines a class method' do
-      expect(use_case).to respond_to(:the_answer)
-    end
-
-    context 'using the flag `as`' do
-      before do
-        use_case.define_entry_point :the_answer, as: :universal_answer
-      end
-
-      it 'defines an entry point with another name' do
-        expect(use_case).to respond_to(:universal_answer)
-      end
-    end
-
 
     context 'using transaction' do
       context 'when there is a transaction method' do
-        let(:transaction_handler) do
-          double(:transaction_handler)
-        end
+        let(:transaction_handler) { double(:transaction_handler) }
 
         before do
           app.transaction_handler = transaction_handler
-          use_case.define_entry_point :the_answer,
-                                      as: :the_answer_with_transaction,
-                                      use_transaction: true
         end
 
         it 'uses the transaction handler' do
           expect(transaction_handler).to receive(:transaction)
-          use_case.the_answer_with_transaction
+          app.the_transactional_answer
         end
       end
 
       context 'when there is no transaction method defined' do
-        before do
-          use_case.define_entry_point :the_answer,
-                                      as: :the_answer_with_transaction,
-                                      use_transaction: true
-        end
-
         it 'raises an exception' do
           expect {
-            use_case.the_answer_with_transaction
+            app.the_transactional_answer
           }.to raise_error(/This action should be executed inside a transaction/)
         end
       end
     end
   end
+
+  describe '.export' do
+    it 'defines a class method' do
+      expect(use_case).to respond_to(:the_answer)
+    end
+
+    context 'using the flag `as`' do
+      before do
+        use_case.export :the_answer, as: :universal_answer
+      end
+
+      it 'defines an entry point with another name' do
+        expect(use_case).to respond_to(:universal_answer)
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: caze
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
-- Magnetis team
+- Philip Sampaio
+- Fabiano Beselga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-05 00:00:00.000000000 Z
+date: 2015-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler