substation 0.0.5 → 0.0.6

data/Changelog.md

@@ -1,3 +1,9 @@
+# v0.0.6 2013-05-17
+
+* [fixed] Fixed bug for actions configured with a const handler (snusnu)
+
+[Compare v0.0.5..v0.0.6](https://github.com/snusnu/substation/compare/v0.0.5...v0.0.6)
+
 # v0.0.5 2013-05-17
 
 * [feature] Shorter action config when no observers are needed (snusnu)
@@ -11,7 +17,6 @@ dispatcher = Substation::Dispatcher.coerce({
   :some_use_case => Proc.new { |request| request.success(:data) }
 }, env)
 ```
-
 [Compare v0.0.4..v0.0.5](https://github.com/snusnu/substation/compare/v0.0.4...v0.0.5)
 
 # v0.0.4 2013-05-15

data/README.md

@@ -282,58 +282,195 @@ the course of performing a usecase (like a logger or a storage engine
 abstraction), you can encapsulate these objects within an application
 specific environment object, and send that along to every action.
 
-Here's a simple example with an environment that encapsulates a logger
-and an artificial storage abstraction object.
-
-The example builds on top of the application specific action baseclass
-shown above:
+Here's a complete example with an environment that encapsulates a very
+primitive storage abstraction object, one simple business entity, and a
+few simple actions.
 
 ```ruby
 module App
+
+  class Database
+    include Concord.new(:entries)
+
+    def [](relation_name)
+      Relation.new(entries[relation_name])
+    end
+
+    class Relation
+      include Concord.new(:tuples)
+      include Enumerable
+
+      def each(&block)
+        return to_enum unless block_given?
+        tuples.each(&block)
+        self
+      end
+
+      def all
+        tuples
+      end
+
+      def insert(tuple)
+        self.class.new(tuples + [tuple])
+      end
+    end
+  end
+
+  module Models
+
+    class Person
+      include Concord.new(:attributes)
+
+      def id
+        attributes[:id]
+      end
+
+      def name
+        attributes[:name]
+      end
+    end
+  end # module Models
+
   class Environment
+    include Concord.new(:storage)
+    include Adamantium::Flat
+
     attr_reader :storage
-    attr_reader :logger
+  end
+
+  class Storage
+    include Concord.new(:db)
+    include Adamantium::Flat
+
+    include Models
+
+    def list_people
+      db[:people].all.map { |tuple| Person.new(tuple) }
+    end
 
-    def initialize(storage, logger)
-      @storage, @logger = storage, logger
+    def load_person(id)
+      Person.new(db[:people].select { |tuple| tuple[:id] == id }.first)
+    end
+
+    def create_person(person)
+      relation = db[:people].insert(:id => person.id, :name => person.name)
+      relation.map { |tuple| Person.new(tuple) }
     end
   end
 
+  class App
+    include Concord.new(:dispatcher)
+    include Adamantium::Flat
+
+    def call(name, input = nil)
+      dispatcher.call(name, input)
+    end
+  end
+
+  # Base class for all actions
+  #
+  # @abstract
   class Action
-    # ...
-    # code from above example
-    # ...
+
+    include AbstractType
+    include Adamantium::Flat
+
+    def self.call(request)
+      new(request).call
+    end
+
+    def initialize(request)
+      @request = request
+      @env     = @request.env
+      @input   = @request.input
+    end
+
+    abstract_method :call
+
+    private
+
+    attr_reader :request
+    attr_reader :env
+    attr_reader :input
 
     def db
       @env.storage
     end
+
+    def success(data)
+      @request.success(data)
+    end
+
+    def error(data)
+      @request.error(data)
+    end
   end
 
-  class SomeUseCase < Action
+  module Actions
+    class ListPeople < Action
 
-    def initialize(request)
-      super
-      @person = request.input
+      def call
+        success(db.list_people)
+      end
     end
 
-    def call
-      if person = db.save_person(@person)
-        success(person)
-      else
-        error("Something went wrong")
+    class LoadPerson < Action
+      def initialize(request)
+        super
+        @id = input
+      end
+
+      def call
+        success(db.load_person(@id))
       end
     end
+
+    class CreatePerson < Action
+
+      def initialize(request)
+        super
+        @person = input
+      end
+
+      def call
+        success(db.create_person(@person))
+      end
+    end
+
+  end # module Actions
+
+  module Observers
+    LogEvent  = Class.new { def self.call(response); end }
+    SendEmail = Class.new { def self.call(response); end }
   end
-end
 
-storage = App::Storage.new # some storage abstraction
-env     = App::Environment.new(storage, Logger.new($stdout))
+  DB = Database.new({
+    :people => [{
+      :id   => 1,
+      :name => 'John'
+    }]
+  })
+
+  actions = {
+    :list_people   => Actions::ListPeople,
+    :load_person   => Actions::LoadPerson,
+    :create_person => {
+      :action   => Actions::CreatePerson,
+      :observer => [
+        Observers::LogEvent,
+        Observers::SendEmail
+      ]
+    }
+  }
+
+  storage    = Storage.new(DB)
+  env        = Environment.new(storage)
+  dispatcher = Substation::Dispatcher.coerce(actions, env)
 
-dispatcher = Substation::Dispatcher.coerce({
-  'some_use_case' => { 'action' => 'App::SomeUseCase' }
-}, env)
+  APP = App.new(dispatcher)
+end
 
-# :some_input is no person, db.save_person will fail
-response = dispatcher.call(:some_use_case, :some_input)
-response.success? # => false
+response = App::APP.call(:list_companies)
+response.success? # => true
+response.output   # => [#<App::Models::Person attributes={:id=>1, :name=>"John"}>]
 ```

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 6
-total_score: 62
+total_score: 65

data/lib/substation/support/utils.rb

@@ -57,7 +57,7 @@ module Substation
       case handler
       when Symbol, String
         Utils.const_get(handler)
-      when Proc
+      when Proc, Class
         handler
       else
         raise(ArgumentError)

data/lib/substation/version.rb

@@ -1,4 +1,4 @@
 module Substation
   # Gem version
-  VERSION = '0.0.5'.freeze
+  VERSION = '0.0.6'.freeze
 end

data/spec/integration/substation/dispatcher/call_spec.rb

@@ -0,0 +1,234 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module App
+
+  class Database
+    include Concord.new(:entries)
+
+    def [](relation_name)
+      Relation.new(entries[relation_name])
+    end
+
+    class Relation
+      include Concord.new(:tuples)
+      include Enumerable
+
+      def each(&block)
+        return to_enum unless block_given?
+        tuples.each(&block)
+        self
+      end
+
+      def all
+        tuples
+      end
+
+      def insert(tuple)
+        self.class.new(tuples + [tuple])
+      end
+    end
+  end
+
+  module Models
+
+    class Person
+      include Concord.new(:attributes)
+
+      def id
+        attributes[:id]
+      end
+
+      def name
+        attributes[:name]
+      end
+    end
+  end # module Models
+
+  class Environment
+    include Concord.new(:storage)
+    include Adamantium::Flat
+
+    attr_reader :storage
+  end
+
+  class Storage
+    include Concord.new(:db)
+    include Adamantium::Flat
+
+    include Models
+
+    def list_people
+      db[:people].all.map { |tuple| Person.new(tuple) }
+    end
+
+    def load_person(id)
+      Person.new(db[:people].select { |tuple| tuple[:id] == id }.first)
+    end
+
+    def create_person(person)
+      relation = db[:people].insert(:id => person.id, :name => person.name)
+      relation.map { |tuple| Person.new(tuple) }
+    end
+  end
+
+  class App
+    include Concord.new(:dispatcher)
+    include Adamantium::Flat
+
+    def call(name, input = nil)
+      dispatcher.call(name, input)
+    end
+  end
+
+  # Base class for all actions
+  #
+  # @abstract
+  class Action
+
+    include AbstractType
+    include Adamantium::Flat
+
+    def self.call(request)
+      new(request).call
+    end
+
+    def initialize(request)
+      @request = request
+      @env     = @request.env
+      @input   = @request.input
+    end
+
+    abstract_method :call
+
+    private
+
+    attr_reader :request
+    attr_reader :env
+    attr_reader :input
+
+    def db
+      @env.storage
+    end
+
+    def success(data)
+      @request.success(data)
+    end
+
+    def error(data)
+      @request.error(data)
+    end
+  end
+
+  module Actions
+    class ListPeople < Action
+
+      def call
+        success(db.list_people)
+      end
+    end
+
+    class LoadPerson < Action
+      def initialize(request)
+        super
+        @id = input
+      end
+
+      def call
+        success(db.load_person(@id))
+      end
+    end
+
+    class CreatePerson < Action
+
+      def initialize(request)
+        super
+        @person = input
+      end
+
+      def call
+        success(db.create_person(@person))
+      end
+    end
+
+  end # module Actions
+
+  module Observers
+    LogEvent  = Class.new { def self.call(response); end }
+    SendEmail = Class.new { def self.call(response); end }
+  end
+
+  DB = Database.new({
+    :people => [{
+      :id   => 1,
+      :name => 'John'
+    }]
+  })
+
+  actions = {
+    :list_people   => Actions::ListPeople,
+    :load_person   => Actions::LoadPerson,
+    :create_person => {
+      :action   => Actions::CreatePerson,
+      :observer => [
+        Observers::LogEvent,
+        Observers::SendEmail
+      ]
+    }
+  }
+
+  storage    = Storage.new(DB)
+  env        = Environment.new(storage)
+  dispatcher = Substation::Dispatcher.coerce(actions, env)
+
+  APP = App.new(dispatcher)
+end
+
+describe App::APP, '#call' do
+
+  context "when dispatching an action" do
+    subject { object.call(action, input) }
+
+    let(:object)   { described_class }
+    let(:request)  { Substation::Request.new(env, input) }
+    let(:env)      { App::Environment.new(storage) }
+    let(:storage)  { App::Storage.new(App::DB) }
+    let(:response) { Substation::Response::Success.new(request, output) }
+
+    let(:john) { App::Models::Person.new(:id => 1, :name => 'John') }
+    let(:jane) { App::Models::Person.new(:id => 2, :name => 'Jane') }
+
+    context "with no input data" do
+      let(:action)  { :list_people }
+      let(:input)   { nil }
+      let(:output)  { [ john ] }
+
+      it { should eql(response) }
+    end
+
+    context "with input data" do
+      context "and no observer" do
+        let(:action) { :load_person }
+        let(:input)  { 1 }
+        let(:output) { john }
+
+        it { should eq(response) }
+      end
+
+      context "and observers" do
+        let(:action)   { :create_person }
+        let(:input)    { jane }
+        let(:output)   { [ john, jane ] }
+
+        before do
+          App::Observers::LogEvent.should_receive(:call).with(response).ordered
+          App::Observers::SendEmail.should_receive(:call).with(response).ordered
+        end
+
+        it { should eql(response) }
+      end
+
+    end
+  end
+end

data/spec/unit/substation/utils/class_methods/coerce_callable_spec.rb

@@ -18,6 +18,12 @@ describe Utils, '.coerce_callable' do
     it { should be(Spec::Action::Success) }
   end
 
+  context "with a const handler" do
+    let(:handler) { Spec::Action::Success }
+
+    it { should be(Spec::Action::Success) }
+  end
+
   context "with a Proc handler" do
     let(:handler) { Proc.new { |response| respone } }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: substation
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-16 00:00:00.000000000 Z
+date: 2013-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: adamantium
@@ -126,6 +126,7 @@ files:
 - lib/substation/response.rb
 - lib/substation/support/utils.rb
 - lib/substation/version.rb
+- spec/integration/substation/dispatcher/call_spec.rb
 - spec/spec_helper.rb
 - spec/unit/substation/dispatcher/action/call_spec.rb
 - spec/unit/substation/dispatcher/action/class_methods/coerce_spec.rb