light_operations 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db2c6c8440e6a48a6ef168af4a7b545132437356
-  data.tar.gz: 575327c90f66617d35a9954efe5870403695faf2
+  metadata.gz: c894c1e7f9c3a1a15692c6875f4ded5b88d458d9
+  data.tar.gz: 9d841c8af28c066013159703d302ef42cb354991
 SHA512:
-  metadata.gz: 84d0758c75019a861344f0ad49ffc2283af17c21aa8c385e84b54eaee2d15f6d746897f65e364527dbf7c8a055261f58aa294212124e30917cd795baab2ab895
-  data.tar.gz: b78d2ae0b6f0776491cc0725c24f543e142e11e2d39814dbcf21fb83beaa5768793ad3408d3b8c4704c6e828aa840b3c3284476bd8e0bd6a360698350355d075
+  metadata.gz: 2c3dcbef05689a60f891fc292b4fb96079406e6703d5ce7df0ca56ca2fee36ccc6808bb4987bbbfe4f095ec03f2dee656ff1aaa90dc5155a6982ddd4a522f3fb
+  data.tar.gz: a1b15f8668462cf6409450825a6a9f23d2e20040b44e53a8b39a42f17a73499a23bf28ab70ead3a583911e3453836bbc13e15bcbfe69163c2aae3df8f8a68952

data/README.md

@@ -24,6 +24,105 @@ Or install it yourself as:
 
 ### Uses cases
 
+#### Basic vote logic
+
+Operation
+
+```ruby
+class ArticleVoteBumperOperation < LightOperations::Core
+  rescue_from ActiveRecord::ActiveRecordError, with: :on_ar_error
+
+  def execute(_params = nil)
+    dependency(:article_model).tap do |article|
+      article.vote = article.vote.next
+      article.save
+    end
+  end
+
+  def on_ar_error(_exception)
+    fail!({ vote: 'could not be updated!' })
+  end
+end
+```
+
+Controller
+
+```ruby
+class ArticleVotesController < ApplicationController
+  def up
+    response = article_vote_bumper_op.run.success? ? { success: true } : article_vote_bumper_op.errors
+    render :up, json: response
+  end
+
+  private
+
+  def article_vote_bumper_op
+    @article_vote_bumper_op ||= ArticleVoteBumperOperation.new(article_model: article)
+  end
+
+  def article
+    Article.find(params.require(:id))
+  end
+end
+```
+
+#### Basic recursion execution for collect newsfeeds from 2 sources
+
+Operation
+
+```ruby
+class CollectFeedsOperation < LightOperations::Core
+  rescue_from Timeout::Error, with: :on_timeout
+
+  def execute(params = {})
+    dependency(:http_client).get(params.fetch(:url)).body
+  end
+
+  def on_timeout
+    fail!
+  end
+end
+```
+
+Controller
+
+```ruby
+class NewsFeedsController < ApplicationController
+  DEFAULT_NEWS_URL = 'http://rss.best_news.pl'
+  BACKUP_NEWS_URL = 'http://rss.not_so_bad_news.pl'
+  def news
+    collect_feeds_op
+      on(success: :display_news, fail: :second_attempt)
+      .run(url: DEFAULT_NEWS_URL)
+  end
+
+  private
+
+  def second_attempt(_news, _errors)
+    collect_feeds_op
+      .on_fail(:display_old_news)
+      .run(url: BACKUP_NEWS_URL)
+  end
+
+  def display_news(news)
+    render :display_news, locals { news: news }
+  end
+
+  def display_old_news
+  end
+
+  def collect_feeds_op
+    @collect_feeds_op ||= CollectFeedsOperation.new(http_client: http_client)
+  end
+
+  def http_client
+    MyAwesomeHttpClient
+  end
+end
+```
+
+
+
 #### Simple case when you want have user authorization
 
 Operation
@@ -32,19 +131,19 @@ Operation
 class AuthOperation < LightOperations::Core
   rescue_from AuthFail, with: :on_auth_error
 
-  def execute
-    dependency(:auth_service).login(login: login, password: password)
+  def execute(params = {})
+    dependency(:auth_service).login(login: login(params), password: password(params))
   end
 
   def on_auth_error(_exception)
     fail!([login: 'unknown']) # or subject.errors.add(login: 'unknown')
   end
 
-  def login
+  def login(params)
     params.fetch(:login)
   end
 
-  def password
+  def password(params)
     params.fetch(:password)
   end
 end
