substation 0.0.10.beta2 → 0.0.10

data/spec/demo/core/observers.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+    module Observers
+      LOG_EVENT  = ->(response) { }
+      SEND_EMAIL = ->(response) { }
+    end
+  end
+end

data/spec/demo/core/validator.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+class Demo
+  module Core
+    module Validator
+
+      # substation support
+
+      DECOMPOSER = ->(request) {
+        request.input.data
+      }
+
+      COMPOSER = ->(request, output) {
+        Input::Incomplete.new(request.input.session, output)
+      }
+
+      EXECUTOR = Substation::Processor::Executor.new(DECOMPOSER, COMPOSER)
+
+    end
+  end
+end

data/spec/demo/domain/actor.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+class Demo
+  module Domain
+
+    class Actor
+      class Session
+        include Equalizer.new(:data)
+
+        attr_reader :account_id
+
+        def initialize(data)
+          @data       = data
+          @account_id = @data.fetch('account_id')
+        end
+
+        protected
+
+        attr_reader :data
+      end
+
+      def self.coerce(session_data, person)
+        new(Session.new(session_data), person)
+      end
+
+      include Concord::Public.new(:session, :person)
+    end
+  end
+end

data/spec/demo/domain/dto/person.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+class Demo
+  module Domain
+    module DTO
+
+      NEW_PERSON_VALIDATOR = Vanguard::Validator.build do
+        validates_presence_of :name
+        validates_length_of :name, :length => 3..20
+      end
+
+      class Person
+        include Anima.new(:id, :name)
+      end
+
+    end
+  end
+end

data/spec/demo/domain/environment.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+class Demo
+  module Domain
+
+    class Environment
+
+      def self.build(name, storage, logger)
+        coerced_name = name.to_sym
+        klass = case coerced_name
+        when :development
+          Development
+        when :test
+          Test
+        when :production
+          Production
+        end
+        klass.new(coerced_name, storage, logger)
+      end
+
+      class Development < self
+        def development?
+          true
+        end
+      end
+
+      class Test < self
+        def test?
+          true
+        end
+      end
+
+      class Production < self
+        def production?
+          true
+        end
+      end
+
+      include AbstractType
+      include Concord::Public.new(:name, :storage, :logger)
+
+      def development?
+        false
+      end
+
+      def test?
+        false
+      end
+
+      def production?
+        false
+      end
+    end
+  end
+end

data/spec/demo/domain/storage.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+class Demo
+  module Domain
+
+    class Storage
+      include Concord::Public.new(:db)
+
+      INITIAL_SEQUENCE_VALUE = 2 # Demo::DATABASE is using 1 and 2
+
+      @sequence = INITIAL_SEQUENCE_VALUE
+
+      def self.next_key
+        @sequence += 1
+      end
+
+      def create_person(person)
+        db[:accounts] << new_person_tuple(next_key, person)
+        person # make specs easier by not testing "server generated" keys
+      end
+
+      def load_person(account_id)
+        tuple = db[:accounts].detect { |person| person[:id] == account_id }
+        tuple ? new_person_instance(tuple) : nil
+      end
+
+      def load_account_privilege(account_id, privilege_name)
+        db[:account_privileges].detect { |account_privilege|
+          account_privilege[:account_id] == account_id &&
+          account_privilege[:privilege_name] == privilege_name
+        }
+      end
+
+      private
+
+      def new_person_tuple(id, person)
+        { :id => id, :name => person.name }
+      end
+
+      def new_person_instance(tuple)
+        DTO::Person.new(:id => tuple[:id], :name => tuple[:name])
+      end
+
+      def next_key
+        self.class.next_key
+      end
+    end
+  end
+end

data/spec/demo/web.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'multi_json'
+
+require 'demo/core'
+
+require 'demo/web/errors'
+require 'demo/web/handler/deserializer'
+require 'demo/web/sanitizer'
+require 'demo/web/sanitizer/person'
+require 'demo/web/presenter'
+require 'demo/web/presenter/person'
+require 'demo/web/views'
+require 'demo/web/renderer'
+
+class Demo
+  module Web
+    ENV = Core::ENV.inherit do
+      register :deserialize, Substation::Processor::Transformer::Incoming, Web::Handler::Deserializer::EXECUTOR
+      register :sanitize,    Substation::Processor::Evaluator::Request, Web::Sanitizer::EXECUTOR
+      register :render,      Substation::Processor::Transformer::Outgoing
+    end
+  end
+end
+
+require 'demo/web/facade'

data/spec/demo/web/errors.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+class Demo
+  module Web
+    class Error < Core::Error
+      SanitizationError = Class.new(self)
+    end
+  end
+end

