substation 0.0.10.beta2 → 0.0.10

data/lib/substation/response/exception/output.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module Substation
+  class Response
+    class Exception < self
+
+      # Wraps response data and an exception not caught from a handler
+      class Output
+        include Equalizer.new(:data)
+
+        # Return the data available when +exception+ was raised
+        #
+        # @return [Object]
+        #
+        # @api private
+        attr_reader :data
+
+        # Return the exception instance
+        #
+        # @return [Class<StandardError>]
+        #
+        # @api private
+        attr_reader :exception
+
+        # Initialize a new instance
+        #
+        # @param [Object] data
+        #   the data available when +exception+ was raised
+        #
+        # @param [Class<StandardError>] exception
+        #   the exception instance raised from a handler
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(data, exception)
+          @data, @exception = data, exception
+        end
+
+        private
+
+        # Tests wether +other+ is comparable using +comparator+
+        #
+        # @param [Symbol] comparator
+        #   the operation used for comparison
+        #
+        # @param [Object] other
+        #   the object to test
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def cmp?(comparator, other)
+          super && exception.class.send(comparator, other.exception.class)
+        end
+      end # class Output
+    end # class Exception
+  end # class Response
+end # module Substation

data/lib/substation/response/failure.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Substation
+  class Response
+
+    # An errorneous {Response}
+    class Failure < self
+      include API::Failure
+    end # class Failure
+  end # class Response
+end # module Substation

data/lib/substation/response/success.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Substation
+  class Response
+
+    # A successful {Response}
+    class Success < self
+      include API::Success
+    end # class Success
+  end # class Response
+end # module Substation

data/lib/substation/version.rb

@@ -1,4 +1,6 @@
+# encoding: utf-8
+
 module Substation
   # Gem version
-  VERSION = '0.0.10.beta2'.freeze
+  VERSION = '0.0.10'.freeze
 end

data/spec/demo/core.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'pp'
+
+require 'anima'
+require 'ducktrap'
+require 'vanguard'
+require 'substation'
+
+class Demo
+
+  Undefined = Object.new.freeze
+
+  require 'demo/domain/storage'
+  require 'demo/domain/environment'
+  require 'demo/domain/actor'
+  require 'demo/domain/dto/person'
+
+  DATABASE =
+  {
+    :privileges => [
+      { :name => 'create_person' }
+    ],
+
+    :accounts => [
+      { :id => 1, :name => 'Jane' },
+      { :id => 2, :name => 'Mr.X' }
+    ],
+
+    :account_privileges => [
+      { :account_id => 1, :privilege_name => 'create_person' }
+    ],
+  }
+
+  logger   = Object.new # some logger instance
+  storage  = Domain::Storage.new(DATABASE)
+  env_name = ::ENV.fetch('APP_ENV', :development)
+
+  APP_ENV = Domain::Environment.build(env_name, storage, logger)
+
+  require 'demo/core/errors'
+  require 'demo/core/input'
+  require 'demo/core/handler'
+  require 'demo/core/handler/authenticator'
+  require 'demo/core/handler/authorizer'
+  require 'demo/core/handler/acceptor'
+  require 'demo/core/validator'
+  require 'demo/core/action'
+  require 'demo/core/action/create_person'
+  require 'demo/core/observers'
+
+  module Core
+    ENV = Substation::Environment.build(APP_ENV) do
+      register :authenticate, Substation::Processor::Evaluator::Request
+      register :authorize,    Substation::Processor::Evaluator::Request
+      register :validate,     Substation::Processor::Evaluator::Request, Core::Validator::EXECUTOR
+      register :accept,       Substation::Processor::Transformer::Incoming, Core::Handler::Acceptor::EXECUTOR
+      register :call,         Substation::Processor::Evaluator::Pivot
+      register :wrap,         Substation::Processor::Wrapper::Outgoing, Core::Handler::Wrapper::Outgoing::EXECUTOR
+    end
+  end
+
+  require 'demo/core/facade'
+end

data/spec/demo/core/action.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+
+    class Action
+      include AbstractType
+      include Adamantium::Flat
+
+      def self.call(request)
+        new(request).call
+      end
+
+      private_class_method :new
+
+      def initialize(request)
+        @request = request
+        @env     = @request.env
+        @input   = @request.input
+        @db      = @env.storage
+      end
+
+      abstract_method :call
+
+      attr_reader :request
+      private     :request
+
+      attr_reader :env
+      private     :env
+
+      attr_reader :input
+      private     :input
+
+      attr_reader :db
+      private     :db
+
+      private
+
+      def success(data)
+        request.success(data)
+      end
+
+      def error(data)
+        request.error(data)
+      end
+
+    end
+  end
+end

