caser 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a75cc231c0399c0f6b15abfe52003f8473a977ab
+  data.tar.gz: fc2b008ef54bc368d7071f40befa4cc31444e119
+SHA512:
+  metadata.gz: f78d5657c158f0b9f8161254ab4ff74c90ffa8caaa9e4d441babc20e66481c221ff363927b40f7c78a577f2eb322802950253e61e00f88dc1b6a4d0831a54809
+  data.tar.gz: 35ef34038154d373822d0c6e17e84be24912ff211a46b7008af6be205eff614c71620d32a669a45ba532d97d759351764724ed271187b3e731561a726f210c9b

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-gemset
+.ruby-version

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in caser.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Simon Robson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,76 @@
+# Caser
+
+This gem is an extraction of a pattern that I've evolved in a few recent web apps to find a home for our business logic between the controller and the persistence layer.
+
+It's somewhat inspired by the ideas in Hexagonal Architecture and Bob Martin's talks on structuring web applications. But it is very light and simple.
+
+I've found it gives me an easy way out of the world of Rails (or your framework of choice) and into pure application code for many common cases once CRUD moves beyond simple single model updates. It tends to make business logic easily testable in isolation and usable from scripts and the console.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'caser'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install caser
+
+## Usage
+
+To create a basic use case, extend Caser::Action:
+
+    class Api::CreateContact < Caser::Action
+      attr_accessor :user, params
+      def after_initialize
+        @user, @params = current_user, params
+      end
+
+      def do_process
+        if valid?(params)
+          contact = SecretSauce::CreateContact(params)
+          set_outcome(contact)
+        end
+      end
+      
+      def valid?(params)
+        unless :whatever
+          errors << 'No, we're not going to do that'
+          return false
+        end
+        true
+      end
+
+
+Here is typical usage in a controller:
+
+    def create
+      update = Api::CreateContact.new(current_user, params[:contact]).process
+      if update.success?
+        ... code for success response (update.outcome contains any result object from the use case)
+      else
+        ... code for failure response (update.errors contains and array of errors)
+      end
+    end
+
+These use cases also support call-back style usage:
+
+    def create
+      Api::CreateContact.new(current_user, params[:contact]) do |on
+        on.success {|action| ... code for success case}
+        on.failure {|action| ... code for failure case}
+      end.process
+    end
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.ruby_opts = ["-w"]
+  t.verbose = true
+end
+
+task :default => :test

data/caser.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'caser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "caser"
+  spec.version       = Caser::VERSION
+  spec.authors       = ["Simon Robson"]
+  spec.email         = ["shrobson@gmail.com"]
+  spec.description   = %q{Simple structures for writing actions / use cases}
+  spec.summary       = %q{Provides a standard approach to plugging the gap between controllers and persistence for the common cases, such as crud, in Ruby web applications.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/caser.rb

@@ -0,0 +1,3 @@
+require 'caser/version'
+require 'caser/action'
+require 'caser/callbacks'

data/lib/caser/action.rb

@@ -0,0 +1,50 @@
+require 'observer'
+
+module Caser
+  class Action
+    include Observable
+
+    def initialize(*params)
+      @_callbacks = nil
+      yield @_callbacks = Callbacks.new if block_given?
+      after_initialize(*params)
+    end
+
+    def process
+      processed!
+      do_process
+      success? ? succeed! : fail!
+      self
+    end
+
+    def succeed!
+      @_callbacks.on_success(self) if @_callbacks
+    end
+
+    def fail!
+      @_callbacks.on_failure(self) if @_callbacks
+    end
+
+    def processed!
+      @_processed = true
+    end
+
+    def processed?
+      @_processed
+    end
+
+    def success?
+      processed? && errors.empty?
+    end
+
+    def errors
+      @_errors ||= []
+    end
+
+    def emit(event)
+      changed
+      notify_observers(event)
+    end
+
+  end
+end

data/lib/caser/callbacks.rb

@@ -0,0 +1,25 @@
+module Caser
+  class Callbacks
+    def initialize
+      @_success_cb = @_failure_cb = nil
+    end
+
+    def on_success(*args)
+      return unless @_success_cb
+      @_success_cb.call(*args)
+    end
+
+    def on_failure(*args)
+      return unless @_failure_cb
+      @_failure_cb.call(*args)
+    end
+
+    def success(&cb)
+      @_success_cb = cb
+    end
+
+    def failure(&cb)
+      @_failure_cb = cb
+    end
+  end
+end

data/lib/caser/version.rb

@@ -0,0 +1,3 @@
+module Caser
+  VERSION = "0.0.1"
+end

data/test/action_test.rb

@@ -0,0 +1,106 @@
+require 'minitest/autorun'
+require 'caser'
+
+describe Caser::Action do
+  class BasicAction < Caser::Action
+    attr_accessor :will_fail
+    def after_initialize(will_fail = false)
+      @will_fail = will_fail
+    end
+
+    def do_process
+      errors << "It failed" if will_fail?
+    end
+
+    def will_fail?
+      will_fail
+    end
+  end
+
+  describe 'A basic action' do
+    it 'results in success' do
+      @action = BasicAction.new
+      @action.process
+      @action.success?.must_equal true
+    end
+
+    it 'returns self from process' do
+      @action = BasicAction.new
+      @action.process.must_be_same_as @action
+    end
+
+    it 'reports failure' do
+      @action = BasicAction.new(true).process
+      @action.success?.must_equal false
+    end
+
+    it 'gives access to errors in failure case' do
+      @action = BasicAction.new(true).process
+      @action.errors.length.must_equal 1
+    end
+  end
+
+  describe 'callback style' do
+    def setup
+      @bug = Minitest::Mock.new
+    end
+
+    it 'calls back on success' do
+      @bug.expect(:succeeded, true)
+      @action = BasicAction.new do |on|
+        on.success { @bug.succeeded }
+        on.failure { @bug.failed }
+      end
+      @action.process
+      @bug.verify
+    end
+
+    it 'passes the action instance to the callbacks' do
+      @passed_in = nil 
+      @action = BasicAction.new do |on|
+        on.success { |a| @passed_in = a }
+      end
+      @action.process
+      @passed_in.must_equal @action
+    end
+
+    it 'calls back on failure' do
+      @bug.expect(:failed, true)
+      BasicAction.new(true) do |on|
+        on.success { @bug.succeeded }
+        on.failure { @bug.failed }
+      end.process
+      @bug.verify
+    end
+  end
+
+  describe 'observability' do
+    class ObservedAction < Caser::Action
+      def after_initialize
+      end
+
+      def do_process
+        emit(:working)
+      end
+    end
+
+    class Watcher
+      def update(message)
+        messages << message
+      end
+
+      def messages
+        @messages ||= []
+      end
+    end
+
+    it 'implements observable and provides and emit method to notify observers' do
+      @action = ObservedAction.new
+      @observer = Watcher.new
+      @action.add_observer(@observer)
+      @action.process
+      @observer.messages.must_equal [:working]
+    end
+  end
+
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: caser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Simon Robson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple structures for writing actions / use cases
+email:
+- shrobson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- caser.gemspec
+- lib/caser.rb
+- lib/caser/action.rb
+- lib/caser/callbacks.rb
+- lib/caser/version.rb
+- test/action_test.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Provides a standard approach to plugging the gap between controllers and
+  persistence for the common cases, such as crud, in Ruby web applications.
+test_files:
+- test/action_test.rb