aldous 1.0.0

data/lib/aldous/build_respondable_service.rb

@@ -0,0 +1,23 @@
+require 'aldous/simple_dto'
+
+module Aldous
+  class BuildRespondableService
+    attr_reader :view_context, :default_view_data
+    attr_reader :respondable_class, :status, :extra_data
+
+    def initialize(view_context:, default_view_data:, respondable_class:, status: nil, extra_data: {})
+      @view_context = view_context
+      @default_view_data = default_view_data
+      @respondable_class = respondable_class
+      @status = status
+      @extra_data = extra_data
+    end
+
+    def perform
+      # we don't need the status as a local
+      actual_extra_data = extra_data.reject{|k, v| k == :status}
+      view_data = SimpleDto.new(default_view_data.merge(actual_extra_data))
+      respondable_class.new(status, view_data, view_context)
+    end
+  end
+end

data/lib/aldous/configuration.rb

@@ -0,0 +1,18 @@
+require 'aldous/dummy_error_reporter'
+require 'aldous/dummy_logger'
+require 'aldous/stdout_logger'
+
+module Aldous
+  class Configuration
+    attr_accessor :error_reporter,
+      :logger,
+      :controller_methods_exposed_to_action
+
+    def initialize
+      @error_reporter = ::Aldous::DummyErrorReporter
+      @logger = ::Aldous::StdoutLogger
+
+      @controller_methods_exposed_to_action = [:params, :session, :cookies, :request, :response]
+    end
+  end
+end

data/lib/aldous/controller/action/precondition/wrapper.rb

@@ -0,0 +1,32 @@
+require 'aldous/logging_wrapper'
+
+module Aldous
+  module Controller
+    module Action
+      class Precondition
+        class Wrapper
+          attr :precondition
+
+          def initialize(precondition)
+            @precondition = precondition
+          end
+
+          def default_view_data
+            precondition.action.default_view_data
+          end
+
+          def default_error_respondable
+            precondition.action.default_error_respondable
+          end
+
+          def perform
+            precondition.perform
+          rescue => e
+            ::Aldous::LoggingWrapper.log(e)
+            precondition.build_view(default_error_respondable, errors: [e])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aldous/controller/action/precondition.rb

@@ -0,0 +1,52 @@
+require 'aldous/controller/action/precondition/wrapper'
+require 'aldous/build_respondable_service'
+
+module Aldous
+  module Controller
+    module Action
+      class Precondition
+        include Aldous
+
+        class << self
+          def build(action)
+            Aldous::Controller::Action::Precondition::Wrapper.new(new(action))
+          end
+
+          def perform(action)
+            build(action).perform
+          end
+
+          def inherited(klass)
+            ::Aldous.configuration.controller_methods_exposed_to_action.each do |method_name|
+              unless klass.method_defined?(method_name)
+                define_method method_name do
+                  action.controller.send(method_name)
+                end
+              end
+            end
+          end
+        end
+
+        attr_reader :action
+
+        def initialize(action)
+          @action = action
+        end
+
+        def perform
+          raise NotImplementedError.new("#{self.class.name} must implement method #perform")
+        end
+
+        def build_view(respondable_class, extra_data = {})
+          ::Aldous::BuildRespondableService.new(
+            view_context: action.controller.view_context,
+            default_view_data: action.default_view_data,
+            respondable_class: respondable_class,
+            status: extra_data[:status],
+            extra_data: extra_data
+          ).perform
+        end
+      end
+    end
+  end
+end

data/lib/aldous/controller/action/result_execution_service.rb

@@ -0,0 +1,27 @@
+require 'aldous/logging_wrapper'
+
+module Aldous
+  module Controller
+    module Action
+      class ResultExecutionService
+        class << self
+          def perform(controller, respondable, default_view_data)
+            self.new(controller, respondable, default_view_data).perform
+          end
+        end
+
+        attr_reader :controller, :respondable, :default_view_data
+
+        def initialize(controller, respondable, default_view_data)
+          @controller = controller
+          @respondable = respondable
+          @default_view_data = default_view_data
+        end
+
+        def perform
+          respondable.action(controller).execute
+        end
+      end
+    end
+  end
+end

