praxis 0.0.1 → 0.9

data/lib/praxis/request.rb

@@ -0,0 +1,131 @@
+module Praxis
+
+  class Request
+    attr_reader :env, :query, :version
+    attr_accessor :route_params, :action
+
+
+    def initialize(env)
+      @env = env
+      @query = Rack::Utils.parse_nested_query(env['QUERY_STRING'.freeze])
+      @route_params = {}
+      load_version
+    end
+
+    def content_type
+      @env['CONTENT_TYPE'.freeze]
+    end
+
+    # The media type (type/subtype) portion of the CONTENT_TYPE header
+    # without any media type parameters. e.g., when CONTENT_TYPE is
+    # "text/plain;charset=utf-8", the media-type is "text/plain".
+    #
+    # For more information on the use of media types in HTTP, see:
+    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
+    def media_type
+      content_type && content_type.split(/\s*[;,]\s*/, 2).first.downcase
+    end
+
+    def path
+      @env['PATH_INFO'.freeze]
+    end
+
+    attr_accessor :headers, :params, :payload
+
+    def params_hash
+      return {} if params.nil?
+
+      params.attributes.each_with_object({}) do |(k,v),hash|
+        hash[k] = v
+      end
+    end
+
+    def verb
+      @env['REQUEST_METHOD'.freeze]
+    end
+
+    def raw_params
+      @raw_params ||= begin
+        params = query.merge(route_params)
+        params.delete('api_version'.freeze)
+        params
+      end
+    end
+
+    def raw_payload
+      @raw_payload ||= begin
+        if (input = env['rack.input'.freeze].read)
+          env['rack.input'.freeze].rewind
+          input
+        end
+      end
+    end
+
+    def coalesce_inputs!
+      self.raw_params
+      self.raw_payload
+    end
+
+    def load_version
+      @version = env.fetch("HTTP_X_API_VERSION".freeze,
+                           @query.fetch('api_version'.freeze, 'n/a'.freeze))
+    end
+
+    def load_headers(context)
+      return unless action.headers
+      defined_headers = action.headers.attributes.keys.each_with_object(Hash.new) do |name, hash|
+        env_name = if name == :CONTENT_TYPE || name == :CONTENT_LENGTH
+          name.to_s
+        else
+          "HTTP_#{name}"
+        end
+        hash[name] = self.env[env_name] if self.env.has_key? env_name
+      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)
+    end
+
+    def load_payload(context)
+      return unless action.payload
+      raw = case content_type
+        when %r|^application/x-www-form-urlencoded|i
+          Rack::Utils.parse_nested_query(self.raw_payload)
+        when nil
+          {}
+        else
+          self.raw_payload
+        end
+
+      self.payload = action.payload.load(raw, context, content_type: content_type)
+    end
+
+    def validate_headers(context)
+      return [] unless action.headers
+
+      action.headers.validate(self.headers, context)
+    end
+
+    def validate_params(context)
+      return [] unless action.params
+
+      action.params.validate(self.params, context)
+    end
+
+    def validate_payload(context)
+      return [] unless action.payload
+
+      action.payload.validate(self.payload, context)
+    end
+
+    # versions that matched all the conditions of the request (except its version)
+    def unmatched_versions
+      @unmatched_versions ||= Set.new
+    end
+
+  end
+
+end

data/lib/praxis/request_stages/action.rb

@@ -0,0 +1,20 @@
+module Praxis
+  module RequestStages
+
+    class Action < RequestStage
+
+      def execute
+        response = controller.send(action.name, **request.params_hash)
+        if response.kind_of? String
+          controller.response.body = response
+        else
+          controller.response = response
+        end
+
+        controller.response.request = request
+      end
+
+    end
+
+  end
+end

data/lib/praxis/request_stages/load_request.rb

@@ -0,0 +1,13 @@
+module Praxis
+  module RequestStages
+
+    class LoadRequest < RequestStage
+
+      def execute
+        request.coalesce_inputs!
+      end
+
+    end
+
+  end
+end

data/lib/praxis/request_stages/request_stage.rb

