goliath 0.9.4 → 1.0.0.beta.1

data/examples/env_use_statements.rb

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-$:<< '../lib' << 'lib'
-
-require 'goliath'
-require 'yajl'
-
-# API must be started with -e [production, development, ...]
-# or set your ENV['RACK_ENV'] to specify the environemtn
-
-class EnvUseStatements < Goliath::API
-  if Goliath.dev?
-    use Goliath::Rack::Render, 'json'
-  elsif Goliath.prod?
-    use Goliath::Rack::Render, 'xml'
-  end
-
-  def response(env)
-    [200, {}, {'Test' => 'Response'}]
-  end
-end

data/examples/favicon.rb

@@ -1,40 +0,0 @@
-#!/usr/bin/env ruby
-require 'time'
-
-#
-# Reads a favicon.ico statically at load time, renders it on any request for
-# '/favicon.ico', and sends every other request on downstream.
-#
-# If you will be serving even one more file than this one, you should instead
-# use Rack::Static:
-#
-#     use(Rack::Static, # render static files from ./public
-#            :root => Goliath::Application.app_path("public"),
-#            :urls => ["/favicon.ico", '/stylesheets', '/javascripts', '/images'])
-#
-class Favicon
-  def initialize(app, filename)
-    @@favicon  = File.read(filename)
-    @@last_mod = File.mtime(filename).utc.rfc822
-    @@expires  = Time.at(Time.now + 604800).utc.rfc822 # 1 week from now
-    @app = app
-  end
-
-  def call(env, *args)
-    if env['REQUEST_PATH'] == '/favicon.ico'
-      return [200, {"Last-Modified"=> @@last_mod.to_s, "Expires" => @@expires, "Content-Type"=>"image/vnd.microsoft.icon"}, @@favicon]
-    else
-      return @app.call(env)
-    end
-  end
-end
-
-if File.expand_path($0) == File.expand_path(__FILE__)
-  $:<< '../lib' << 'lib'
-  require 'goliath'
-  puts "starting hello world!"
-  class HelloWorld < Goliath::API
-    HelloWorld.use(Favicon, File.expand_path(File.dirname(__FILE__)+"/public/favicon.ico"))
-  end
-  require(File.dirname(__FILE__)+'/hello_world.rb')
-end

data/examples/rack_routes.rb

@@ -1,125 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-$:<< '../lib' << 'lib'
-
-require 'goliath'
-
-# Example demonstrating how to have an API acting as a router.
-# RackRoutes defines multiple uris and how to map them accordingly.
-# Some of these routes are redirected to other Goliath API.
-#
-# The reason why only the last API is being used by the Goliath Server
-# is because its name matches the filename.
-# All the APIs are available but by default the server will use the one
-# matching the file name.
-
-# Our custom Goliath API
-class HelloWorld < Goliath::API
-  def response(env)
-    [200, {}, "hello world!"]
-  end
-end
-
-class PostHelloWorld < Goliath::API
-  def response(env)
-    [200, {}, "hello post world!"]
-  end
-end
-
-class HeaderCollector < Goliath::API
-  def on_headers(env, header)
-    @headers ||= {}
-    @headers.merge!(header)
-  end
-
-  def response(env)
-    [200, {}, "headers: #{@headers.inspect}"]
-  end
-end
-
-class HelloNumber < Goliath::API
-  use Goliath::Rack::Params
-  def response(env)
-    [200, {}, "number #{params[:number]}!"]
-  end
-end
-
-class BigNumber < Goliath::API
-  use Goliath::Rack::Params
-  def response(env)
-    [200, {}, "big number #{params[:number]}!"]
-  end
-end
-
-class Bonjour < Goliath::API
-  def response(env)
-    [200, {}, "bonjour!"]
-  end
-end
-
-class Hola < Goliath::API
-  use Goliath::Rack::Params
-  use Goliath::Rack::Validation::RequiredParam, {:key => "foo"}
-
-  def response(env)
-    [200, {}, "hola!"]
-  end
-end
-
-class Aloha < Goliath::API
-  use Goliath::Rack::Validation::RequestMethod, %w(GET)
-
-  def response(env)
-    [200, {}, "Aloha"]
-  end
-end
-
-class RackRoutes < Goliath::API
-  map '/version' do
-    run Proc.new { |env| [200, {"Content-Type" => "text/html"}, ["Version 0.1"]] }
-  end
-
-  post "/hello_world" do
-    run PostHelloWorld.new
-  end
-
-  get "/hello_world" do
-    run HelloWorld.new
-  end
-
-  head "/hello_world" do
-    run HelloWorld.new
-  end
-
-  map "/headers", HeaderCollector do
-    use Goliath::Rack::Validation::RequestMethod, %w(GET)
-  end
-
-  map "/bonjour" do
-    run Bonjour.new
-  end
-
-  map "/hola" do
-    use Goliath::Rack::Validation::RequestMethod, %w(GET)
-    run Hola.new
-  end
-
-  map "/aloha", Aloha
-
-  map "/:number", :number => /\d+/ do
-    if params[:number].to_i > 100
-      run BigNumber.new
-    else
-      run HelloNumber.new
-    end
-  end
-
-  not_found('/') do
-    run Proc.new { |env| [404, {"Content-Type" => "text/html"}, ["Try /version /hello_world, /bonjour, or /hola"]] }
-  end
-
-  # You must use either maps or response, but never both!
-  def response(env)
-    raise RuntimeException.new("#response is ignored when using maps, so this exception won't raise. See spec/integration/rack_routes_spec.")
-  end
-end

