praxis 2.0.pre.16 → 2.0.pre.20

data/lib/praxis/bootloader_stages/routing.rb

@@ -1,17 +1,17 @@
-module Praxis
-
+# frozen_string_literal: true
 
+module Praxis
   module BootloaderStages
-
     class Routing < Stage
       class Target
         attr_reader :action
+
         def initialize(application, controller, action)
           @application = application
           @controller = controller
           @action = action
         end
-        
+
         def call(request)
           request.action = @action
           dispatcher = Dispatcher.current(application: @application)
@@ -19,7 +19,7 @@ module Praxis
           dispatcher.dispatch(@controller, @action, request)
         end
       end
-      
+
       def execute
         application.controllers.each do |controller|
           controller.definition.actions.each do |action_name, action|
@@ -29,14 +29,11 @@ module Praxis
         end
       end
 
-
       def target_factory(controller, action_name)
         action = controller.definition.actions.fetch(action_name)
 
         Target.new(application, controller, action)
       end
-
     end
-
   end
 end

data/lib/praxis/bootloader_stages/subgroup_loader.rb

@@ -1,17 +1,10 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   module BootloaderStages
-
     class SubgroupLoader < Stage
-
       attr_writer :order
 
-      def initialize(name, application)
-        super
-        # always finalize Taylor after loading app code.
-
-      end
-
       def order
         @order ||= application.file_layout[name] == [] ? [] : application.file_layout[name].groups.keys
       end
@@ -23,6 +16,5 @@ module Praxis
         setup_deferred_callbacks!
       end
     end
-
   end
 end

data/lib/praxis/bootloader_stages/warn_unloaded_files.rb

@@ -1,28 +1,26 @@
-module Praxis
-
+# frozen_string_literal: true
 
+module Praxis
   module BootloaderStages
-
     class WarnUnloadedFiles < Stage
       @enabled = true
 
-      def self.enabled=(enabled)
-        @enabled = enabled
+      class << self
+        attr_writer :enabled
       end
 
-      def self.enabled
-        @enabled
+      class << self
+        attr_reader :enabled
       end
 
       def execute
         return unless self.class.enabled
 
-        if application.file_layout[:app] == []
-          return
-        end
+        return if application.file_layout[:app] == []
 
         base = application.file_layout[:app].base
         return unless base.exist?
+
         file_enum = base.find.to_a
         files = file_enum.select do |file|
           path = file.relative_path_from(base)
@@ -30,17 +28,15 @@ module Praxis
         end
 
         missing = Set.new(files) - application.loaded_files
-        if missing.any?
-          msg = "The following application files under #{base} were not loaded:\n"
-          missing.each do |file|
-            path = file.relative_path_from(base)
-            msg << " * #{path}\n"
-          end
-          warn msg
+        return unless missing.any?
+
+        msg = "The following application files under #{base} were not loaded:\n"
+        missing.each do |file|
+          path = file.relative_path_from(base)
+          msg << " * #{path}\n"
         end
+        warn msg
       end
-
-
     end
   end
 end

data/lib/praxis/callbacks.rb

@@ -1,33 +1,34 @@
+# frozen_string_literal: true
+
 module Praxis
   module Callbacks
     extend ::ActiveSupport::Concern
 
     included do
       class_attribute :before_callbacks, :after_callbacks, :around_callbacks
-      self.before_callbacks = Hash.new
-      self.after_callbacks = Hash.new
-      self.around_callbacks = Hash.new
+      self.before_callbacks = ({})
+      self.after_callbacks = ({})
+      self.around_callbacks = ({})
     end
-    
+
     module ClassMethods
- 
       def before(*stage_path, **conditions, &block)
         stage_path = [:action] if stage_path.empty?
-        before_callbacks[stage_path] ||= Array.new
+        before_callbacks[stage_path] ||= []
         before_callbacks[stage_path] << [conditions, block]
       end
-      
+
       def after(*stage_path, **conditions, &block)
         stage_path = [:action] if stage_path.empty?
