crepe 0.0.1.pre

data/lib/crepe/endpoint/filter/parser.rb

@@ -0,0 +1,43 @@
+require 'active_support/core_ext/object/blank'
+
+module Crepe
+  class Endpoint
+    module Filter
+      # A default before filter that parses the body of an incoming request.
+      class Parser
+
+        class << self
+
+          def filter endpoint
+            endpoint.instance_eval do
+              body = request.body
+              return if body.blank?
+
+              input = env['crepe.input'] = case request.content_type
+              when %r{application/json}
+                begin
+                  MultiJson.load body
+                rescue MultiJson::DecodeError
+                  error! :bad_request, "Invalid JSON"
+                end
+              when %r{application/xml}
+                begin
+                  MultiXml.parse body
+                rescue MultiXml::ParseError
+                  error! :bad_request, "Invalid XML"
+                end
+              else
+                error! :unsupported_media_type,
+                  %(Content-type "#{request.content_type}" not supported)
+              end
+
+              @params = @params.merge input if input.is_a? Hash
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/crepe/endpoint/renderer.rb

@@ -0,0 +1,19 @@
+module Crepe
+  class Endpoint
+    module Renderer
+
+      # A RenderError can be used to indicate that rendering has failed for
+      # some reason. More specific errors in a renderer should inherit from
+      # this class so that a Crepe::API class can rescue all errors within
+      # rendering by rescuing Endpoint::Renderer::RenderError.
+      class RenderError < StandardError
+      end
+
+      autoload :Base,   'crepe/endpoint/renderer/base'
+      autoload :Simple, 'crepe/endpoint/renderer/simple'
+      autoload :Tilt,   'crepe/endpoint/renderer/tilt'
+
+    end
+  end
+end
+

data/lib/crepe/endpoint/renderer/base.rb

