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

data/lib/praxis/plugins/mapper_plugin.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'singleton'
 
 require 'praxis/extensions/field_selection'
 
-module Praxis  
+module Praxis
   module Plugins
     module MapperPlugin
       include Praxis::PluginConcern
@@ -15,7 +17,7 @@ module Praxis
       #
       # The plugin accepts only 1 configuration option thus far, which you can set inside the same block as:
       #   application.config.mapper.debug_queries = true
-      # when debug_queries is set to true, the system will output information about the expanded fields 
+      # when debug_queries is set to true, the system will output information about the expanded fields
       # and associations that the system ihas calculated necessary to pull from the DB, based on the requested
       # API fields, API filters and `property` dependencies defined in the domain models (i.e., resources)
       class Plugin < Praxis::Plugin
@@ -32,7 +34,7 @@ module Praxis
         def prepare_config!(node)
           node.attributes do
             attribute :debug_queries, Attributor::Boolean, default: false,
-              description: 'Weather or not to log debug information about queries executed in the build_query automation module'
+                                                           description: 'Weather or not to log debug information about queries executed in the build_query automation module'
           end
         end
       end
@@ -45,27 +47,27 @@ module Praxis
           include Praxis::Extensions::FieldExpansion
         end
 
-        def build_query(base_query) # rubocop:disable Metrics/AbcSize
-          domain_model = self.media_type&.domain_model
-          raise "No domain model defined for #{self.name}. Cannot use the attribute filtering helpers without it" unless domain_model
-          
-          filters = request.params.filters if request.params&.respond_to?(:filters)
+        def build_query(base_query)
+          domain_model = media_type&.domain_model
+          raise "No domain model defined for #{name}. Cannot use the attribute filtering helpers without it" unless domain_model
+
+          filters = request.params.filters if request.params.respond_to?(:filters)
           # Handle filters
-          base_query = domain_model.craft_filter_query( base_query , filters: filters )
+          base_query = domain_model.craft_filter_query(base_query, filters: filters)
           # Handle field and nested field selection
           base_query = domain_model.craft_field_selection_query(base_query, selectors: selector_generator.selectors)
           # handle pagination and ordering if the pagination extention is included
-          base_query = domain_model.craft_pagination_query(base_query, pagination: _pagination)  if self.respond_to?(:_pagination)
+          base_query = domain_model.craft_pagination_query(base_query, pagination: _pagination) if respond_to?(:_pagination)
 
           base_query
         end
 
         def selector_generator
-          return unless self.media_type.respond_to?(:domain_model) &&
-            self.media_type.domain_model < Praxis::Mapper::Resource
+          return unless media_type.respond_to?(:domain_model) &&
+                        media_type.domain_model < Praxis::Mapper::Resource
 
           @selector_generator ||= \
-            Praxis::Mapper::SelectorGenerator.new.add(self.media_type.domain_model, self.expanded_fields)
+            Praxis::Mapper::SelectorGenerator.new.add(media_type.domain_model, expanded_fields)
         end
       end
     end

data/lib/praxis/plugins/pagination_plugin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 require 'praxis/extensions/pagination'
 
@@ -6,7 +8,7 @@ require 'praxis/extensions/pagination'
 # When combined with the MapperPlugin, there is no extra configuration that needs to be done for
 # the system to appropriately identify the pagination and order parameters in the API, and translate
 # that in to the appropriate queries to fetch.
-# 
+#
 # To use this plugin without the MapperPlugin (probably a rare case), one can apply the appropriate
 # clauses onto a query, by directly calling (in the controller) the `craft_pagination_query` method
 # of the domain_model associated to the controller's mediatype.
@@ -17,7 +19,7 @@ require 'praxis/extensions/pagination'
 #   objs = domain_model.craft_pagination_query(base_query, pagination: _pagination)
 #   display(objs)
 # end
-# 
+#
 # This plugin accepts configuration about the default behavior of pagination.
 # Any of these configs can individually be overidden when defining each Pagination/Order parameters
 # in any of the Endpoint actions.
@@ -33,12 +35,12 @@ require 'praxis/extensions/pagination'
 #     disallow_paging_by_default: true, # Default false
 #     # Disallows the use of the cursor type pagination mode when true (i.e., using 'by=' or 'from=' parameter)
 #     disallow_cursor_by_default: true, # Default false