-        after_callbacks[stage_path] ||= Array.new
+        after_callbacks[stage_path] ||= []
         after_callbacks[stage_path] << [conditions, block]
       end
-      
+
       def around(*stage_path, **conditions, &block)
         stage_path = [:action] if stage_path.empty?
-        around_callbacks[stage_path] ||= Array.new
+        around_callbacks[stage_path] ||= []
         around_callbacks[stage_path] << [conditions, block]
       end
     end
   end
-end
+end

data/lib/praxis/collection.rb

@@ -1,28 +1,25 @@
+# frozen_string_literal: true
+
 module Praxis
   class Collection < Attributor::Collection
     include Types::MediaTypeCommon
 
     def self.of(type)
-      if defined?(type::Collection)
-        return type::Collection
-      end
+      return type::Collection if defined?(type::Collection)
 
       klass = super
       klass.anonymous_type
 
-      if type < Praxis::Types::MediaTypeCommon
-        klass.member_type type
-        type.const_set :Collection, klass
-      else
-        raise "Praxis::Collection.of() for non-MediaTypes is unsupported. Use Attributor::Collection.of() instead."
-      end
+      raise 'Praxis::Collection.of() for non-MediaTypes is unsupported. Use Attributor::Collection.of() instead.' unless type < Praxis::Types::MediaTypeCommon
 
+      klass.member_type type
+      type.const_set :Collection, klass
     end
 
-    def self.member_type(type=nil)
+    def self.member_type(type = nil)
       unless type.nil?
         @member_type = type
-        self.identifier(type.identifier + ';type=collection') unless type.identifier.nil?
+        identifier("#{type.identifier};type=collection") unless type.identifier.nil?
       end
 
       @member_type
@@ -36,11 +33,11 @@ module Praxis
       :array
     end
 
-    def self.as_json_schema(**args)
-      the_type = @attribute && @attribute.type || member_type
+    def self.as_json_schema(**_args)
+      the_type = @attribute&.type || member_type
       {
         type: json_schema_type,
-        items: { '$ref': "#/components/schemas/#{the_type.id}" }
+        items: the_type.as_json_schema
       }
     end
   end

data/lib/praxis/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Praxis
   class Config
     include Attributor::Type
@@ -10,7 +12,7 @@ module Praxis
     end
 
     # You can define the configuration in different ways
-    # 
+    #
     # Add a key to the top struct
     # define do
     #   attribute :added_to_top, String
@@ -28,46 +30,36 @@ module Praxis
     #     attribute :two String
     #   end
     # end
-    
+
     # ...or using this way too (equivalent)
     # define(:app) do
     #   attribute :two, String
     # end
     # You can also define a key to be a non-Struct type
     # define :app, Attributor::Hash
-        
-    def define(key=nil, type=Attributor::Struct, **opts, &block)
-      if key.nil? && type != Attributor::Struct
-        raise Exceptions::InvalidConfiguration.new(
-          "You cannot define the top level configuration with a non-Struct type. Got: #{type.inspect}"
-        )
-      end
-      
+
+    def define(key = nil, type = Attributor::Struct, **opts, &block)
+      raise Exceptions::InvalidConfiguration, "You cannot define the top level configuration with a non-Struct type. Got: #{type.inspect}" if key.nil? && type != Attributor::Struct
+
       case key
       when String, Symbol, NilClass
 
         top = key.nil? ? @attribute : @attribute.attributes[key]
-        if top #key defined...redefine
-          unless  type == Attributor::Struct && top.type < Attributor::Struct
-            raise Exceptions::InvalidConfiguration.new(
-              "Incompatible type received for extending configuration key [#{key}]. Got type #{type.name}"
-            )
-          end
+        if top # key defined...redefine
+          raise Exceptions::InvalidConfiguration, "Incompatible type received for extending configuration key [#{key}]. Got type #{type.name}" unless type == Attributor::Struct && top.type < Attributor::Struct
+
           top.options.merge!(opts)
           top.type.attributes(**opts, &block)
         else
           @attribute.attributes[key] = Attributor::Attribute.new(type, opts, &block)
         end
       else