data/lib/aldous/controller/action/wrapper.rb

@@ -0,0 +1,34 @@
+require 'aldous/logging_wrapper'
+
+module Aldous
+  module Controller
+    module Action
+      class Wrapper
+        attr :controller_action
+
+        def initialize(controller_action)
+          @controller_action = controller_action
+        end
+
+        def preconditions
+          controller_action.preconditions
+        end
+
+        def default_view_data
+          controller_action.default_view_data
+        end
+
+        def default_error_respondable
+          controller_action.default_error_respondable
+        end
+
+        def perform
+          controller_action.perform
+        rescue => e
+          ::Aldous::LoggingWrapper.log(e)
+          controller_action.build_view(default_error_respondable, errors: [e])
+        end
+      end
+    end
+  end
+end

data/lib/aldous/controller/action_execution_service.rb

@@ -0,0 +1,42 @@
+require 'aldous/controller/preconditions_execution_service'
+require 'aldous/controller/action/result_execution_service'
+require 'aldous/logging_wrapper'
+
+module Aldous
+  module Controller
+    class ActionExecutionService
+      class << self
+        def perform(controller, controller_action_class)
+          self.new(controller, controller_action_class).perform
+        end
+      end
+
+      attr_reader :controller, :controller_action_class
+
+      def initialize(controller, controller_action_class)
+        @controller = controller
+        @controller_action_class = controller_action_class
+      end
+
+      def perform
+        action = controller_action_class.build(controller)
+
+        precondition, precondition_result = PreconditionsExecutionService.new(action, controller).perform
+
+        action_result = nil
+        if precondition_result
+          action = precondition
+          action_result = precondition_result
+        else
+          action_result = action.perform
+        end
+
+        Action::ResultExecutionService.perform(controller, action_result, action.default_view_data)
+      rescue => e
+        LoggingWrapper.log(e)
+        controller.head :internal_server_error
+      end
+    end
+  end
+end
+

data/lib/aldous/controller/preconditions_execution_service.rb

@@ -0,0 +1,32 @@
+require 'aldous/respondable/base'
+require 'aldous/controller/action/precondition/wrapper'
+
+module Aldous
+  module Controller
+    class PreconditionsExecutionService
+      attr_reader :action, :controller
+
+      def initialize(action, controller)
+        @action = action
+        @controller = controller
+      end
+
+      def perform
+        if action.respond_to?(:preconditions) && !action.preconditions.empty?
+          action.preconditions.each do |precondition_class|
+            # action here is actually an action wrapper hence the
+            # action.controller_action below
+            precondition = precondition_class.build(action.controller_action)
+            precondition_result = precondition.perform
+
+            if precondition_result.kind_of?(::Aldous::Respondable::Base)
+              return [precondition, precondition_result]
+            end
+          end
+        end
+        [nil, nil]
+      end
+    end
+  end
+end
+

data/lib/aldous/controller.rb

@@ -0,0 +1,21 @@
+require 'aldous/controller/action_execution_service'
+
+module Aldous
+  module Controller
+    include Aldous
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def controller_actions(*actions)
+        actions.each do |action_name|
+          define_method action_name do
+            ::Aldous::Controller::ActionExecutionService.perform(self, self.class.const_get(action_name.to_s.classify))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aldous/controller_action.rb

