nucleus-core 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cad40c45a637495932d264dfef04ca978e3f47dba177e8acbfbd59a37e0c2217
-  data.tar.gz: 3389a5a8e8bb3d63c4afb7fb47ae900367295d86c7bb4ccf651773b1805ca9b2
+  metadata.gz: 05f1cb3a1cdbe91b800911bb9f62b22496be36e29d620847f955ea52e823b166
+  data.tar.gz: 95d2d4eeab4797441ddff2473f29a61c37b49adbec2168599cd67e3ef3803502
 SHA512:
-  metadata.gz: 461315b12ca674353043961e25e49498878392b89d4aef410aa1e0d16e43938087e4eb377840dd4b815d4a176e3f8f09c296be096198dcd39022b647cee4b89a
-  data.tar.gz: 6cbd15c2ce8e2d264ecdd849e1f723b60519c132e2b422f9fc9857f0fc9828649b712bed93bf90680d1a422e87d25e6277fb801dd457436e39667665f390b3c4
+  metadata.gz: 5d8948f0e23f0724b396d3888a06cd515b36427b540e706330de247a12d713407d1b053bad5c49fe85bed7cbe49756cec28c20f62bd51273a39c25f30d4535ff
+  data.tar.gz: 8e6ea5ea9ca756d24c73c11186651687bb5eea6acc817f13c5c44e2b7a023684a290972ca71b209c3ad19ef2dcc49ad5bb5bb8333ba2cfe6251758cc4e956c2c

data/README.md