-        raise Exceptions::InvalidConfiguration.new(
-          "Defining a configuration key requires a String or a Symbol key. Got: #{key.inspect}"
-        )
+        raise Exceptions::InvalidConfiguration, "Defining a configuration key requires a String or a Symbol key. Got: #{key.inspect}"
       end
-            
     end
 
     def set(config)
-      context = ['Application', 'config']
+      context = %w[Application config]
 
       begin
         @value = @attribute.load(config, context, recurse: true)
@@ -77,17 +69,14 @@ module Praxis
 
       errors = @attribute.validate(@value, context)
 
-      unless errors.empty?
-        raise Exceptions::ConfigValidation.new(errors: errors)
-      end
+      raise Exceptions::ConfigValidation.new(errors: errors) unless errors.empty?
     end
 
     def get
-      @value ||= begin
-        context = ['Application','config'].freeze
-        @attribute.load({},context, recurse: true)
+      @value ||= begin # rubocop:disable Naming/MemoizedInstanceVariableName
+        context = %w[Application config].freeze
+        @attribute.load({}, context, recurse: true)
       end
     end
-
   end
 end

data/lib/praxis/config_hash.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # TODO: move to Praxis proper...it's not used here
 module Praxis
   class ConfigHash < BasicObject
@@ -22,7 +23,7 @@ module Praxis
       true
     end
 
-    def method_missing(name, value, *rest, &block) # rubocop:disable Style/MethodMissing
+    def method_missing(name, value, *rest, &block)
       if (existing = @hash[name])
         if block
           existing << [value, block]

data/lib/praxis/controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 require 'active_support/all'
 
@@ -24,11 +26,11 @@ module Praxis
       end
 
       def id
-        self.name.gsub('::'.freeze,'-'.freeze)
+        name.gsub('::', '-')
       end
     end
 
-    def initialize(request, response=Responses::Ok.new)
+    def initialize(request, response = Responses::Ok.new)
       @request = request
       @response = response
     end
@@ -38,12 +40,11 @@ module Praxis
     end
 
     def media_type
-      if (response_definition = self.request.action.responses[self.response.name])
-        return response_definition.media_type
+      if (response_definition = request.action.responses[response.name])
+        response_definition.media_type
       else
-        self.definition.media_type
+        definition.media_type
       end
     end
-
   end
 end

data/lib/praxis/dispatcher.rb

@@ -1,35 +1,33 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   CONTEXT_FOR = {
-    params: [Attributor::AttributeResolver::ROOT_PREFIX, "params".freeze],
-    headers: [Attributor::AttributeResolver::ROOT_PREFIX, "headers".freeze],
-    payload: [Attributor::AttributeResolver::ROOT_PREFIX, "payload".freeze]
+    params: [Attributor::ROOT_PREFIX, 'params'],
+    headers: [Attributor::ROOT_PREFIX, 'headers'],
+    payload: [Attributor::ROOT_PREFIX, 'payload']
   }.freeze
 
   class Dispatcher
-    attr_reader :controller
-    attr_reader :action
-    attr_reader :request
-    attr_reader :application
+    attr_reader :controller, :action, :request, :application
 
-    @deferred_callbacks = Hash.new do |hash,stage|
-      hash[stage] = {before: [], after:[]}
+    @deferred_callbacks = Hash.new do |hash, stage|
+      hash[stage] = { before: [], after: [] }
     end
 
     class << self
       attr_reader :deferred_callbacks
     end
 
-    def self.before(*stage_path, **conditions, &block)
+    def self.before(*_stage_path, **conditions, &block)
       @deferred_callbacks[:before] << [conditions, block]
     end
 
-    def self.after(*stage_path, **conditions, &block)
+    def self.after(*_stage_path, **conditions, &block)
       @deferred_callbacks[:after] << [conditions, block]
     end
 
     def self.current(thread: Thread.current, application: Application.instance)
