light_operations 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d66e8c5f9729b8c5d261eab885164317a64619f
-  data.tar.gz: aec76cd8d6088dfbcafee5e1eb607d58cd30d901
+  metadata.gz: db2c6c8440e6a48a6ef168af4a7b545132437356
+  data.tar.gz: 575327c90f66617d35a9954efe5870403695faf2
 SHA512:
-  metadata.gz: 51a815033d9623f4e3b70087e6a9b85e70a1a982dcafadd92676b415037fd604daddffa02a6f132121591b7f54a6d7f1406288e6eb311395341275f7fb783242
-  data.tar.gz: ee0e5dc1efa1f059421fc5fca252e78da16e5a07345decac4c7fd091f4cb69d2d95e0388f9422f024e12069737f09e32eb66124f603a6102e8dc8d18a7633e69
+  metadata.gz: 84d0758c75019a861344f0ad49ffc2283af17c21aa8c385e84b54eaee2d15f6d746897f65e364527dbf7c8a055261f58aa294212124e30917cd795baab2ab895
+  data.tar.gz: b78d2ae0b6f0776491cc0725c24f543e142e11e2d39814dbcf21fb83beaa5768793ad3408d3b8c4704c6e828aa840b3c3284476bd8e0bd6a360698350355d075

data/.rubocop.yml

@@ -45,3 +45,4 @@ Metrics/LineLength:
 AllCops:
   Exclude:
     - '**/Guardfile'
+    - '**/light_operations.gemspec'

data/README.md

@@ -1,6 +1,7 @@
 # LightOperations
 
-TODO: Write a gem description
+When you want have slim controllers or some logic with several operations
+this gem could help you to have nice separated and clan code. CAN HELP YOU! :D
 
 ## Installation
 
@@ -20,7 +21,142 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+
+### Uses cases
+
+#### Simple case when you want have user authorization
+
+Operation
+
+```ruby
+class AuthOperation < LightOperations::Core
+  rescue_from AuthFail, with: :on_auth_error
+
+  def execute
+    dependency(:auth_service).login(login: login, password: password)
+  end
+
+  def on_auth_error(_exception)
+    fail!([login: 'unknown']) # or subject.errors.add(login: 'unknown')
+  end
+
+  def login
+    params.fetch(:login)
+  end
+
+  def password
+    params.fetch(:password)
+  end
+end
+```
+
+Controller way #1
+
+```ruby
+class AuthController < ApplicationController
+  def new
+    render :new, locals: { account: Account.new }
+  end
+
+  def create
+    auth_op
+      .run
+      .bind_with(self)
+      .on_success(:create_session_with_dashbord_redirection)
+      .on_fail(:render_account_with_errors)
+  end
+
+  private
+
+  def create_session_with_dashbord_redirection(account)
+    session_create_for(account)
+    redirect_to :dashboard
+  end
+
+  def render_account_with_errors(account, _errors)
+    render :new, locals: { account: account }
+  end
+
+  def auth_op
+    @auth_op ||= AuthOperation.new(params, auth_service: auth_service)
+  end
+
+  def auth_service
+    @auth_service ||= AuthService.new
+  end
+end
+```
+
+Controller way #2
+
+```ruby
+class AuthController < ApplicationController
+  def new
+    render :new, locals: { account: Account.new }
+  end
+
+  def create
+    auth_op
+      .run
+      .on_success{ |account| create_session_with_dashbord_redirection(account) }
+      .on_fail { |account, _errors| render :new, locals: { account: account } }
+  end
+
+  private
+
+  def create_session_with_dashbord_redirection(account)
+    session_create_for(account)
+    redirect_to :dashboard
+  end
+
+  def auth_op
+    @auth_op ||= AuthOperation.new(params, auth_service: auth_service)
+  end
+
+  def auth_service
+    @auth_service ||= AuthService.new
+  end
+end
+```
+
+Controller way #3
+
+```ruby
+class AuthController < ApplicationController
+  def new
+    render :new, locals: { account: Account.new }
+  end
+
+  def create
+    auth_op.run.on_success(&go_to_dashboard).on_fail(&go_to_login)
+  end
+
+  private
+
+  def go_to_dashboard
+    -> (account) do
+      session_create_for(account)
+      redirect_to :dashboard
+    end
+  end
+
+  def go_to_login
+    -> (account, _errors) { render :new, locals: { account: account } }
+  end
+
+  def auth_op
+    @auth_op ||= AuthOperation.new(params, auth_service: auth_service)
+  end
+
+  def auth_service
+    @auth_service ||= AuthService.new
+  end
+end
+```
+
+When operation status is most importent we can simply use `#success?` or `#fail?` on the executed operation
+
+Errors are available by `#errors` after operation is executed
 
 ## Contributing
 

