light_operations 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: daff2324f298c8c3565ac162ad4f898b46a67444
-  data.tar.gz: c29a35d3bb49d0f939dd0ceda12d7199bf818af4
+  metadata.gz: 6b1cafc172727a76d2b73b15c1eaf8c16726dd4e
+  data.tar.gz: 5cbaaa590c2c85b73a440c2366f67960a789d02a
 SHA512:
-  metadata.gz: e49fc15fc00e7a754d7cbcf9d1b42543b01ab1233916e57af9238453de7f222e55d7d515d49b6bebaa15f00856a773fb46f2fe728f4d203ee86e460d0ecfa377
-  data.tar.gz: 75f5551894d511923473fd6644c836510586b1a74f0bfdcb0b04e22da3b8127493146102deb57b7d7d7714d1c3e6dd4751b47b843d62b040ee40e919be9a7ea7
+  metadata.gz: bd91a0435ba27b38faa56e17b0ea1ed94bc2b2a645858e9b7c1324a8b171447cf983a3e8b0de37af3b1795efc76feb4a45c0bc197f893497a888c40b034ad6b9
+  data.tar.gz: 9e29c25d4ccbd1da90da0ad9e8ad6b85ccda391663d1b280e27c7e9eb7c8258198c61ad523fbe1bdac899091620c3894836f37abfbd162df2468dedfa758e640

data/.rubocop.yml

@@ -45,4 +45,5 @@ Metrics/LineLength:
 AllCops:
   Exclude:
     - '**/Guardfile'
-    - '**/light_operations.gemspec'
+    - '**/model_operations.gemspec'
+    - '**/spec/support/factory_helper.rb'

data/README.md

@@ -39,6 +39,71 @@ There is many possible usecases where and how you could use operations.
 You can build csacade of opreations, use them one after the other,
 use them recursively and a lot more.
 
+
+Examples:
+
+#### Simple
+```ruby
+require 'light_operations'
+
+class CorrectNumber < LightOperations::Core
+  def execute(params)
+    params[:number] > 0 || fail!(:wrong_number)
+  end
+end
+
+op = CorrectNumber.new
+
+p op.run(number: 0).success? # return false
+p op.run(number: 0).false?   # return true
+p op.run(number: 1).success? # return true
+p op.run(number: 1).false?   # return false
+```
+
+#### With active_model
+
+```ruby
+require 'light_operations'
+require 'active_model'
+
+class Person
+  include ActiveModel::Model
+
+  attr_accessor :name, :age
+  validates_presence_of :name
+end
+
+class CreatePerson < LightOperations::Core
+  subject_name :person
+  def execute(params = {})
+    dependency(:repository).new(params).tap do |person|
+      person.valid?
+    end
+  end
+end
+
+class FakeController
+  def create(params = {})
+    create_operation.run(params)
+  end
+
+  def create_operation
+    @create_operation ||= CreatePerson.new(repository: Person).bind_with(self).on(success: :render_success, fail: :render_fail)
+  end
+
+  def render_success(operation)
+    person = operation.person
+    puts "name: #{person.name}"
+  end
+
+  def render_fail(operation)
+    person, errors = operation.subject, operation.errors
+    puts errors.as_json
+    puts "name: #{person.name}"
+  end
+end
+
+```
 Class
 
 ```ruby
@@ -60,9 +125,9 @@ You can add deferred actions for success and fail
 
 ```ruby
 # 1
-MyOperation.new.on_success { |model| render :done, locals: { model: model } }
+MyOperation.new.on_success { |operation| render :done, locals: { model: operation.subject } }
 # 2
