grapeape 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d68ce46191052f09bdbbf499ebae1fd5bb9e48d9
+  data.tar.gz: 38e7d9103f7f8c389c7db49bbf1653cc6de502f6
+SHA512:
+  metadata.gz: edb0b9d3ac677a0145999073dee62348ecd80a21692ad64a4949609d2fa0018a186384983b1bbcefd1fc996d8a5b6c77f0a49ea717433393e628f0ea5daad6b3
+  data.tar.gz: 555485bfe9218645b428328ecd0d3eeab1806683ecb8192b8cd1e4a99e4af11ed6f10536bc0212e83cd0085a342b5ce3ae1885f79e1bc8b93def986cb0b54da2

data/.gitignore

@@ -0,0 +1,26 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+Gemfile.lock
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+# Rubymine artifacts
+.idea/
+
+# RVM
+.ruby-version
+.ruby-gemset

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+ - 2.0.0 
+services:
+ - rabbitmq

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+ruby '2.0.0'
+
+# Specify your gem's dependencies in grapeape.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 David Justice
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+# GrapeApe
+
+[![Code Climate](https://codeclimate.com/github/devigned/grapeape.png)](https://codeclimate.com/github/devigned/grapeape)
+[![Build Status](https://travis-ci.org/devigned/grapeape.png)](https://travis-ci.org/devigned/grapeape)
+[![Coverage Status](https://coveralls.io/repos/devigned/grapeape/badge.png?branch=master)](https://coveralls.io/r/devigned/grapeape?branch=master)
+
+Eventmachine driven distributed web API in ruby. The project stands up an event driven web API
+([goliath](http://postrank-labs.github.io/goliath/) / [grape](http://intridea.github.io/grape/)) backed by
+[AMQP](http://www.amqp.org/). AMQP is used to route messages from the web to a collection of event driven worker
+processes in an RPC flow.
+
+Note: this is not ready for primetime
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'grapeape'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install grapeape
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler/gem_tasks'
+require 'rubygems'
+require 'rake'
+
+def safe_load
+  begin
+    yield
+  rescue LoadError => ex
+    puts 'Error loading rake tasks, but will continue...'
+    puts ex.message
+  end
+end
+
+safe_load do
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+end
+
+task :default => [:spec]

data/examples/hello_world/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+ruby '2.0.0'
+
+gem 'grapeape', path: '../../'

data/examples/hello_world/Procfile

@@ -0,0 +1,2 @@
+web: bundle exec ruby api.rb -sv
+worker: bundle exec ruby worker.rb

data/examples/hello_world/api.rb

@@ -0,0 +1,7 @@
+require 'grape_ape'
+
+class Api < GrapeApe::API
+  format :json
+
+  get '/', routing_key: 'foo', method: 'hello_world'
+end

data/examples/hello_world/worker.rb

@@ -0,0 +1,9 @@
+require 'grape_ape'
+
+class Worker < GrapeApe::Worker
+  routing_key :foo
+
+  def hello_world(request)
+    'Hello World!!'
+  end
+end

data/grape_ape.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'grape_ape/version'
+
+Gem::Specification.new do |s|
+  s.platform      = Gem::Platform::RUBY
+  s.name          = 'grapeape'
+  s.version       = GrapeApe::VERSION
+  s.authors       = ['David Justice']
+  s.email         = %w(david@devigned.com)
+  s.description   = 'Message based, event driven web dsl in ruby'
+  s.summary       = <<-MSG
+Message based, event driven web dsl in ruby. The project stands up an event driven web (goliath / grape) dsl backed by
+AMQP. AMQP is used to route messages from the web to a collection of event driven worker processes in an RPC flow.
+
+This could be used to set up a quick [CQRS](http://martinfowler.com/bliki/CQRS.html) architecture.
+  MSG
+  s.homepage      = ''
+  s.license       = 'MIT'
+  s.required_ruby_version = '>= 2.0.0'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = %w(lib)
+
+  s.add_development_dependency 'bundler', '~> 1.3'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rack-test'
+  s.add_development_dependency 'em-http-request'
+  s.add_development_dependency 'coveralls'
+
+  s.add_dependency 'goliath'
+  s.add_dependency 'grape'
+  s.add_dependency 'amqp'
+  s.add_dependency 'activesupport'
+end

data/lib/grape_ape.rb

@@ -0,0 +1,15 @@
+require 'hashie'
+require 'active_support/json'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'grape'
+require 'grape_ape/version'
+require 'amqp'
+
+module GrapeApe
+  autoload :API,            'grape_ape/api'
+  autoload :Dispatcher,     'grape_ape/dispatcher'
+  autoload :Endpoint,       'grape_ape/endpoint'
+  autoload :Worker,         'grape_ape/worker'
+  autoload :Server,         'grape_ape/server'
+end
+

data/lib/grape_ape/api.rb

@@ -0,0 +1,48 @@
+require 'active_support/core_ext/class/attribute'
+require 'grape_ape/goliath/application_patch'
+
+module GrapeApe
+  class API < Grape::API
+    REQUIRED_ROUTE_KEYS = [:routing_key, :method]
+
+    cattr_accessor :app_class
+
+    class << self
+      def inherited(subclass)
+        super
+        GrapeApe::API.app_class = subclass.name if defined?(GrapeApe::API)
+      end
+
+      def route(methods, paths = %w(/), route_options = {}, &block)
+        if ape_route?(route_options)
+          endpoint_options = {
+              :method => methods,
+              :path => paths,
+              :route_options => (@namespace_description || {}).deep_merge(@last_description || {}).deep_merge(route_options || {})
+          }
+
+          endpoints << GrapeApe::Endpoint.new(settings.clone, endpoint_options) do
+            message = rpc(env, route_options[:routing_key], {method: route_options[:method], params: params})
+            if block
+              block.call(message)
+            else
+              message
+            end
+          end
+
+          @last_description = nil
+          reset_validations!
+        else
+          super
+        end
+      end
+
+      private
+
+      def ape_route?(route_options)
+        keys = Set.new(route_options.keys)
+        Set[*REQUIRED_ROUTE_KEYS].subset?(keys)
+      end
+    end
+  end
+end

data/lib/grape_ape/consumer/application.rb

@@ -0,0 +1,66 @@
+require 'active_support/core_ext/class/attribute'
+require 'eventmachine'
+require 'em-synchrony'
+require 'amqp'
+
+module GrapeApe
+  module Consumer
+    module Application
+
+      module_function
+
+      def amqp_channel
+        @channel
+      end
+
+      def register(routing_key, klass)
+        @keys_and_klasses ||= {}
+        @keys_and_klasses[routing_key] = klass
+      end
+
+      def run!
+        start do
+          connect
+        end
+      end
+
+      def connect
+        AMQP.connect do |connection|
+          @channel = AMQP::Channel.new(connection)
+
+          @keys_and_klasses.each do |key, value|
+            q = @channel.queue(key, :auto_delete => true)
+            q.subscribe do |metadata, payload|
+              value.new.handle_message(metadata, payload)
+            end
+          end
+        end
+      end
+
+      # Stops the consumer running.
+      def stop
+        logger.info('Stopping the consumers...')
+        EM.stop
+      end
+
+      def start
+        EM.epoll
+        EM.synchrony do
+          trap('INT') { stop }
+          trap('TERM') { stop }
+          yield if block_given?
+        end
+      end
+
+      at_exit do
+        # Only run the application if ...
+        #  - we want it to run
+        #  - there has been no exception raised
+        #  - the file that has been run, is the goliath application file
+        if $!.nil?
+          Application.run!
+        end
+      end
+    end
+  end
+end

data/lib/grape_ape/dispatcher.rb

@@ -0,0 +1,22 @@
+module GrapeApe
+  module Dispatcher
+    def rpc(env, queue_name, message = {})
+      f = Fiber.current
+      response = nil
+      env['subscription'] = env.grape_amqp_em_channel.subscribe do |msg|
+        if msg[:meta].correlation_id == env['correlation_id']
+          response = msg[:data]
+          f.resume
+        end
+      end
+
+      env['correlation_id'] = SecureRandom.uuid
+      env.grape_amqp_exchange.publish(message.to_json,
+                          routing_key: queue_name,
+                          reply_to: env.grape_amqp_response_queue,
+                          correlation_id: env['correlation_id'])
+      Fiber.yield
+      JSON.parse(response)
+    end
+  end
+end

data/lib/grape_ape/endpoint.rb

@@ -0,0 +1,5 @@
+module GrapeApe
+  class Endpoint < Grape::Endpoint
+    include GrapeApe::Dispatcher
+  end
+end

data/lib/grape_ape/goliath/application_patch.rb

@@ -0,0 +1,47 @@
+require 'goliath'
+require 'goliath/websocket'
+require 'grape_ape'
+require 'grape_ape/goliath/server'
+require 'grape_ape/goliath/runner'
+
+Goliath::Application.module_eval do
+
+  Goliath::Application::CALLERS_TO_IGNORE << /\/grape_ape\/goliath_runner.rb$/
+  Goliath::Application::CALLERS_TO_IGNORE << /\/ruby-debug-ide-(.+)\//
+  Goliath::Application::CALLERS_TO_IGNORE << /\/debase\//
+
+  module_function
+
+  def camel_case(str)
+    return str if str !~ /_/ && str =~ /[A-Z]+.*/
+
+    str.split('_').map { |e| e.capitalize }.join
+  end
+
+  alias :super_run! :run!
+
+  # Execute the application
+  #
+  # @return [Nil]
+  def run!
+    if GrapeApe::API.app_class
+      begin
+        klass = Kernel
+        GrapeApe::API.app_class.split('::').each { |con| klass = klass.const_get(con) }
+        api = GrapeApe::Server.new(api: klass)
+      rescue NameError
+        raise NameError, "Class #{@app_class} not found."
+      end
+
+      runner = GrapeApe::Goliath::Runner.new(ARGV, api)
+      runner.app = Goliath::Rack::Builder.build(GrapeApe::Server, api)
+
+      runner.load_plugins(GrapeApe::Server.plugins)
+
+      runner.run
+    else
+      super_run!
+    end
+  end
+
+end

data/lib/grape_ape/goliath/runner.rb

@@ -0,0 +1,24 @@
+require 'goliath/runner'
+require 'grape_ape/goliath/server'
+
+module GrapeApe
+  module Goliath
+    class Runner < ::Goliath::Runner
+
+      # Sets up the Goliath server
+      #
+      # @param log [Logger] The logger to configure the server to log to
+      # @return [Server] an instance of a Goliath server
+      def setup_server(log = setup_logger)
+        server = GrapeApe::Goliath::Server.new(@address, @port)
+        server.logger = log
+        server.app = @app
+        server.api = @api
+        server.plugins = @plugins || []
+        server.options = @server_options
+        server
+      end
+
+    end
+  end
+end

data/lib/grape_ape/goliath/server.rb

@@ -0,0 +1,67 @@
+require 'eventmachine'
+
+module GrapeApe
+  module Goliath
+    class Server < ::Goliath::Server
+      def start(&blk)
+        EM.epoll
+        EM.synchrony do
+          trap('INT') { stop }
+          trap('TERM') { stop }
+
+          if RUBY_PLATFORM !~ /mswin|mingw/
+            trap('HUP') { load_config(options[:config]) }
+          end
+
+          load_config(options[:config])
+          load_plugins
+          setup_amqp
+
+          EM.set_effective_user(options[:user]) if options[:user]
+
+          config[::Goliath::Constants::GOLIATH_SIGNATURE] = EM.start_server(address, port, ::Goliath::Connection) do |conn|
+            if options[:ssl]
+              conn.start_tls(
+                  :private_key_file => options[:ssl_key],
+                  :cert_chain_file => options[:ssl_cert],
+                  :verify_peer => options[:ssl_verify]
+              )
+            end
+
+            conn.port = port
+            conn.app = app
+            conn.api = api
+            conn.logger = logger
+            conn.status = status
+            conn.config = config
+            conn.options = options
+          end
+
+          blk.call(self) if blk
+        end
+      end
+
+      def stop
+        logger.info('Stopping server...')
+        config['grape_amqp_conn'].close { EM.stop }
+      end
+
+      def setup_amqp
+        config['grape_amqp_conn'] = AMQP.connect(on_possible_authentication_failure: Proc.new { |settings|
+          logger.info "Authentication failed, as expected, settings are: #{settings.inspect}"
+          EM.stop
+        })
+        config['grape_amqp_channel'] = AMQP::Channel.new(config['grape_amqp_conn'])
+        config['grape_amqp_exchange'] = config['grape_amqp_channel'].default_exchange
+        config['grape_amqp_response_queue'] = SecureRandom.uuid
+        config['grape_amqp_em_channel'] = EM::Channel.new
+
+        q = config['grape_amqp_channel'].queue(config['grape_amqp_response_queue'], exclusive: true)
+
+        q.subscribe do |meta, payload|
+          config['grape_amqp_em_channel'].push({meta: meta, data: payload})
+        end
+      end
+    end
+  end
+end

data/lib/grape_ape/server.rb

@@ -0,0 +1,15 @@
+require 'goliath'
+require 'goliath/api'
+require 'goliath/websocket'
+
+module GrapeApe
+  class Server < ::Goliath::API
+    def initialize(opts = {})
+      @api = opts.delete(:api)
+    end
+
+    def response(env)
+      @api.call(env)
+    end
+  end
+end

data/lib/grape_ape/test_helper.rb

@@ -0,0 +1,41 @@
+require 'goliath/test_helper'
+
+module GrapeApe
+  module TestHelper
+    include ::Goliath::TestHelper
+
+    # Wrapper for launching API and executing given code block. This
+    # will start the EventMachine reactor running.
+    #
+    # @param api [Class] The GrapeApe::API class to launch
+    # @param options [Hash] The options to pass to the server
+    # @param blk [Proc] The code to execute after the server is launched.
+    # @note This will not return until stop is called.
+    def with_api(api, options = {}, &blk)
+      server(GrapeApe::Server.new(api: api), options.delete(:port) || 9900, options, &blk)
+    end
+
+    # Launches an instance of a given API server. The server
+    # will launch on the specified port.
+    #
+    # @param api [Class] The API class to launch
+    # @param port [Integer] The port to run the server on
+    # @param options [Hash] The options hash to provide to the server
+    # @return [Goliath::Server] The executed server
+    def server(api, port, options = {}, &blk)
+      op = OptionParser.new
+
+      s = GrapeApe::Goliath::Server.new
+      s.logger = setup_logger(options)
+      s.api = api
+      s.app = ::Goliath::Rack::Builder.build(api.class, s.api)
+      s.api.options_parser(op, options)
+      s.options = options
+      s.port = port
+      s.plugins = api.class.plugins
+      @test_server_port = s.port if blk
+      s.start(&blk)
+      s
+    end
+  end
+end

data/lib/grape_ape/version.rb

@@ -0,0 +1,3 @@
+module GrapeApe
+  VERSION = '0.0.1'
+end

data/lib/grape_ape/worker.rb

@@ -0,0 +1,39 @@
+require 'grape_ape/consumer/application'
+
+module GrapeApe
+  class Worker
+    class << self
+
+      attr_reader :routing_key
+
+      def routing_key(key)
+        @routing_key = key
+        Consumer::Application.register(key, self)
+      end
+    end
+
+    def handle_message(metadata, payload)
+      payload = JSON.parse(payload).with_indifferent_access
+      response = if respond_to?(payload[:method].to_sym)
+                   begin
+                     ok(send(payload[:method].to_sym, payload[:params]))
+                   rescue Exception => ex
+                     error({message: ex.message, backtrace: ex.backtrace})
+                   end
+                 else
+                   error("Worker listening to routing_key: #{self.routing_key} does not have method: #{payload[:method]}")
+                 end
+      Consumer::Application.amqp_channel.default_exchange.publish(response.to_json,
+                                       routing_key: metadata.reply_to,
+                                       correlation_id: metadata.correlation_id)
+    end
+
+    def ok(response)
+      [:ok, response]
+    end
+
+    def error(response)
+      [:error, response]
+    end
+  end
+end

data/spec/api_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe GrapeApe::API do
+
+  before(:each) do
+    described_class.endpoints.clear
+  end
+
+  subject { Class.new(GrapeApe::API) }
+
+  def app;
+    subject
+  end
+
+  describe '.route' do
+    let(:ape_options) { {routing_key: 'blah', method: 'hello'} }
+
+    it 'should ask if the route is an ape route' do
+      described_class.should_receive(:ape_route?).with(hash_including(ape_options)).and_return(true)
+      described_class.route(:get, '/', ape_options)
+    end
+
+    it 'should call super route with no ape route options' do
+      described_class.superclass.should_receive(:route)
+      described_class.route(:get, '/')
+    end
+
+    it 'should add an endpoint to the endpoint collection' do
+      expect {
+        described_class.route(:get, '/', ape_options)
+      }.to change { described_class.endpoints.count }.from(0).to(1)
+    end
+
+    context 'api responses' do
+      it 'returns the message that rpc returns with out a block provided to the dsl method' do
+        subject.get '/', ape_options
+        GrapeApe::Endpoint.any_instance.should_receive(:rpc).and_return('hello_world')
+        get '/'
+        last_response.body.should eql 'hello_world'
+      end
+
+      it 'should pass the rpc message to the provided block for processing' do
+        subject.get '/', ape_options do |message|
+          'hello ' + message
+        end
+        GrapeApe::Endpoint.any_instance.should_receive(:rpc).and_return('world')
+        get '/'
+        last_response.body.should eql 'hello world'
+      end
+    end
+  end
+end

data/spec/dispatcher_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe GrapeApe::Dispatcher do
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'support'))
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'grape_ape'
+require 'rubygems'
+require 'bundler'
+require 'rack/test'
+Bundler.setup :default, :test
+
+Dir["#{File.dirname(__FILE__)}/support/*.rb"].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.order = 'random'
+  config.include Rack::Test::Methods
+end

data/spec/test_helper_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'grape_ape/test_helper'
+
+describe GrapeApe::TestHelper do
+  include GrapeApe::TestHelper
+
+  class TestApi < GrapeApe::API
+    format :json
+
+    get '/' do
+      {hello: 'world'}
+    end
+  end
+
+  context 'make request to root' do
+    it 'should get a 200' do
+      with_api(TestApi) do
+        em_http_client = get_request path: '/'
+        em_http_client.response_header.status.should eq(200)
+      end
+    end
+
+    it 'should get json' do
+      with_api(TestApi) do
+        em_http_client = get_request path: '/'
+        JSON.parse(em_http_client.response).should eq({'hello' => 'world'})
+      end
+    end
+  end
+
+  context 'make request to not routed path' do
+    it 'get a 404' do
+      with_api(TestApi) do
+        em_http_client = get_request path: '/something'
+        em_http_client.response_header.status.should eq(404)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,219 @@
+--- !ruby/object:Gem::Specification
+name: grapeape
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Justice
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: goliath
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: grape
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: amqp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Message based, event driven web dsl in ruby
+email:
+- david@devigned.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- examples/hello_world/Gemfile
+- examples/hello_world/Procfile
+- examples/hello_world/api.rb
+- examples/hello_world/worker.rb
+- grape_ape.gemspec
+- lib/grape_ape.rb
+- lib/grape_ape/api.rb
+- lib/grape_ape/consumer/application.rb
+- lib/grape_ape/dispatcher.rb
+- lib/grape_ape/endpoint.rb
+- lib/grape_ape/goliath/application_patch.rb
+- lib/grape_ape/goliath/runner.rb
+- lib/grape_ape/goliath/server.rb
+- lib/grape_ape/server.rb
+- lib/grape_ape/test_helper.rb
+- lib/grape_ape/version.rb
+- lib/grape_ape/worker.rb
+- spec/api_spec.rb
+- spec/dispatcher_spec.rb
+- spec/spec_helper.rb
+- spec/test_helper_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Message based, event driven web dsl in ruby. The project stands up an event
+  driven web (goliath / grape) dsl backed by AMQP. AMQP is used to route messages
+  from the web to a collection of event driven worker processes in an RPC flow.  This
+  could be used to set up a quick [CQRS](http://martinfowler.com/bliki/CQRS.html)
+  architecture.
+test_files:
+- spec/api_spec.rb
+- spec/dispatcher_spec.rb
+- spec/spec_helper.rb
+- spec/test_helper_spec.rb