data/spec/demo/core/action/create_person.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+    class Action
+
+      class CreatePerson < self
+
+        def initialize(*)
+          super
+          @person = input.data
+        end
+
+        def call
+          name = @person.name
+          if name == 'error'
+            error(@person)
+          elsif name == 'exception'
+            raise RuntimeError
+          else
+            success(db.create_person(@person))
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/demo/core/errors.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+    class Error
+      include Concord::Public.new(:object)
+      include Adamantium::Flat
+
+      InternalError       = Class.new(self)
+      ApplicationError    = Class.new(self)
+      AuthenticationError = Class.new(self)
+      AuthorizationError  = Class.new(self)
+      ValidationError     = Class.new(self)
+    end
+  end
+end

data/spec/demo/core/facade.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+
+    module App
+
+      AUTHENTICATION_ERROR = Core::ENV.chain { wrap Error::AuthenticationError }
+      AUTHORIZATION_ERROR  = Core::ENV.chain { wrap Error::AuthorizationError }
+      VALIDATION_ERROR     = Core::ENV.chain { wrap Error::ValidationError }
+      APPLICATION_ERROR    = Core::ENV.chain { wrap Error::ApplicationError }
+      INTERNAL_ERROR       = Core::ENV.chain { wrap Error::InternalError }
+
+      AUTHENTICATE = Core::ENV.chain do
+        authenticate Handler::Authenticator, AUTHENTICATION_ERROR
+      end
+
+      AUTHORIZE = Core::ENV.chain(nil, AUTHENTICATE) do
+        authorize Handler::Authorizer, AUTHORIZATION_ERROR
+      end
+
+      Core::ENV.register(:create_person, AUTHORIZE, INTERNAL_ERROR) do
+        validate Domain::DTO::NEW_PERSON_VALIDATOR, VALIDATION_ERROR
+        accept   Handler::Acceptor
+
+        call Action::CreatePerson, APPLICATION_ERROR, [
+          Observers::LOG_EVENT,
+          Observers::SEND_EMAIL
+        ]
+      end
+
+    end
+
+    # The application
+    APP = Core::ENV.dispatcher
+
+  end
+end

data/spec/demo/core/handler.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+    module Handler
+      include Adamantium::Flat
+
+      def call(request)
+        new(request).call
+      end
+
+      module Wrapper
+        module Outgoing
+          DECOMPOSER = ->(response) { response.data }
+          COMPOSER   = ->(response, output) { output }
+          EXECUTOR   = Substation::Processor::Executor.new(DECOMPOSER, COMPOSER)
+        end
+      end
+    end
+  end
+end

data/spec/demo/core/handler/acceptor.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+    module Handler
+
+      class Acceptor
+        extend  Handler
+        include Equalizer.new(:session)
+
+        DECOMPOSER = ->(request) { request }
+
+        COMPOSER = ->(request, output) {
+          Input::Accepted.new(output, request.input.data)
+        }
+
+        EXECUTOR = Substation::Processor::Executor.new(DECOMPOSER, COMPOSER)
+
+        def initialize(request)
+          @db         = request.env.storage
+          @session    = request.input.session
+          @account_id = @session.fetch('account_id')
+        end
+
+        def call
+          Domain::Actor.coerce(session, person)
+        end
+
+        attr_reader :session
+        private     :session
+
+        attr_reader :account_id
+        private     :account_id
+
+        private
+
+        def person
+          Domain::DTO::Person.new(:id => account_id, :name => name)
+        end
+
+        def name
+          @db.load_person(account_id).name
+        end
+      end
+    end
+  end
+end

data/spec/demo/core/handler/authenticator.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+    module Handler
+
+      class Authenticator
+        extend Handler
+        include Substation::Processor::Evaluator::Handler
+
+        def initialize(request)
+          @request    = request
+          @input      = @request.input
+          @db         = @request.env.storage
+          @account_id = @request.input.session.fetch('account_id')
+        end
+
+        def call
+          authenticated? ? success(input) : error(input)
+        end
+
+        attr_reader :request
+        private     :request
+
+        attr_reader :input
+        private     :input
+
+        private
+
+        def authenticated?
+          !!@db.load_person(@account_id)
+        end
+      end
+    end
+  end
+end

data/spec/demo/core/handler/authorizer.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+    module Handler
+
+      class Authorizer
+        extend Handler
+        include Substation::Processor::Evaluator::Handler
+
+        def initialize(request)
+          @request    = request
+          @input      = @request.input
+          @db         = @request.env.storage
+          @account_id = @request.input.session.fetch('account_id')
+          @privilege  = @request.name.to_s
+        end
+
+        def call
+          authorized? ? success(input) : error(input)
+        end
+
+        attr_reader :request
+        private     :request
+
+        attr_reader :input
+        private     :input
+
+        private
+
+        def authorized?
+          !!@db.load_account_privilege(@account_id, @privilege)
+        end
+      end
+
+    end
+  end
+end

data/spec/demo/core/input.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+
+    class Input
+      class Incomplete
+        include Concord::Public.new(:session, :data)
+      end
+      class Accepted
+        include Concord::Public.new(:actor, :data)
+      end
+    end
+  end
+end