data/examples/valid.rb

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-$:<< '../lib' << 'lib'
-
-require 'goliath'
-
-class Valid < Goliath::API
-  use Goliath::Rack::Params
-  use Goliath::Rack::Validation::RequiredParam, {:key => 'test'}
-
-  # If you are using Golaith version <=0.9.1 you need to use Goliath::Rack::ValidationError
-  # to prevent the request from remaining open after an error occurs
-  #use Goliath::Rack::ValidationError
-
-  def response(env)
-    [200, {}, 'OK']
-  end
-end

data/lib/goliath/deprecated/async_aroundware.rb

@@ -1,133 +0,0 @@
-module Goliath
-  module Rack
-    #
-    # Note: This class is deprecated. Instead, use BarrierAroundwareFactory
-    # (orchestrates multiple concurrent requests) or SimpleAroundwareFactory
-    # (like AsyncMiddleware, but with a simpler interface).
-    #
-    # The differences:
-    # * ResponseReceiver/MultiReceiver was a stupid name. The thing that has
-    #   pre_ and post_process is the Aroundware, the thing that manufactures
-    #   it is an AroundwareFactory.
-    # * An aroundware's pre_process may return a direct response, which is
-    #   immediately sent back upstream (no further downstream processing
-    #   happens). In the typical case, you will want to add
-    #       return Goliath::Connection::AsyncResponse
-    #   to your pre_process method.
-    # * ResponseReceiver used to masquerade as callback and middleware. Yuck.
-    #   The downstream response is now set via #accept_response, not #call.
-    #
-    # * change
-    #       use Goliath::Rack::AsyncAroundware, MyObsoleteReceiver
-    #   to
-    #       use Goliath::Rack::BarrierAroundwareFactory, MyHappyBarrier
-    # * `BarrierAroundware` provides the combined functionality of
-    #   `MultiReceiver` and `ResponseReceiver`, which will go away. It's now a
-    #   mixin (module) so you're not forced to inherit from it.
-    # * There is no more `responses` method: either use instance accessors or
-    #   look in the `successes`/`failures` hashes for yourresults.
-    # * Both enqueued responses and the downstream response are sent to
-    #   `accept_response`; there is no more  `call` method.
-    # * `MongoReceiver` will go away, because there's no need for it. See
-    #   `examples/auth_and_rate_limit.rb` for examples
-    #
-    class AsyncAroundware
-      include Goliath::Rack::Validator
-
-      #
-      # Called by the framework to create the middleware.
-      #
-      # Any extra args passed to the use statement are sent to each
-      # aroundware_klass as it is created.
-      #
-      # @example
-      #   class Awesomizer2011 < Goliath::Rack::MultiReceiver
-      #     def initialize(env, aq)
-      #       @awesomeness_quotient = aq
-      #       super(env)
-      #     end
-      #     # ... define pre_process and post_process ...
-      #   end
-      #
-      #   class AwesomeApiWithShortening < Goliath::API
-      #     use Goliath::Rack::AsyncAroundware, Awesomizer2011, 3
-      #     # ... stuff ...
-      #   end
-      #
-      # @param app [#call] the downstream app
-      # @param aroundware_klass a class that quacks like a
-      #   Goliath::Rack::ResponseReceiver and an EM::Deferrable
-      # @param *args [Array] extra args to pass to the aroundware
-      # @return [Goliath::Rack::AsyncAroundware]
-      def initialize app, aroundware_klass, *args
-        @app = app
-        @aroundware_klass = aroundware_klass
-        @aroundware_args  = args
-      end
-
-      # Coordinates aroundware to process a request.
-      #
-      # We hook the aroundware in the middle of the async_callback chain:
-      # * send the downstream response to the aroundware, whether received directly
-      #   from @app.call or via async callback
-      # * have the upstream callback chain be invoked when the aroundware completes
-      #
-      # @param env [Goliath::Env] The goliath environment
-      # @return [Array] The [status_code, headers, body] tuple
-      def call(env)
-        aroundware = new_aroundware(env)
-
-        aroundware_resp = aroundware.pre_process
-
-        hook_into_callback_chain(env, aroundware)
-
-        downstream_resp = @app.call(env)
-
-        # if downstream resp is final, pass it to the aroundware; it will invoke
-        # the callback chain at its leisure. Our response is *always* async.
-        if final_response?(downstream_resp)
-          aroundware.call(downstream_resp)
-        end
-        return Goliath::Connection::AsyncResponse
-      end
-
-      # Put aroundware in the middle of the async_callback chain:
-      # * save the old callback chain;
-      # * have the downstream callback send results to the aroundware (possibly
-      #   completing it)
-      # * set the old callback chain to fire when the aroundware completes
-      def hook_into_callback_chain(env, aroundware)
-        async_callback = env['async.callback']
-
-        # The response from the downstream app is accepted by the aroundware...
-        downstream_callback = Proc.new do |resp|
-          safely(env){ aroundware.call(resp) }
-        end
-
-        # .. but the upstream chain is only invoked when the aroundware completes
-        invoke_upstream_chain = Proc.new do
-          new_resp = safely(env){ aroundware.post_process }
-          async_callback.call(new_resp)
-        end
-
-        env['async.callback'] = downstream_callback
-        aroundware.callback(&invoke_upstream_chain)
-        aroundware.errback(&invoke_upstream_chain)
-      end
-
-      def final_response?(resp)
-        resp != Goliath::Connection::AsyncResponse
-      end
-
-      # Generate a aroundware to process the request, using request env & any args
-      # passed to this AsyncAroundware at creation
-      #
-      # @param env [Goliath::Env] The goliath environment
-      # @return [Goliath::Rack::ResponseReceiver] The response_receiver to process this request
-      def new_aroundware(env)
-        @aroundware_klass.new(env, *@aroundware_args)
-      end
-
-    end
-  end
-end