@@ -0,0 +1,95 @@
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/object/to_query'
+require 'uri'
+
+module Crepe
+  class Endpoint
+    module Renderer
+      # A base renderer class that sets pagination headers.
+      class Base
+
+        # Generates pagination links based on provided page, limit, and total.
+        class Links < Struct.new :page, :per_page, :count
+
+          def render request
+            uri = URI request.url
+            params = request.query_parameters.except 'page'
+
+            links = {
+              first: first, prev: prev, next: self.next, last: last
+            }
+            links = links.map do |rel, query|
+              next unless query
+              %(<#{uri + "?#{params.merge(query).to_query}"}>; rel="#{rel}")
+            end
+
+            links.compact.join ', '
+          end
+
+          def first
+            return if page == 1
+            {} # page=1
+          end
+
+          def prev
+            return if page == 1
+            prev = page.pred
+            prev > 1 ? { page: prev } : {} # page=1
+          end
+
+          def next
+            if count.nil? || page * per_page < count
+              { page: page.next } unless page == last[:page]
+            end
+          end
+
+          def last
+            last = (count.to_f / per_page).ceil
+            { page: last } unless page == last
+          end
+
+        end
+
+        PER_PAGE = 20
+
+        attr_reader :endpoint
+
+        def initialize endpoint
+          @endpoint = endpoint
+        end
+
+        def render resource, options = {}
+          if resource.respond_to? :paginate
+            count = resource.count if resource.respond_to? :count
+            endpoint.headers['Count'] = count.to_s if count
+
+            params = endpoint.params.slice :page, :per_page
+            page = validate_param params, :page, 1
+            per_page = resource.per_page if resource.respond_to? :per_page
+            per_page = validate_param params, :per_page, per_page || PER_PAGE
+            links = Links.new page, per_page, count
+            endpoint.headers['Link'] = links.render endpoint.request
+
+            resource = resource.paginate params
+          end
+
+          throw :head if endpoint.request.head?
+
+          resource
+        end
+
+        private
+
+          def validate_param params, name, default
+            value = Integer params.fetch(name, default.to_s), 10
+            raise ArgumentError if value < 1
+            value
+          rescue ArgumentError
+            endpoint.error! 400, "Invalid value #{params[name]} for #{name}"
+          end
+
+      end
+    end
+  end
+end

data/lib/crepe/endpoint/renderer/simple.rb

@@ -0,0 +1,21 @@
+module Crepe
+  class Endpoint
+    module Renderer
+      # The simplest renderer delegates rendering to the resource itself.
+      class Simple < Base
+
+        def render resource, options = {}
+          resource = super
+          format = options.fetch :format, endpoint.format
+
+          if resource.respond_to? "to_#{format}"
+            resource.__send__("to_#{format}")
+          else
+            resource.to_s
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/crepe/endpoint/renderer/tilt.rb

@@ -0,0 +1,87 @@
+module Crepe
+  class Endpoint
+    module Renderer
+      # Sends a resource and template to [Tilt][] for rendering, falling back
+      # to {Renderer::Simple} if no template name is provided (or can be
+      # derived). Template names are derived by the resource class's ability to
+      # return a {.model_name}.
+      #
+      # [Tilt]: https://github.com/rtomayko/tilt
+      class Tilt < Base
+
+        # Raised when a template name is derived but cannot be found in the
+        # template path.
+        class MissingTemplate < RenderError
+        end
+
+        class << self
+
+          def configure
+            yield self
+          end
+
+          def template_path
+            @template_path ||= 'app/views'
+          end
+
+          attr_writer :template_path
+
+        end
+
+        def render resource, options = {}
+          resource      = super
+
+          format        = options.fetch :format,   endpoint.format
+          handlers      = options.fetch :handlers, [:rabl, :erb, :*]
+          template_name = options.fetch :template, model_name(resource)
+
+          unless template_name
+            return Simple.new(endpoint).render resource, options
+          end
+
+          path_options = { format: format, handlers: handlers }
+          unless template = find_template(template_name, path_options)
+            raise MissingTemplate,
+              "Missing template #{template_name} with #{path_options}"
+          end
+
+          # FIXME: this is only needed for Rabl, which doesn't support Tilt
+          # locals properly. Can probably move into a Renderer::Rabl.
+          endpoint.instance_variable_set :"@#{template_name}", resource
+          endpoint.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            attr_reader :#{template_name}
+          RUBY
+
+          template.render endpoint
+        end
+
+        private
+
+          def model_name resource
+            if resource.respond_to? :model_name
+              resource.model_name.tableize
+            elsif resource.class.respond_to? :model_name
+              resource.class.model_name.underscore
+            end
+          end
+
+          def find_template relative_path, path_options
+            path_query = File.join self.class.template_path, relative_path
+
+            format, handlers = path_options.values
+            path_query << '.{%{format}.{%{handlers}},{%{handlers}}}' % {
+              format: format, handlers: handlers.join(',')
+            }
+
+            template_path = Dir[path_query].reject { |path|
+              ext = File.basename(path).split('.').last
+              File.directory?(path) || ::Tilt.mappings[ext].nil?
+            }.first
+
+            template_path && ::Tilt.new(template_path)
+          end
+
+      end
+    end
+  end
+end

data/lib/crepe/endpoint/request.rb

@@ -0,0 +1,59 @@
+require 'rack/request'
+
+module Crepe
+  class Endpoint
+    # A thin wrapper over {Rack::Request} that provides helper methods to
+    # better access request attributes.
+    class Request < Rack::Request
+
+      @@env_keys = Hash.new { |h, k| h[k] = "HTTP_#{k.upcase.tr '-', '_'}" }
+
+      def method
+        @method ||= env['crepe.original_request_method'] || request_method
+      end
+
+      def head?
+        method == 'HEAD'
+      end
+
+      def path
+        @path ||= Util.normalize_path! super
+      end
+
+      def headers
+        @headers ||= Hash.new { |h, k| h.fetch @@env_keys[k], nil }.update env
+      end
+
+      alias query_parameters GET
+
+      def POST
+        env['crepe.input'] || super
+      end
+      alias request_parameters POST
+
+      def path_parameters
+        @path_parameters ||= env['rack.routing_args'] || {}
+      end
+
+      def parameters
+        @parameters ||= path_parameters.merge self.GET.merge self.POST
+      end
+      alias params parameters
+
+      def body
+        env['crepe.input'] || begin
+          body = super
+          body.respond_to?(:read) ? body.read : body
+        end
+      end
+
+      def credentials
+        @credentials ||= begin
+          request = Rack::Auth::Basic::Request.new env
+          request.provided? ? request.credentials : []
+        end
+      end
+
+    end
+  end
+end

data/lib/crepe/middleware.rb

@@ -0,0 +1,9 @@
+module Crepe
+  module Middleware
+
+    autoload :ContentNegotiation, 'crepe/middleware/content_negotiation'
+    autoload :Head,               'crepe/middleware/head'
+    autoload :RestfulStatus,      'crepe/middleware/restful_status'
+
+  end
+end

data/lib/crepe/middleware/content_negotiation.rb

@@ -0,0 +1,110 @@
+require 'active_support/core_ext/object/to_query'
+require 'rack/utils'
+require 'crepe/util'
+
+module Crepe
+  module Middleware
+    # Negotiates API content type and version from an Accept header.
+    #
+    # Given an Accept header with a vendor-specific mime type, it will
+    # transform the Rack environment: prefixing a version and postfixing
+    # an extension to the path, and removing the vendor-specific parts of the
+    # Accept header.
+    #
+    # E.g., the following request:
+    #
+    #   GET /users
+    #   Accept: application/vnd.crepe-v2+json
+    #
+    # Will pass through to the next middleware as this:
+    #
+    #   GET /v2/users.json
+    #   Accept: application/json
+    #
+    # The vendor name is stored as <tt>crepe.vendor</tt> in the Rack
+    # environment.
+    #
+    #   env['crepe.vendor'] # => "crepe"
+    #--
+    # TODO: Support Accept headers with multiple mime types:
+    #
+    #   Accept: application/vnd.crepe-v2+xml, application/vnd.crepe-v1+xml;q=0.7
+    #
+    # XXX: Should the env be modified more? Should we store version
+    # somewhere? As is, this middleware depends heavily on Crepe and
+    # Rack::Mount to be useful.
+    #++
+    class ContentNegotiation
+
+      # Matches an `type`, `vendor`, `version`, and `format` (subtype) given
+      # an accept header.
+      ACCEPT_HEADER = %r{
+        (?<type>[^/;,\s]+)
+          /
+        (?:
+          (?:
+            (?:vnd\.)(?<vendor>[^/;,\s\.+-]+)
+            (?:-(?<version>[^/;,\s\.+-]+))?
+            (?:\+(?<format>[^/;,\s\.+-]+))?
+          )
+        |
+          (?<format>[^/;,\s\.+]+)
+        )
+      }ix
+
+      MIME_TYPES = {
+        'application/json' => :json,
+        'application/pdf'  => :pdf,
+        'application/xml'  => :xml,
+        'text/html'        => :html,
+        'text/plain'       => :txt
+      }
+
+      def initialize app
+        @app = app
+      end
+
+      def call env
+        accept = ACCEPT_HEADER.match(env['HTTP_ACCEPT']) || {}
+        path = env['crepe.original_path_info'] = env['PATH_INFO']
+
+        env['crepe.vendor'] = accept[:vendor] if accept[:vendor]
+
+        version = accept[:version] || query_string_version(env)
+        if version && !path.start_with?("/#{version}")
+          path = ::File.join '/', version, path
+        end
+
+        if accept[:format]
+          env['crepe.original_http_accept'] = env['HTTP_ACCEPT'].dup
+          content_type = [accept[:type], accept[:format]].join '/'
+
+          env['HTTP_ACCEPT'][ACCEPT_HEADER] = content_type
+          extension = MIME_TYPES.fetch content_type, accept[:format]
+
+          if ::File.extname(path) != ".#{extension}"
+            path += ".#{extension}" unless extension == '*'
+          end
+        end
+
+        env['PATH_INFO'] = Util.normalize_path path
+
+        @app.call env
+      end
+
+      private
+
+        def query_string_version env
+          env['crepe.original_query_string'] = env['QUERY_STRING']
+          query = Rack::Utils.parse_nested_query env['QUERY_STRING']
+
+          version = query.delete('v')
+          if version
+            env['QUERY_STRING'] = query.to_query
+            version
+          end
+        end
+
+    end
+  end
+end