@@ -0,0 +1,63 @@
+require 'aldous/controller/action/wrapper'
+require 'aldous/view/blank/html_view'
+require 'aldous/simple_dto'
+require 'aldous/build_respondable_service'
+
+module Aldous
+  class ControllerAction
+    include Aldous
+
+    class << self
+      def build(controller)
+        Aldous::Controller::Action::Wrapper.new(new(controller))
+      end
+
+      def perform(controller)
+        build(controller).perform
+      end
+
+      def inherited(klass)
+        # expose methods from controller to the service, according to configuration
+        ::Aldous.configuration.controller_methods_exposed_to_action.each do |method_name|
+          unless klass.method_defined?(method_name)
+            define_method method_name do
+              controller.send(method_name)
+            end
+          end
+        end
+      end
+    end
+
+    attr_reader :controller
+
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def perform
+      raise NotImplementedError.new("#{self.class.name} must implement method #perform")
+    end
+
+    def default_view_data
+      {}
+    end
+
+    def preconditions
+      []
+    end
+
+    def default_error_respondable
+      ::Aldous::View::Blank::HtmlView
+    end
+
+    def build_view(respondable_class, extra_data = {})
+      ::Aldous::BuildRespondableService.new(
+        view_context: controller.view_context,
+        default_view_data: default_view_data,
+        respondable_class: respondable_class,
+        status: extra_data[:status],
+        extra_data: extra_data
+      ).perform
+    end
+  end
+end

data/lib/aldous/dummy_error_reporter.rb

@@ -0,0 +1,9 @@
+module Aldous
+  class DummyErrorReporter
+    class << self
+      def report(e, data = {})
+        nil
+      end
+    end
+  end
+end

data/lib/aldous/dummy_logger.rb

@@ -0,0 +1,8 @@
+module Aldous
+  class DummyLogger
+    class << self
+      def info(message)
+      end
+    end
+  end
+end

data/lib/aldous/errors/user_error.rb

@@ -0,0 +1,6 @@
+module Aldous
+  module Errors
+    class UserError < StandardError
+    end
+  end
+end

data/lib/aldous/logging_wrapper.rb

@@ -0,0 +1,16 @@
+module Aldous
+  class LoggingWrapper
+    class << self
+      def log(error)
+        if error.kind_of?(String)
+          ::Aldous.config.error_reporter.report(error)
+          ::Aldous.config.logger.info(error)
+        else # it's an error object
+          ::Aldous.config.error_reporter.report(error)
+          ::Aldous.config.logger.info(error.message)
+          ::Aldous.config.logger.info(error.backtrace.join("\n"))
+        end
+      end
+    end
+  end
+end

data/lib/aldous/params.rb

@@ -0,0 +1,34 @@
+require 'aldous/logging_wrapper'
+
+module Aldous
+  class Params
+    include Aldous
+
+    class << self
+      def build(*args)
+        new(*args)
+      end
+    end
+
+    attr_reader :params
+
+    def initialize(params)
+      @params = params
+    end
+
+    def fetch
+      permitted_params
+    rescue => e
+      Aldous::LoggingWrapper.log(e)
+      nil
+    end
+
+    def permitted_params
+      {}
+    end
+
+    def error_message
+      'Missing param'
+    end
+  end
+end

data/lib/aldous/respondable/base.rb

@@ -0,0 +1,32 @@
+require 'aldous/simple_dto'
+
+module Aldous
+  module Respondable
+    class Base
+      attr_reader :view_data, :view_context
+
+      def initialize(status, view_data, view_context)
+        @status = status
+        @view_data = view_data
+        @view_context = view_context
+      end
+
+      def action(controller)
+        raise Errors::UserError.new("Respondables must define an 'action' method")
+      end
+
+      def status
+        @status || default_status
+      end
+
+      def default_status
+        :ok
+      end
+
+      def build_view(klass, extra_data = {})
+        dto = Aldous::SimpleDto.new(view_data._data.merge(extra_data))
+        klass.new(status, dto, view_context)
+      end
+    end
+  end
+end

data/lib/aldous/respondable/headable.rb

@@ -0,0 +1,30 @@
+require 'aldous/respondable/base'
+
+module Aldous
+  module Respondable
+    class Headable < Base
+      def action(controller)
+        HeadAction.new(controller, status)
+      end
+
+      def default_status
+        :ok
+      end
+
+      private
+
+      class HeadAction
+        attr_reader :controller, :status
+
+        def initialize(controller, status)
+          @controller = controller
+          @status = status
+        end
+
+        def execute
+          controller.head status
+        end
+      end
+    end
+  end
+end