data/lib/light_operations/core.rb

@@ -3,10 +3,9 @@ require 'active_support'
 module LightOperations
   class Core
     include ::ActiveSupport::Rescuable
-    include ::ActiveSupport
     MissingDependency = Class.new(StandardError)
 
-    attr_reader :dependencies, :params, :subject
+    attr_reader :dependencies, :params, :subject, :bind_oject
 
     def initialize(params = {}, dependencies = {})
       @params, @dependencies = params, dependencies
@@ -18,17 +17,27 @@ module LightOperations
       self
     rescue => exception
       rescue_with_handler(exception) || raise
-    ensure
       self
     end
 
-    def on_success(&block)
-      block.call(subject) if success?
+    def bind_with(binding_obj)
+      @bind_oject = binding_obj
       self
     end
 
-    def on_fail(&block)
-      block.call(subject, errors) unless success?
+    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
+      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?
+      end
       self
     end
 
@@ -46,6 +55,10 @@ module LightOperations
 
     protected
 
+    def can_use_binding_method?(method_name)
+      method_name && bind_oject && bind_oject.respond_to?(method_name)
+    end
+
     def execute
       fail 'Not implemented yet'
     end

data/lib/light_operations/version.rb

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

data/spec/lib/core_spec.rb

@@ -18,6 +18,15 @@ describe LightOperations::Core do
   end
 
   context 'use cases' do
+    let(:binding_object) do
+      Class.new(Object).tap do |klass|
+        klass.class_eval do
+          def success_action(_subject); end
+
+          def error_action(_subject, _errors); end
+        end
+      end.new
+    end
 
     # dependency using
 
@@ -93,16 +102,30 @@ describe LightOperations::Core do
         end
       end
 
-      it '#on_success' do
-        subject.run.on_success do |result|
-          expect(result).to eq(:success)
+      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)
+        end
+
+        it 'when block is userd' do
+          subject.run.on_success do |result|
+            expect(result).to eq(:success)
+          end
         end
       end
 
-      it '#on_fail' do
-        block_to_exec = -> () {}
-        expect(block_to_exec).not_to receive(:call)
-        subject.run.on_fail(&block_to_exec)
+      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)
+        end
+
+        it 'when block is userd' do
+          block_to_exec = -> () {}
+          expect(block_to_exec).not_to receive(:call)
+          subject.run.on_fail(&block_to_exec)
+        end
       end
 
       it '#errors' do
@@ -128,17 +151,30 @@ describe LightOperations::Core do
         end
       end
 
-      it '#on_success' do
-        block_to_exec = -> () {}
-        expect(block_to_exec).not_to receive(:call)
-        subject.run.on_success(&block_to_exec)
+      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)
+        end
+
+        it 'when block is userd' do
+          block_to_exec = -> () {}
+          expect(block_to_exec).not_to receive(:call)
+          subject.run.on_success(&block_to_exec)
+        end
       end
 
-      it '#on_fail' do
+      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)
+        end
 
-        subject.run.on_fail do |result, errors|
-          expect(result).to eq(:fail)
-          expect(errors).to eq([email: :unknown])
+        it 'when block is userd' do
+          subject.run.on_fail do |result, errors|
+            expect(result).to eq(:fail)
+            expect(errors).to eq([email: :unknown])
+          end
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: light_operations
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Pawel Niemczyk