data/lib/goliath/deprecated/mongo_receiver.rb

@@ -1,84 +0,0 @@
-require 'goliath/deprecated/response_receiver'
-require 'em-synchrony/em-mongo'
-
-module Goliath
-  module Synchrony
-    #
-    # Note: This class is deprecated. Please instead use BarrierAroundware
-    # (orchestrates multiple concurrent requests) or SimpleAroundware (like
-    # AsyncMiddleware, but with a simpler interface).
-    #
-    # There are more notes on the lib/goliath/deprecated/async_aroundware docs.
-    #
-    # ___________________________________________________________________________
-    #
-    # Currently, you must provide in the env a method 'mongo' that returns a mongo
-    # collection or collection proxy (probably by setting it up in the config).
-    #
-    # This will almost certainly change to something less crappy.
-    #
-    class MongoReceiver
-      include Goliath::Synchrony::ResponseReceiver
-      include EM::Deferrable
-      include Goliath::Rack::Validator
-
-      def initialize(env, db_name)
-        @env = env
-        @pending_queries = 0
-        @db = env.config[db_name]
-      end
-
-      def db
-        @db
-      end
-
-      def finished?
-        response_received? && (@pending_queries == 0)
-      end
-
-      def enqueue(handle, req_id)
-        # ... requests aren't deferrables so they're tracked in @pending_queries
-      end
-
-      if defined?(EM::Mongo::Cursor)
-        def find(collection, selector={}, opts={}, &block)
-          @pending_queries += 1
-          db.collection(collection).afind(selector, opts).to_a.callback do |result|
-            yield result
-            @pending_queries -= 1
-            self.succeed if finished?
-          end
-        end
-      else
-        def find(collection, selector={}, opts={}, &block)
-          @pending_queries += 1
-          db.collection(collection).afind(selector, opts) do |result|
-            yield result
-            @pending_queries -= 1
-            self.succeed if finished?
-          end
-        end
-      end
-
-      def first(collection, selector={}, opts={}, &block)
-        opts[:limit] = 1
-        self.find(collection, selector, opts) do |result|
-          yield result.first
-        end
-      end
-
-      def insert(collection, *args)
-        db.collection(collection).insert(*args)
-      end
-      def update(collection, *args)
-        db.collection(collection).update(*args)
-      end
-      def save(collection, *args)
-        db.collection(collection).save(*args)
-      end
-      def remove(collection, *args)
-        db.collection(collection).remove(*args)
-      end
-    end
-  end
-end

