crepe 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 607eb8356da44e5aff8eed0dd093b1843d361730
+  data.tar.gz: 7f51f2c1953f9d2872dce4d01af9431a62a870ad
+SHA512:
+  metadata.gz: f3d1c4851a4dbc373646bf9851290232cd683285c9013d77d89bab68f5d20da780a6197bd83687ba052c51f82fca64baaf8a35a46eb0008510ddfeb9279cf878
+  data.tar.gz: cc943546f40ce8826880abdd2b63bf2d30b72c6847690ae92ceb230c3109d61142a88bd6e1f7ef4465671eeb07059eae07a5684b622fa4c9f6d3937cf58031f1

data/lib/crepe.rb

@@ -0,0 +1,10 @@
+module Crepe
+
+  autoload :API,        'crepe/api'
+  autoload :Endpoint,   'crepe/endpoint'
+  autoload :Middleware, 'crepe/middleware'
+  autoload :Params,     'crepe/params'
+  autoload :Util,       'crepe/util'
+  autoload :VERSION,    'crepe/version'
+
+end

data/lib/crepe/api.rb

@@ -0,0 +1,242 @@
+require 'rack/mount'
+
+module Crepe
+  # The API class provides a DSL to build a collection of endpoints.
+  class API
+
+    # Module class that is instantiated and stores an API's helper methods.
+    # Supports dynamic extensibility via {Util::ChainedInclude}, ensuring that
+    # helpers defined after endpoints are still accessible to those endpoints.
+    class Helper < Module
+      include Util::ChainedInclude
+    end
+
+    METHODS = %w[GET POST PUT PATCH DELETE]
+
+    @running = false
+
+    @config = Util::HashStack.new(
+      endpoint: Endpoint.default_config,
+      helper: Helper.new,
+      middleware: [
+        Rack::Runtime,
+        Middleware::ContentNegotiation,
+        Middleware::RestfulStatus,
+        Middleware::Head,
+        Rack::ConditionalGet,
+        Rack::ETag
+      ],
+      namespace: nil,
+      routes: [],
+      vendor: nil,
+      version: nil
+    )
+
+    class << self
+
+      attr_reader :config
+
+      def running?
+        @running
+      end
+
+      def running!
+        @running = true
+      end
+
+      def inherited subclass
+        subclass.config = config.dup
+      end
+
+      def namespace path, options = {}, &block
+        if block
+          config.with namespaced_config(path, options), &block
+        else
+          config[:namespace] = path
+        end
+      end
+      alias_method :resource, :namespace
+
+      def param name, &block
+        namespace "/:#{name}", &block
+      end
+
+      def vendor vendor
+        config[:endpoint][:vendor] = vendor
+      end
+
+      def version version, &block
+        config.with version: version do
+          namespace version, &block
+        end
+      end
+
+      def use middleware, *args, &block
+        config[:middleware] << [middleware, args, block]
+      end
+
+      def respond_to *formats
+        config[:endpoint][:formats] = []
+
+        formats.each do |format|
+          if format.respond_to? :each_pair
+            format.each_pair do |f, renderer|
+              config[:endpoint][:formats] << f.to_sym
+              config[:endpoint][:renderers][f.to_sym] = renderer
+            end
+          else
+            config[:endpoint][:formats] << format.to_sym
+          end
+        end
+      end
+
+      def rescue_from exception, options = {}, &block
+        config[:endpoint][:rescuers] << {
+          exception_class: exception, options: options, block: block
+        }
+      end
+
+      def before_filter mod = nil, &block
+        warn 'block takes precedence over module' if block && mod
+        filter = block || mod
+        config[:endpoint][:before_filters] << filter if filter
+      end
+
+      def after_filter mod = nil, &block
+        warn 'block takes precedence over module' if block && mod
+        filter = block || mod
+        config[:endpoint][:after_filters] << filter if filter
+      end
+
+      def basic_auth *args, &block
+        before_filter do
+          unless instance_exec request.credentials, &block
+            unauthorized!(*args)
+          end
+        end
+      end
+
+      def helper mod = nil, &block
+        if block
+          warn 'block takes precedence over module' if mod
+          mod = Module.new(&block)
+        end
+        config[:helper].send :include, mod
+      end
+
+      def call env
+        app.call env
+      end
+
+      METHODS.each do |method|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method.downcase} *args, &block
+            route '#{method}', *args, &block
+          end
+        RUBY
+      end
+
+      def any *args, &block
+        route nil, *args, &block
+      end
+
+      def route method, path = '/', options = {}, &block
+        options = config[:endpoint].merge(handler: block).merge options
+        endpoint = Endpoint.new(options).extend config[:helper]
+        mount endpoint, (options[:conditions] || {}).merge(
+          at: path, method: method, anchor: true
+        )
+      end
+
+      def mount app, options = nil
+        if options
+          path = options.delete(:at) { '/' }
+        else
+          options = app
+          app, path = options.find { |k, v| k.respond_to? :call }
+          options.delete app if app
+        end
+
+        method = options.delete :method
+        method = %r{#{method.join '|'}}i if method.respond_to? :join
+
+        path_info = mount_path path, options
+        conditions = { path_info: path_info, request_method: method }
+
+        defaults = { format: config[:endpoint][:formats].first }
+        defaults[:version] = config[:version].to_s if config[:version]
+
+        config[:routes] << [app, conditions, defaults]
+      end
+
+      protected
+
+        attr_writer :config
+
+      private
+
+        def namespaced_config namespace, options = {}
+          parent_helper = config[:helper]
+          options.merge(
+            namespace: namespace,
+            endpoint: Util.deep_dup(config[:endpoint]),
+            helper: Helper.new { include parent_helper }
+          )
+        end
+
+        def app
+          @app ||= begin
+            generate_options_routes!
+            routes = Rack::Mount::RouteSet.new
+            config[:routes].each { |route| routes.add_route(*route) }
+            routes.freeze
+
+            if Crepe::API.running?
+              app = routes
+            else
+              builder = Rack::Builder.new
+              config[:middleware].each do |middleware, args, block|
+                builder.use middleware, *args, &block
+              end
+              builder.run routes
+              app = builder.to_app
+              Crepe::API.running!
+            end
+
+            app
+          end
+        end
+
+        def mount_path path, conditions
+          return path if path.is_a? Regexp
+
+          namespaces = config.all(:namespace).compact
+          separator = conditions.delete(:separator) { %w[ / . ? ] }
+          anchor = conditions.delete(:anchor) { false }
+
+          path = Util.normalize_path ['/', namespaces, path].join '/'
+          path << '(.:format)' if anchor
+
+          Rack::Mount::Strexp.compile path, conditions, separator, anchor
+        end
+
+        def generate_options_routes!
+          paths = config[:routes].group_by { |_, cond| cond[:path_info] }
+          paths.each do |path, routes|
+            allowed = routes.map { |_, cond| cond[:request_method] }
+
+            route 'OPTIONS', path do
+              headers['Allow'] = allowed.join ', '
+              { allow: allowed }
+            end
+            route METHODS - allowed, path do
+              headers['Allow'] = allowed.join ', '
+              error! :method_not_allowed, allow: allowed
+            end
+          end
+        end
+
+    end
+
+  end
+end

data/lib/crepe/endpoint.rb

@@ -0,0 +1,173 @@
+require 'active_support/core_ext/hash/deep_merge'
+require 'rack/utils'
+
+module Crepe
+  # A single API endpoint.
+  class Endpoint
+
+    autoload :Filter,   'crepe/endpoint/filter'
+    autoload :Renderer, 'crepe/endpoint/renderer'
+    autoload :Request,  'crepe/endpoint/request'
+
+    class << self
+
+      def default_config
+        {
+          after_filters: [],
+          before_filters: [
+            Filter::Acceptance,
+            Filter::Parser
+          ],
+          formats: [:json],
+          handler: nil,
+          renderers: Hash.new(Renderer::Tilt),
+          rescuers: []
+        }
+      end
+
+    end
+
+    attr_reader :config
+
+    attr_reader :env
+
+    attr_accessor :body
+
+    attr_reader :io
+
+    def initialize config = {}, &block
+      @config = self.class.default_config.deep_merge config
+      @status = 200
+
+      if block
+        warn 'block takes precedence over handler option' if @config[:handler]
+        @config[:handler] = block
+      end
+
+      if @config[:formats].empty?
+        raise ArgumentError, 'wrong number of formats (at least 1)'
+      end
+
+      @config.freeze
+    end
+
+    def call env
+      clone.call! env
+    end
+
+    def request
+      @request ||= Request.new env
+    end
+
+    def params
+      @params ||= Params.new request.params
+    end
+
+    def format
+      @format ||= params.fetch(:format, config[:formats].first).to_sym
+    end
+
+    def status value = nil
+      @status = Rack::Utils.status_code value if value
+      @status
+    end
+
+    def headers
+      @headers ||= {}
+    end
+
+    def content_type
+      @content_type ||= begin
+        extension = format == :json && params[:callback] ? :js : format
+        content_type = Rack::Mime.mime_type ".#{extension}"
+        vendor = config[:vendor]
+        version = params[:version]
+
+        if vendor || version
+          type, subtype = content_type.split '/'
+          content_type  = "#{type}/vnd.#{vendor || 'crepe'}"
+          content_type << ".#{version}" if version
+          content_type << "+#{subtype}"
+        end
+
+        content_type
+      end
+    end
+
+    def render object, options = {}
+      renderer = config[:renderers][format].new self
+      if io
+        io.puts renderer.render object, options
+      else
+        headers['Content-Type'] ||= content_type
+        self.body ||= catch(:head) { renderer.render object, options }
+      end
+    end
+
+    def stream
+      headers['rack.hijack'] = -> io { @io = io and yield }
+      throw :halt, [status, headers, nil]
+    end
+
+    def error! code = :bad_request, message = nil, data = {}
+      throw :halt, error(code, message, data)
+    end
+
+    def unauthorized! message = nil, data = {}
+      data, message = message, nil if message.respond_to? :each_pair
+      realm = data.delete(:realm) { config[:vendor] }
+      headers['WWW-Authenticate'] = %(Basic realm="#{realm}")
+      error! :unauthorized, message || data.delete(:message), data
+    end
+
+    protected
+
+      def call! env
+        @env = env
+
+        halt = catch :halt do
+          begin
+            config[:before_filters].each { |filter| run_filter filter }
+            render instance_eval(&config[:handler])
+            break
+          rescue => e
+            handle_exception e
+          end
+        end
+        render halt if halt
+        config[:after_filters].each { |filter| run_filter filter }
+
+        [status, headers, [body]]
+      end
+
+    private
+
+      def run_filter filter
+        return filter.filter self if filter.respond_to? :filter
+        filter = filter.to_proc if filter.respond_to? :to_proc
+        instance_eval(&filter)
+      end
+
+      def handle_exception exception
+        rescuer = config[:rescuers].find do |r|
+          exception.is_a? r[:exception_class]
+        end
+
+        if rescuer && rescuer[:block]
+          instance_exec exception, &rescuer[:block]
+        else
+          code = rescuer && rescuer[:options][:status] ||
+            :internal_server_error
+          error! code, exception.message, backtrace: exception.backtrace
+        end
+      end
+
+      def error code, message = nil, data = {}
+        data, message = message, nil if message.respond_to? :each_pair
+        status code
+        message ||= Rack::Utils::HTTP_STATUS_CODES[status]
+        { error: data.merge(message: message) }
+      end
+
+  end
+end

data/lib/crepe/endpoint/filter.rb

@@ -0,0 +1,10 @@
+module Crepe
+  class Endpoint
+    module Filter
+
+      autoload :Acceptance, 'crepe/endpoint/filter/acceptance'
+      autoload :Parser,     'crepe/endpoint/filter/parser'
+
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Crepe
+  class Endpoint
+    module Filter
+      # A default before filter that makes sure an endpoint is capable of
+      # responding with a format acceptable to the request.
+      class Acceptance
+
+        class << self
+
+          def filter endpoint
+            endpoint.instance_eval do
+              unless config[:formats].include? format
+                @format = config[:formats].first
+                not_acceptable = true
+              end
+
+              if [config[:vendor], env['crepe.vendor']].compact.uniq.length > 1
+                not_acceptable = true
+              end
+
+              if not_acceptable
+                error! :not_acceptable, accepts: config[:formats].map { |f|
+                  content_type.sub(/#{format}$/, f.to_s)
+                }
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end