-MyOperation.new.on(success: -> () { |model| render :done, locals: { model: model } )
+MyOperation.new.on(success: -> () { |operation| render :done, locals: { model: operation.subject } )
 ```
 
 When you bind operation with other object you could delegate actions to binded object methods
@@ -104,24 +169,26 @@ operation.new(dependencies).tap do |op|
 end
 ```
 
-#### success block or method receive subject as argument
-`(subject) -> { }`
+#### success block or method receive operation as argument
+##### operation.subject  hold success object. You can use subject_name to create alias_method for subject
+`(operation) -> { }`
 
 or
 
 ```ruby
-def success_method(subject)
+def success_method(operation)
   ...
 end
 
 ```
-#### fail block or method receive subject and errors as argument
-`(subject, errors) -> { }`
+#### fail block or method receive operation as argument
+##### operation.subject, operation.errors  hold failure object and errors. You can use subject_name to create alias_method for subject
+`(operation) -> { }`
 
 or
 
 ```ruby
-def fail_method(subject, errors)
+def fail_method(operation)
   ...
 end
 
@@ -182,6 +249,7 @@ Operation
 ```ruby
 class CollectFeedsOperation < LightOperations::Core
   rescue_from Timeout::Error, with: :on_timeout
+  subject_name :news
 
   def execute(params = {})
     dependency(:http_client).get(params.fetch(:url)).body
@@ -208,14 +276,14 @@ class NewsFeedsController < ApplicationController
 
   private
 
-  def second_attempt(_news, _errors)
-    collect_feeds_op
+  def second_attempt(operation)
+    operation
       .on_fail(:display_old_news)
       .run(url: BACKUP_NEWS_URL)
   end
 
-  def display_news(news)
-    render :display_news, locals: { news: news }
+  def display_news(operation)
+    render :display_news, locals: { news: operation.news }
   end
 
   def display_old_news
@@ -237,6 +305,7 @@ Operation
 
 ```ruby
 class AddBookOperation < LightOperations::Core
+  subject_name :book
   def execute(params = {})
     dependency(:book_model).new(params).tap do |model|
       model.valid? # this method automatically provide errors from model.errors
@@ -266,11 +335,12 @@ class BooksController < ApplicationController
 
   private
 
-  def book_created(book)
-    redirect_to :index, notice: "book #{book.name} created"
+  def book_created(operation)
+    redirect_to :index, notice: "book #{operation.book.name} created"
   end
 
-  def render_book_form(book = Book.new, _errors = nil)
+  def render_book_form(operation=nil)
+  book = operation ? operation.book : Book.new
     render :new, locals: { book: book }
   end
 
@@ -291,7 +361,7 @@ Operation
 ```ruby
 class AuthOperation < LightOperations::Core
   rescue_from AuthFail, with: :on_auth_error
-
+  subject_name :account
   def execute(params = {})
     dependency(:auth_service).login(login: login(params), password: password(params))
   end
@@ -328,13 +398,13 @@ class AuthController < ApplicationController
 
   private
 
-  def create_session_with_dashbord_redirection(account)
-    session_create_for(account)
+  def create_session_with_dashbord_redirection(operation)
+    session_create_for(operation.account)
     redirect_to :dashboard
   end
 
-  def render_account_with_errors(account, _errors)
-    render :new, locals: { account: account }
+  def render_account_with_errors(operation)
+    render :new, locals: { account: operation.account }
   end
 
   def auth_op
@@ -357,8 +427,8 @@ class AuthController < ApplicationController
 
   def create
     auth_op
-      .on_success{ |account| create_session_with_dashbord_redirection(account) }
-      .on_fail { |account, _errors| render :new, locals: { account: account } }
+      .on_success{ |op| create_session_with_dashbord_redirection(op.account) }
+      .on_fail { |op| render :new, locals: { account: op.account } }
       .run(params)
   end
 
@@ -394,14 +464,14 @@ class AuthController < ApplicationController
   private
 
   def go_to_dashboard
-    -> (account) do
-      session_create_for(account)
+    -> (op) do
+      session_create_for(op.account)
       redirect_to :dashboard
     end
   end
 
   def go_to_login
-    -> (account, _errors) { render :new, locals: { account: account } }
+    -> (op) { render :new, locals: { account: op.account } }
   end
 
   def auth_op

data/lib/light_operations/core.rb

@@ -5,7 +5,11 @@ module LightOperations
     include ::ActiveSupport::Rescuable
     MissingDependency = Class.new(StandardError)
 
-    attr_reader :dependencies, :bind_object, :subject
+    attr_reader :subject
+
+    def self.subject_name(method_name)
+      send(:define_method, method_name, proc { self.subject })
+    end
 
     def initialize(dependencies = {})
       @dependencies = dependencies
@@ -78,28 +82,21 @@ module LightOperations
 
     protected
 
-    attr_reader :fail_errors
+    attr_reader :dependencies, :bind_object, :fail_errors
 
     def actions_assign(hash, *keys)
       keys.each { |key| actions[key] = hash[key] if hash.key?(key) }
     end
 
     def execute_actions
-      success? ? execute_success_action : execute_fail_action
-    end
-
-    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)
+      success? ? execute_action_kind(:success) : execute_action_kind(:fail)
     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)