@@ -0,0 +1,52 @@
+module Praxis
+  module RequestStages
+
+    class RequestStage < Stage
+      extend Forwardable
+
+      def_delegators :@context, :controller, :action, :request
+      alias :dispatcher :application # it's technically application in the base Stage
+
+      def path
+        [name]
+      end
+
+      def execute_controller_callbacks(callbacks)
+        if callbacks.has_key?(path)
+          callbacks[path].each do |(conditions, block)|
+            if conditions.has_key?(:actions)
+              next unless conditions[:actions].include? action.name
+            end
+            block.call(controller)
+          end
+        end
+      end
+
+      def run
+        setup!
+        setup_deferred_callbacks!
+        execute_callbacks(self.before_callbacks)
+        execute_controller_callbacks(controller.class.before_callbacks)
+        result = execute
+        execute_controller_callbacks(controller.class.after_callbacks)
+        execute_callbacks(self.after_callbacks)
+
+        result
+      end
+
+
+      def execute
+        raise NotImplementedError, 'Subclass must implement Stage#execute' unless @stages.any?
+
+        @stages.each do |stage|
+          result = stage.run
+          return result if result.kind_of?(Praxis::Response)
+        end
+
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/praxis/request_stages/response.rb

@@ -0,0 +1,26 @@
+module Praxis
+  module RequestStages
+
+    class Response < RequestStage
+
+      def execute
+        response = controller.response
+
+        unless action.responses.include?(response.response_name)
+          raise Exceptions::InvalidResponse.new(
+            "Response #{response.name.inspect} is not allowed for #{action.name.inspect}"
+          )
+        end
+
+        response.handle
+
+        praxis_config = Application.instance.config.praxis
+        unless praxis_config && praxis_config.validate_responses == false
+          response.validate(action)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/praxis/request_stages/validate.rb

@@ -0,0 +1,20 @@
+module Praxis
+  module RequestStages
+
+    class Validate < RequestStage
+
+      def setup!
+        @stages << RequestStages::ValidateParamsAndHeaders.new(:params_and_headers, context, parent: self)
+        @stages << RequestStages::ValidatePayload.new(:payload, context, parent: self)
+      end
+
+      def execute
+        super
+      rescue Attributor::AttributorException => e
+        return Responses::ValidationError.new(exception: e)
+      end
+
+    end
+
+  end
+end

data/lib/praxis/request_stages/validate_params_and_headers.rb

@@ -0,0 +1,38 @@
+module Praxis
+  module RequestStages
+
+    class ValidateParamsAndHeaders < RequestStage
+      attr_reader :parent
+
+      def initialize(name, context, parent:)
+        super
+        @parent = parent
+      end
+
+
+      def path
+        @parent.path + [name]
+      end
+
+      def execute
+        request.load_headers(CONTEXT_FOR[:headers])
+        request.load_params(CONTEXT_FOR[:params])
+
+        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?
+          return Responses::ValidationError.new(errors: errors)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/praxis/request_stages/validate_payload.rb

@@ -0,0 +1,32 @@
+module Praxis
+  module RequestStages
+
+    class ValidatePayload < RequestStage
+
+      attr_reader :parent
+
+      def initialize(name, context, parent:)
+        super
+        @parent = parent
+      end
+
+      def path
+        @parent.path + [name]
+      end
+
+      def execute
+        if request.action.payload
+          request.load_payload(CONTEXT_FOR[:payload])
+          Attributor::AttributeResolver.current.register("payload",request.payload)
+
+          errors = request.validate_payload(CONTEXT_FOR[:payload])
+          if errors.any?
+            return Responses::ValidationError.new(errors: errors)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/praxis/resource_definition.rb

