reck 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e42763c73766c0f37b6d11774d0ae7d4c090e933142a293ab4fa8020fbc115c3
-  data.tar.gz: 0b34320493ef0739d2bbe5c6c21ae2bd28b02c823de789172f302f5bd930f884
+  metadata.gz: c9e41fabc8f64172e6a876965805f8809f023d6a69a4c72658fab8e5ad5e7a7f
+  data.tar.gz: a7728943273b489293f1427c7a13d39527ebd7e401dccc91b4c52131583f0434
 SHA512:
-  metadata.gz: 605e3033cafec280edff30012a1214ed09df89c012488f7a762ce63014410a668a7f20742899898681b538ae84a84d52207965fcdc12996720d187fe1078f5d1
-  data.tar.gz: 70bcdc64891926d594082827225d43bf29c3490cb095478b5b1656784a73d4f0da64382073ac3ad43c13800fcd165eff707b6d71c0d253de80204ba7befeedd2
+  metadata.gz: b223feb28dc8c6e0f4a0dcbeacb529bab88cfc115a8ec9152e6df508835221e4145455c4146c45a1d2609e1e3f7cd948024be02554b137049a0a35af6ba7101d
+  data.tar.gz: d471b6fb88845324c7ae227e4e94ff1a00c2727fa1684e5d57d8728533444e02c1e4d919d66691256efa120173b2704545f8ec2726264cd505d448d7724f3295

data/README.md

@@ -2,20 +2,22 @@
 
 An exception-based web framework for Ruby.
 
