aldous 1.0.0

data/lib/aldous/service/result/base/predicate_methods_for_inheritance.rb

@@ -0,0 +1,44 @@
+require 'aldous/service/result/base'
+
+module Aldous
+  class Service
+    module Result
+      class Base < ::Aldous::SimpleDto
+        module PredicateMethodsForInheritance
+          # For every child class, create a predicate method on the base named
+          # after the child that returns false and override the same predicate
+          # method on the child to return true. So if the child class is called
+          # Failure then we'll have a predicate method called failure? which will
+          # return false on the base class and true on the actual child class.
+          def inherited(child)
+            return if child.name == nil # unnamed class
+            child_class_name_as_predicate = "#{underscore(child.name.split("::").last)}?"
+
+            add_predicate_method_to_class(Aldous::Service::Result::Base, child_class_name_as_predicate, false)
+            add_predicate_method_to_class(child, child_class_name_as_predicate, true)
+          end
+
+          private
+
+          def add_predicate_method_to_class(klass, method_name, method_value)
+            unless klass.instance_methods(false).include?(method_name)
+              klass.class_eval do
+                define_method method_name do
+                  method_value
+                end
+              end
+            end
+          end
+
+          def underscore(string)
+            string.gsub(/::/, '/').
+              gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+              gsub(/([a-z\d])([A-Z])/,'\1_\2').
+              tr("-", "_").
+              downcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aldous/service/result/base.rb

@@ -0,0 +1,13 @@
+require 'aldous/simple_dto'
+require 'aldous/service/result/base/predicate_methods_for_inheritance'
+
+module Aldous
+  class Service
+    module Result
+      class Base < ::Aldous::SimpleDto
+        extend PredicateMethodsForInheritance
+      end
+    end
+  end
+end
+

data/lib/aldous/service/result/failure.rb

@@ -0,0 +1,11 @@
+require 'aldous/service/result/base'
+
+module Aldous
+  class Service
+    module Result
+      class Failure < ::Aldous::Service::Result::Base
+      end
+    end
+  end
+end
+

data/lib/aldous/service/result/success.rb

@@ -0,0 +1,11 @@
+require 'aldous/service/result/base'
+
+module Aldous
+  class Service
+    module Result
+      class Success < ::Aldous::Service::Result::Base
+      end
+    end
+  end
+end
+

data/lib/aldous/service/wrapper.rb

@@ -0,0 +1,48 @@
+require 'aldous/logging_wrapper'
+require 'aldous/service/result/base'
+require 'aldous/service/result/failure'
+
+module Aldous
+  class Service
+    class Wrapper
+      attr :service
+
+      def initialize(service)
+        @service = service
+      end
+
+      def raisable_error
+        service.raisable_error
+      end
+
+      def default_result_data
+        service.default_result_data
+      end
+
+      def perform!
+        result = service.perform
+
+        unless result.kind_of?(::Aldous::Service::Result::Base)
+          raise "Return value of #perform must be a type of #{::Aldous::Service::Result::Base}"
+        end
+
+        build_result_with_default_options(result)
+      rescue => e
+        raise raisable_error.new(e.message)
+      end
+
+      def perform
+        perform!
+      rescue => e
+        Aldous::LoggingWrapper.log(e.cause || e)
+        Aldous::Service::Result::Failure.new(default_result_data.merge(errors: [e]))
+      end
+
+      private
+
+      def build_result_with_default_options(result)
+        result.class.new(default_result_data.merge(result._data))
+      end
+    end
+  end
+end

data/lib/aldous/service.rb

@@ -0,0 +1,34 @@
+require 'aldous/service/wrapper'
+require 'aldous/errors/user_error'
+
+module Aldous
+  class Service
+    include Aldous
+
+    class << self
+      def build(*args)
+        Aldous::Service::Wrapper.new(new(*args))
+      end
+
+      def perform(*args)
+        build(*args).perform
+      end
+
+      def perform!(*args)
+        build(*args).perform!
+      end
+    end
+
+    def perform
+      raise NotImplementedError.new("#{self.class.name} must implement method #perform")
+    end
+
+    def raisable_error
+      Aldous::Errors::UserError
+    end
+
+    def default_result_data
+      {}
+    end
+  end
+end