@@ -0,0 +1,89 @@
+require 'active_support/concern'
+require 'active_support/inflector'
+
+
+
+module Praxis
+  module ResourceDefinition
+    extend ActiveSupport::Concern
+
+    included do
+      @version = 'n/a'.freeze
+      @actions = Hash.new
+      @responses = Hash.new
+      Application.instance.resource_definitions << self
+    end
+
+    module ClassMethods
+      attr_reader :actions
+      attr_reader :routing_config
+      attr_reader :responses
+
+      attr_accessor :controller
+
+      # FIXME: this is inconsistent with the rest of the magic DSL convention.
+      def routing(&block)
+        @routing_config = block
+      end
+
+      def media_type(media_type=nil)
+        return @media_type unless media_type
+
+        if media_type.kind_of?(String)
+          media_type = SimpleMediaType.new(media_type)
+        end
+        @media_type = media_type
+      end
+
+      def version(version=nil)
+        return @version unless version
+        @version = version
+      end
+
+      def action(name, &block)
+        @actions[name] = ActionDefinition.new(name, self, &block)
+      end
+
+      def params(type=Attributor::Struct, **opts, &block)
+        return @params if type == Attributor::Struct && !block
+        @params = [type, opts, block]
+      end
+
+      def payload(type=Attributor::Struct, **opts, &block)
+        return @payload if type == Attributor::Struct && !block
+        @payload = [type, opts, block]
+      end
+
+      def headers(**opts, &block)
+        return @headers unless block
+        @headers = [opts, block]
+      end
+
+      def description(text=nil)
+        @description = text if text
+        @description
+      end
+
+      def response(name, **args)
+        @responses[name] = args
+      end
+
+      def describe
+        {}.tap do |hash|
+          hash[:description] = description
+          hash[:media_type] = media_type.name if media_type
+          hash[:actions] = actions.values.map(&:describe)
+        end
+      end
+
+      def use(trait_name)
+        unless ApiDefinition.instance.traits.has_key? trait_name
+          raise Exceptions::InvalidTrait.new("Trait #{trait_name} not found")
+        end
+        self.instance_eval(&ApiDefinition.instance.traits[trait_name])
+      end
+
+    end
+
+  end
+end

data/lib/praxis/response.rb

@@ -0,0 +1,107 @@
+module Praxis
+  class Response
+
+
+    attr_reader :name
+    attr_reader :parts
+
+    attr_accessor :status
+    attr_accessor :headers
+    attr_accessor :body
+    attr_accessor :request
+
+    class << self
+      attr_accessor :response_name
+      attr_accessor :status
+    end
+
+    def self.inherited(klass)
+      klass.response_name = klass.name.demodulize.underscore.to_sym
+      klass.status = self.status if self.status
+    end
+
+    def initialize(status:self.class.status, headers:{}, body:'')
+      @name    = response_name
+      @status  = status
+      @headers = headers
+      @body    = body
+      @form_data = nil
+      @parts = Hash.new
+    end
+
+    def handle
+    end
+
+    def add_part(name=nil, part)
+      @form_data ||= begin
+        form = MIME::Multipart::FormData.new
+        @headers.merge! form.headers.headers
+        form
+      end
+
+      name ||= "part-#{part.object_id}"
+
+      @parts[name.to_s] = part
+    end
+
+    def response_name
+      self.class.response_name
+    end
+
+    def format!
+    end
+
+    def encode!
+      case @body
+      when Hash, Array
+        @body = JSON.pretty_generate(@body)
+      end
+    end
+
+    def finish
+      format!
+      encode!
+
+      @body = Array(@body)
+
+      if @form_data
+        if @body.any?
+          unless @body.last =~ /\n$/
+            @body << "\r\n"
+          end
+        end
+
+        @parts.each do |name, part|
+          part.encode!
+          entity = MIME::Text.new(part.body)
+
+          part.headers.each do |header_name, header_value|
+            entity.headers.set header_name, header_value
+          end
+
+          @form_data.add entity, name
+        end
+
+        @body << @form_data.body.to_s
+      end
+
+      [@status, @headers, @body]
+    end
+
+
+    # Validates the response
+    #
+    # @param [Object] action
+    #
+    def validate(action)
+      unless ( response_definition = action.responses[response_name] )
+        raise ArgumentError, "Attempting to return a response with name #{response_name} " \
+          "but no response definition with that name can be found"
+      end
+
+      response_definition.validate(self)
+    end
+
+
+  end
+end