praxis 0.16.1 → 0.17.0

data/lib/praxis/request.rb

@@ -18,7 +18,6 @@ module Praxis
       @env = env
       @query = Rack::Utils.parse_nested_query(env[QUERY_STRING_NAME])
       @route_params = {}
-      @path_version_matcher = path_version_matcher
     end
 
     # Determine the content type of this request as indicated by the Content-Type header.
@@ -83,23 +82,29 @@ module Praxis
       PATH_VERSION_PREFIX
     end
 
+    # DEPRECATED: remove with ResourceDefinition.version using: :path
     PATH_VERSION_MATCHER = %r{^#{self.path_version_prefix}(?<version>[^\/]+)\/}.freeze
 
     def path_version_matcher
-      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]
+      else
+        PATH_VERSION_MATCHER.match(self.path)[:version]
+      end
     end
 
-    def version(using: VERSION_USING_DEFAULTS)
+    def version
       result = nil
-      Array(using).find do |mode|
+
+      Array(Application.instance.versioning_scheme).find do |mode|
         case mode
         when :header;
           result = env[API_VERSION_HEADER_NAME]
         when :params;
           result = @query[API_VERSION_PARAM_NAME]
         when :path;
-          m = self.path.match(@path_version_matcher)
-          result = m[:version] unless m.nil?
+          result = self.path_version_matcher
         else
           raise "Unknown method for retrieving the API version: #{mode}"
         end
@@ -124,13 +129,11 @@ module Praxis
       return unless action.payload
       return if content_type.nil?
 
-      handler = Praxis::Application.instance.handlers[content_type.handler_name]
-
-      if handler
-        raw = handler.parse(self.raw_payload)
+      raw = if (handler = Praxis::Application.instance.handlers[content_type.handler_name])
+        handler.parse(self.raw_payload)
       else
         # TODO is this a good default?
-        raw = self.raw_payload
+        self.raw_payload
       end
 
       self.payload = action.payload.load(raw, context, content_type: content_type.to_s)

data/lib/praxis/request_stages/request_stage.rb

@@ -45,6 +45,10 @@ module Praxis
         @context.request
       end
 
+      def validation_handler
+        dispatcher.application.validation_handler
+      end
+
       def run
         # stage-level callbacks (typically empty) will never shortcut
         execute_callbacks(self.before_callbacks)

data/lib/praxis/request_stages/response.rb

@@ -2,24 +2,25 @@ module Praxis
   module RequestStages
 
     class Response < RequestStage
-      WHITELIST_RESPONSES = [:validation_error]
 
       def execute
         response = controller.response
 
-        unless action.responses.include?(response.response_name) || WHITELIST_RESPONSES.include?(response.response_name)
-          raise Exceptions::InvalidResponse.new(
-            "Response #{response.name.inspect} is not allowed for #{action.name.inspect}"
-          )
-        end
-
         response.handle
 
         if Application.instance.config.praxis.validate_responses == true
-          response.validate(action)
+          validate_body = Application.instance.config.praxis.validate_response_bodies
+
+          response.validate(action, validate_body: validate_body)
         end
       rescue Exceptions::Validation => e
-        controller.response = Responses::ValidationError.new(exception: e)
+        controller.response = validation_handler.handle!(
+          summary: "Error validating response", 
+          exception: e,
+          request: request,
+          stage: name, 
+          errors: e.errors
+        )
         retry
       end
 

data/lib/praxis/request_stages/validate.rb

@@ -8,16 +8,10 @@ module Praxis
         # Add our sub-stages
         @stages = [
           RequestStages::ValidateParamsAndHeaders.new(:params_and_headers, context, parent: self),
-          RequestStages::ValidatePayload.new(:payload, context, parent: self) 
+          RequestStages::ValidatePayload.new(:payload, context, parent: self)
         ]
       end
 
-      def execute
-        super
-      rescue Attributor::AttributorException => e
-        return Responses::ValidationError.new(exception: e)
-      end
-
     end
 
   end

data/lib/praxis/request_stages/validate_params_and_headers.rb

@@ -9,14 +9,34 @@ module Praxis
         @parent = parent
       end
 
-
       def path
         @_path ||= ( @parent.path + [name] )
       end
 
       def execute
-        request.load_headers(CONTEXT_FOR[:headers])
-        request.load_params(CONTEXT_FOR[:params])
+        begin
+          request.load_headers(CONTEXT_FOR[:headers])
+        rescue => e
+          message = "Error loading headers."
+          return validation_handler.handle!(
+            exception: e,
+            summary: message,
+            request: request,
+            stage: name
+          )
+        end
+
+        begin
+          request.load_params(CONTEXT_FOR[:params])
+        rescue Attributor::AttributorException => e
+          message = "Error loading params."
+          return validation_handler.handle!(
+            exception: e,
+            summary: message,
+            request: request,
+            stage: name
+          )
+        end
 
         attribute_resolver = Attributor::AttributeResolver.new
         Attributor::AttributeResolver.current = attribute_resolver