data/lib/goliath/deprecated/response_receiver.rb

@@ -1,97 +0,0 @@
-module Goliath
-  module Synchrony
-
-    #
-    # Note: This class is deprecated. Please instead use BarrierAroundware
-    # (orchestrates multiple concurrent requests) or SimpleAroundware (like
-    # AsyncMiddleware, but with a simpler interface).
-    #
-    # There are more notes on the lib/goliath/deprecated/async_aroundware docs.
-    #
-    module ResponseReceiver
-      # The request environment, set in the initializer
-      attr_reader :env
-      # The response, set by the ResponseReceiver's downstream
-      attr_accessor :status, :headers, :body
-
-      # Override this method in your middleware to perform any preprocessing
-      # (launching a deferred request, perhaps).
-      #
-      # @return [Array] array contains [status, headers, body]
-      def pre_process
-        Goliath::Connection::AsyncResponse
-      end
-
-      # Override this method in your middleware to perform any postprocessing.
-      # This will only be invoked when all deferred requests (including the
-      # response) have completed.
-      #
-      # @return [Array] array contains [status, headers, body]
-      def post_process
-        [status, headers, body]
-      end
-
-      # Virtual setter for the downstream middleware/endpoint response
-      def downstream_resp=(status_headers_body)
-        @status, @headers, @body = status_headers_body
-      end
-
-      # Invoked by the async_callback chain. Stores the [status, headers, body]
-      # for post_process'ing
-      def call resp
-        return resp if resp.first == Goliath::Connection::AsyncResponse.first
-        self.downstream_resp = resp
-        check_progress(nil)
-      end
-
-      # Have we received a response?
-      def response_received?
-        !! @status
-      end
-
-    protected
-
-      def check_progress(fiber)
-        if finished?
-          succeed
-          # continue processing
-          fiber.resume(self) if fiber && fiber.alive? && fiber != Fiber.current
-        end
-      end
-    end
-
-    #
-    # Note: This class is deprecated. Please instead use BarrierAroundware
-    # (orchestrates multiple concurrent requests) or SimpleAroundware (like
-    # AsyncMiddleware, but with a simpler interface).
-    #
-    # There are more notes on the lib/goliath/deprecated/async_aroundware docs.
-    #
-    class MultiReceiver < EM::Synchrony::Multi
-      include ResponseReceiver
-
-      # Create a new MultiReceiver
-      # @param env [Goliath::Env] the current environment
-      def initialize env
-        @env = env
-        super()
-      end
-
-      alias_method :enqueue, :add
-
-      def successes
-        responses[:callback]
-      end
-
-      def failures
-        responses[:errback]
-      end
-
-      # Finished if we received a response and the multi request is finished
-      def finished?
-        super && response_received?
-      end
-    end
-
-  end
-end

data/spec/integration/rack_routes_spec.rb