-      thread[:praxis_dispatcher] ||= self.new(application: application)
+      thread[:praxis_dispatcher] ||= new(application: application)
     end
 
     def initialize(application: Application.instance)
@@ -43,20 +41,18 @@ module Praxis
       @stages << RequestStages::Validate.new(:validate, self)
       @stages << RequestStages::Action.new(:action, self)
       @stages << RequestStages::Response.new(:response, self)
-      @stages.each do |s|
-        s.setup!
-      end
+      @stages.each(&:setup!)
       setup_deferred_callbacks!
     end
 
     def setup_deferred_callbacks!
       self.class.deferred_callbacks.each do |stage_name, callbacks|
         callbacks[:before].each do |(*stage_path, block)|
-          self.before(stage_name, *stage_path, &block)
+          before(stage_name, *stage_path, &block)
         end
 
         callbacks[:after].each do |(*stage_path, block)|
-          self.after(stage_name, *stage_path, &block)
+          after(stage_name, *stage_path, &block)
         end
       end
     end
@@ -76,38 +72,35 @@ module Praxis
       @action = action
       @request = request
 
-      payload = {request: request, response: nil, controller: @controller}
-
-      instrumented_dispatch( payload )
+      payload = { request: request, response: nil, controller: @controller }
 
+      instrumented_dispatch(payload)
     ensure
       @controller = nil
       @action = nil
       @request = nil
     end
 
-    def instrumented_dispatch( payload )
-      Notifications.instrument 'praxis.request.all'.freeze, payload do
-        begin
-          # the response stage must be the final stage in the list
-          *stages, response_stage = @stages
-
-          stages.each do |stage|
-            result = stage.run
-            case result
-            when Response
-              controller.response = result
-              break
-            end
+    def instrumented_dispatch(payload)
+      Notifications.instrument 'praxis.request.all', payload do
+        # the response stage must be the final stage in the list
+        *stages, response_stage = @stages
+
+        stages.each do |stage|
+          result = stage.run
+          case result
+          when Response
+            controller.response = result
+            break
           end
+        end
 
-          response_stage.run
+        response_stage.run
 
-          payload[:response] = controller.response
-          controller.response.finish
-        rescue => e
-          @application.error_handler.handle!(request, e)
-        end
+        payload[:response] = controller.response
+        controller.response.finish
+      rescue StandardError => e
+        @application.error_handler.handle!(request, e)
       end
     end
 
@@ -116,9 +109,8 @@ module Praxis
       return unless Praxis::Blueprint.caching_enabled?
 
       Praxis::Blueprint.cache = Hash.new do |hash, key|
-        hash[key] = Hash.new
+        hash[key] = {}
       end
     end
-
   end
 end

data/lib/praxis/docs/open_api/info_object.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 module Praxis
   module Docs
     module OpenApi
       class InfoObject
         attr_reader :info, :version
-        def initialize(version: , api_definition_info: )
+
+        def initialize(version:, api_definition_info:)
           @version = version
           @info = api_definition_info
           raise "OpenApi docs require a 'Title' for your API." unless info.title
@@ -11,12 +14,12 @@ module Praxis
 
         def dump
           data = { version: version }