data/lib/aldous/respondable/redirectable.rb

@@ -0,0 +1,38 @@
+require 'aldous/respondable/base'
+require 'aldous/respondable/shared/flash'
+
+module Aldous
+  module Respondable
+    class Redirectable < Base
+      def action(controller)
+        RedirectAction.new(location, controller, view_data, status)
+      end
+
+      def location
+        raise Errors::UserError.new("Redirectable objects must define a 'location' method")
+      end
+
+      def default_status
+        :found
+      end
+
+      private
+
+      class RedirectAction
+        attr_reader :controller, :view_data, :location, :status
+
+        def initialize(location, controller, view_data, status)
+          @location = location
+          @controller = controller
+          @view_data = view_data
+          @status = status
+        end
+
+        def execute
+          Shared::Flash.new(view_data, controller.flash).set_error
+          controller.redirect_to location, {status: status}
+        end
+      end
+    end
+  end
+end

data/lib/aldous/respondable/renderable.rb

@@ -0,0 +1,50 @@
+require 'aldous/respondable/base'
+require 'aldous/respondable/shared/flash'
+
+module Aldous
+  module Respondable
+    class Renderable < Base
+      def action(controller)
+        RenderAction.new(template, status, controller, view_data)
+      end
+
+      def default_status
+        :ok
+      end
+
+      def default_template_locals
+        {}
+      end
+
+      def template_data
+        {}
+      end
+
+      def template(extra_locals = {})
+        template_locals = template_data[:locals] || {}
+        locals = default_template_locals.merge(template_locals)
+        locals = locals.merge(extra_locals || {})
+        template_hash = template_data.merge(locals: locals)
+        template_hash
+      end
+
+      private
+
+      class RenderAction
+        attr_reader :template, :controller, :view_data, :status
+
+        def initialize(template, status, controller, view_data)
+          @status = status
+          @template = template
+          @controller = controller
+          @view_data = view_data
+        end
+
+        def execute
+          Shared::Flash.new(view_data, controller.flash.now).set_error
+          controller.render template.merge(status: status)
+        end
+      end
+    end
+  end
+end

data/lib/aldous/respondable/request_http_basic_authentication.rb

@@ -0,0 +1,23 @@
+module Aldous
+  module Respondable
+    class RequestHttpBasicAuthentication < Base
+      def action(controller)
+        RequestHttpBasicAuthenticationAction.new(controller)
+      end
+
+      private
+
+      class RequestHttpBasicAuthenticationAction
+        attr_reader :controller
+
+        def initialize(controller)
+          @controller = controller
+        end
+
+        def execute
+          controller.request_http_basic_authentication
+        end
+      end
+    end
+  end
+end

data/lib/aldous/respondable/send_data.rb

@@ -0,0 +1,36 @@
+require 'aldous/respondable/base'
+
+module Aldous
+  module Respondable
+    class SendData < Base
+      def action(controller)
+        SendDataAction.new(data, options, controller, view_data)
+      end
+
+      def data
+        raise Errors::UserError.new("SendData objects must define a 'data' method")
+      end
+
+      def options
+        raise Errors::UserError.new("SendData objects must define an 'options' method")
+      end
+
+      private
+
+      class SendDataAction
+        attr_reader :controller, :view_data, :data, :options
+
+        def initialize(data, options, controller, view_data)
+          @controller = controller
+          @view_data = view_data
+          @data = data
+          @options = options
+        end
+
+        def execute
+          controller.send_data data, options
+        end
+      end
+    end
+  end
+end

data/lib/aldous/respondable/shared/flash.rb

@@ -0,0 +1,24 @@
+module Aldous
+  module Respondable
+    module Shared
+      class Flash
+        attr_reader :result, :flash_container
+
+        def initialize(result, flash_container)
+          @result = result
+          @flash_container = flash_container
+        end
+
+        def set_error
+          flash_container[:error] = error if error
+        end
+
+        private
+
+        def error
+          result.errors.first
+        end
+      end
+    end
+  end
+end