-# Why another framework?
+[![Build Status](https://travis-ci.org/honeybadger-io/reck.svg?branch=master)](https://travis-ci.org/honeybadger-io/reck)
+[![Gem Version](https://badge.fury.io/rb/reck.svg)](https://badge.fury.io/rb/reck)
+
+---
+:zap: Brought to you by **Honeybadger.io**: Zero-instrumentation, 360 degree
+coverage of errors, outages and service degradation. [Deploy with confidence and
+be your team's devops
+hero!](https://www.honeybadger.io/?utm_source=github&utm_medium=readme&utm_campaign=reck)
+:zap:
 
-If you've ever programmed in Ruby on Rails, you know that it prefers convention
-over configuration. We believe this approach works well as a design paradigm but
-falls down over time (just ask anyone who has maintained a Rails application
-since version 1). In order to remain competitive with newer high-level (and
-often concurrent) programming languages like Node and Elixir, Ruby needs a
-strong component-based framework which let's you use the *right* tool for the
-job.
+# Why another framework?
 
 Reck is very light-weight compared to other web frameworks such as Rails
-or even Sinatra. We handle the routing and controller layer using a very simple
-exception-based DSL and then get out of the way so that any existing model or
-view components may be used.
+and Sinatra. We handle the routing layer using a very simple
+exception-based DSL and then get out of the way so that you can use your
+preferred model, view, and controller components.
 
 ## Installation
 
@@ -26,12 +28,12 @@ $ gem install reck
 ## Usage
 
 To respond to the defined route with rendered content, simply raise an
-exception. The message of the exception will be evaluated as ERB before being
-added to the response. If the exception is raised without a message, a
-no-content response will be sent. This exception-based DSL is dead-simple and
-great for controlling the flow of your application.
+exception. The message of the exception will be evaluated as ERB before
+being added to the response. If the exception is raised without a message,
+a no-content response will be sent. This exception-based DSL is great for
+controlling the flow of your application.
 
-Routing code to a controller is as simple as:
+Routing is as simple as:
 
 ```ruby
 Reck.route '/' do |request|
@@ -39,7 +41,7 @@ Reck.route '/' do |request|
 end
 ```
 
-Want to add authentication? No problem. (Actually, with a single-page app, this *really is* all you need!)
+Want to add authentication? No problem.
 
 ```ruby
 Reck.route '/admin' do |request|
@@ -49,7 +51,7 @@ Reck.route '/admin' do |request|
 end
 ```
 
-Since the message of each exception is actually a template, use ERB tags to
+The message of each exception is actually a template. Use ERB tags to
 interpolate Ruby values in your views:
 
 ```ruby
@@ -58,7 +60,7 @@ Reck.route '/version' do |request|
 end
 ```
 
-Since Reck depends on Rack, you also have access to helper methods
+Reck depends on Rack. You also have access to helper methods
 derived from the keys in Rack's env hash:
 
 ```ruby
@@ -87,65 +89,42 @@ Each response inherits from the exception `Reck::Response`.
 ## Handling exceptions
 
 While responses should always be raised, you may wish to handle other types of
-unexpected exceptions, or "exceptional exceptions", if you will. In these cases,
-we recommend using Honeybadger. Honeybadger provides middleware (and a bunch of
-other cool features) to catch exceptions in Ruby applications -- whether you're
-using Reck, Rails, Sinatra, Rack, or rolling your own Ruby web-framework.
-
-There are two ways you can get Honeybadger to monitor Reck:
-
-1. Reporting errors inside a controller
-
-  ```ruby
-  require 'reck'
-  require 'honeybadger'
-
-  Honeybadger.configure do |config|
-    config.api_key = 'your_api_key'
-  end
-
-  Reck.route '/oops' do |request|
-    begin
-      fail 'oops!'
-    rescue Reck::Response
-      raise # Raise the response to the router
-    rescue => e
-      # Exceptional Reck exception: report it with Honeybadger!
-      Honeybadger.notify(e)
-    end
-  end
-  ```
-
-  ```sh
-  ruby application.rb
-  ```
+unexpected exceptions, or "exceptional exceptions". In these cases, use
+[Honeybadger](https://www.honeybadger.io/?utm_source=github&utm_medium=readme&utm_campaign=reck).
+Honeybadger provides middleware (and a bunch of other cool features) to monitor
+Ruby applications -- whether you're using Reck, Rails, Sinatra, Rack, or rolling
+your own Ruby web-framework.
 
-2. Automatically catching all errors which aren't responses
+To monitor Reck for exceptions:
 
-  ```ruby
-  require 'reck/application'
-  require 'honeybadger'
-
-  Honeybadger.configure do |config|
-    config.api_key = 'your_api_key'
-    config.exceptions.ignore << Reck::Response
-  end
+```ruby
+# application.rb
+require 'honeybadger'
+require 'reck'
+
+Honeybadger.configure do |config|
+  config.api_key = 'your_api_key'
+  config.report_data = true
+  config.exceptions.ignore = [Reck::Response]
+end
 
-  Reck.route '/oops' do |request|
-    fail 'oops!'
-  end
+use Honeybadger::Rack::ErrorNotifier
 
-  use Honeybadger::Rack::ErrorNotifier
+Reck.route '/oops' do |request|
+  fail 'oops!'
+end
+```
 
-  run Reck::Application
-  ```
+Run the server:
 
-  ```sh
-  rackup application.ru
-  ```
+```sh
+$ ruby application.rb
+```
 
 Don't forget to replace `'your_api_key'` with the API key from your [project
-settings page](https://www.honeybadger.io/) on Honeybadger.
+settings
+page](https://www.honeybadger.io/?utm_source=github&utm_medium=readme&utm_campaign=reck)
+in Honeybadger.
 
 ## TODO
 
@@ -163,8 +142,5 @@ settings page](https://www.honeybadger.io/) on Honeybadger.
 
 ## License
 
-Reck is Copyright 2015 © Honeybadger Industries LLC. It is free software, and
+Reck is Copyright 2018 © Honeybadger Industries LLC. It is free software, and
 may be redistributed under the terms specified in the LICENSE file.
-
-Brought to you by :zap: **Honeybadger.io**: our kick-ass exception tracking is no joke. :trollface:
-[Start exterminating errors in your Ruby apps today](https://www.honeybadger.io/)!

data/lib/reck.rb

@@ -1,7 +1,22 @@
 require 'reck/application'
 
+$middleware = []
+
+def use(middleware, *args, &block)
+  $middleware << [middleware, args, block]
+end
+
 module Reck
   at_exit do
-    Rack::Handler::WEBrick.run Reck::Application
+    app = Rack::Builder.new
+
+    $middleware.each { |c,a,b| app.use(c, *a, &b) }
+    app.run(Reck::Application)
+
+    begin
+      Rack::Handler::WEBrick.run(app)
+    rescue Interrupt
+      # Clean exit
+    end
   end
 end

data/lib/reck/version.rb

@@ -1,3 +1,3 @@
 module Reck
-  VERSION = '0.0.1'.freeze
+  VERSION = '0.0.2'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reck
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Honeybadger Industries LLC