@@ -60,10 +159,10 @@ class AuthController < ApplicationController
 
   def create
     auth_op
-      .run
       .bind_with(self)
       .on_success(:create_session_with_dashbord_redirection)
       .on_fail(:render_account_with_errors)
+      .run(params)
   end
 
   private
@@ -78,7 +177,7 @@ class AuthController < ApplicationController
   end
 
   def auth_op
-    @auth_op ||= AuthOperation.new(params, auth_service: auth_service)
+    @auth_op ||= AuthOperation.new(auth_service: auth_service)
   end
 
   def auth_service
@@ -97,9 +196,9 @@ class AuthController < ApplicationController
 
   def create
     auth_op
-      .run
       .on_success{ |account| create_session_with_dashbord_redirection(account) }
       .on_fail { |account, _errors| render :new, locals: { account: account } }
+      .run(params)
   end
 
   private
@@ -110,7 +209,7 @@ class AuthController < ApplicationController
   end
 
   def auth_op
-    @auth_op ||= AuthOperation.new(params, auth_service: auth_service)
+    @auth_op ||= AuthOperation.new(auth_service: auth_service)
   end
 
   def auth_service
@@ -128,7 +227,7 @@ class AuthController < ApplicationController
   end
 
   def create
-    auth_op.run.on_success(&go_to_dashboard).on_fail(&go_to_login)
+    auth_op.on_success(&go_to_dashboard).on_fail(&go_to_login).run(params)
   end
 
   private
@@ -145,7 +244,7 @@ class AuthController < ApplicationController
   end
 
   def auth_op
-    @auth_op ||= AuthOperation.new(params, auth_service: auth_service)
+    @auth_op ||= AuthOperation.new(auth_service: auth_service)
   end
 
   def auth_service

data/lib/light_operations/core.rb

@@ -5,44 +5,68 @@ module LightOperations
     include ::ActiveSupport::Rescuable
     MissingDependency = Class.new(StandardError)
 
-    attr_reader :dependencies, :params, :subject, :bind_oject
+    attr_reader :dependencies, :bind_object, :subject
 
-    def initialize(params = {}, dependencies = {})
-      @params, @dependencies = params, dependencies
+    def initialize(dependencies = {})
+      @dependencies = dependencies
     end
 
-    # do not override this method
-    def run
-      @subject = execute
+    # do no.t override this method
+    def run(params = {})
+      @subject = execute(params)
+      execute_actions
       self
     rescue => exception
       rescue_with_handler(exception) || raise
       self
     end
 
-    def bind_with(binding_obj)
-      @bind_oject = binding_obj
+    def on_success(binded_method = nil, &block)
+      actions[:success] = binded_method || block
       self
     end
 
-    def on_success(binded_method = nil, &block)
-      if success?
-        bind_oject.send(binded_method, subject) if can_use_binding_method?(binded_method)
-        block.call(subject) if block_given?
-      end
+    def on_fail(binded_method = nil, &block)
+      actions[:fail] = binded_method || block
       self
     end
 
-    def on_fail(binded_method = nil, &block)
-      unless success?
-        bind_oject.send(binded_method, subject, errors) if can_use_binding_method?(binded_method)
-        block.call(subject, errors) if block_given?
+    def on(actions_with_responses = {})
+      actions_with_responses.slice(:success, :fail).each do |action, response|
+        actions[action] = response
       end
       self
     end
 
+    def clear!
+      clear_actions!
+      unbind!
+      clear_subject_with_errors!
+      self
+    end
+
+    def unbind!
+      @bind_object = nil
+      self
+    end
+
+    def clear_subject_with_errors!
+      @subject, @fail_errors, @errors = nil, nil, nil
+      self
+    end
+
+    def clear_actions!
+      @actions = {}
+      self
+    end
+
+    def bind_with(bind_object)
+      @bind_object = bind_object
+      self
+    end
+
     def errors
-      @errors ||= (subject.respond_to?(:errors) ? subject.errors : [])
+      @errors ||= fail_errors || (subject.respond_to?(:errors) ? subject.errors : [])
     end
 
     def fail?
@@ -55,16 +79,36 @@ module LightOperations
 
     protected
 
-    def can_use_binding_method?(method_name)
-      method_name && bind_oject && bind_oject.respond_to?(method_name)
+    attr_reader :fail_errors
+
+    def execute_actions
+      success? ? execute_success_action : execute_fail_action
     end
 