-#     # The default mode params to use 
+#     # The default mode params to use
 #     paging_default_mode: {by: :uuid}, # Default {by: :uid}
 #     # Weather or not to enforce that all requested sort fields are part of the media_type attributes
 #     # when false (not enforced) only the first field would be checked
 #     sorting: {
-#       enforce_all_fields: false       # Default true 
+#       enforce_all_fields: false       # Default true
 #     }
 #   end
 # end
@@ -77,7 +79,7 @@ module Praxis
         end
 
         def setup!
-          self.config.each do |name, val|
+          config.each do |name, val|
             if name == :sorting
               val.each do |ordername, orderval|
                 Praxis::Types::OrderingParams.send(ordername, orderval)
@@ -85,7 +87,7 @@ module Praxis
             else
               Praxis::Types::PaginationParams.send(name, val)
             end
-          end      
+          end
         end
       end
 

data/lib/praxis/plugins/rails_plugin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'praxis/plugin'
 require 'praxis/plugin_concern'
 
@@ -7,40 +9,42 @@ module Praxis
       include Praxis::PluginConcern
 
       class Plugin < Praxis::Plugin
-
         def setup!
           require 'praxis/dispatcher'
           enable_action_controller_instrumentation
         end
 
         private
+
         def enable_action_controller_instrumentation
           Praxis::Dispatcher.class_eval do
             # Wrap the original action dispatch with a method that instruments rails-expected bits...
             alias_method :orig_instrumented_dispatch, :instrumented_dispatch
 
-            def instrumented_dispatch( praxis_payload )
+            def instrumented_dispatch(praxis_payload)
               rails_payload = {
-                :controller => controller.class.name,
-                :action     => action.name,
-                :params     => ( (request.params) ? request.params.dump : {} ),
-                :method     => request.verb,
-                :path       => (request.fullpath rescue "unknown")
+                controller: controller.class.name,
+                action: action.name,
+                params: (request.params ? request.params.dump : {}),
+                method: request.verb,
+                path: begin
+                  request.fullpath
+                rescue StandardError
+                  'unknown'
+                end
               }
-              Praxis::Notifications.instrument("start_processing.action_controller", rails_payload.dup)
+              Praxis::Notifications.instrument('start_processing.action_controller', rails_payload.dup)
 
               Praxis::Notifications.instrument 'process_action.action_controller' do |data|
-                begin
-                  res = orig_instrumented_dispatch(praxis_payload)
-                  # TODO: also add the db_runtime and view_runtime values...
-                  data[:status] = res[0]
-                  res
-                ensure
-                  # Append DB runtime to payload
-                  #data[:db_runtime] = 999
-                  # Append rendering time to payload
-                  #data[:view_runtime] = 123
-                end
+                res = orig_instrumented_dispatch(praxis_payload)
+                # TODO: also add the db_runtime and view_runtime values...
+                data[:status] = res[0]
+                res
+
+                # Append DB runtime to payload
+                # data[:db_runtime] = 999
+                # Append rendering time to payload
+                # data[:view_runtime] = 123
               end
             end
           end
@@ -59,30 +63,33 @@ module Praxis
         # Avoid using them explicitly in your controllers though. Use request.params object instead, as they are
         # the Praxis ones that have been validated and coerced into the types you've defined.
         def params
-          self.request.parameters
+          request.parameters
         end
 
         # Allow accessing the response headers from the controller
         def headers
-          self.response.headers
+          response.headers
         end
 
         def session
-          self.request.session
+          request.session
         end
 
         # Allow setting the status and body of the response from the controller itself.
         def status=(code)
-          self.response.status = code
+          response.status = code
         end
 
         def response_body=(body)
-          #TODO: @_rendered = true # Necessary to know if to stop filter chain or not...
-          self.response.body = body
+          # TODO: @_rendered = true # Necessary to know if to stop filter chain or not...
+          response.body = body
         end
 
         def head(status, options = {})
-          options, status = status, nil if status.is_a?(Hash)
+          if status.is_a?(Hash)
+            options = status
+            status = nil
+          end
           status ||= options.delete(:status) || :ok
           location = options.delete(:location)
           content_type = options.delete(:content_type)
@@ -96,9 +103,7 @@ module Praxis
           response.content_type = content_type if content_type
           response
         end
-
       end
-
     end
   end
 end

data/lib/praxis/renderer.rb

@@ -2,12 +2,10 @@
 
 module Praxis
   class Renderer
-    attr_reader :include_nil
-    attr_reader :cache
+    attr_reader :include_nil, :cache
 
     class CircularRenderingError < StandardError
-      attr_reader :object
-      attr_reader :context
+      attr_reader :object, :context
 
       def initialize(object, context)
         @object = object
@@ -35,18 +33,16 @@ module Praxis
     def render(object, fields, context: Attributor::DEFAULT_ROOT_CONTEXT)
       if object.is_a? Praxis::Blueprint
         @cache[object._cache_key][fields] ||= _render(object, fields, context: context)
-      else
-        if object.class < Attributor::Collection
-          object.each_with_index.collect do |sub_object, i|
-            sub_context = context + ["at(#{i})"]
-            render(sub_object, fields, context: sub_context)
-          end
-        else
-          _render(object, fields, context: context)
+      elsif object.class < Attributor::Collection
+        object.each_with_index.collect do |sub_object, i|
+          sub_context = context + ["at(#{i})"]
+          render(sub_object, fields, context: sub_context)
         end
+      else
+        _render(object, fields, context: context)
       end
     rescue SystemStackError
-      raise CircularRenderingError.new(object, context)      
+      raise CircularRenderingError.new(object, context)
     end
 
     def _render(object, fields, context: Attributor::DEFAULT_ROOT_CONTEXT)
@@ -62,12 +58,12 @@ module Praxis
       fields.each_with_object({}) do |(key, subfields), hash|
         begin
           value = object._get_attr(key)
-        rescue => e
+        rescue StandardError => e
           raise Attributor::DumpError.new(context: context, name: key, type: object.class, original_exception: e)
         end
 
         if value.nil?
-          hash[key] = nil if self.include_nil
+          hash[key] = nil if include_nil
           next
         end
 

data/lib/praxis/request.rb

@@ -1,18 +1,19 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   class Request < Praxis.request_superclass
     attr_reader :env, :query
-    attr_accessor :route_params, :action
-
-    PATH_VERSION_PREFIX = "/v".freeze
-    CONTENT_TYPE_NAME = 'CONTENT_TYPE'.freeze
-    PATH_INFO_NAME = 'PATH_INFO'.freeze
-    REQUEST_METHOD_NAME = 'REQUEST_METHOD'.freeze
-    QUERY_STRING_NAME = 'QUERY_STRING'.freeze
-    API_VERSION_HEADER_NAME = "HTTP_X_API_VERSION".freeze
-    API_VERSION_PARAM_NAME = 'api_version'.freeze
-    API_NO_VERSION_NAME = 'n/a'.freeze
-    VERSION_USING_DEFAULTS = [:header, :params].freeze
+    attr_accessor :route_params, :action, :headers, :params, :payload
+
+    PATH_VERSION_PREFIX = '/v'
+    CONTENT_TYPE_NAME = 'CONTENT_TYPE'
+    PATH_INFO_NAME = 'PATH_INFO'
+    REQUEST_METHOD_NAME = 'REQUEST_METHOD'
+    QUERY_STRING_NAME = 'QUERY_STRING'
+    API_VERSION_HEADER_NAME = 'HTTP_X_API_VERSION'
+    API_VERSION_PARAM_NAME = 'api_version'
+    API_NO_VERSION_NAME = 'n/a'
+    VERSION_USING_DEFAULTS = %i[header params].freeze
 
     def initialize(env)
       @env = env
@@ -45,10 +46,9 @@ module Praxis
       @env[PATH_INFO_NAME]
     end
 
-    attr_accessor :headers, :params, :payload
-
     def params_hash
       return {} if params.nil?
+
       params.attributes
     end
 
@@ -65,17 +65,15 @@ module Praxis
     end
 
     def raw_payload
-      @raw_payload ||= begin
-        if (input = env['rack.input'.freeze].read)
-          env['rack.input'.freeze].rewind
-          input
-        end
-      end
+      @raw_payload ||= if (input = env['rack.input'].read)
+                         env['rack.input'].rewind
+                         input
+                       end
     end
 
     def coalesce_inputs!
-      self.raw_params
-      self.raw_payload
+      raw_params
+      raw_payload
     end
 
     def self.path_version_prefix
@@ -83,14 +81,14 @@ module Praxis
     end
 
     # DEPRECATED: remove with EndpointDefinition.version using: :path
-    PATH_VERSION_MATCHER = %r{^#{self.path_version_prefix}(?<version>[^\/]+)\/}.freeze
+    PATH_VERSION_MATCHER = %r{^#{path_version_prefix}(?<version>[^/]+)/}.freeze
 
     def path_version_matcher
       if Application.instance.versioning_scheme == :path
-        matcher = Mustermann.new(ApiDefinition.instance.info.base_path + '*')
-        matcher.params(self.path)[API_VERSION_PARAM_NAME]
+        matcher = Mustermann.new("#{ApiDefinition.instance.info.base_path}*")
+        matcher.params(path)[API_VERSION_PARAM_NAME]
       else
-        PATH_VERSION_MATCHER.match(self.path)[:version]
+        PATH_VERSION_MATCHER.match(path)[:version]
       end
     end
 
@@ -99,30 +97,32 @@ module Praxis
 
       Array(Application.instance.versioning_scheme).find do |mode|
         case mode
-        when :header;
+        when :header
           result = env[API_VERSION_HEADER_NAME]
-        when :params;
+        when :params
           result = @query[API_VERSION_PARAM_NAME]
-        when :path;
-          result = self.path_version_matcher
+        when :path
+          result = path_version_matcher
         else
           raise "Unknown method for retrieving the API version: #{mode}"
         end
       end
-      return result || API_NO_VERSION_NAME
+      result || API_NO_VERSION_NAME
     end
 
     def load_headers(context)
       return unless action.headers
-      defined_headers = action.precomputed_header_keys_for_rack.each_with_object(Hash.new) do |(upper, original), hash|
-        hash[original] = self.env[upper] if self.env.has_key? upper
+
+      defined_headers = action.precomputed_header_keys_for_rack.each_with_object({}) do |(upper, original), hash|
+        hash[original] = env[upper] if env.key? upper
       end
       self.headers = action.headers.load(defined_headers, context)
     end
 
     def load_params(context)
       return unless action.params
-      self.params = action.params.load(self.raw_params, context)
+
+      self.params = action.params.load(raw_params, context)
     end
 
     def load_payload(context)
@@ -130,11 +130,11 @@ module Praxis
       return if content_type.nil?
 
       raw = if (handler = Praxis::Application.instance.handlers[content_type.handler_name])
-        handler.parse(self.raw_payload)
-      else
-        # TODO is this a good default?
-        self.raw_payload
-      end
+              handler.parse(raw_payload)
+            else
+              # TODO: is this a good default?
+              raw_payload
+            end
 
       self.payload = action.payload.load(raw, context, content_type: content_type.to_s)
     end
@@ -142,24 +142,25 @@ module Praxis
     def validate_headers(context)
       return [] unless action.headers
 
-      return ["Attribute #{Attributor.humanize_context(context)} is required."] if action.headers.options[:required] == true && self.headers.nil?
+      return ["Attribute #{Attributor.humanize_context(context)} is required."] if action.headers.options[:required] == true && headers.nil?
 
-      action.headers.validate(self.headers, context)
+      action.headers.validate(headers, context)
     end
 
     def validate_params(context)
       return [] unless action.params
 
-      return ["Attribute #{Attributor.humanize_context(context)} is required."] if action.params.options[:required] == true && self.params.nil?
+      return ["Attribute #{Attributor.humanize_context(context)} is required."] if action.params.options[:required] == true && params.nil?
 
-      action.params.validate(self.params, context)
+      action.params.validate(params, context)
     end
 
     def validate_payload(context)
       return [] unless action.payload
 
-      return ["Attribute #{Attributor.humanize_context(context)} is required."] if action.payload.options[:required] == true && self.payload.nil?
-      action.payload.validate(self.payload, context)
+      return ["Attribute #{Attributor.humanize_context(context)} is required."] if action.payload.options[:required] == true && payload.nil?
+
+      action.payload.validate(payload, context)
     end
 
     # versions that matched all the conditions of the request (except its version)
@@ -172,7 +173,5 @@ module Praxis
     def inspect
       "'@env' => #{@env.inspect},\n'@headers' => #{@headers.inspect},\n'@params' => #{@params.inspect},\n'@query' => #{@query.inspect}"
     end
-
   end
-
 end

data/lib/praxis/request_stages/action.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 module Praxis
   module RequestStages
-
     class Action < RequestStage
-
       def execute
-        response = Notifications.instrument 'praxis.request_stage.execute'.freeze, controller: controller do
-          if controller.method(action.name).arity == 0
+        response = Notifications.instrument 'praxis.request_stage.execute', controller: controller do
+          if controller.method(action.name).arity.zero?
             controller.__send__(action.name)
           else
             controller.__send__(action.name, **request.params_hash)
@@ -23,8 +23,6 @@ module Praxis
         controller.response.request = request
         nil # Action cannot return its OK request, as it would indicate the end of the stage chain
       end
-
     end
-
   end
 end

data/lib/praxis/request_stages/load_request.rb

@@ -1,13 +1,11 @@
+# frozen_string_literal: true
+
 module Praxis
   module RequestStages
-
     class LoadRequest < RequestStage
-
       def execute
         request.coalesce_inputs!
       end
-
     end
-
   end
 end

data/lib/praxis/request_stages/request_stage.rb

@@ -1,25 +1,24 @@
+# frozen_string_literal: true
+
 module Praxis
   module RequestStages
-
     # Special Stage what will hijack the run and execute methods to:
     # 1- Run specific controller callbacks (in addition to any normal callbacks)
     # 2- Shortcut the controller callback chain if any returns a Response object
     class RequestStage < Stage
-
-      alias :dispatcher :application # it's technically application in the base Stage
+      alias dispatcher application # it's technically application in the base Stage
 
       def path
-        @the_path ||= [name].freeze
+        @path ||= [name].freeze
       end
 
       def execute_controller_callbacks(callbacks)
         if callbacks.key?(path)
           callbacks[path].each do |(conditions, block)|
-            if conditions.key?(:actions)
-              next unless conditions[:actions].include? action.name
-            end
+            next if conditions.key?(:actions) && !(conditions[:actions].include? action.name)
+
             result = block.call(controller)
-            if result && result.kind_of?(Praxis::Response)
+            if result.is_a?(Praxis::Response)
               controller.response = result
               return result
             end
@@ -51,7 +50,7 @@ module Praxis
 
       def run
         # stage-level callbacks (typically empty) will never shortcut
-        execute_callbacks(self.before_callbacks)
+        execute_callbacks(before_callbacks)
 
         r = execute_controller_callbacks(controller.class.before_callbacks)
         # Shortcut lifecycle if filters return non-nil value
@@ -61,7 +60,7 @@ module Praxis
         result = execute_with_around
         # Shortcut lifecycle if filters return a response
         # (non-nil but non-response-class response is ignored)
-        if result && result.kind_of?(Praxis::Response)
+        if result.is_a?(Praxis::Response)
           controller.response = result
           return result
         end
@@ -72,52 +71,49 @@ module Praxis
         return r if r
 
         # stage-level callbacks (typically empty) will never shortcut
-        execute_callbacks(self.after_callbacks)
+        execute_callbacks(after_callbacks)
 
         result
       end
 
       def execute_with_around
-        cb = controller.class.around_callbacks[ path ]
-        if cb == nil || cb.empty?
+        cb = controller.class.around_callbacks[path]
+        if cb.nil? || cb.empty?
           execute
         else
           inner_proc = proc { execute }
 
-          applicable = cb.select do |(conditions, handler)|
-            if conditions.has_key?(:actions)
-              (conditions[:actions].include? action.name) ? true : false
+          applicable = cb.select do |(conditions, _handler)|
+            if conditions.key?(:actions)
+              conditions[:actions].include?(action.name) ? true : false
             else
               true
             end
           end
 
-          chain = applicable.reverse.inject(inner_proc) do |blk, (conditions, handler)|
+          chain = applicable.reverse.inject(inner_proc) do |blk, (_conditions, handler)|
             if blk
-              proc{ handler.call(controller,blk) }
+              proc { handler.call(controller, blk) }
             else
-              proc{ handler.call }
+              proc { handler.call }
             end
           end
           chain.call
         end
       end
 
-
       def execute
         raise NotImplementedError, 'Subclass must implement Stage#execute' unless @stages.any?
 
         @stages.each do |stage|
           shortcut = stage.run
-          if shortcut && shortcut.kind_of?(Praxis::Response)
+          if shortcut.is_a?(Praxis::Response)
             controller.response = shortcut
             return shortcut
           end
         end
         nil
       end
-
     end
-
   end
 end

data/lib/praxis/request_stages/response.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
+
 module Praxis
   module RequestStages
-
     class Response < RequestStage
-
       def execute
         response = controller.response
 
@@ -15,16 +15,14 @@ module Praxis
         end
       rescue Exceptions::Validation => e
         controller.response = validation_handler.handle!(
-          summary: "Error validating response", 
+          summary: 'Error validating response',
           exception: e,
           request: request,
-          stage: name, 
+          stage: name,
           errors: e.errors
         )
         retry
       end
-
     end
-
   end
 end