@@ -1,143 +1,170 @@
-# NucleusCore
+# Nucleus Core
 
 [![Gem Version](https://badge.fury.io/rb/nucleus-core.svg)](https://rubygems.org/gems/nucleus-core)
 [![Circle](https://circleci.com/gh/dodgerogers/nucleus-core/tree/main.svg?style=shield)](https://app.circleci.com/pipelines/github/dodgerogers/nucleus-core?branch=main)
 [![Code Climate](https://codeclimate.com/github/dodgerogers/nucleus-core/badges/gpa.svg)](https://codeclimate.com/github/dodgerogers/nucleus-core)
 
-NucleusCore Core is a framework to express and orchestrate business logic in a way that is agnostic to the framework.
+- [Overview](#overview)
+- [Components](#components)
+- [Supported Frameworks](#supported-frameworks)
+- [Quick start](#quick-start)
+- [Best practices](#best-practices)
+- [Support](#support)
+- [License](#license)
+- [Code of conduct](#code-of-conduct)
+- [Contribution guide](#contribution-guide)
+
+## Overview
+
+Nucleus Core defines a boundary between your business logic, and a framework.
 
-## This gem is still very much in development. A `nucleus-rails` gem will handle the adaptation of NucleusCore::View objects to the rails rendering methods.
+## Components
 
-Here are the classes NucleusCore exposes, they have preordained responsibilities, can be composed together, and tested simply in isolation from the framework.
+**Responder** - The boundary which passes request parameters to your business logic, then renders a response (requires framework request, and response adapaters).\
+**Operations** - Service implementation that executes one side effect.\
+**Workflows** - Service orchestration which composes complex, multi stage processes.\
+**Views** - Presentation objects which render multiple formats.
 
-- Policy (Authorization) - Can this user perform this process?
-- Operation (Services) - Executes a single unit of business logic, or side effect (ScheduleAppointment, CancelOrder, UpdateAddress).
-- Workflow (Service Orchestration) - Excecutes multiple units of work, and side effects (ApproveLoan, TakePayment, CancelFulfillments).
-- View (Presentation) - A presentation object which can render to multiple formats.
-- Repository (Data access) - Interacts with data sources to hide the implementation details to callers, and return Aggregates. Data sources could be an API, ActiveRecord, SQL, a local file, etc.
-- Aggregate (Domain/business Object) - Maps data from the data source to an object the aplication defines, known as an anti corruption layer.
+## Supported Frameworks
 
-Below is an example using NucleusCore Core with Rails:
+These packages implement request, and response adapters for their respective framework.
+
+- [nucleus-rails](https://rubygems.org/gems/nucleus-rails).
+
+## Getting started
+
+1. Install the gem
+
+```
+$ gem install nuclueus-core
+```
+
+2. Initialize, and configure `NucleusCore`
 
 ```ruby
-# controllers/payments_controller.rb
-class PaymentsController < ApplicationController
-  include NucleusCore::Responder
+require "nucleus-core"
 
-  def create
-    handle_response do
-      policy.enforce!(:can_write?)
+NucleusCore.configure do |config|
+  config.logger = Logger.new($stdout)
+  config.default_response_format = :json
+  config.exceptions = {
+    not_found: ActiveRecord::RecordNotFound,
+    unprocessible: [ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved],
+    bad_request: Apipie::ParamError,
+    unauthorized: Pundit::NotAuthorizedError
+  }
+end
+```
 
-      context, _process = HandleCheckoutWorkflow.call(invoice_params)
+3. Create a class that implements the rendering methods below. Class, or instance methods can be used, make sure to initialize the responder accordingly.
 
-      return context if !context.success?
+```ruby
+class ResponderAdapter
+  # entity: Nucleus::ResponseAdapter
 
-      return PaymentView.new(cart: context.cart, paid: context.paid)
-    end
+  def render_json(entity)
   end
 
-  private
-
-  def policy
-    Policy.new(current_user)
+  def render_xml(entity)
   end
 
-  def invoice_params
-    params.slice(:cart_id)
+  def render_pdf(entity)
   end
-end
 
-# workflows/handle_checkout_workflow.rb
-class HandleCheckoutWorkflow < NucleusCore::Workflow
-  def define
-    start_node(continue: :calculate_amount)
-    register_node(
-      state: :calculate_amount,
-      operation: FetchShoppingCart,
-      determine_signal: ->(context) { context.cart.total > 10 ? :discount : :pay },
-      signals: { discount: :apply_discount, pay: :take_payment }
-    )
-    register_node(
-      state: :apply_discount,
-      operation: ApplyDiscountToShoppingCart,
-      signals: { continue: :take_payment }
-    )
-    register_node(
-      state: :take_payment,
-      operation: ->(context) { context.paid = context.cart.paid },
-      determine_signal: ->(_) { :completed }
-    )
-    register_node(
-      state: :completed,
-      determine_signal: ->(_) { :wait }
-    )
+  def render_csv(entity)
   end
-end
 
-# app/operations/fetch_shopping_cart.rb
-class FetchShoppingCart < NucleusCore::Operation
-  def call
-    cart = ShoppingCartRepository.find(context.cart_id)
+  def render_text(entity)
+  end
 
-    context.cart = cart
-  rescue NucleusCore::NotFound => e
-    context.fail!(e.message, exception: e)
+  def render_nothing(entity)
   end
 end
+```
 
-# app/repositories/shopping_cart_repository.rb
-class ShoppingCartRepository < NucleusCore::Repository
-  def self.find(cart_id)
-    cart = ShoppingCart.find(cart_id)
+4. Create a class that implements `call` which returns a hash of request details. `format` and `parameters` are required, but there others can be returned.
 
-    return ShoppingCart::Aggregate.new(cart)
-  rescue ActiveRecord::RecordNotFound => e
-    raise NucleusCore::NotFound, e.message
+```ruby
+class RequestAdapter
+  def call(args={})
+    { format: args[:format], parameters: args[:params], ...}
   end
+end
+```
 
-  def self.discount(cart_id, percentage)
-    cart = find(cart_id, percentage=0.5)
+4. Implement your business logic using Operations, and orchestrate more complex proceedures with Workflows.
 
-    cart.update!(total: cart.total * percentage, paid: true)
+`operations/fetch_order.rb`
 
-    return ShoppingCart::Aggregate.new(cart)
+```ruby
+class Operations::FetchOrder < NucleusCore::Operation
+  def call
+    context.order = find_order(context.id)
   rescue NucleusCore::NotFound => e
-    raise e
+    context.fail!(e.message, exception: e)
   end
 end
+```
 
-# app/models/shopping_cart.rb
-class ShoppingCart < ActiveRecord::Base
-  # ...
-end
+`operations/apply_order_discount.rb`
+
+```ruby
+class Operations::ApplyOrderDiscount < NucleusCore::Operation
+  def call
+    discount = context.discount || 0.25
+    order = update_order(context.order, discount: discount)
 
-# app/aggregates/shopping_cart.rb
-class ShoppingCart::Aggregate < NucleusCore::Aggregate
-  def initialize(cart)
-    super(id: cart.id, total: cart.total, paid: cart.paid, created_at: cart.created_at)
+    context.order = order
+  rescue NucleusCore::NotFound, NucleusCore::Unprocessable => e
+    context.fail!(e.message, exception: e)
   end
 end
+```
 
-# app/operations/apply_discount_to_shopping_cart.rb
-class ApplyDiscountToShoppingCart < NucleusCore::Operation
-  def call
-    cart = ShoppingCartRepository.discount(context.cart_id, 0.75)
+`workflows/fulfill_order.rb`
 
-    context.cart
-  rescue NucleusCore::NotFound => e
-    context.fail!(e.message, exception: e)
+```ruby
+class Workflows::FulfillOrder < NucleusCore::Workflow
+  def define
+    start_node(continue: :apply_discount?)
+    register_node(
+      state: :apply_discount?,
+      operation: Operations::FetchOrder,
+      determine_signal: ->(context) { context.order.total > 10 ? :discount : :pay },
+      signals: { discount: :discount_order, pay: :take_payment }
+    )
+    register_node(
+      state: :discount_order,
+      operation: Operations::ApplyOrderDiscount,
+      signals: { continue: :take_payment }
+    )
+    register_node(
+      state: :take_payment,
+      operation: ->(context) { context.paid = context.order.pay! },
+      signals: { continue: :completed }
+    )
+    register_node(
+      state: :completed,
+      determine_signal: ->(_) { :wait }
+    )
   end
 end
+```
 
-# app/views/payments_view.rb
-class NucleusCore::PaymentView < NucleusCore::View
-  def initialize(cart)
-    super(total: "$#{cart.total}", paid: cart.paid, created_at: cart.created_at)
+5. Define your view, and it's responses.
+
+`views/order.rb`
+
+```ruby
+class Views::Order < NucleusCore::View
+  def initialize(order)
+    super(id: order.id, price: "$#{order.total}", paid: order.paid, created_at: order.created_at)
   end
 
   def json_response
     content = {
       payment: {
+        id: id,
         price: price,
         paid: paid,
         created_at: created_at,
@@ -149,38 +176,50 @@ class NucleusCore::PaymentView < NucleusCore::View
   end
 
   def pdf_response
-    pdf_string = generate_pdf_string(price, paid)
+    pdf = generate_pdf(id, price, paid)
 
-    NucleusCore::PdfResponse.new(content: pdf_string)
-  end
-
-  private def generate_pdf_string(price, paid)
-    # pdf string genration...
+    NucleusCore::PdfResponse.new(content: pdf)
   end
 end
 ```
 
----
+4. Initialize the responder with your adapters, then call your business logic, and return a view.
 
-- [Quick start](#quick-start)
-- [Support](#support)
-- [License](#license)
-- [Code of conduct](#code-of-conduct)
-- [Contribution guide](#contribution-guide)
+`controllers/orders_controller.rb`
 
-## Quick start
+```ruby
+class OrdersController
+  before_action do
+    @responder = Nucleus::Responder.new(
+      response_adapter: ResponseAdapter.new,
+      request_adapter: RequestAdapter.new
+    )
 
-```
-$ gem install nucleus-core
-```
+    @request = {
+      format: request.format,
+      parameters: request.params
+    }
+  end
 
-```ruby
-require "nucleus-core"
+  def create
+    @responder.execute(@request) do |req|
+      context, _process = Workflows::FulfillOrder.call(context: req.parameters)
+
+      return Views::Order.new(order: context.order) if context.success?
+
+      return context
+    end
+  end
+end
 ```
 
+5. Then tell us about it!
+
+---
+
 ## Support
 
-If you want to report a bug, or have ideas, feedback or questions about the gem, [let me know via GitHub issues](https://github.com/dodgerogers/nucleus_core/issues/new) and I will do my best to provide a helpful answer. Happy hacking!
+If you want to report a bug, or have ideas, feedback or questions about the gem, [let me know via GitHub issues](https://github.com/dodgerogers/nucleus_core/issues/new) and we will do our best to provide a helpful answer.
 
 ## License
 

data/lib/nucleus_core/exceptions/bad_request.rb

@@ -0,0 +1,3 @@
+require "nucleus_core/exceptions/base"
+
+class NucleusCore::BadRequest < NucleusCore::BaseException; end

data/lib/nucleus_core/exceptions/base.rb

@@ -0,0 +1 @@
+class NucleusCore::BaseException < StandardError; end

data/lib/nucleus_core/exceptions/not_authorized.rb

@@ -0,0 +1,3 @@
+require "nucleus_core/exceptions/base"
+
+class NucleusCore::NotAuthorized < NucleusCore::BaseException; end

data/lib/nucleus_core/exceptions/not_found.rb

@@ -0,0 +1,3 @@
+require "nucleus_core/exceptions/base"
+
+class NucleusCore::NotFound < NucleusCore::BaseException; end

data/lib/nucleus_core/exceptions/unprocessable.rb

@@ -0,0 +1,3 @@
+require "nucleus_core/exceptions/base"
+
+class NucleusCore::Unprocessable < NucleusCore::BaseException; end

data/lib/nucleus_core/extensions/utils.rb

@@ -0,0 +1,88 @@
+# Rack::Utils patch for status code
+class Utils
+  HTTP_STATUS_CODES = {
+    100 => "Continue",
+    101 => "Switching Protocols",
+    102 => "Processing",
+    103 => "Early Hints",
+    200 => "OK",
+    201 => "Created",
+    202 => "Accepted",
+    203 => "Non-Authoritative Information",
+    204 => "No Content",
+    205 => "Reset Content",
+    206 => "Partial Content",
+    207 => "Multi-Status",
+    208 => "Already Reported",
+    226 => "IM Used",
+    300 => "Multiple Choices",
+    301 => "Moved Permanently",
+    302 => "Found",
+    303 => "See Other",
+    304 => "Not Modified",
+    305 => "Use Proxy",
+    306 => "(Unused)",
+    307 => "Temporary Redirect",
+    308 => "Permanent Redirect",
+    400 => "Bad Request",
+    401 => "Unauthorized",
+    402 => "Payment Required",
+    403 => "Forbidden",
+    404 => "Not Found",
+    405 => "Method Not Allowed",
+    406 => "Not Acceptable",
+    407 => "Proxy Authentication Required",
+    408 => "Request Timeout",
+    409 => "Conflict",
+    410 => "Gone",
+    411 => "Length Required",
+    412 => "Precondition Failed",
+    413 => "Payload Too Large",
+    414 => "URI Too Long",
+    415 => "Unsupported Media Type",
+    416 => "Range Not Satisfiable",
+    417 => "Expectation Failed",
+    421 => "Misdirected Request",
+    422 => "Unprocessable Entity",
+    423 => "Locked",
+    424 => "Failed Dependency",
+    425 => "Too Early",
+    426 => "Upgrade Required",
+    428 => "Precondition Required",
+    429 => "Too Many Requests",
+    431 => "Request Header Fields Too Large",
+    451 => "Unavailable for Legal Reasons",
+    500 => "Internal Server Error",
+    501 => "Not Implemented",
+    502 => "Bad Gateway",
+    503 => "Service Unavailable",
+    504 => "Gateway Timeout",
+    505 => "HTTP Version Not Supported",
+    506 => "Variant Also Negotiates",
+    507 => "Insufficient Storage",
+    508 => "Loop Detected",
+    509 => "Bandwidth Limit Exceeded",
+    510 => "Not Extended",
+    511 => "Network Authentication Required"
+  }.freeze
+
+  SYMBOL_TO_STATUS_CODE = Hash[*HTTP_STATUS_CODES.map do |code, message|
+    [message.downcase.gsub(/\s|-|'/, "_").to_sym, code]
+  end.flatten]
+
+  def self.status_code(status)
+    if status.is_a?(Symbol)
+      return SYMBOL_TO_STATUS_CODE.fetch(status) do
+        raise ArgumentError, "Unrecognized status code #{status.inspect}"
+      end
+    end
+
+    status.to_i
+  end
+
+  def self.wrap(object)
+    return [] if object.nil?
+
+    object.is_a?(Array) ? object : [object]
+  end
+end

data/lib/nucleus_core/request_adapter.rb

@@ -0,0 +1,23 @@
+require "nucleus_core/simple_object"
+
+module NucleusCore
+  class RequestAdapter < NucleusCore::SimpleObject
+    def initialize(attrs=nil)
+      attrs ||= {}
+      attributes = defaults
+        .merge(attrs)
+        .slice(*defaults.keys)
+
+      super(attributes)
+    end
+
+    private
+
+    def defaults
+      {
+        format: NucleusCore.configuration.default_response_format,
+        parameters: {}
+      }
+    end
+  end
+end

data/lib/nucleus_core/responder.rb

@@ -1,27 +1,22 @@
 require "set"
 
 module NucleusCore
-  module Responder
-    attr_reader :request_format, :response_adapter
+  class Responder
+    attr_accessor :response_adapter, :request_adapter, :request_context
 
-    def init_responder(request_format: nil, response_adapter: nil)
-      set_request_format(request_format)
-      set_response_adapter(response_adapter)
-    end
-
-    def set_request_format(request=nil)
-      @request_format = request&.to_sym || :json
-    end
-
-    # rubocop:disable Naming/AccessorMethodName
-    def set_response_adapter(response_adapter)
+    def initialize(request_adapter: nil, response_adapter: nil)
+      @request_adapter = request_adapter
       @response_adapter = response_adapter
+      @request_context = nil
     end
-    # rubocop:enable Naming/AccessorMethodName
 
     # rubocop:disable Lint/RescueException:
-    def handle_response(&block)
-      entity = proc_to_lambda(&block)
+    def execute(raw_request_context=nil, &block)
+      return if block.nil?
+
+      request_context_attrs = request_adapter&.call(raw_request_context) || {}
+      @request_context = NucleusCore::RequestAdapter.new(request_context_attrs)
+      entity = execute_block(@request_context, &block)
 
       render_entity(entity)
     rescue Exception => e
@@ -29,49 +24,36 @@ module NucleusCore
     end
     # rubocop:enable Lint/RescueException:
 
-    def handle_exception(exception)
-      logger(exception)
-
-      status = exception_to_status(exception)
-      attrs = { message: exception.message, status: status }
-      error = NucleusCore::ErrorView.new(attrs)
-
-      render_entity(error)
-    end
-
     # Calling `return` in a block/proc returns from the outer calling scope as well.
     # Lambdas do not have this limitation. So we convert the proc returned
     # from a block method into a lambda to avoid 'return' exiting the method early.
     # https://stackoverflow.com/questions/2946603/ruby-convert-proc-to-lambda
-    def proc_to_lambda(&block)
+    def execute_block(request, &block)
       define_singleton_method(:_proc_to_lambda_, &block)
 
-      method(:_proc_to_lambda_).to_proc.call
+      method(:_proc_to_lambda_).to_proc.call(request)
     end
 
     def render_entity(entity)
       return handle_context(entity) if entity.is_a?(NucleusCore::Operation::Context)
-      return render_response(entity) if subclass_of(entity, NucleusCore::ResponseAdapter)
       return render_view(entity) if subclass_of(entity, NucleusCore::View)
+      return render_response(entity) if subclass_of(entity, NucleusCore::ResponseAdapter)
     end
 
     def handle_context(context)
       return render_nothing(context) if context.success?
       return handle_exception(context.exception) if context.exception
 
-      message = context.message
-      attrs = { message: message, status: :unprocessable_entity }
-      error_view = NucleusCore::ErrorView.new(attrs)
+      view = NucleusCore::ErrorView.new(message: context.message, status: :unprocessable_entity)
 
-      render_view(error_view)
+      render_view(view)
     end
 
     def render_view(view)
-      format_rendering = "#{request_format}_response".to_sym
-      renders_format = view.respond_to?(format_rendering)
-      format_response = view.send(format_rendering) if renders_format
+      render_to_format = "#{request_context.format}_response".to_sym
+      format_response = view.send(render_to_format) if view.respond_to?(render_to_format)
 
-      raise NucleusCore::BadRequest, "#{request_format} is not supported" if format_response.nil?
+      raise NucleusCore::BadRequest, "`#{request_context.format}` is not supported" if format_response.nil?
 
       render_response(format_response)
     end
@@ -79,7 +61,7 @@ module NucleusCore
     def render_response(entity)
       render_headers(entity.headers)
 
-      method_name = {
+      render_method = {
         NucleusCore::JsonResponse => :render_json,
         NucleusCore::XmlResponse => :render_xml,
         NucleusCore::PdfResponse => :render_pdf,
@@ -88,7 +70,16 @@ module NucleusCore
         NucleusCore::NoResponse => :render_nothing
       }.fetch(entity.class, nil)
 
-      response_adapter&.send(method_name, entity)
+      response_adapter&.send(render_method, entity)
+    end
+
+    def handle_exception(exception)
+      logger(exception)
+
+      status = exception_to_status(exception)
+      view = NucleusCore::ErrorView.new(message: exception.message, status: status)
+
+      render_view(view)
     end
 
     def render_headers(headers={})
@@ -99,26 +90,22 @@ module NucleusCore
       end
     end
 
-    # rubocop:disable Lint/DuplicateBranch
     def exception_to_status(exception)
-      config = exception_map
+      exceptions = NucleusCore.configuration.exceptions
 
       case exception
-      when NucleusCore::NotFound, *config.not_found
+      when NucleusCore::NotFound, *exceptions.not_found
         :not_found
-      when NucleusCore::BadRequest, *config.bad_request
+      when NucleusCore::BadRequest, *exceptions.bad_request
         :bad_request
-      when NucleusCore::NotAuthorized, *config.forbidden
+      when NucleusCore::NotAuthorized, *exceptions.forbidden
         :forbidden
-      when NucleusCore::Unprocessable, *config.unprocessable
+      when NucleusCore::Unprocessable, *exceptions.unprocessable
         :unprocessable_entity
-      when NucleusCore::BaseException, *config.server_error
-        :internal_server_error
       else
         :internal_server_error
       end
     end
-    # rubocop:enable Lint/DuplicateBranch
 
     def subclass_of(entity, *classes)
       Set[*entity.class.ancestors].intersect?(classes.to_set)
@@ -127,9 +114,5 @@ module NucleusCore
     def logger(object, log_level=:info)
       NucleusCore.configuration.logger&.send(log_level, object)
     end
-
-    def exception_map
-      NucleusCore.configuration.exceptions_map
-    end
   end
 end

data/lib/nucleus_core/response_adapters/csv_response.rb

@@ -0,0 +1,13 @@
+require "nucleus_core/response_adapters/response_adapter"
+
+class NucleusCore::CsvResponse < NucleusCore::ResponseAdapter
+  def initialize(attrs={})
+    attrs = attrs.merge(
+      disposition: "attachment",
+      filename: attrs.fetch(:filename) { "response.csv" },
+      type: "text/csv; charset=UTF-8;"
+    )
+
+    super(attrs)
+  end
+end

data/lib/nucleus_core/response_adapters/json_response.rb

@@ -0,0 +1,9 @@
+require "nucleus_core/response_adapters/response_adapter"
+
+class NucleusCore::JsonResponse < NucleusCore::ResponseAdapter
+  def initialize(attrs={})
+    attrs = attrs.merge(type: "application/json")
+
+    super(attrs)
+  end
+end

data/lib/nucleus_core/response_adapters/no_response.rb

@@ -0,0 +1,9 @@
+require "nucleus_core/response_adapters/response_adapter"
+
+class NucleusCore::NoResponse < NucleusCore::ResponseAdapter
+  def initialize(attrs={})
+    attrs = attrs.merge(content: nil, type: "text/html; charset=utf-8")
+
+    super(attrs)
+  end
+end

data/lib/nucleus_core/response_adapters/pdf_response.rb

@@ -0,0 +1,13 @@
+require "nucleus_core/response_adapters/response_adapter"
+
+class NucleusCore::PdfResponse < NucleusCore::ResponseAdapter
+  def initialize(attrs={})
+    attrs = attrs.merge(
+      disposition: "inline",
+      filename: attrs.fetch(:filename) { "response.pdf" },
+      type: "application/pdf"
+    )
+
+    super(attrs)
+  end
+end

data/lib/nucleus_core/response_adapters/response_adapter.rb

@@ -0,0 +1,32 @@
+require "nucleus_core/simple_object"
+
+class NucleusCore::ResponseAdapter < NucleusCore::SimpleObject
+  def initialize(attrs={})
+    attributes = defaults
+      .merge(attrs)
+      .slice(*defaults.keys)
+      .tap do |hash|
+        hash[:status] = status_code(hash[:status])
+      end
+
+    super(attributes)
+  end
+
+  private
+
+  def defaults
+    {
+      content: nil,
+      headers: nil,
+      status: nil,
+      location: nil
+    }
+  end
+
+  def status_code(status=nil)
+    status = Utils.status_code(status)
+    default_status = 200
+
+    status.zero? ? default_status : status
+  end
+end

data/lib/nucleus_core/response_adapters/text_response.rb

@@ -0,0 +1,9 @@
+require "nucleus_core/response_adapters/response_adapter"
+
+class NucleusCore::TextResponse < NucleusCore::ResponseAdapter
+  def initialize(attrs={})
+    attrs = attrs.merge(type: "application/text")
+
+    super(attrs)
+  end
+end

data/lib/nucleus_core/response_adapters/xml_response.rb

@@ -0,0 +1,9 @@
+require "nucleus_core/response_adapters/response_adapter"
+
+class NucleusCore::XmlResponse < NucleusCore::ResponseAdapter
+  def initialize(attrs={})
+    attrs = attrs.merge(type: "application/xml")
+
+    super(attrs)
+  end
+end

data/lib/nucleus_core/{basic_object.rb → simple_object.rb}

@@ -1,6 +1,10 @@
 module NucleusCore
-  class BasicObject
+  class SimpleObject
+    attr_reader :__attributes__
+
     def initialize(attrs={})
+      @__attributes__ = {}
+
       attrs.each_pair do |key, value|
         define_singleton_method(key.to_s) do
           instance_variable_get("@#{key}")
@@ -8,17 +12,16 @@ module NucleusCore
 
         define_singleton_method("#{key}=") do |val|
           instance_variable_set("@#{key}", val)
+          @__attributes__[key] = val
         end
 
         instance_variable_set("@#{key}", value)
+        @__attributes__[key] = value
       end
     end
 
     def to_h
-      instance_variables
-        .reduce({}) do |acc, var|
-        acc.merge(var.to_s.delete("@") => instance_variable_get(var))
-      end
+      __attributes__
     end
   end
 end

data/lib/nucleus_core/version.rb

@@ -1,3 +1,3 @@
 module NucleusCore
-  VERSION = "0.1.4".freeze
+  VERSION = "0.2.0".freeze
 end

data/lib/nucleus_core/views/error_view.rb

@@ -1,4 +1,5 @@
-require "nucleus_core/response_adapter"
+require "nucleus_core/response_adapters/response_adapter"
+require "nucleus_core/views/view"
 
 class NucleusCore::ErrorView < NucleusCore::View
   def initialize(attrs={})

data/lib/nucleus_core/views/view.rb

@@ -1,4 +1,6 @@
-class NucleusCore::View < NucleusCore::BasicObject
+require "nucleus_core/response_adapters/response_adapter"
+
+class NucleusCore::View < NucleusCore::SimpleObject
   def json_response
     NucleusCore::JsonResponse.new(content: to_h, status: :ok)
   end

data/lib/nucleus_core.rb

@@ -2,61 +2,48 @@ require "ostruct"
 require "json"
 require "set"
 
-Dir[File.join(__dir__, "nucleus_core", "extensions", "*.rb")].sort.each { |file| require file }
+extensions = File.join(__dir__, "nucleus_core", "extensions", "*.rb")
+exceptions = File.join(__dir__, "nucleus_core", "exceptions", "*.rb")
+views = File.join(__dir__, "nucleus_core", "views", "*.rb")
+response_adapters = File.join(__dir__, "nucleus_core", "response_adapters", "*.rb")
+[extensions, exceptions, views, response_adapters].each do |dir|
+  Dir[dir].sort.each { |f| require f }
+end
 
 module NucleusCore
   autoload :CLI, "nucleus_core/cli"
   autoload :VERSION, "nucleus_core/version"
-  autoload :BasicObject, "nucleus_core/basic_object"
-  autoload :View, "nucleus_core/views/view"
-  autoload :ErrorView, "nucleus_core/views/error_view"
-  autoload :ResponseAdapter, "nucleus_core/response_adapter"
-  autoload :Aggregate, "nucleus_core/aggregate"
-  autoload :Policy, "nucleus_core/policy"
   autoload :Operation, "nucleus_core/operation"
   autoload :Workflow, "nucleus_core/workflow"
   autoload :Responder, "nucleus_core/responder"
-
-  class BaseException < StandardError; end
-  class NotAuthorized < BaseException; end
-  class NotFound < BaseException; end
-  class Unprocessable < BaseException; end
-  class BadRequest < BaseException; end
+  autoload :RequestAdapter, "nucleus_core/request_adapter"
+  autoload :SimpleObject, "nucleus_core/basic_object"
 
   class Configuration
-    attr_reader :exceptions_map
-    attr_accessor :logger
+    attr_accessor :default_response_format, :logger
+    attr_reader :exceptions
 
-    RESPONSE_ADAPTER_METHODS = %i[
-      render_json render_xml render_text render_pdf render_csv render_nothing set_header
-    ].freeze
+    ERROR_STATUSES = %i[not_found bad_request unauthorized unprocessable].freeze
 
     def initialize
       @logger = nil
-      @exceptions_map = nil
+      @exceptions = format_exceptions
+      @default_response_format = :json
     end
 
-    def exceptions_map=(args={})
-      @exceptions_map = format_exceptions(args)
+    def exceptions=(args={})
+      @exceptions = format_exceptions(args)
     end
 
     private
 
-    def objectify(hash)
-      OpenStruct.new(hash)
-    end
-
-    ERROR_STATUSES = %i[not_found bad_request unauthorized unprocessable server_error].freeze
-
-    def format_exceptions(exceptions={})
-      exception_defaults = ERROR_STATUSES.reduce({}) { |acc, ex| acc.merge(ex => nil) }
-      exceptions_map = (exceptions || exception_defaults)
-        .slice(*exception_defaults.keys)
-        .reduce({}) do |acc, (key, value)|
-          acc.merge(key => Array.wrap(value))
-        end
+    def format_exceptions(args={})
+      exceptions = ERROR_STATUSES
+        .reduce({}) { |acc, name| acc.merge(name => nil) }
+        .merge(args)
+        .transform_values { |values| Utils.wrap(values) }
 
-      objectify(exceptions_map)
+      OpenStruct.new(exceptions)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nucleus-core
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - dodgerogers
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-02-02 00:00:00.000000000 Z
+date: 2023-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -70,16 +70,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.44.1
+        version: 1.45.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.44.1
+        version: 1.45.1
 - !ruby/object:Gem::Dependency
   name: rubocop-minitest
   requirement: !ruby/object:Gem::Requirement
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.15.2
+        version: 1.16.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.15.2
+        version: 1.16.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
@@ -136,7 +136,7 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.6.0
-description:
+description: 
 email:
 - dodgerogers@hotmail.com
 executables:
@@ -148,16 +148,24 @@ files:
 - README.md
 - exe/nucleus
 - lib/nucleus_core.rb
-- lib/nucleus_core/aggregate.rb
-- lib/nucleus_core/basic_object.rb
 - lib/nucleus_core/cli.rb
-- lib/nucleus_core/extensions/array.rb
-- lib/nucleus_core/extensions/rack.rb
+- lib/nucleus_core/exceptions/bad_request.rb
+- lib/nucleus_core/exceptions/base.rb
+- lib/nucleus_core/exceptions/not_authorized.rb
+- lib/nucleus_core/exceptions/not_found.rb
+- lib/nucleus_core/exceptions/unprocessable.rb
+- lib/nucleus_core/extensions/utils.rb
 - lib/nucleus_core/operation.rb
-- lib/nucleus_core/policy.rb
-- lib/nucleus_core/repository.rb
+- lib/nucleus_core/request_adapter.rb
 - lib/nucleus_core/responder.rb
-- lib/nucleus_core/response_adapter.rb
+- lib/nucleus_core/response_adapters/csv_response.rb
+- lib/nucleus_core/response_adapters/json_response.rb
+- lib/nucleus_core/response_adapters/no_response.rb
+- lib/nucleus_core/response_adapters/pdf_response.rb
+- lib/nucleus_core/response_adapters/response_adapter.rb
+- lib/nucleus_core/response_adapters/text_response.rb
+- lib/nucleus_core/response_adapters/xml_response.rb
+- lib/nucleus_core/simple_object.rb
 - lib/nucleus_core/version.rb
 - lib/nucleus_core/views/error_view.rb
 - lib/nucleus_core/views/view.rb
@@ -171,7 +179,7 @@ metadata:
   source_code_uri: https://github.com/dodgerogers/nucleus-core
   homepage_uri: https://github.com/dodgerogers/nucleus-core
   rubygems_mfa_required: 'true'
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -186,8 +194,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.5
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: A Ruby business logic framework
 test_files: []

data/lib/nucleus_core/aggregate.rb

@@ -1 +0,0 @@
-class NucleusCore::Aggregate < NucleusCore::BasicObject; end

data/lib/nucleus_core/extensions/array.rb

@@ -1,11 +0,0 @@
-class Array
-  def self.wrap(object)
-    if object.nil?
-      []
-    elsif object.respond_to?(:to_ary)
-      object.to_ary || [object]
-    else
-      [object]
-    end
-  end
-end

data/lib/nucleus_core/extensions/rack.rb

@@ -1,86 +0,0 @@
-# Rack::Utils patch for status code
-module NucleusCore
-  module Rack
-    class Utils
-      HTTP_STATUS_CODES = {
-        100 => "Continue",
-        101 => "Switching Protocols",
-        102 => "Processing",
-        103 => "Early Hints",
-        200 => "OK",
-        201 => "Created",
-        202 => "Accepted",
-        203 => "Non-Authoritative Information",
-        204 => "No Content",
-        205 => "Reset Content",
-        206 => "Partial Content",
-        207 => "Multi-Status",
-        208 => "Already Reported",
-        226 => "IM Used",
-        300 => "Multiple Choices",
-        301 => "Moved Permanently",
-        302 => "Found",
-        303 => "See Other",
-        304 => "Not Modified",
-        305 => "Use Proxy",
-        306 => "(Unused)",
-        307 => "Temporary Redirect",
-        308 => "Permanent Redirect",
-        400 => "Bad Request",
-        401 => "Unauthorized",
-        402 => "Payment Required",
-        403 => "Forbidden",
-        404 => "Not Found",
-        405 => "Method Not Allowed",
-        406 => "Not Acceptable",
-        407 => "Proxy Authentication Required",
-        408 => "Request Timeout",
-        409 => "Conflict",
-        410 => "Gone",
-        411 => "Length Required",
-        412 => "Precondition Failed",
-        413 => "Payload Too Large",
-        414 => "URI Too Long",
-        415 => "Unsupported Media Type",
-        416 => "Range Not Satisfiable",
-        417 => "Expectation Failed",
-        421 => "Misdirected Request",
-        422 => "Unprocessable Entity",
-        423 => "Locked",
-        424 => "Failed Dependency",
-        425 => "Too Early",
-        426 => "Upgrade Required",
-        428 => "Precondition Required",
-        429 => "Too Many Requests",
-        431 => "Request Header Fields Too Large",
-        451 => "Unavailable for Legal Reasons",
-        500 => "Internal Server Error",
-        501 => "Not Implemented",
-        502 => "Bad Gateway",
-        503 => "Service Unavailable",
-        504 => "Gateway Timeout",
-        505 => "HTTP Version Not Supported",
-        506 => "Variant Also Negotiates",
-        507 => "Insufficient Storage",
-        508 => "Loop Detected",
-        509 => "Bandwidth Limit Exceeded",
-        510 => "Not Extended",
-        511 => "Network Authentication Required"
-      }.freeze
-
-      SYMBOL_TO_STATUS_CODE = Hash[*HTTP_STATUS_CODES.map do |code, message|
-        [message.downcase.gsub(/\s|-|'/, "_").to_sym, code]
-      end.flatten]
-
-      def self.status_code(status)
-        if status.is_a?(Symbol)
-          return SYMBOL_TO_STATUS_CODE.fetch(status) do
-            raise ArgumentError, "Unrecognized status code #{status.inspect}"
-          end
-        end
-
-        status.to_i
-      end
-    end
-  end
-end

data/lib/nucleus_core/policy.rb

@@ -1,21 +0,0 @@
-module NucleusCore
-  class Policy
-    attr_reader :user, :record
-
-    def initialize(user, record=nil)
-      @user = user
-      @record = record
-    end
-
-    def enforce!(*policy_methods)
-      policy_methods.each do |policy_method_and_args|
-        next if send(*policy_method_and_args)
-
-        name = Array.wrap(policy_method_and_args).first
-        message = "You do not have access to: #{name}"
-
-        raise NucleusCore::NotAuthorized, message
-      end
-    end
-  end
-end

data/lib/nucleus_core/repository.rb

@@ -1,6 +0,0 @@
-module NucleusCore
-  class Repository
-    def self.execute
-    end
-  end
-end

data/lib/nucleus_core/response_adapter.rb

@@ -1,81 +0,0 @@
-class NucleusCore::ResponseAdapter < NucleusCore::BasicObject
-  def initialize(attrs={})
-    attributes = defaults
-      .merge(attrs)
-      .slice(*defaults.keys)
-      .tap do |hash|
-        hash[:status] = status_code(hash[:status])
-      end
-
-    super(attributes)
-  end
-
-  private
-
-  def defaults
-    { content: "", headers: {}, status: 200, location: nil }
-  end
-
-  def status_code(status=nil)
-    status = NucleusCore::Rack::Utils.status_code(status)
-    default_status = 200
-
-    status.zero? ? default_status : status
-  end
-end
-
-class NucleusCore::NoResponse < NucleusCore::ResponseAdapter
-  def initialize(attrs={})
-    attrs = attrs.merge(content: nil, type: "text/html; charset=utf-8")
-
-    super(attrs)
-  end
-end
-
-class NucleusCore::TextResponse < NucleusCore::ResponseAdapter
-  def initialize(attrs={})
-    attrs = attrs.merge(type: "application/text")
-
-    super(attrs)
-  end
-end
-
-class NucleusCore::JsonResponse < NucleusCore::ResponseAdapter
-  def initialize(attrs={})
-    attrs = attrs.merge(type: "application/json")
-
-    super(attrs)
-  end
-end
-
-class NucleusCore::XmlResponse < NucleusCore::ResponseAdapter
-  def initialize(attrs={})
-    attrs = attrs.merge(type: "application/xml")
-
-    super(attrs)
-  end
-end
-
-class NucleusCore::CsvResponse < NucleusCore::ResponseAdapter
-  def initialize(attrs={})
-    attrs = attrs.merge(
-      disposition: "attachment",
-      filename: attrs.fetch(:filename) { "response.csv" },
-      type: "text/csv; charset=UTF-8;"
-    )
-
-    super(attrs)
-  end
-end
-
-class NucleusCore::PdfResponse < NucleusCore::ResponseAdapter
-  def initialize(attrs={})
-    attrs = attrs.merge(
-      disposition: "inline",
-      filename: attrs.fetch(:filename) { "response.pdf" },
-      type: "application/pdf"
-    )
-
-    super(attrs)
-  end
-end