praxis 2.0.pre.18 → 2.0.pre.19

data/lib/praxis/dispatcher.rb

@@ -1,35 +1,33 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   CONTEXT_FOR = {
-    params: [Attributor::ROOT_PREFIX, "params".freeze],
-    headers: [Attributor::ROOT_PREFIX, "headers".freeze],
-    payload: [Attributor::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
+                       else
+                         { '$ref': "#/components/schemas/#{type.id}" }
+                       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
@@ -21,9 +24,9 @@ module Praxis
           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: [{}]
@@ -31,7 +34,7 @@ module Praxis
           }
           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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'schema_object'
 
 module Praxis
@@ -6,7 +8,8 @@ module Praxis
       class ParameterObject
         # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#parameter-object
         attr_reader :location, :name, :is_required, :info
-        def initialize(location: , name:, is_required:,  info:)
+
+        def initialize(location:, name:, is_required:, info:)
           @location = location
           @name = name
           @info = info
@@ -25,39 +28,39 @@ module Praxis
           # style
           # explode
           # allowReserved
-          
+
           # Now merge the rest schema and example
           # schema
           # example
           # examples (Example and Examples are mutually exclusive)
           schema = SchemaObject.new(info: info)
           h[:schema] = schema.dump_schema
-          # Note: we do not support the 'content' key...we always use schema
+          # NOTE: we do not support the 'content' key...we always use schema
           h[:example] = schema.dump_example
           h
         end
 
-        def self.process_parameters( action )
+        def self.process_parameters(action)
           output = []
-          # An array, with one hash per param inside  
+          # An array, with one hash per param inside
           if action.headers
-            (action.headers.attributes||{}).each_with_object(output) do |(name, info), out|
-              out << ParameterObject.new( location: 'header', name: name, is_required: info.options[:required], info: info ).dump
+            (action.headers.attributes || {}).each_with_object(output) do |(name, info), out|
+              out << ParameterObject.new(location: 'header', name: name, is_required: info.options[:required], info: info).dump
             end
           end
-  
+
           if action.params
             route_params = \
-              unless action.route
+              if action.route
+                action.route.path.named_captures.keys.collect(&:to_sym)
+              else
                 warn "Warning: No routes defined for action #{action.name}"
                 []
-              else
-                action.route.path.named_captures.keys.collect(&:to_sym)
               end
-            (action.params.attributes||{}).each_with_object(output) do |(name, info), out|
+            (action.params.attributes || {}).each_with_object(output) do |(name, info), out|
               in_type = route_params.include?(name) ? :path : :query
-              is_required = (in_type == :path ) ? true : info.options[:required]
-              out << ParameterObject.new( location: in_type, name: name, is_required: is_required, info: info ).dump
+              is_required = in_type == :path ? true : info.options[:required]
+              out << ParameterObject.new(location: in_type, name: name, is_required: is_required, info: info).dump
             end
           end
 

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

@@ -1,10 +1,13 @@
-require_relative 'operation_object.rb'
+# frozen_string_literal: true
+
+require_relative 'operation_object'
 module Praxis
   module Docs
     module OpenApi
       class PathsObject
         # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#paths-object
         attr_reader :resources, :paths
+
         def initialize(resources:)
           @resources = resources
           # A hash with keys of paths, and values of hash
@@ -15,18 +18,17 @@ module Praxis
           #       "post": { ...}
           #   "/humans": {
           #       "get": {...},
-          @paths = Hash.new {|h,k| h[k] = {} }
+          @paths = Hash.new { |h, k| h[k] = {} }
         end
 
-
         def dump
           resources.each do |resource|
-            compute_resource_paths( resource )
+            compute_resource_paths(resource)
           end
           paths
         end
 
-        def compute_resource_paths( resource )
+        def compute_resource_paths(resource)
           id = resource.id
           # fill in the paths hash with a key for each path for each action/route
           resource.actions.each do |action_name, action|
@@ -38,15 +40,15 @@ module Praxis
             path_entry = paths[templetized_path]
             # Let's fill in verb stuff within the working hash
             raise "VERB #{_verb} already defined for #{id}!?!?!" if path_entry[verb]
-            
+
             action_uid = "action-#{action_name}-#{id}"
             # Add a tag matching the resource name (hoping all actions of a resource are grouped)
             action_tags = [resource.display_name]
-            path_entry[verb] = OperationObject.new( id: action_uid, url: url, action: action, tags: action_tags).dump
+            path_entry[verb] = OperationObject.new(id: action_uid, url: url, action: action, tags: action_tags).dump
           end
-          # For each path, we can further annotate with 
+          # For each path, we can further annotate with
           # servers
-          # parameters 
+          # parameters
           # But we don't have that concept in praxis
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'schema_object'
 
 module Praxis
@@ -5,7 +7,8 @@ module Praxis
     module OpenApi
       class RequestBodyObject
         # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#request-body-object
-        attr_reader :attribute 
+        attr_reader :attribute
+
         def initialize(attribute:)
           @attribute = attribute
         end
@@ -18,18 +21,18 @@ module Praxis
           # OpenApi wants a set of bodies per MediaType/Content-Type
           # For us there's really only one schema (regardless of encoding)...
           # so we'll show all the supported MTs...but repeating the schema
-          #dumped_schema = SchemaObject.new(info: attribute).dump_schema
+          # dumped_schema = SchemaObject.new(info: attribute).dump_schema
 
           example_handlers = if attribute.type < Praxis::Types::MultipartArray
-            ident = MediaTypeIdentifier.load('multipart/form-data')
-            [{ident.to_s => 'plain'}] # Multipart content type, but with the plain renderer (so there's no modification)
-          else
-            # TODO: We could run it through other handlers I guess...if they're registered
-            [{'application/json' => 'json'}]
-          end
-          
-          h[:content] = MediaTypeObject.create_content_attribute_helper(type: attribute.type, 
-                                                                        example_payload: attribute.example(nil), 
+                               ident = MediaTypeIdentifier.load('multipart/form-data')
+                               [{ ident.to_s => 'plain' }] # Multipart content type, but with the plain renderer (so there's no modification)
+                             else
+                               # TODO: We could run it through other handlers I guess...if they're registered
+                               [{ 'application/json' => 'json' }]
+                             end
+
+          h[:content] = MediaTypeObject.create_content_attribute_helper(type: attribute.type,
+                                                                        example_payload: attribute.example(nil),
                                                                         example_handlers: example_handlers)
           # # Key string (of MT) , value MTObject
           # content_hash = info[:examples].each_with_object({}) do |(handler, example_hash),accum|
@@ -43,8 +46,6 @@ module Praxis
           # h[:content] = content_hash
           h
         end
-
-        
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'media_type_object'
 
 module Praxis
@@ -6,33 +8,39 @@ module Praxis
       class ResponseObject
         # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#response-object
         attr_reader :info
+
         def initialize(info:)
           @info = info
           default_handlers = ApiDefinition.instance.info.produces
-          @output_handlers = Praxis::Application.instance.handlers.select do |k,v|
+          @output_handlers = Praxis::Application.instance.handlers.select do |k, _v|
             default_handlers.include?(k)
           end
         end
 
-        def dump_response_headers_object( headers )
-          headers.each_with_object({}) do |(name,data),accum|
-            # each header comes from Praxis::ResponseDefinition 
+        def dump_response_headers_object(headers)
+          headers.each_with_object({}) do |(name, data), accum|
+            # each header comes from Praxis::ResponseDefinition
             # the keys are the header names, and value can be:
             #  "true"  => means it only needs to exist
             #  String => which means that it has to fully match
             #  Regex  => which means it has to regexp match it
 
             # Get the schema from the type (defaulting to string in case the type doesn't have the as_json_schema defined)
-            schema = data[:attribute].type.as_json_schema rescue { type: :string }
+            schema = begin
+              data[:attribute].type.as_json_schema
+            rescue StandardError
+              { type: :string }
+            end
             hash = { description: data[:description] || '', schema: schema }
-            # Note, our Headers in response definition are not full types...they're basically only 
+            # Note, our Headers in response definition are not full types...they're basically only
             # strings, which can either match anything, match the exact word or match a regex
             # they don't even have a description...
             data_value = data[:value]
-            if data_value.is_a? String
+            case data_value
+            when String
               hash[:pattern] = "^#{data_value}$" # Exact String match
-            elsif data_value.is_a? Regexp
-              sanitized_pattern = data_value.inspect[1..-2] #inspect returns enclosing '/' characters
+            when Regexp
+              sanitized_pattern = data_value.inspect[1..-2] # inspect returns enclosing '/' characters
               hash[:pattern] = sanitized_pattern
             end
 
@@ -41,10 +49,10 @@ module Praxis
         end
 
         def dump
-          data = { 
+          data = {
             description: info.description || ''
           }
-          if headers_object = dump_response_headers_object( info.headers )
+          if (headers_object = dump_response_headers_object(info.headers))
             data[:headers] = headers_object
           end
 
@@ -52,12 +60,13 @@ module Praxis
 
             identifier = MediaTypeIdentifier.load(info.media_type.identifier)
             example_handlers = @output_handlers.each_with_object([]) do |(name, _handler), accum|
-              accum.push({ (identifier + name).to_s => name})
+              accum.push({ (identifier + name).to_s => name })
             end
             data[:content] = MediaTypeObject.create_content_attribute_helper(
-                                                                            type: info.media_type, 
-                                                                            example_payload: info.example(nil),
-                                                                            example_handlers: example_handlers)
+              type: info.media_type,
+              example_payload: info.example(nil),
+              example_handlers: example_handlers
+            )
           end
 
           # if payload = info[:payload]
@@ -66,12 +75,9 @@ module Praxis
           #   data[:schema] = {"$ref" => "#/definitions/#{body_type}" }
           # end
 
-          
           # TODO: we do not support 'links'
           data
         end
-
-        
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'response_object'
 
 module Praxis
@@ -6,11 +8,11 @@ module Praxis
       class ResponsesObject
         # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#responses-object
         attr_reader :responses
+
         def initialize(responses:)
           @responses = responses
         end
 
-
         def dump
           # {
           #   "200": {

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

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 module Praxis
   module Docs
     module OpenApi
       class SchemaObject
         # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#schema-object
         attr_reader :type, :attribute
+
         def initialize(info:)
-          #info could be an attribute ... or a type?
+          # info could be an attribute ... or a type?
           if info.is_a? Attributor::Attribute
             @attribute = info
           else
@@ -29,7 +32,7 @@ module Praxis
           else
             type.as_json_schema(shallow: true, example: nil)
           end
-          # # TODO: FIXME: return a generic object type if the passed info was weird. 
+          # # TODO: FIXME: return a generic object type if the passed info was weird.
           # return { type: :object } unless info
 
           # h = {
@@ -41,7 +44,7 @@ module Praxis
           # h[:default] = info[:default] if info[:default]
           # h[:pattern] = info[:regexp] if info[:regexp]
           # # TODO: there are other possible things we can do..maximum, minimum...etc
-  
+
           # if h[:type] == :array
           #   # FIXME: ... hack it for MultiPart arrays...where there's no member attr
           #   member_type =  info[:type][:member_attribute]
@@ -51,27 +54,25 @@ module Praxis
           #   h[:items] = SchemaObject.new(info: member_type ).dump_schema
           # end
           # h
-        rescue => e
+        rescue StandardError => e
           puts "Error dumping schema #{e}"
         end
-        
-        def convert_family_to_json_type( praxis_type )
+
+        def convert_family_to_json_type(praxis_type)
           case praxis_type[:family].to_sym
           when :string
             :string
           when :hash
             :object
-          when :array #Warning! Multipart types are arrays!
+          when :array # Warning! Multipart types are arrays!
             :array
           when :numeric
-            case praxis_type[:id]
-            when 'Attributor-Integer'
-              :integer
-            when 'Attributor-BigDecimal'
-              :integer
-            when 'Attributor-Float'
-              :number
-            end
+            jtypes = {
+              'Attributor-Integer' => :integer,
+              'Attributor-BigDecimal' => :integer,
+              'Attributor-Float' => :number
+            }
+            jtypes[praxis_type[:id]]
           when :temporal
             :string
           when :boolean
@@ -80,7 +81,6 @@ module Praxis
             raise "Unknown praxis family type: #{praxis_type[:family]}"
           end
         end
-
       end
     end
   end