@@ -1,169 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require File.join(File.dirname(__FILE__), '../../', 'examples/rack_routes')
-
-describe RackRoutes do
-  let(:err) { Proc.new { fail "API request failed" } }
-
-  context "when using maps" do
-
-    it "ignores #response" do
-      expect {
-        with_api(RackRoutes) do
-          get_request({:path => '/'}, err) {}
-        end
-      }.to_not raise_error
-    end
-
-    it 'fallback not found to missing' do
-      with_api(RackRoutes) do
-        get_request({:path => '/donkey'}, err) do |cb|
-          cb.response_header.status.should == 404
-          cb.response.should == 'Try /version /hello_world, /bonjour, or /hola'
-        end
-      end
-      with_api(RackRoutes) do
-        get_request({:path => '/'}, err) do |cb|
-          cb.response_header.status.should == 404
-          cb.response.should == 'Try /version /hello_world, /bonjour, or /hola'
-        end
-      end
-    end
-
-    it 'fallback not found to /' do
-      with_api(RackRoutes) do
-        get_request({:path => '/donkey'}, err) do |cb|
-          cb.response_header.status.should == 404
-          cb.response.should == 'Try /version /hello_world, /bonjour, or /hola'
-        end
-      end
-    end
-
-    it 'routes to the correct API' do
-      with_api(RackRoutes) do
-        get_request({:path => '/bonjour'}, err) do |c|
-          c.response_header.status.should == 200
-          c.response.should == 'bonjour!'
-        end
-      end
-    end
-
-    it 'routes to the correct API using regex filters' do
-      with_api(RackRoutes) do
-        get_request({:path => '/98'}, err) do |c|
-          c.response_header.status.should == 200
-          c.response.should == 'number 98!'
-        end
-      end
-    end
-
-    it 'routes to the correct API referencing params in the body of the buidler' do
-      with_api(RackRoutes) do
-        get_request({:path => '/123123'}, err) do |c|
-          c.response_header.status.should == 200
-          c.response.should == 'big number 123123!'
-        end
-      end
-    end
-
-    context 'sinatra style route definition' do
-      it 'should honor the request method' do
-        with_api(RackRoutes) do
-          post_request({:path => '/hello_world'}, err) do |c|
-            c.response_header.status.should == 200
-            c.response.should == 'hello post world!'
-          end
-        end
-      end
-
-      it 'should reject other request methods' do
-        with_api(RackRoutes) do
-          put_request({:path => '/hello_world'}, err) do |c|
-            c.response_header.status.should == 405
-            c.response_header['ALLOW'].split(/, /).should == %w(GET HEAD POST)
-          end
-        end
-      end
-    end
-
-    context 'routes defined with get' do
-      it 'should allow get' do
-        with_api(RackRoutes) do
-          get_request({:path => '/hello_world'}, err) do |c|
-            c.response_header.status.should == 200
-            c.response.should == 'hello world!'
-          end
-        end
-      end
-    end
-
-    context 'routes defined with head' do
-      it 'should allow head' do
-        with_api(RackRoutes) do
-          head_request({:path => '/hello_world'}, err) do |c|
-            c.response_header.status.should == 200
-            c.response.should == 'hello world!'
-          end
-        end
-      end
-    end
-
-    context "defined in blocks" do
-      it 'uses middleware defined in the block' do
-        with_api(RackRoutes) do
-          post_request({:path => '/hola'}, err) do |c|
-            # the /hola route only supports GET requests
-            c.response_header.status.should == 405
-            c.response.should == '[:error, "Invalid request method"]'
-            c.response_header['ALLOW'].should == 'GET'
-          end
-        end
-      end
-
-      it "doesn't use middleware defined in the API" do
-        with_api(RackRoutes) do
-          get_request({:path => '/hola'}, err) do |cb|
-            # it doesn't raise required param error
-            cb.response_header.status.should == 200
-            cb.response.should == "hola!"
-          end
-        end
-      end
-    end
-
-    context "defined in classes" do
-      it 'uses API middleware' do
-        with_api(RackRoutes) do
-          post_request({:path => '/aloha'}, err) do |c|
-            # the /hola route only supports GET requests
-            c.response_header.status.should == 405
-            c.response.should == '[:error, "Invalid request method"]'
-            c.response_header['ALLOW'].should == 'GET'
-          end
-        end
-      end
-    end
-
-    context "with event handlers" do
-      it "collects header events" do
-        with_api(RackRoutes) do
-          get_request({:path => '/headers'}, err) do |c|
-            c.response_header.status.should == 200
-            c.response.should == 'headers: {"Connection"=>"close", "Host"=>"localhost:9900", "User-Agent"=>"EventMachine HttpClient"}'
-          end
-        end
-      end
-
-      it "rejects POST request" do
-        with_api(RackRoutes) do
-          post_request({:path => '/headers'}, err) do |c|
-            # the /headers route only supports GET requests
-            c.response_header.status.should == 405
-            c.response.should == '[:error, "Invalid request method"]'
-            c.response_header['ALLOW'].should == 'GET'
-          end
-        end
-      end
-    end
-  end
-end