substation 0.0.10.beta2 → 0.0.10

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 674a347348ff4f36dbca255925b70c9ea794c95d
-  data.tar.gz: a28efb6f4038ee99e8f820f2dcaee74506e4182b
-SHA512:
-  metadata.gz: 5a9dcabb1d4a225cee6a4579587387c3829747fcaf77319ae2a0c2a2863eae6558c4d825e6c48f59ecc7d2a860831ae8dcadcda053d947f431b9b73bbaa0c593
-  data.tar.gz: bbd1fca2660e54697b3d1d8f5a69e4a527cf5a129a0995e589cf99966d7c54f9a10b30313e3f51b91a60b4ea38443dcb0a5f3e68253e028ffcda4804def5d107

data/lib/substation/observer.rb

@@ -1,66 +0,0 @@
-module Substation
-
-  # Abstract observer base class
-  #
-  # @abstract
-  class Observer
-
-    include AbstractType
-    include Adamantium::Flat
-
-    # Notify the observer
-    #
-    # @param [Response] response
-    #   the response returned when calling the observed action
-    #
-    # @return [self]
-    #
-    # @api private
-    abstract_method :call
-
-    # Coerce +input+ to an instance of {Observer}
-    #
-    # @param [nil, String, Array<String>] input
-    #   0..n observer class names
-    #
-    # @return [Observer::NULL, Object, Observer::Chain]
-    #   a null observer, an observer object, or a chain of observers
-    #
-    # @api private
-    def self.coerce(input)
-      case input
-      when nil
-        NULL
-      when Array
-        Chain.new(input.map { |item| coerce(item) })
-      else
-        Utils.coerce_callable(input)
-      end
-    end
-
-    # Null observer
-    NULL = Class.new(self) { def call(_response); self; end; }.new.freeze
-
-    # Chain of observers
-    class Chain < self
-
-      include Concord.new(:observers)
-
-      # Notify the observer
-      #
-      # @param [Response] response
-      #   the response returned when calling the observed action
-      #
-      # @return [self]
-      #
-      # @api private
-      def call(response)
-        observers.each do |observer|
-          observer.call(response)
-        end
-        self
-      end
-
-    end # Chain
-  end # Observer
-end # Substation

data/lib/substation/processor/pivot.rb

@@ -1,25 +0,0 @@
-module Substation
-  module Processor
-
-    # A processor to invoke a chain's pivot handler
-    class Pivot
-
-      include Processor
-      include Chain::Pivot
-      include Concord.new(:env, :handler)
-
-      # Invoke a chain's pivot handler
-      #
-      # @param [Request] request
-      #   the request to process
-      #
-      # @return [Response]
-      #
-      # @api private
-      def call(request)
-        handler.call(request)
-      end
-
-    end # class Caller
-  end # module Processor
-end # module Substation

data/lib/substation/utils.rb

@@ -1,68 +0,0 @@
-module Substation
-
-  # A collection of utility methods
-  module Utils
-
-    # Get the constant for the given FQN
-    #
-    # @param [#to_s] name
-    #   the FQN denoting a constant
-    #
-    # @return [Class, nil]
-    #
-    # @api private
-    def self.const_get(name)
-      list = name.to_s.split("::")
-      list.shift if list.first.empty?
-      obj = Object
-      list.each do |const|
-        # This is required because const_get tries to look for constants in the
-        # ancestor chain, but we only want constants that are HERE
-        obj =
-          if obj.const_defined?(const)
-            obj.const_get(const)
-          else
-            obj.const_missing(const)
-          end
-      end
-      obj
-    end
-
-    # Converts string keys into symbol keys
-    #
-    # @param [Hash<#to_sym, Object>] hash
-    #   a hash with keys that respond to `#to_sym`
-    #
-    # @return [Hash<Symbol, Object>]
-    #   a hash with symbol keys
-    #
-    # @api private
-    def self.symbolize_keys(hash)
-      hash.each_with_object({}) { |(key, value), normalized_hash|
-        normalized_value = value.is_a?(Hash) ? symbolize_keys(value) : value
-        normalized_hash[key.to_sym] = normalized_value
-      }
-    end
-
-    # Coerce the given +handler+ object
-    #
-    # @param [Symbol, String, Proc] handler
-    #   a name denoting a const that responds to `#call(object)`, or a proc
-    #
-    # @return [Class, Proc]
-    #   the callable action handler
-    #
-    # @api private
-    def self.coerce_callable(handler)
-      case handler
-      when Symbol, String
-        Utils.const_get(handler)
-      when Proc, Class, Chain
-        handler
-      else
-        raise(ArgumentError)
-      end
-    end
-
-  end # module Utils
-end # module Substation

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