@@ -26,9 +46,14 @@ module Praxis
 
         errors = request.validate_headers(CONTEXT_FOR[:headers])
         errors += request.validate_params(CONTEXT_FOR[:params])
-
         if errors.any?
-          return Responses::ValidationError.new(errors: errors)
+          message = "Error validating request data."
+          return validation_handler.handle!(
+            summary: message,
+            errors: errors,
+            request: request,
+            stage: name
+          )
         end
       end
 

data/lib/praxis/request_stages/validate_payload.rb

@@ -18,16 +18,25 @@ module Praxis
         if request.action.payload
           begin
             request.load_payload(CONTEXT_FOR[:payload])
-          rescue Attributor::AttributorException => e
-            message = e.message
-            message << ". For request Content-Type: '#{request.content_type}'"
-            return Responses::ValidationError.new(exception: e, message: message)
+          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 Responses::ValidationError.new(errors: errors)
+            return validation_handler.handle!(
+              summary: "Errors validating payload data",
+              errors: errors,
+              request: request,
+              stage: name
+            )
           end
         end
       end

data/lib/praxis/resource_definition.rb

@@ -4,6 +4,7 @@ require 'active_support/inflector'
 module Praxis
   module ResourceDefinition
     extend ActiveSupport::Concern
+
     DEFAULT_RESOURCE_HREF_ACTION = :show
 
     included do
@@ -11,34 +12,62 @@ module Praxis
       @actions = Hash.new
       @responses = Hash.new
       @action_defaults = Trait.new
+
       @version_options = {}
       @metadata = {}
       @traits = []
 
       if self.name
-        @routing_prefix = '/' + self.name.split("::").last.underscore
+        @prefix = '/' + self.name.split("::").last.underscore
       else
-        @routing_prefix = '/'
+        @prefix = '/'
       end
 
       @version_prefix = ''
 
+      @parent = nil
+      @parent_prefix = ''
+
+      @routing_prefix = nil
+
+      @on_finalize = Array.new
+
       Application.instance.resource_definitions << self
     end
 
+    def self.finalize!
+      Application.instance.resource_definitions.each do |resource_definition|
+
+        while (block = resource_definition.on_finalize.shift)
+          block.call
+        end
+      end
+    end
+
+
+
     module ClassMethods
       attr_reader :actions
       attr_reader :responses
       attr_reader :version_options
       attr_reader :traits
-      attr_reader :routing_prefix
       attr_reader :version_prefix
+      attr_reader :parent_prefix
+
       # opaque hash of user-defined medata, used to decorate the definition,
       # and also available in the generated JSON documents
       attr_reader :metadata
 
       attr_accessor :controller
 
+      def on_finalize
+        if block_given?
+          @on_finalize << Proc.new
+        end
+
+        @on_finalize
+      end
+
       # FIXME: this is inconsistent with the rest of the magic DSL convention.
       def routing(&block)
         warn "DEPRECATED: ResourceDefinition.routing is deprecated use prefix directly instead."
@@ -48,14 +77,13 @@ module Praxis
       end
 
       def prefix(prefix=nil)
-        unless prefix.nil?
-          @routing_prefix = prefix
-        end
-        @routing_prefix
+        return @prefix if prefix.nil?
+        @routing_prefix = nil # reset routing_prefix
+        @prefix = prefix
       end
 
       def media_type(media_type=nil)
-        return @media_type unless media_type
+        return @media_type if media_type.nil?
 
         if media_type.kind_of?(String)
           media_type = SimpleMediaType.new(media_type)
@@ -63,12 +91,81 @@ module Praxis
         @media_type = media_type
       end
 