-          [
-            :title,
-            :description,
-            :termsOfService,
-            :contact,
-            :license
+          %i[
+            title
+            description
+            termsOfService
+            contact
+            license
           ].each do |attr|
             val = info.send(attr)
             data[attr] = val if val
@@ -27,7 +30,7 @@ module Praxis
           if info.logo_url
             data[:'x-logo'] = {
               url: info.logo_url,
-              backgroundColor: "#FFFFFF",
+              backgroundColor: '#FFFFFF',
               altText: info.title
             }
           end

data/lib/praxis/docs/open_api/media_type_object.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 module Praxis
   module Docs
     module OpenApi
       class MediaTypeObject
         attr_reader :schema, :example
+
         def initialize(schema:, example:)
           @schema = schema
           @example = example
@@ -10,26 +13,24 @@ module Praxis
 
         def dump
           {
-           schema: schema,
-           example: example,   
-           # encoding: TODO SUPPORT IT maybe be great/necessary for multipart
+            schema: schema,
+            example: example
+            # encoding: TODO SUPPORT IT maybe be great/necessary for multipart
           }
         end
 
         # Helper to create the typical content attribute for responses and request bodies
-        def self.create_content_attribute_helper(type: , example_payload:, example_handlers: nil)
+        def self.create_content_attribute_helper(type:, example_payload:, example_handlers: nil)
           # Will produce 1 example encoded with a given handler (and marking it with the given content type)
-          unless example_handlers
-            example_handlers = [ {'application/json' => 'json' } ] 
-          end
+          example_handlers ||= [{ 'application/json' => 'json' }]
           # NOTE2: we should just create a $ref here unless it's an anon mediatype...
-          return {} if type.is_a? SimpleMediaType           # NOTE: skip if it's a SimpleMediaType?? ... is that correct?
+          return {} if type.is_a? SimpleMediaType # NOTE: skip if it's a SimpleMediaType?? ... is that correct?
 
-          the_schema = if type.anonymous? || ! (type < Praxis::MediaType) # Avoid referencing  custom/simple Types? (i.e., just MTs)
-            SchemaObject.new(info: type).dump_schema
-          else
-            { '$ref': "#/components/schemas/#{type.id}" }
-          end
+          the_schema = if type.anonymous? || !(type < Praxis::MediaType) # Avoid referencing  custom/simple Types? (i.e., just MTs)
+                         SchemaObject.new(info: type).dump_schema(shallow: false, allow_ref: false)
+                       else
+                         SchemaObject.new(info: type).dump_schema(shallow: true, allow_ref: true)
+                       end
 
           if example_payload
             examples_by_content_type = {}
@@ -40,16 +41,16 @@ module Praxis
               handler = Praxis::Application.instance.handlers[handler_name]
               # ReDoc is not happy to display json generated outputs when served as JSON...wtf?
               generated = handler.generate(rendered_payload)
-              final = ( handler_name == 'json') ? JSON.parse(generated) : generated
+              final = handler_name == 'json' ? JSON.parse(generated) : generated
               examples_by_content_type[content_type] = final
             end
           end
 
           # Key string (of MT) , value MTObject
-          content_hash = examples_by_content_type.each_with_object({}) do |(content_type, example_hash),accum|
-            accum[content_type] = MediaTypeObject.new(
+          examples_by_content_type.transform_values do |example_hash|
+            MediaTypeObject.new(
               schema: the_schema, # Every MT will have the same exact type..oh well .. maybe a REF?
-              example: example_hash,
+              example: example_hash
             ).dump
           end
         end

data/lib/praxis/docs/open_api/operation_object.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'parameter_object'
 require_relative 'request_body_object'
 require_relative 'responses_object'
@@ -8,6 +10,7 @@ module Praxis
       class OperationObject
         # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#operation-object
         attr_reader :id, :url, :action, :tags
+
         def initialize(id:, url:, action:, tags:)
           @id = id
           @url = url
@@ -20,18 +23,18 @@ module Praxis
           all_tags = tags + action.traits
           h = {
             summary: action.name.to_s,
-            description: action.description,
-            #externalDocs: {}, # TODO/FIXME
+            # externalDocs: {}, # TODO/FIXME
             operationId: id,
-            responses: ResponsesObject.new(responses: action.responses).dump, 
+            responses: ResponsesObject.new(responses: action.responses).dump
             # callbacks
             # deprecated: false
             # security: [{}]
             # servers: [{}]
           }
+          h[:description] = action.description if action.description
           h[:tags] = all_tags.uniq unless all_tags.empty?
           h[:parameters] = all_parameters unless all_parameters.empty?
-          h[:requestBody] = RequestBodyObject.new(attribute: action.payload ).dump if action.payload
+          h[:requestBody] = RequestBodyObject.new(attribute: action.payload).dump if action.payload
           h
         end
       end