@@ -1,260 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module App
-
-  class Database
-    include Equalizer.new(:relations)
-
-    def initialize(relations)
-      @relations = relations
-    end
-
-    def [](relation_name)
-      Relation.new(relations[relation_name])
-    end
-
-    protected
-
-    attr_reader :relations
-
-    class Relation
-      include Equalizer.new(:tuples)
-      include Enumerable
-
-      def initialize(tuples)
-        @tuples = tuples
-      end
-
-      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
-
-      protected
-
-      attr_reader :tuples
-    end
-  end
-
-  module Models
-
-    class Person
-      include Equalizer.new(:id, :name)
-
-      attr_reader :id
-      attr_reader :name
-
-      def initialize(attributes)
-        @id, @name = attributes.values_at(:id, :name)
-      end
-    end
-  end # module Models
-
-  class Environment
-    include Equalizer.new(:storage)
-
-    attr_reader :storage
-
-    def initialize(storage)
-      @storage = storage
-    end
-  end
-
-  class Storage
-    include Equalizer.new(:db)
-    include Models
-
-    def initialize(db)
-      @db = db
-    end
-
-    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
-
-    protected
-
-    attr_reader :db
-  end
-
-  class App
-    include Equalizer.new(:dispatcher)
-
-    def initialize(dispatcher)
-      @dispatcher = dispatcher
-    end
-
-    def call(name, input = nil)
-      @dispatcher.call(name, input)
-    end
-  end
-
-  # Base class for all actions
-  #
-  # @abstract
-  class Action
-
-    include AbstractType
-
-    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  = Proc.new { |response| response }
-    SendEmail = Proc.new { |response| response }
-  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/chain/call_spec.rb

@@ -1,63 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Chain, '#call' do
-
-  subject { object.call(request) }
-
-  let(:object)   { described_class.new(handlers) }
-  let(:handlers) { [ handler_1, handler_2 ] }
-  let(:request)  { Request.new(env, input) }
-  let(:env)      { double }
-  let(:input)    { double }
-
-  let(:handler_2) {
-    Class.new {
-      include Substation::Chain::Outgoing
-      def call(request)
-        request.success(request.input)
-      end
-    }.new
-  }
-
-  let(:response) { response_class.new(request, request.input) }
-
-  context "when all handlers are successful" do
-    let(:handler_1) {
-      Class.new {
-        include Substation::Chain::Incoming
-        def call(request)
-          request.success(request.input)
-        end
-      }.new
-    }
-
-    let(:response_class) { Response::Success }
-
-    before do
-      handler_2.should_receive(:call).with(request).and_return(response)
-    end
-
-    it { should eql(response) }
-  end
-
-  context "when an intermediate handler is not successful" do
-    let(:handler_1) {
-      Class.new {
-        include Substation::Chain::Incoming
-        def call(request)
-          request.error(request.input)
-        end
-      }.new
-    }
-
-    let(:response_class) { Response::Failure }
-
-    before do
-      handler_2.should_not_receive(:call)
-    end
-
-    it { should eql(response) }
-  end
-end