-    def execute
-      fail 'Not implemented yet'
+    def execute_success_action
+      return unless actions.key?(:success)
+      action = actions[:success]
+      bind_object.send(action, subject) if action.is_a?(Symbol) && bind_object
+      action.call(subject) if action.is_a?(Proc)
+    end
+
+    def execute_fail_action
+      return unless actions.key?(:fail)
+      action = actions[:fail]
+      bind_object.send(action, subject, errors) if action.is_a?(Symbol) && bind_object
+      action.call(subject, errors) if action.is_a?(Proc)
     end
 
     def fail!(errors = [])
-      @errors = errors
+      @fail_errors = errors
+    end
+
+    def actions
+      @actions ||= {}
+    end
+
+    def execute(_params = {})
+      fail 'Not implemented yet'
     end
 
     def dependency(name)

data/lib/light_operations/version.rb

@@ -1,3 +1,3 @@
 module LightOperations
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/spec/lib/core_spec.rb

@@ -8,13 +8,13 @@ describe LightOperations::Core do
   def subject_factory(&block)
     Class.new(described_class).tap do |klass|
       klass.class_eval(&block)
-    end.new(params, dependencies)
+    end.new(dependencies)
   end
 
-  subject { described_class.new(params, dependencies) }
+  subject { described_class.new(dependencies) }
 
   it 'raise error when #execute is not implemented' do
-    expect { subject.run }.to raise_error('Not implemented yet')
+    expect { subject.on(success: :do_nothing).run }.to raise_error('Not implemented yet')
   end
 
   context 'use cases' do
@@ -33,12 +33,14 @@ describe LightOperations::Core do
     context 'dependency usage' do
       subject do
         subject_factory do
-          def execute
+          def execute(_params)
             dependency(:login_service)
           end
         end
       end
 
+      before { subject.on(success: -> (_subject) {}) }
+
       it 'is allowed when is initialized correctly' do
         expect { subject.run }.not_to raise_error
       end
@@ -46,7 +48,7 @@ describe LightOperations::Core do
       context 'raise_error' do
         let(:dependencies) { {} }
         it 'when dependency missing' do
-          expect { subject.run }.to raise_error(LightOperations::Core::MissingDependency)
+          expect { subject.run }.to raise_error(described_class::MissingDependency)
         end
       end
     end
@@ -54,49 +56,55 @@ describe LightOperations::Core do
     # error handling
 
     context '.rescue_from specific error' do
+      TestError = Class.new(StandardError)
+
+      before { subject.on(success: -> (_subject) {}) }
+
       context 'by block' do
         subject do
           subject_factory do
-            rescue_from StandardError do |_exception|
-              fail 'execute block instead original error'
+            rescue_from TestError do |exception|
+              fail "execute block instead original #{exception.class}"
             end
 
-            def execute
-              fail StandardError, 'What now'
+            def execute(_params)
+              fail TestError, 'What now'
             end
           end
         end
 
         it 'call' do
-          expect { subject.run }.to raise_error('execute block instead original error')
+          expect { subject.run }.to raise_error('execute block instead original TestError')
         end
       end
 
       context 'by defined method' do
         subject do
           subject_factory do
-            rescue_from StandardError, with: :rescue_me
+            rescue_from TestError, with: :rescue_me
 
-            def rescue_me
-              fail 'execute rescue_me method instead original error'
+            def rescue_me(exception)
+              fail "execute rescue_me method instead original #{exception.class}"
             end
 
-            def execute
-              fail StandardError, 'What now'
+            def execute(_params)
+              fail TestError, 'What now'
             end
           end
         end
 
         it 'execute' do
-          expect { subject.run }.to raise_error('execute rescue_me method instead original error')
+          expect { subject.run }.to raise_error('execute rescue_me method instead original TestError')
         end
       end
     end
 
+    # on actions success/fail
+
     context 'when operation is successful' do
       subject do
         subject_factory do
-          def execute
+          def execute(_params)
             :success
           end
         end
@@ -105,46 +113,44 @@ describe LightOperations::Core do
       context '#on_success' do
         it 'when bind_with and send_method is used' do
           expect(binding_object).to receive(:success_action).with(:success)
-          subject.run.bind_with(binding_object).on_success(:success_action)
+          subject.on_success(:success_action).bind_with(binding_object).run
         end
 