data/lib/aldous/simple_dto.rb

@@ -0,0 +1,47 @@
+module Aldous
+  class SimpleDto
+    attr_reader :_data
+
+    def initialize(data = {})
+      @_data = data
+
+      handle_errors_and_messages
+      define_accessors
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+    def messages
+      @messages ||= []
+    end
+
+    private
+
+    def handle_errors_and_messages
+      # ensure that any errors or messages end up in the appropriate array
+      _data.each_pair do |key, value|
+        if key.to_s == 'errors'
+          @errors = [value].flatten.compact
+        elsif key.to_s == 'messages'
+          @messages = [value].flatten.compact
+        end
+      end
+    end
+
+    def define_accessors
+      self.class.class_exec(_data) do |_data|
+        _data.each_key do |key|
+          next if key.to_s == 'errors' || key.to_s == 'messages'
+          # do nothing if method is already defined
+          next if instance_methods(false).include?(key.to_sym)
+
+          define_method key do
+            @_data[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aldous/stdout_logger.rb

@@ -0,0 +1,9 @@
+module Aldous
+  class StdoutLogger
+    class << self
+      def info(message)
+        $stdout.puts message
+      end
+    end
+  end
+end

data/lib/aldous/version.rb

@@ -0,0 +1,3 @@
+module Aldous
+  VERSION = "1.0.0"
+end

data/lib/aldous/view/blank/atom_view.rb

@@ -0,0 +1,12 @@
+require 'aldous/respondable/renderable'
+
+module Aldous
+  module View
+    module Blank
+      class AtomView < Respondable::Renderable
+        def template
+        end
+      end
+    end
+  end
+end

data/lib/aldous/view/blank/html_view.rb

@@ -0,0 +1,16 @@
+require 'aldous/respondable/renderable'
+
+module Aldous
+  module View
+    module Blank
+      class HtmlView < Respondable::Renderable
+        def template
+          {
+            html: "", layout: true
+          }
+        end
+      end
+    end
+  end
+end
+

data/lib/aldous/view/blank/json_view.rb

@@ -0,0 +1,16 @@
+require 'aldous/respondable/renderable'
+
+module Aldous
+  module View
+    module Blank
+      class JsonView < Respondable::Renderable
+        def template
+          {
+            json: {}
+          }
+        end
+      end
+    end
+  end
+end
+

data/lib/aldous.rb

@@ -0,0 +1,40 @@
+require 'aldous/version'
+require 'aldous/configuration'
+
+require 'aldous/errors/user_error'
+
+require 'aldous/respondable/base'
+require 'aldous/respondable/headable'
+require 'aldous/respondable/redirectable'
+require 'aldous/respondable/renderable'
+require 'aldous/respondable/send_data'
+require 'aldous/respondable/request_http_basic_authentication'
+
+require 'aldous/service/result/failure'
+require 'aldous/service/result/success'
+
+require 'aldous/service'
+
+require 'aldous/controller'
+require 'aldous/controller_action'
+require 'aldous/controller/action/precondition'
+require 'aldous/params'
+
+require 'aldous/view/blank/atom_view'
+require 'aldous/view/blank/json_view'
+require 'aldous/view/blank/html_view'
+
+module Aldous
+  class << self
+    def configuration(&block)
+      @configuration ||= Aldous::Configuration.new
+      if block_given?
+        block.call(@configuration)
+      else
+        @configuration
+      end
+    end
+    alias :config :configuration # can use either config or configuration
+  end
+end
+

data/spec/aldous/build_respondable_service_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe Aldous::BuildRespondableService do
+  let(:service) do
+    described_class.new(
+      view_context: view_context,
+      default_view_data: default_view_data,
+      respondable_class: respondable_class,
+      status: status,
+      extra_data: extra_data
+    )
+  end
+
+  let(:view_context)      { double "view_context" }
+  let(:default_view_data) { {hello: 1} }
+  let(:respondable_class) { double "respondable_class"}
+  let(:status)            { :foo }
+  let(:extra_data)        { {world: 2} }
+
+  let(:simple_dto) {instance_double(Aldous::SimpleDto)}
+  let(:respondable_instance) {double "respondable_instance"}
+
+  describe "#perform" do
+    let(:view_data) { {hello: 1, world: 2} }
+
+    before do
+      allow(Aldous::SimpleDto).to receive(:new).and_return(simple_dto)
+      allow(respondable_class).to receive(:new).and_return(respondable_instance)
+    end
+
+    context "when status is part of the extra_data" do
+      let(:extra_data) { {world: 2, status: status} }
+
+      it "creates a dto with the correct data" do
+        expect(Aldous::SimpleDto).to receive(:new).with(view_data).and_return(simple_dto)
+        service.perform
+      end
+    end
+
+    it "creates a dto with the correct data" do
+      expect(Aldous::SimpleDto).to receive(:new).with(view_data).and_return(simple_dto)
+      service.perform
+    end
+
+    it "returns a respondable instance" do
+      expect(respondable_class).to receive(:new).with(status, simple_dto, view_context)
+      service.perform
+    end
+  end
+end

data/spec/aldous/configuration_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Aldous::Configuration do
+  subject(:config) {described_class.new}
+
+  describe "#error_reporter" do
+    it "is configured to use the dummy error reporter by default" do
+      expect(config.error_reporter).to eq ::Aldous::DummyErrorReporter
+    end
+  end
+
+  describe "#logger" do
+    it "is configured to use the stdout logger by default" do
+      expect(config.logger).to eq ::Aldous::StdoutLogger
+    end
+  end
+end

data/spec/aldous/controller/action/precondition/wrapper_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe Aldous::Controller::Action::Precondition::Wrapper do
+  let(:wrapper) { described_class.new precondition }
+
+  let(:precondition) {double 'precondition',
+                      action: controller_action,
+                      perform: nil,
+                      build_view: nil }
+
+  let(:controller_action) { double 'controller action',
+                            default_view_data: default_view_data,
+                            default_error_respondable: default_error_respondable,
+                            perform: nil,
+                            build_view: nil }
+
+  let(:default_view_data) { {default_view_data: true} }
+  let(:default_error_respondable) {double 'default_error_respondable'}
+
+  before do
+    allow(Aldous::LoggingWrapper).to receive(:log)
+  end
+
+  describe '#perform' do
+    subject(:perform) { wrapper.perform }
+
+    it "calls perform on the precondition" do
+      expect(precondition).to receive(:perform)
+      perform
+    end
+
+    context 'when precondition throws an exception' do
+      let(:e) { StandardError.new 'message' }
+
+      before do
+        allow(precondition).to receive(:perform).and_raise(e)
+      end
+
+      it "builds a default error view with errors" do
+        expect(precondition).to receive(:build_view).with(default_error_respondable, errors: [e])
+        perform
+      end
+
+      it 'reports the error' do
+        expect(Aldous::LoggingWrapper).to receive(:log).with(e)
+        perform
+      end
+    end
+  end
+end

data/spec/aldous/controller/action/precondition_spec.rb

@@ -0,0 +1,81 @@
+RSpec.describe Aldous::Controller::Action::Precondition do
+  before do
+    class ExamplePrecondition < Aldous::Controller::Action::Precondition
+    end
+  end
+
+  after do
+    Object.send :remove_const, 'ExamplePrecondition'
+  end
+
+  let(:precondition) {ExamplePrecondition.new(action)}
+
+  let(:action) {double 'action', controller: controller, default_view_data: default_view_data}
+  let(:controller) {double 'controller', view_context: view_context}
+  let(:view_context) {double "view_context"}
+  let(:default_view_data) {double "default_view_data"}
+
+  describe "::build" do
+    before do
+      allow(ExamplePrecondition).to receive(:new).and_return(precondition)
+      allow(Aldous::Controller::Action::Precondition::Wrapper).to receive(:new)
+    end
+
+    it "wraps a controller action instance" do
+      expect(Aldous::Controller::Action::Precondition::Wrapper).to receive(:new).with(precondition)
+      ExamplePrecondition.build(action)
+    end
+  end
+
+  describe "::perform" do
+    let(:wrapper) {double "wrapper", perform: nil}
+
+    before do
+      allow(ExamplePrecondition).to receive(:new).and_return(action)
+      allow(Aldous::Controller::Action::Precondition::Wrapper).to receive(:new).and_return(wrapper)
+    end
+
+    it "calls perform on the wrapper" do
+      expect(wrapper).to receive(:perform)
+      ExamplePrecondition.perform(action)
+    end
+  end
+
+  describe "::inherited" do
+    context "a precondition instance" do
+      Aldous.configuration.controller_methods_exposed_to_action.each do |method_name|
+        it "responds to #{method_name}" do
+          expect(precondition).to respond_to method_name
+        end
+      end
+    end
+  end
+
+  describe "#perform" do
+    it "raises an error since it should be overridden" do
+      expect{precondition.perform}.to raise_error
+    end
+  end
+
+  describe "#build_view" do
+    before do
+      allow(Aldous::BuildRespondableService).to receive(:new).with(
+        view_context: view_context,
+        default_view_data: default_view_data,
+        respondable_class: respondable_class,
+        status: nil,
+        extra_data: extra_data
+      ).and_return(build_respondable_service)
+    end
+
+    let(:respondable_class) {double "respondable_class"}
+    let(:extra_data) { {hello: 1} }
+
+    let(:build_respondable_service) {double "build_respondable_service", perform: nil}
+
+    it "executes the BuildRespondableService" do
+      expect(build_respondable_service).to receive(:perform)
+      precondition.build_view(respondable_class, extra_data)
+    end
+  end
+end

data/spec/aldous/controller/action/result_execution_service_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe Aldous::Controller::Action::ResultExecutionService do
+  let(:result_execution_service) {described_class.new(controller, respondable, default_view_data)}
+
+  let(:controller) {double "controller"}
+  let(:respondable) {double "respondable", action: action}
+  let(:default_view_data) {'hello'}
+
+  let(:action) {double 'action', execute: nil}
+
+  describe "::perform" do
+    subject(:perform) {described_class.perform(controller, respondable, default_view_data)}
+
+    let(:result_execution_service) {double "result_execution_service", perform: nil}
+
+    before do
+      allow(described_class).to receive(:new).and_return(result_execution_service)
+    end
+
+    it "instantiates the result execution service" do
+      expect(described_class).to receive(:new).with(controller, respondable, default_view_data)
+      perform
+    end
+
+    it "performs the result execution service" do
+      expect(result_execution_service).to receive(:perform)
+      perform
+    end
+  end
+
+  describe "#perform" do
+    subject(:perform) {result_execution_service.perform}
+
+    it "fetches the action from the respondable" do
+      expect(respondable).to receive(:action).with(controller)
+      perform
+    end
+
+    it "executes the respondable action" do
+      expect(action).to receive(:execute)
+      perform
+    end
+  end
+end

data/spec/aldous/controller/action/wrapper_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe Aldous::Controller::Action::Wrapper do
+  let(:wrapper) { described_class.new controller_action }
+
+  let(:controller_action) { double 'controller action',
+                            default_view_data: default_view_data,
+                            preconditions: preconditions,
+                            default_error_respondable: default_error_respondable,
+                            perform: nil,
+                            build_view: nil }
+
+  let(:default_view_data) { {default_view_data: true} }
+  let(:preconditions) { double 'preconditions' }
+  let(:default_error_respondable) {double 'default_error_respondable'}
+
+  before do
+    allow(Aldous::LoggingWrapper).to receive(:log)
+  end
+
+  describe '#perform' do
+    subject(:perform) { wrapper.perform }
+
+    it "calls perform on the controller action" do
+      expect(controller_action).to receive(:perform)
+      perform
+    end
+
+    context 'when controller service throws an exception' do
+      let(:e) { StandardError.new 'message' }
+
+      before do
+        allow(controller_action).to receive(:perform).and_raise(e)
+      end
+
+      it "builds a default error view with errors" do
+        expect(controller_action).to receive(:build_view).with(default_error_respondable, errors: [e])
+        perform
+      end
+
+      it 'reports the error' do
+        expect(Aldous::LoggingWrapper).to receive(:log).with(e)
+        perform
+      end
+    end
+  end
+end
+

data/spec/aldous/controller/action_execution_service_spec.rb

@@ -0,0 +1,79 @@
+RSpec.describe Aldous::Controller::ActionExecutionService do
+  let(:action_execution_service) {described_class.new(controller, controller_action_class)}
+
+  let(:controller) {double "controller", head: nil}
+  let(:controller_action_class) {double "controller_action_class", build: action}
+
+  let(:action) {double 'action', perform: action_result, default_view_data: default_view_data}
+  let(:action_result) {'foobar'}
+  let(:default_view_data) {'hello'}
+
+  describe "::perform" do
+    subject(:perform) {described_class.perform(controller, controller_action_class)}
+
+    let(:action_execution_service) {double "action_execution_service", perform: nil}
+
+    before do
+      allow(described_class).to receive(:new).and_return(action_execution_service)
+    end
+
+    it "instantiates the action execution service" do
+      expect(described_class).to receive(:new).with(controller, controller_action_class)
+      perform
+    end
+
+    it "performs the action execution service" do
+      expect(action_execution_service).to receive(:perform)
+      perform
+    end
+  end
+
+  describe "#perform" do
+    subject(:perform) {action_execution_service.perform}
+
+    let(:preconditions_execution_service) {double "preconditions_execution_service", perform: preconditions_result}
+    let(:preconditions_result) {[nil, nil]}
+
+    before do
+      allow(Aldous::Controller::PreconditionsExecutionService).to receive(:new).and_return(preconditions_execution_service)
+      allow(Aldous::Controller::Action::ResultExecutionService).to receive(:perform)
+    end
+
+    context "when preconditions did not halt execution" do
+      it "executes the result with action_result" do
+        expect(Aldous::Controller::Action::ResultExecutionService).to receive(:perform).with(controller, action_result, default_view_data)
+        perform
+      end
+    end
+
+    context "when preconditions did halt execution" do
+      let(:preconditions_result) {[precondition, precondition_result]}
+
+      let(:precondition) {double 'precondition', perform: precondition_result, default_view_data: default_view_data}
+      let(:precondition_result) {'preconditionfoobar'}
+      let(:default_view_data) {'precondtionhello'}
+
+      it "executes the result with precondition_result" do
+        expect(Aldous::Controller::Action::ResultExecutionService).to receive(:perform).with(controller, precondition_result, default_view_data)
+        perform
+      end
+    end
+
+    context "when error occurs" do
+      before do
+        allow(Aldous::LoggingWrapper).to receive(:log)
+        allow(Aldous::Controller::PreconditionsExecutionService).to receive(:new).and_raise
+      end
+
+      it "logs the error" do
+        expect(Aldous::LoggingWrapper).to receive(:log)
+        perform
+      end
+
+      it "returns a 500 via controller" do
+        expect(controller).to receive(:head).with(:internal_server_error)
+        perform
+      end
+    end
+  end
+end