+    def execute_action_kind(kind)
+      return unless actions.key?(kind)
+      action = actions[kind]
+      bind_object.send(action, self) if action.is_a?(Symbol) && bind_object
+      action.call(self) if action.is_a?(Proc)
     end
 
     def fail!(fail_obj = true)

data/lib/light_operations/version.rb

@@ -1,3 +1,3 @@
 module LightOperations
-  VERSION = '0.0.9'
+  VERSION = '0.1.0'
 end

data/spec/lib/core_spec.rb

@@ -8,9 +8,9 @@ describe LightOperations::Core do
   let(:binding_object) do
     Class.new(Object).tap do |klass|
       klass.class_eval do
-        def success_action(_subject); end
+        def success_action(_operation); end
 
-        def error_action(_subject, _errors); end
+        def error_action(_operaation); end
       end
     end.new
   end
@@ -27,6 +27,17 @@ describe LightOperations::Core do
     expect { subject.on(success: :do_nothing).run }.to raise_error('Not implemented yet')
   end
 
+  it '.subject_name' do
+    test_obj = subject_factory do
+      subject_name :order
+      def execute(params)
+        params[:done] || fail!(:error)
+      end
+    end
+    test_obj.run(done: :success)
+    expect(test_obj.order).to eq(:success)
+  end
+
   context 'use cases' do
     # dependency using
 
@@ -112,12 +123,12 @@ 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)
+          expect(binding_object).to receive(:success_action).with(subject)
           subject.on_success(:success_action).bind_with(binding_object).run
         end
 
         it 'when block is used' do
-          subject.on_success { |result| expect(result).to eq(:success) }.run
+          subject.on_success { |operation| expect(operation.subject).to eq(:success) }.run
         end
       end
 
@@ -172,14 +183,14 @@ describe LightOperations::Core 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])
+          expect(binding_object).to receive(:error_action).with(subject)
           subject.bind_with(binding_object).on_fail(:error_action).run
         end
 
         it 'when block is used' do
-          subject.on_fail do |result, errors|
-            expect(result).to eq(:fail)
-            expect(errors).to eq([email: :unknown])
+          subject.on_fail do |operation|
+            expect(operation.subject).to eq(:fail)
+            expect(operation.errors).to eq([email: :unknown])
           end
           subject.run
         end
@@ -202,7 +213,7 @@ describe LightOperations::Core do
   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 }
+      expect { subject.unbind! }.to change { subject.send(:bind_object) }
         .from(:some_object)
         .to(nil)
     end
@@ -235,6 +246,27 @@ describe LightOperations::Core do
     end
   end
 
+  context '#fail! in execute when is without arguments' do
+    subject do
+      subject_factory do
+        def execute(params = {})
+          fail! unless params.key?(:result)
+          params[:result]
+        end
+      end
+    end
+
+    it 'setup operation in fail state' do
+      expect(subject.run.success?).to eq(false)
+      expect(subject.run.fail?).to eq(true)
+    end
+
+    it 'setup operation in fail state' do
+      expect(subject.run(result: 'ok').success?).to eq(true)
+      expect(subject.run(result: 'ok').fail?).to eq(false)
+    end
+  end
+
   context 'Operation executed several times' do
     subject do
       subject_factory do
@@ -250,9 +282,9 @@ describe LightOperations::Core do
         .bind_with(binding_object)
         .on(success: :success_action, fail: :error_action)
 
-      expect(binding_object).to receive(:error_action).with(nil, :missing_result)
+      expect(binding_object).to receive(:error_action).with(subject)
       subject.run
-      expect(binding_object).to receive(:success_action).with(:success)
+      expect(binding_object).to receive(:success_action).with(subject)
       subject.run(result: :success)
     end
   end

metadata

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