data/spec/demo/web/facade.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+class Demo
+  module Web
+
+    SANITIZATION_ERROR = Web::ENV.chain { wrap Error::SanitizationError }
+
+    INTERNAL_ERROR = Web::ENV.chain(nil, Core::App::INTERNAL_ERROR) do
+      wrap Views::InternalError
+    end
+
+    CREATE_PERSON = Web::ENV.chain do
+      deserialize Handler::Deserializer
+      sanitize    Sanitizer::NEW_PERSON, SANITIZATION_ERROR
+      chain       Core::ENV[:create_person]
+    end
+
+    module HTML
+
+      SANITIZATION_ERROR = Web::ENV.chain(nil, Web::SANITIZATION_ERROR) do
+        wrap   Views::SanitizationError
+        render Renderer::SanitizationError
+      end
+
+      AUTHENTICATION_ERROR = Web::ENV.chain(nil, Core::App::AUTHENTICATION_ERROR) do
+        render Renderer::AuthenticationError
+      end
+
+      AUTHORIZATION_ERROR = Web::ENV.chain(nil, Core::App::AUTHORIZATION_ERROR) do
+        render Renderer::AuthorizationError
+      end
+
+      VALIDATION_ERROR = Web::ENV.chain(nil, Core::App::VALIDATION_ERROR) do
+        render Renderer::ValidationError
+      end
+
+      APPLICATION_ERROR = Web::ENV.chain(nil, Core::App::APPLICATION_ERROR) do
+        render Renderer::ApplicationError
+      end
+
+      INTERNAL_ERROR  = Web::ENV.chain(nil, Web::INTERNAL_ERROR) do
+        render Renderer::InternalError
+      end
+
+      Web::ENV.register(:create_person, Web::CREATE_PERSON, INTERNAL_ERROR) do
+        failure_chain :sanitize,     SANITIZATION_ERROR
+        failure_chain :authenticate, AUTHENTICATION_ERROR
+        failure_chain :authorize,    AUTHORIZATION_ERROR
+        failure_chain :validate,     VALIDATION_ERROR
+        failure_chain :call,         APPLICATION_ERROR
+        wrap Presenter::Person
+        wrap Views::Person
+      end
+
+      # The application
+      APP = Web::ENV.dispatcher
+
+    end # module HTML
+  end # module Web
+end # class Demo

data/spec/demo/web/handler/deserializer.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+class Demo
+  module Web
+    module Handler
+
+      class Deserializer
+        extend  Core::Handler
+        include Concord.new(:input)
+
+        DECOMPOSER = ->(request) {
+          request.input
+        }
+
+        COMPOSER = ->(request, output) {
+          Core::Input::Incomplete.new(output.fetch('session'), output.fetch('data'))
+        }
+
+        EXECUTOR = Substation::Processor::Executor.new(DECOMPOSER, COMPOSER)
+
+        def call
+          {
+            'session' => deserialize(input.fetch('session')),
+            'data'    => deserialize(input.fetch('data'))
+          }
+        end
+
+        private
+
+        def deserialize(json)
+          MultiJson.load(json)
+        end
+      end
+    end
+  end
+end

data/spec/demo/web/presenter.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+class Demo
+  module Web
+
+    class Presenter
+      include AbstractType
+      include Adamantium::Flat
+      include Concord.new(:data)
+
+      def method_missing(method, *args, &block)
+        @data.send(method, *args, &block)
+      end
+
+      def respond_to?(method)
+        super || @data.respond_to?(method)
+      end
+
+      class Collection < self
+
+        def self.member(presenter = Undefined)
+          return @member if presenter.equal?(Undefined)
+          @member = presenter
+        end
+
+        alias_method :entries, :data
+
+        protected :entries
+
+        def each
+          return to_enum unless block_given?
+          entries.each { |entry| yield self.class.member.new(entry) }
+          self
+        end
+      end
+    end
+  end
+end

data/spec/demo/web/presenter/person.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+class Demo
+  module Web
+    class Presenter
+
+      class Person < self
+
+        def name
+          "Presenting: #{super}"
+        end
+
+        class Collection < Presenter::Collection
+          member(Person)
+        end
+      end
+    end
+  end
+end

data/spec/demo/web/renderer.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+class Demo
+  module Web
+
+    module Renderer
+
+      class SanitizationError
+        def self.call(response)
+          "Don't mess with the input params: #{response.input.data.inspect}"
+        end
+      end
+
+      class AuthenticationError
+        def self.call(response)
+          "Failed to authenticate: #{response.input.data.inspect}"
+        end
+      end
+
+      class AuthorizationError
+        def self.call(response)
+          "Failed to authorize: #{response.input.data.inspect}"
+        end
+      end
+
+      class ValidationError
+        def self.call(response)
+          "Failed to validate: #{response.input.data.inspect}"
+        end
+      end
+
+      class ApplicationError
+        def self.call(response)
+          "Failed to process: #{response.output.inspect}"
+        end
+      end
+
+      class InternalError
+        def self.call(response)
+          "Something bad happened: #{response.output.inspect}"
+        end
+      end
+    end
+  end
+end

data/spec/demo/web/sanitizer.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+class Demo
+  module Web
+
+    module Sanitizer
+
+      # substation support
+
+      DECOMPOSER = ->(request) {
+        request.input.data
+      }
+
+      COMPOSER = ->(request, output) {
+        Core::Input::Incomplete.new(request.input.session, output)
+      }
+
+      EXECUTOR = Substation::Processor::Executor.new(DECOMPOSER, COMPOSER)
+
+      # sanitizers
+
+      ID_TRAP = Ducktrap.build do
+        custom do
+          forward { |input| input.merge(:id => nil) }
+          inverse { |input|
+            input = input.dup
+            input.delete(:id)
+            input
+          }
+        end
+      end
+
+    end
+  end
+end