-        it 'when block is userd' do
-          subject.run.on_success do |result|
-            expect(result).to eq(:success)
-          end
+        it 'when block is used' do
+          subject.on_success { |result| expect(result).to eq(:success) }.run
         end
       end
 
       context '#on_fail' do
         it 'when bind_with and send_method is used' do
           expect(binding_object).not_to receive(:error_action)
-          subject.run.bind_with(binding_object).on_fail(:error_action)
+          subject.bind_with(binding_object).on_fail(:error_action).run
         end
 
-        it 'when block is userd' do
+        it 'when block is used' do
           block_to_exec = -> () {}
           expect(block_to_exec).not_to receive(:call)
-          subject.run.on_fail(&block_to_exec)
+          subject.on_fail(&block_to_exec).run
         end
       end
 
       it '#errors' do
-        expect(subject.run.errors).to eq([])
+        expect(subject.on_success(:success_action).run.errors).to eq([])
       end
 
       it '#fail?' do
-        expect(subject.run.fail?).to eq(false)
+        expect(subject.on_success(:success_action).run.fail?).to eq(false)
       end
 
       it '#success?' do
-        expect(subject.run.success?).to eq(true)
+        expect(subject.on_success(:success_action).run.success?).to eq(true)
       end
     end
 
     context 'when operation is fail' do
       subject do
         subject_factory do
-          def execute
+          def execute(_params)
             fail!([email: :unknown])
             :fail
           end
@@ -154,41 +160,78 @@ describe LightOperations::Core do
       context '#on_success' do
         it 'when bind_with and send_method is used' do
           expect(binding_object).not_to receive(:success_action)
-          subject.run.bind_with(binding_object).on_success(:success_action)
+          subject.bind_with(binding_object).on_success(:success_action).run
         end
 
-        it 'when block is userd' do
+        it 'when block is used' do
           block_to_exec = -> () {}
           expect(block_to_exec).not_to receive(:call)
-          subject.run.on_success(&block_to_exec)
+          subject.on_success(&block_to_exec).run
         end
       end
 
       context '#on_fail' do
         it 'when bind_with and send_method is used' do
           expect(binding_object).to receive(:error_action).with(:fail, [email: :unknown])
-          subject.run.bind_with(binding_object).on_fail(:error_action)
+          subject.bind_with(binding_object).on_fail(:error_action).run
         end
 
-        it 'when block is userd' do
-          subject.run.on_fail do |result, errors|
+        it 'when block is used' do
+          subject.on_fail do |result, errors|
             expect(result).to eq(:fail)
             expect(errors).to eq([email: :unknown])
           end
+          subject.run
         end
       end
 
       it '#errors' do
-        expect(subject.run.errors).to eq([email: :unknown])
+        expect(subject.on_fail(:error_action).run.errors).to eq([email: :unknown])
       end
 
       it '#fail?' do
-        expect(subject.run.fail?).to eq(true)
+        expect(subject.on_fail(:error_action).run.fail?).to eq(true)
       end
 
       it '#success?' do
-        expect(subject.run.success?).to eq(false)
+        expect(subject.on_fail(:error_action).run.success?).to eq(false)
       end
     end
   end
+
+  context 'prepare operation to reuse or simply clear' do
+    it '#unbind!' do
+      subject.bind_with(:some_object)
+      expect { subject.unbind! }.to change { subject.bind_object }
+        .from(:some_object)
+        .to(nil)
+    end
+
+    it '#clear_actions!' do
+      subject.on(success: :abc, fail: :def)
+      expect { subject.clear_actions! }.to change { subject.send(:actions) }
+        .from(success: :abc, fail: :def)
+        .to({})
+    end
+
+    it '#clear_subject_with_errors!' do
+      %w{ subject fail_errors errors }.each do |variable|
+        subject.instance_variable_set("@#{variable}", variable)
+      end
+      expect(subject.subject).to eq('subject')
+      expect(subject.instance_variable_get('@errors')).to eq('errors')
+      expect(subject.instance_variable_get('@fail_errors')).to eq('fail_errors')
+      subject.clear_subject_with_errors!
+      expect(subject.subject).to be_nil
+      expect(subject.instance_variable_get('@errors')).to be_nil
+      expect(subject.instance_variable_get('@fail_errors')).to be_nil
+    end
+
+    it '#clear!' do
+      expect(subject).to receive(:unbind!)
+      expect(subject).to receive(:clear_actions!)
+      expect(subject).to receive(:clear_subject_with_errors!)
+      subject.clear!
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light_operations
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Pawel Niemczyk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-26 00:00:00.000000000 Z
+date: 2015-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport