praxis 2.0.pre.17 → 2.0.pre.21

data/lib/praxis/request_stages/validate.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 module Praxis
   module RequestStages
-
     class Validate < RequestStage
-
-      def initialize(name, context,**opts)
+      def initialize(name, context, **opts)
         super
         # Add our sub-stages
         @stages = [
@@ -11,8 +11,6 @@ module Praxis
           RequestStages::ValidatePayload.new(:payload, context, parent: self)
         ]
       end
-
     end
-
   end
 end

data/lib/praxis/request_stages/validate_params_and_headers.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Praxis
   module RequestStages
-
     class ValidateParamsAndHeaders < RequestStage
       attr_reader :parent
 
@@ -10,14 +11,14 @@ module Praxis
       end
 
       def path
-        @_path ||= ( @parent.path + [name] )
+        @path ||= (@parent.path + [name])
       end
 
       def execute
         begin
           request.load_headers(CONTEXT_FOR[:headers])
-        rescue => e
-          message = "Error loading headers."
+        rescue StandardError => e
+          message = 'Error loading headers.'
           return validation_handler.handle!(
             exception: e,
             summary: message,
@@ -29,7 +30,7 @@ module Praxis
         begin
           request.load_params(CONTEXT_FOR[:params])
         rescue Attributor::AttributorException => e
-          message = "Error loading params."
+          message = 'Error loading params.'
           return validation_handler.handle!(
             exception: e,
             summary: message,
@@ -38,26 +39,18 @@ module Praxis
           )
         end
 
-        attribute_resolver = Attributor::AttributeResolver.new
-        Attributor::AttributeResolver.current = attribute_resolver
-
-        attribute_resolver.register("headers",request.headers)
-        attribute_resolver.register("params",request.params)
-
         errors = request.validate_headers(CONTEXT_FOR[:headers])
         errors += request.validate_params(CONTEXT_FOR[:params])
-        if errors.any?
-          message = "Error validating request data."
-          return validation_handler.handle!(
-            summary: message,
-            errors: errors,
-            request: request,
-            stage: name
-          )
-        end
+        return unless errors.any?
+
+        message = 'Error validating request data.'
+        validation_handler.handle!(
+          summary: message,
+          errors: errors,
+          request: request,
+          stage: name
+        )
       end
-
     end
-
   end
 end

data/lib/praxis/request_stages/validate_payload.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
+
 module Praxis
   module RequestStages
-
     class ValidatePayload < RequestStage
-
       attr_reader :parent
 
       def initialize(name, context, parent:)
@@ -11,37 +11,34 @@ module Praxis
       end
 
       def path
-        @_path ||= ( @parent.path + [name] )
+        @path ||= (@parent.path + [name])
       end
 
       def execute
-        if request.action.payload
-          begin
-            request.load_payload(CONTEXT_FOR[:payload])
-          rescue => e
-            message = "Error loading payload. Used Content-Type: '#{request.content_type}'"
-            return validation_handler.handle!(
-              exception: e,
-              summary: message,
-              request: request,
-              stage: name
-            )
-          end
-          Attributor::AttributeResolver.current.register("payload",request.payload)
-
-          errors = request.validate_payload(CONTEXT_FOR[:payload])
-          if errors.any?
-            return validation_handler.handle!(
-              summary: "Errors validating payload data",
-              errors: errors,
-              request: request,
-              stage: name
-            )
-          end
+        return unless request.action.payload
+
+        begin
+          request.load_payload(CONTEXT_FOR[:payload])
+        rescue StandardError => e
+          message = "Error loading payload. Used Content-Type: '#{request.content_type}'"
+          return validation_handler.handle!(
+            exception: e,
+            summary: message,
+            request: request,
+            stage: name
+          )
         end
-      end
 
-    end
+        errors = request.validate_payload(CONTEXT_FOR[:payload])
+        return unless errors.any?
 
+        validation_handler.handle!(
+          summary: 'Errors validating payload data',
+          errors: errors,
+          request: request,
+          stage: name
+        )
+      end
+    end
   end
 end

data/lib/praxis/request_superclassing.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 module Praxis
   class << self
-
     attr_writer :request_superclass
 
     def request_superclass
       @request_superclass || Object
     end
-
   end
-end
+end

data/lib/praxis/resource_definition.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 raise "ResourceDefinition class has changed name in this version of Praxis.\n" \
       'Please blanket-replace all uses of ResourceDefinition with EndpointDefinition instead.'

data/lib/praxis/response.rb

@@ -1,31 +1,28 @@
+# frozen_string_literal: true
+
 module Praxis
   class Response
-    attr_reader :name
-    attr_reader :parts
+    attr_reader :name, :parts
 
-    attr_accessor :status
-    attr_accessor :headers
-    attr_accessor :body
-    attr_accessor :request
+    attr_accessor :status, :headers, :body, :request
 
     class << self
-      attr_accessor :response_name
-      attr_accessor :status
+      attr_accessor :response_name, :status
     end
 
     def self.inherited(klass)
       klass.response_name = klass.name.demodulize.underscore.to_sym
-      klass.status = self.status if self.status
+      klass.status = status if status
     end
 
-    def initialize(status:self.class.status, headers:{}, body: nil, location: nil)
+    def initialize(status: self.class.status, headers: {}, body: nil, location: nil)
       @name    = response_name
       @status  = status
       @headers = headers
       @body    = body
       @headers['Location'] = location if location
       @form_data = nil
-      @parts = Hash.new
+      @parts = {}
     end
 
     # Determine the content type of this response.
@@ -44,10 +41,9 @@ module Praxis
       headers['Content-Type'] = MediaTypeIdentifier.load(identifier).to_s
     end
 
-    def handle
-    end
+    def handle; end
 
-    def add_part(name=nil, part)
+    def add_part(part, name = nil)
       @form_data ||= begin
         form = MIME::Multipart::FormData.new
         @headers.merge! form.headers.headers
@@ -63,8 +59,7 @@ module Praxis
       self.class.response_name
     end
 
-    def format!
-    end
+    def format!; end
 
     def encode!
       case @body
@@ -85,11 +80,7 @@ module Praxis
       @body = Array(@body)
 
       if @form_data
-        if @body.any?
-          unless @body.last =~ /\n$/
-            @body << "\r\n"
-          end
-        end
+        @body << "\r\n" if @body.any? && @body.last !~ /\n$/
 
         @parts.each do |name, part|
           part.encode!
@@ -108,7 +99,6 @@ module Praxis
       [@status, @headers, @body]
     end
 
-
     # Validates the response
     #
     # @param [Object] action
@@ -118,12 +108,20 @@ module Praxis
 
       unless (response_definition = action.responses[response_name])
         raise Exceptions::Validation, "Attempting to return a response with name #{response_name} " \
-          "but no response definition with that name can be found"
+          'but no response definition with that name can be found'
       end
-
       response_definition.validate(self, validate_body: validate_body)
+    rescue Exceptions::Validation => e
+      ve = Application.instance.validation_handler.handle!(
+        summary: 'Error validating response',
+        exception: e,
+        request: request,
+        stage: 'response',
+        errors: e.errors
+      )
+      body = ve.format!
+
+      Responses::InternalServerError.new(body: body)
     end
-
-
   end
 end

data/lib/praxis/response_definition.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Praxis
   # Response spec DSL container
@@ -6,57 +7,46 @@ module Praxis
     attr_reader :name
 
     def initialize(response_name, **spec, &block)
-      unless response_name
-        raise Exceptions::InvalidConfiguration.new(
-          "Response name is required for a response specification"
-        )
-      end
-      @spec = { headers:{} }
+      raise Exceptions::InvalidConfiguration, 'Response name is required for a response specification' unless response_name
+
+      @spec = { headers: {} }
       @name = response_name
-      self.instance_exec(**spec, &block) if block_given?
+      instance_exec(**spec, &block) if block_given?
 
-      if self.status.nil?
-        raise Exceptions::InvalidConfiguration.new(
-          "Status code is required for a response specification"
-        )
-      end
+      raise Exceptions::InvalidConfiguration, 'Status code is required for a response specification' if status.nil?
     end
 
-    def description(text=nil)
+    def description(text = nil)
       return @spec[:description] if text.nil?
+
       @spec[:description] = text
     end
 
-    def status(code=nil)
+    def status(code = nil)
       return @spec[:status] if code.nil?
+
       @spec[:status] = code
     end
 
-    def media_type(media_type=nil)
+    def media_type(media_type = nil)
       return @spec[:media_type] if media_type.nil?
 
       @spec[:media_type] = case media_type
-      when String
-        SimpleMediaType.new(media_type)
-      when Class
-        if media_type < Praxis::Types::MediaTypeCommon
-          media_type
-        else
-          raise Exceptions::InvalidConfiguration.new(
-            'Invalid media_type specification. media_type must be a Praxis::MediaType'
-          )
-        end
-      when SimpleMediaType
-        media_type
-      else
-        raise Exceptions::InvalidConfiguration.new(
-          'Invalid media_type specification. media_type must be a String, MediaType or SimpleMediaType'
-        )
-      end
+                           when String
+                             SimpleMediaType.new(media_type)
+                           when Class
+                             raise Exceptions::InvalidConfiguration, 'Invalid media_type specification. media_type must be a Praxis::MediaType' unless media_type < Praxis::Types::MediaTypeCommon
+
+                             media_type
+                           when SimpleMediaType
+                             media_type
+                           else
+                             raise Exceptions::InvalidConfiguration, 'Invalid media_type specification. media_type must be a String, MediaType or SimpleMediaType'
+                           end
     end
 
-    def location(loc=nil, description: nil)
-      return  headers.dig('Location',:value) if loc.nil?
+    def location(loc = nil, description: nil)
+      return headers.dig('Location', :value) if loc.nil?
 
       header('Location', loc, description: description)
     end
@@ -67,101 +57,88 @@ module Praxis
 
     def header(name, value, description: nil)
       the_type, args = case value
-      when nil,String
-        [String, {}]
-      when Regexp
-        # A regexp means it's gonna be a String typed, attached to a regexp
-        [String, { regexp: value }]
-      else
-        raise Exceptions::InvalidConfiguration.new(
-          "A header definition for a response can only take String, Regexp or nil values (to match anything)." +
-          "Received the following value for header name #{name}: #{value}"
-        )
-      end
-
-      info = { 
-        value: value, 
+                       when nil, String
+                         [String, {}]
+                       when Regexp
+                         # A regexp means it's gonna be a String typed, attached to a regexp
+                         [String, { regexp: value }]
+                       else
+                         raise Exceptions::InvalidConfiguration, 'A header definition for a response can only take String, Regexp or nil values (to match anything).' \
+                                                                 "Received the following value for header name #{name}: #{value}"
+                       end
+
+      info = {
+        value: value,
         attribute: Attributor::Attribute.new(the_type, **args)
       }
       info[:description] = description if description
       @spec[:headers][name] = info
     end
 
-    def example(context=nil)
-      return nil if self.media_type.nil?
-      return nil if self.media_type.kind_of?(SimpleMediaType)
+    def example(context = nil)
+      return nil if media_type.nil?
+      return nil if media_type.is_a?(SimpleMediaType)
 
-      if context.nil?
-        context = "#{self.media_type.name}-#{self.name}"
-      end
+      context = "#{media_type.name}-#{name}" if context.nil?
 
-      self.media_type.example(context)
+      media_type.example(context)
     end
 
-
     def describe(context: nil)
-      location_type = location.is_a?(Regexp) ? :regexp : :string
-      location_value = location.is_a?(Regexp) ? location.inspect : location
       content = {
-        :description => description,
-        :status => status,
-        :headers => {}
+        description: description,
+        status: status,
+        headers: {}
       }
 
-      unless headers == nil
-        headers.each do |name, value|
-          content[:headers][name] = _describe_header(value)
-        end
+      headers&.each do |name, value|
+        content[:headers][name] = _describe_header(value)
       end
       content[:location] = content[:headers]['Location']
 
-
-      if self.media_type
+      if media_type
         payload = media_type.describe(true)
 
-        if (example_payload = self.example(context))
+        if (example_payload = example(context))
           payload[:examples] = {}
           rendered_payload = example_payload.dump
 
           # FIXME: remove load when when MediaTypeCommon.identifier returns a MediaTypeIdentifier
-          identifier = MediaTypeIdentifier.load(self.media_type.identifier)
+          identifier = MediaTypeIdentifier.load(media_type.identifier)
 
           default_handlers = ApiDefinition.instance.info.produces
 
-          handlers = Praxis::Application.instance.handlers.select do |k,v|
+          handlers = Praxis::Application.instance.handlers.select do |k, _v|
             default_handlers.include?(k)
           end
 
-          if (identifier && handler = handlers[identifier.handler_name])
+          if identifier && (handler = handlers[identifier.handler_name])
             payload[:examples][identifier.handler_name] = {
               content_type: identifier.to_s,
               body: handler.generate(rendered_payload)
             }
           else
-            handlers.each do |name, handler|
-              content_type = ( identifier ) ? identifier + name : 'application/' + name
+            handlers.each do |name, handler_class|
+              content_type = identifier ? identifier + name : "application/#{name}"
               payload[:examples][name] = {
                 content_type: content_type.to_s,
-                body: handler.generate(rendered_payload)
+                body: handler_class.generate(rendered_payload)
               }
             end
           end
         end
 
-        content[:payload] = {type: payload}
+        content[:payload] = { type: payload }
       end
 
-      unless parts == nil
-        content[:parts_like] = parts.describe
-      end
+      content[:parts_like] = parts.describe unless parts.nil?
       content
     end
 
     def _describe_header(data)
-
       data_type = data[:value].is_a?(Regexp) ? :regexp : :string
       data_value = data[:value].is_a?(Regexp) ? data[:value].inspect : data[:value]
-      { :value => data_value, :type => data_type }
+      { value: data_value, type: data_type }
     end
 
     def validate(response, validate_body: false)
@@ -170,20 +147,18 @@ module Praxis
       validate_content_type!(response)
       validate_parts!(response)
 
-      if validate_body
-        validate_body!(response)
-      end
+      validate_body!(response) if validate_body
     end
 
-    def parts(proc=nil, like: nil,  **args, &block)
+    def parts(proc = nil, like: nil, **args, &block)
       a_proc = proc || block
       if like.nil? && !a_proc
-        raise ArgumentError, "Parts definition for response #{name} needs a :like argument or a block/proc" if !args.empty?
+        raise ArgumentError, "Parts definition for response #{name} needs a :like argument or a block/proc" unless args.empty?
+
         return @parts
       end
-      if like && a_proc
-        raise ArgumentError, "Parts definition for response #{name} does not allow :like and a block simultaneously"
-      end
+      raise ArgumentError, "Parts definition for response #{name} does not allow :like and a block simultaneously" if like && a_proc
+
       if like
         template = ApiDefinition.instance.response(like)
         @parts = template.compile(nil, **args)
@@ -198,13 +173,9 @@ module Praxis
     #
     def validate_status!(response)
       return unless status
+
       # Validate status code if defined in the spec
-      if response.status != status
-        raise Exceptions::Validation.new(
-          "Invalid response code detected. Response %s dictates status of %s but this response is returning %s." %
-          [name, status.inspect, response.status.inspect]
-        )
-      end
+      raise Exceptions::Validation, format('Invalid response code detected. Response %<name>s dictates status of %<status>s but this response is returning %<response>s.', name: name, status: status.inspect, response: response.status.inspect) if response.status != status
     end
 
     # Validates Headers
@@ -215,23 +186,13 @@ module Praxis
       return unless headers
 
       headers.each do |name, value|
-        if name.is_a? Symbol
-          raise Exceptions::Validation.new(
-            "Symbols are not supported in headers"
-          )
-        end
+        raise Exceptions::Validation, 'Symbols are not supported in headers' if name.is_a? Symbol
 
-        unless response.headers.has_key?(name)
-          raise Exceptions::Validation.new(
-            "Header #{name.inspect} was required but is missing"
-          )
-        end
+        raise Exceptions::Validation, "Header #{name.inspect} was required but is missing" unless response.headers.key?(name)
 
         errors = value[:attribute].validate(response.headers[name])
 
-        unless errors.empty? 
-          raise Exceptions::Validation.new("Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}.")
-        end
+        raise Exceptions::Validation, "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}." unless errors.empty?
         # case value
         # when String
         #   if response.headers[name] != value
@@ -249,7 +210,6 @@ module Praxis
       end
     end
 
-
     # Validates Content-Type header and response media type
     #
     # @param [Object] response
@@ -261,13 +221,10 @@ module Praxis
 
       response_content_type = response.content_type
       expected_content_type = Praxis::MediaTypeIdentifier.load(media_type.identifier)
+      return if expected_content_type.match(response_content_type)
 
-      unless expected_content_type.match(response_content_type)
-        raise Exceptions::Validation.new(
-          "Bad Content-Type header. #{response_content_type}" +
-          " is incompatible with #{expected_content_type} as described in response: #{self.name}"
-        )
-      end
+      raise Exceptions::Validation, "Bad Content-Type header. #{response_content_type}" \
+                                    " is incompatible with #{expected_content_type} as described in response: #{name}"
     end
 
     # Validates response body
@@ -277,15 +234,14 @@ module Praxis
     # @raise [Exceptions::Validation]  When there is a missing required header..
     def validate_body!(response)
       return unless media_type
-      return if media_type.kind_of? SimpleMediaType
+      return if media_type.is_a? SimpleMediaType
 
-      errors = self.media_type.validate(self.media_type.load(response.body))
-      if errors.any?
-        message = "Invalid response body for #{media_type.identifier}." +
-          "Errors: #{errors.inspect}"
-          raise Exceptions::Validation.new(message, errors: errors)
-      end
+      errors = media_type.validate(media_type.load(response.body))
+      return unless errors.any?
 
+      message = "Invalid response body for #{media_type.identifier}." \
+                "Errors: #{errors.inspect}"
+      raise Exceptions::Validation.new(message, errors: errors)
     end
 
     def validate_parts!(response)
@@ -295,6 +251,5 @@ module Praxis
         parts.validate(part)
       end
     end
-
   end
 end

data/lib/praxis/response_template.rb

@@ -1,5 +1,6 @@
-module Praxis
+# frozen_string_literal: true
 
+module Praxis
   class ResponseTemplate
     attr_reader :name, :block
 
@@ -8,27 +9,22 @@ module Praxis
       @block = block
     end
 
-    def compile(action=nil, **args)
+    def compile(action = nil, **args)
       # Default media_type to the endpoint_definition one, if the block has it in
       # its required args but no value is passed (funky, but can help in the common case)
-      if block.parameters.any? { |(type, name)| name == :media_type && type == :keyreq } && action
-        unless args.has_key? :media_type
-          media_type = action.endpoint_definition.media_type
-          unless media_type
-            raise Exceptions::InvalidConfiguration.new(
-              "Could not default :media_type argument for response template #{@name}." +
-               " Endpoint #{action.endpoint_definition} does not have an associated mediatype and none was passed"
-            )
-          end
-          args[:media_type] = media_type
+      if block.parameters.any? { |(type, name)| name == :media_type && type == :keyreq } && action && !(args.key? :media_type)
+        media_type = action.endpoint_definition.media_type
+        unless media_type
+          raise Exceptions::InvalidConfiguration, "Could not default :media_type argument for response template #{@name}." \
+                                                  " Endpoint #{action.endpoint_definition} does not have an associated mediatype and none was passed"
         end
+        args[:media_type] = media_type
       end
-      Praxis::ResponseDefinition.new(name, **args, &block)   
+      Praxis::ResponseDefinition.new(name, **args, &block)
     end
 
     def describe
-      puts "TODO!!!!!!"
+      puts 'TODO!!!!!!'
     end
   end
-
 end