+
+      def parent(parent=nil, **mapping)
+        return @parent if parent.nil?
+
+        @routing_prefix = nil # reset routing_prefix
+
+        parent_action = parent.canonical_path
+        parent_route = parent_action.primary_route.path
+
+        # if a mapping is passed, it *must* resolve any param name conflicts
+        unless mapping.any?
+          # assume last capture is the relevant one to replace
+          # if not... then I quit.
+          parent_param_name = parent_route.names.last
+
+          # more assumptions about names
+          parent_name = parent.name.demodulize.underscore.singularize
+
+          # put it together to find what we should call this new param
+          param = "#{parent_name}_#{parent_param_name}".to_sym
+          mapping[parent_param_name.to_sym] = param
+        end
+
+        # complete the mapping and massage the route
+        parent_route.names.collect(&:to_sym).each do |name|
+          if mapping.key?(name)
+            param = mapping[name]
+            # FIXME: this won't handle URI Template type paths, ie '/{parent_id}'
+            prefixed_path = parent_action.primary_route.prefixed_path
+            @parent_prefix = prefixed_path.gsub(/(:)(#{name})(\W+|$)/, "\\1#{param.to_s}\\3")
+          else
+            mapping[name] = name
+          end
+        end
+
+        self.on_finalize do
+          self.inherit_params_from_parent(parent_action, **mapping)
+        end
+
+        @parent = parent
+      end
+
+      def inherit_params_from_parent(parent_action, **mapping)
+        actions.each do |name, action|
+          action.params do
+            mapping.each do |parent_name, name|
+              next if action.params && action.params.attributes.key?(name)
+
+              parent_attribute = parent_action.params.attributes[parent_name]
+
+              attribute name, parent_attribute.type, parent_attribute.options
+            end
+          end
+        end
+
+      end
+
+      attr_writer :routing_prefix
+
+      def routing_prefix
+        return @routing_prefix if @routing_prefix
+
+        @routing_prefix = parent_prefix + prefix
+      end
+
+
       def version(version=nil, options=nil)
         return @version unless version
+
         @version = version
-        @version_options = options || {using: [:header,:params]}
 
-        if @version_options
+        unless options.nil?
+          warn 'DEPRECATED: ResourceDefinition.version with options is no longer supported. Define in api global info instead.'
+
+          @version_options = options
           version_using = Array(@version_options[:using])
           if version_using.include?(:path)
             @version_prefix = "#{Praxis::Request::path_version_prefix}#{self.version}"
@@ -76,7 +173,8 @@ module Praxis
         end
       end
 
-      def canonical_path( action_name=nil )
+
+      def canonical_path(action_name=nil)
         if action_name
           raise "Canonical path for #{self.name} is already defined as: '#{@canonical_action_name}'. 'canonical_path' can only be defined once." if @canonical_action_name
           @canonical_action_name = action_name
@@ -98,6 +196,9 @@ module Praxis
       end
 
       def parse_href(path)
+        if path.kind_of?(::URI::Generic)
+          path = path.path
+        end
         param_values = canonical_path.primary_route.path.params(path)
         attrs = canonical_path.params.attributes
         param_values.each_with_object({}) do |(key,value),hash|
@@ -125,28 +226,28 @@ module Praxis
       end
 
       def params(type=Attributor::Struct, **opts, &block)
-        warn 'DEPRECATION: ResourceDefinition.params is deprecated. Use it in action_defaults instead.'
+        warn 'DEPRECATED: ResourceDefinition.params is deprecated. Use it in action_defaults instead.'
         action_defaults do
           params type, **opts, &block
         end
       end
 
       def payload(type=Attributor::Struct, **opts, &block)
-        warn 'DEPRECATION: ResourceDefinition.payload is deprecated. Use action_defaults instead.'
+        warn 'DEPRECATED: ResourceDefinition.payload is deprecated. Use action_defaults instead.'
         action_defaults do
           payload type, **opts, &block
         end
       end
 
       def headers(**opts, &block)
-        warn 'DEPRECATION: ResourceDefinition.headers is deprecated. Use action_defaults instead.'
+        warn 'DEPRECATED: ResourceDefinition.headers is deprecated. Use action_defaults instead.'
         action_defaults do
           headers **opts, &block
         end
       end
 
       def response(name, **args)
-        warn 'DEPRECATION: ResourceDefinition.response is deprecated. Use action_defaults instead.'
+        warn 'DEPRECATED: ResourceDefinition.response is deprecated. Use action_defaults instead.'
         action_defaults do
           response name, **args
         end
@@ -173,6 +274,7 @@ module Praxis
           hash[:media_type] = media_type.id if media_type
           hash[:actions] = actions.values.map(&:describe)
           hash[:name] = self.name
+          hash[:parent] = self.parent.id if self.parent
           hash[:metadata] = metadata
           hash[:traits] = self.traits
         end

data/lib/praxis/response.rb

@@ -54,7 +54,7 @@ module Praxis
       end
 
       name ||= "part-#{part.object_id}"
-
+      part.name = name
       @parts[name.to_s] = part
     end
 
@@ -112,14 +112,15 @@ module Praxis
     #
     # @param [Object] action
     #
-    def validate(action)
+    def validate(action, validate_body: false)
       return if response_name == :validation_error
-      unless ( response_definition = action.responses[response_name] )
-        raise ArgumentError, "Attempting to return a response with name #{response_name} " \
+
+      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"
       end
 
-      response_definition.validate(self)
+      response_definition.validate(self, validate_body: validate_body)
     end