angelo 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bfff4ac5299ee639afca3b56bc130f71b36940fb
-  data.tar.gz: bae829642aefa5762ff1f1b612d5bf7cfd707d99
+  metadata.gz: 71eca9d2230c44d5b635e6e46080b5fab3848dab
+  data.tar.gz: 2a29741be7955f76e270e08b7fd05ad5a2ee0394
 SHA512:
-  metadata.gz: 100f313a038eb3dd61f1a87542f9339158c7e0e7b8e4f179c01f7ef83b08a7860f1c49db9ce01a7ba14d1765540d556f98c6f4994cb44a6535a3567a0f5e5da9
-  data.tar.gz: 29708a62189bb0ee987e84d34d2b31c19a56f710ab7147c304f7575a5a59d1a9b20ce4edb0b3d8b0ac96818a5886ab2de29fd041a3d567777127eb536e2fd243
+  metadata.gz: e274a5f18cc333463ccaee271cd7ba08dd1b550552f045cfe82ba18b08e73caa09df6712b2e296dc41e37c2b05be079be205337e055a3fdee18e3f822e3e9ab5
+  data.tar.gz: b7034f60500807c47f0177acab56c5de0c4e15bf647ec3a61c995ac5635f2d0653b9217f530077be7a8b95b81e3a2256e30d110c2988bfd9e85d9ac0ec131a95

data/.gitignore

@@ -1,3 +1,4 @@
 angelo-*.gem
 tmp
 Gemfile.lock
+test/coverage

data/.travis.yml

@@ -1,11 +1,8 @@
 sudo: false
 language: ruby
 rvm:
-  - "1.9.3"
-  - "2.0.0"
-  - "2.1.2"
-  - "2.1.3"
   - "2.1.5"
+  - "2.2.0"
   - "rbx-2"
 script: rake
 matrix:

data/CHANGELOG.md

@@ -1,6 +1,28 @@
 changelog
 =========
 
+### 0.4.0 5 feb 2015
+
+thanks: @tommay, @kyledrake, @katjaeinsfeld
+
+* refactor UnboundMethod -> instance_exec (#38)
+* add angelo/main for sinatra-like top-level DSL (#37)
+* make SymHash.new recurse array values
+* remove 'layouts_' from view_dir/layouts/*
+* return anything that respond_to? :to_json when content_type :json
+* remove event restriction to SSE stash contexts
+* add reload_templates! DSL method
+* refactor testing helpers (#35)
+* refactor ParamsParser#parse_post_body (#34)
+* Responder.symhash refactored to Angelo::SymHash (#33)
+* define_app now accepts a subclass of Angelo::Base (#32)
+* testing auxiliary classes moved to angelo/minitest/helpers (#32)
+* SimpleCov testing output support on MRI (#28)
+* Mustermann wholly integrated
+* include Angelo::Tilt::ERB by default
+* add Tilt ~> 2.0 and Mustermann ~> 0.4 to gemspec
+* require ruby >= 2.1 (also a Mustermann requirement)
+
 ### 0.3.3 16 jan 2015
 
 thanks: @mighe, @tarcieri, @jc00ke, @gunnarmarten, @tommay

data/Gemfile

@@ -4,10 +4,7 @@ gem 'reel', '~>0.5'
 gem 'tilt', '~>2.0'
 gem 'mime-types', '~>2.4'
 gem 'websocket-driver', '~>0.3'
-
-platform :ruby_21, :ruby_22 do
-  gem 'mustermann', '~>0.4'
-end
+gem 'mustermann', '~>0.4'
 
 group :development do
   gem 'pry', '~>0.10'
@@ -23,4 +20,8 @@ end
 group :test do
   gem 'httpclient', '~>2.5'
   gem 'minitest', '~>5.4'
+
+  platform :mri do
+    gem 'simplecov', '~>0.9.1'
+  end
 end

data/README.md

@@ -3,7 +3,7 @@ Angelo
 
 [![Build Status](https://travis-ci.org/kenichi/angelo.png?branch=master)](https://travis-ci.org/kenichi/angelo)
 
-A [Sinatra](https://github.com/sinatra/sinatra)-esque DSL for [Reel](https://github.com/celluloid/reel).
+A [Sinatra](https://github.com/sinatra/sinatra)-like DSL for [Reel](https://github.com/celluloid/reel).
 
 ### tl;dr
 
@@ -12,34 +12,35 @@ A [Sinatra](https://github.com/sinatra/sinatra)-esque DSL for [Reel](https://git
 * contextual websocket/sse stashing via `websockets` and `sses` helpers
 * `task` handling via `async` and `future` helpers
 * no rack
-* optional tilt/erb support
-* optional mustermann support
+* tilt/erb support
+* mustermann support
 
 ### What is Angelo?
 
 Just like Sinatra, Angelo gives you an expressive DSL for creating web applications. There are some
-notable differences, but the basics remain the same. It mostly follows the subclass style of Sinatra:
-you must define a subclass of `Angelo::Base` but also `.run` on that class for the service to start.
+notable differences, but the basics remain the same: you can either create a "classic" application
+by requiring 'angelo/main' and using the DSL at the top level of your script, or a "modular"
+application by requiring 'angelo', subclassing `Angelo::Base`, and calling `.run!` on that class for the
+service to start.
 In addition, and perhaps more importantly, **Angelo is built upon Reel, which is, in turn, built upon
 Celluloid::IO and gives you a reactor with evented IO in Ruby!**
 
-Note: There currently is no "standalone" capability where one can define route handlers at the top level.
+Things will feel very familiar to anyone experienced with Sinatra. You can define
+route handlers denoted by HTTP verb and path with parameters set from path matching (using
+[Mustermann](#mustermann)), the query string, and post body.
+A route block may return:
 
-Things will feel very familiar to anyone experienced with Sinatra. Inside the subclass, you can define
-route handlers denoted by HTTP verb and path. One acceptable return value from a route block is the body
-of the response in full as a `String`. Another is a `Hash` if the content type is set to `:json`. Finally,
-you may return any object that responds to `#each(&block)` if the transfer encoding is set to `:chunked`.
+* The body of the response in full as a `String`.
+* A `Hash` (or anything that `respond_to? :to_json`) if the content type is set to `:json`.
+* Any object that responds to `#each(&block)` if the transfer encoding is set to `:chunked`.
 There is also a `chunked_response` helper that will take a block, set the transfer encoding, and return
-an appropriate object for you.
+an appropriate object.
 
-There is also [Mustermann](#mustermann) support for full-on, Sinatra-like path
-matching and params.
-
-Angelo also features `before` and `after` blocks, just like Sinatra. Filters are ordered as defined,
+Angelo also features `before` and `after` filter blocks, just like Sinatra. Filters are ordered as defined,
 and called in that order. When defined without a path, they run for all matched requests. With a path,
-the path must match exactly for the block to be called. If `Angelo::Mustermann` is included, the paths
-are interpreted as a Mustermann pattern and params are merged. For more info on the difference in how
-after blocks are handled, see the Errors section below for more info.
+the path is interpreted as a Mustermann pattern and params are merged. `before` filters can set instance
+variables which can be used in the route block and the `after` filter.
+For more info on the difference in how after blocks are handled, see the Errors section below for more info.
 
 ### Websockets!
 
@@ -52,9 +53,8 @@ for you to build real-time web applications.
 The `websocket` route builder accepts a path and a block, and passes the actual websocket to the block
 as the only argument. This socket is an instance of Reel's
 [WebSocket](https://github.com/celluloid/reel/blob/master/lib/reel/websocket.rb) class, and, as such,
-responds to methods like `on_message` and `on_close`. A service-wide `on_pong` handler (defined at the
-
-a connected websocket client.
+responds to methods like `on_message` and `on_close`. A service-wide `on_pong` handler may be defined
+to customize the behavior when a pong frame comes back from a connected websocket client.
 
 ##### `websockets` helper
 
@@ -96,15 +96,15 @@ end
 Foo.run!
 ```
 
-In this case, any clients that connected to a websocket at the path '/' would be stashed in the
-default websockets array; clients that connected to '/bar' would be stashed into the `:bar` section.
+In this case, any clients that connect to a websocket at the path '/' will be stashed in the
+default websockets array; clients that connect to '/bar' will be stashed in the `:bar` section.
 
-Each "section" can accessed with a familiar, `Hash`-like syntax, and can be iterated over with
+Each "section" is accessed with a familiar, `Hash`-like syntax, and can be iterated over with
 a `.each` block.
 
-When a `POST /` with a 'foo' param is received, any value is messaged out to any '/' connected
+When a `POST /` with a 'foo' param is received, any value is messaged out to all '/' connected
 websockets. When a `POST /bar` with a 'bar' param is received, any value is messaged out to all
-websockets that connected to '/bar'.
+websockets connected to '/bar'.
 
 ### SSE - Server-Sent Events
 
@@ -176,12 +176,12 @@ end
 ##### `sses` helper
 
 Angelo also includes a "stash" helper for SSE connections. One can `<<` a socket into `sses` from
-inside an `eventsource` handler block. These can also be "later" be iterated over so one can do things
+inside an `eventsource` handler block. These can "later" be iterated over so one can do things
 like emit a message on every SSE connection when the service receives a POST request.
 
-The `sses` helper includes the same a context ability as the `websockets` helper. Also, by default,
+The `sses` helper includes the same context ability as the `websockets` helper. Also, by default,
 the helper will `reject!` any closed sockets before returning, just like `websockets`. You may
-optionally pass `false` to the helper to skip this step.In addition, the `sses` stash includes
+optionally pass `false` to the helper to skip this step. In addition, the `sses` stash includes
 methods for easily sending events or messages to all stashed connections. **Note that the
 `Stash::SSE#event` method only works on non-default contexts and uses the context name as the event
 name.**
@@ -227,7 +227,7 @@ do not support EventSource yet, since this will respond with a non-"text/event-s
 
 ##### `EventSource#on_close` helper
 
-When inside an eventsource block, you can use may want to do something specific when a client closes the
+When inside an eventsource block, you may want to do something specific when a client closes the
 connection. For this case, there are `on_close` and `on_close=` methods on the object passed to the block
 that will get called if the client closes the socket. The assignment method takes a proc object and the
 other one takes a block:
@@ -252,13 +252,13 @@ eventsource '/sse' do |es|
 end
 ```
 
-Note the use of the optional parameter the stashes here; by default, stash accessors (`websockets` and
+Note the use of the optional parameter of the stashes here; by default, stash accessors (`websockets` and
 `sses`) will `reject!` any closed sockets before letting you in. If you pass `false` to the stash
 accessors, they will skip the `reject!` step.
 
 ### Tasks + Async / Future
 
-Angelo is built on Reel and Celluloid::IO, giving your web application class the ability to define
+Angelo is built on Reel and Celluloid::IO, giving your web application the ability to define
 "tasks" and call them from route handler blocks in an `async` or `future` style.
 
 ##### `task` builder
@@ -268,7 +268,7 @@ block. The block can take arguments that you can pass later, with `async` or `fu
 
 ```ruby
 # defining a task on the reactor called `:in_sec` which will sleep for
-# given number of seconds, then return the given message.
+# the given number of seconds, then return the given message.
 #
 task :in_sec do |sec, msg|
   sleep sec.to_i
@@ -300,9 +300,9 @@ end
 ##### `future` helper
 
 Just like `async`, this comes from Celluloid as well. It behaves exactly like `async`, with the
-notable exception of returing a "future" object that you can call `#value` on later to retreive
-the return value of the task. Once `#value` is called, things will "block" until the task is
-finished.
+notable exception of returning a "future" object that you can call `#value` on later to retrieve
+the return value of the task. Calling `#value` will "block" until the task is finished, while the
+reactor continues to process requests.
 
 ```ruby
 get '/' do
@@ -324,8 +324,8 @@ Angelo gives you two ordained methods of stopping route processing:
 * raise an instance of `RequestError`
 * `halt` with a status code and message
 
-The main difference is that `halt` will still run an `after` block, and raising `RequestError`
-will bypass the `after` block.
+The main difference is that `halt` will still run `after` blocks, and raising `RequestError`
+will bypass `after` blocks.
 
 Any other exceptions or errors raised by your route handler will be handled with a 500 status
 code and the message will be the body of the response.
@@ -334,7 +334,7 @@ code and the message will be the body of the response.
 
 Raising an instance of `Angelo::RequestError` causes a 400 status code response, and the message
 in the instance is the body of the the response. If the route or class was set to respond with
-JSON, the body is converted to a JSON object with one key, `error`, that has a value of the message.
+JSON, the body is converted to a JSON object with one key, `error`, that has the value of the message.
 If the message is a `Hash`, the hash is converted to a JSON object, or to a string for other content
 types.
 
@@ -414,15 +414,8 @@ everything's fine
 
 ### [Tilt](https://github.com/rtomayko/tilt) / ERB
 
-To make `erb` available in route blocks
-
-1. add `tilt` to your `Gemfile`: `gem 'tilt'`
-2. require `angelo/tilt/erb`
-3. include `Angelo::Tilt::ERB` in your app
-
 ```ruby
 class Foo < Angelo::Base
-  include Angelo::Tilt::ERB
 
   views_dir 'some/other/path' # defaults to './views'
 
@@ -448,17 +441,8 @@ See [views](https://github.com/kenichi/angelo/tree/master/test/test_app_root/vie
 
 ### [Mustermann](https://github.com/rkh/mustermann)
 
-To make routes blocks match path with Mustermann patterns
-
-1. be using ruby &gt;=2.0.0
-2. add 'mustermann' to to your `Gemfile`: `platform(:ruby_20){ gem 'mustermann' }`
-3. require `angelo/mustermann`
-4. include `Angelo::Mustermann` in your app
-
 ```ruby
 class Foo < Angelo::Base
-  include Angelo::Tilt::ERB
-  include Angelo::Mustermann
 
   get '/:foo/things/:bar' do
 
@@ -486,6 +470,68 @@ class Foo < Angelo::Base
 end
 ```
 
+### Classic vs. modular apps
+
+Like Sinatra, Angelo apps can be written in either "classic" style or
+so-called "modular" style.  Which style you use is more of a personal
+preference than anything else.
+
+A classic-style app requires "angelo/main" and defines the app
+directly at the top level using the DSL.  In addition, classic apps:
+
+* Can use a `helpers` block to define methods that can be called from
+filters and route handlers. The `helpers` method can also include methods
+from one or more modules passed as arguments instead of or in addition
+to taking a block.
+* Parse optional command-line options "-o addr" and "-p port" to set
+the bind address and listen port, respectively.
+* Are run automatically.
+
+*Note: unlike Sinatra, define a classic app by requiring "angelo/main"
+and a modular app by requiring "angelo".  Sinatra uses "sinatra" and
+"sinatra/base" to do the same things.*
+
+Here's a classic app:
+
+```ruby
+require 'angelo/main'
+
+helpers do
+  def say_hello
+    "Hello"
+  end
+end
+
+get "/hello" do
+  "#{say_hello} to you, too."
+end
+```
+
+And the same app in modular style:
+
+```ruby
+require 'angelo'
+
+class HelloApp < Angelo::Base
+  def say_hello
+    "Hello"
+  end
+
+  get "/hello" do
+    "#{say_hello} to you, too."
+  end
+end
+
+HelloApp.run!
+```
+
+### Documentation
+
+**I'm bad at documentation and I feel bad.**
+
+Others have helped, and there is a YaRD plugin for Angelo [here](https://github.com/artcom/yard-angelo)
+if you would like to document your apps built with Angelo. (thanks: @katjaeinsfeld, @artcom)
+
 ### WORK LEFT TO DO
 
 Lots of work left to do!
@@ -494,10 +540,8 @@ Lots of work left to do!
 
 ```ruby
 require 'angelo'
-require 'angelo/mustermann'
 
 class Foo < Angelo::Base
-  include Angelo::Mustermann
 
   # just some constants to use in routes later...
   #

data/angelo.gemspec

@@ -2,16 +2,19 @@
 require File.expand_path('../lib/angelo/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Kenichi Nakamura"]
-  gem.email         = ["kenichi.nakamura@gmail.com"]
-  gem.description   = gem.summary = "A Sinatra-esque DSL for Reel"
-  gem.homepage      = "https://github.com/kenichi/angelo"
-  gem.files         = `git ls-files | grep -Ev '^example'`.split("\n")
-  gem.test_files    = `git ls-files -- spec/*`.split("\n")
-  gem.name          = "angelo"
-  gem.require_paths = ["lib"]
-  gem.version       = Angelo::VERSION
-  gem.license       = 'apache'
+  gem.authors          = ["Kenichi Nakamura"]
+  gem.email            = ["kenichi.nakamura@gmail.com"]
+  gem.description      = gem.summary = "A Sinatra-like DSL for Reel"
+  gem.homepage         = "https://github.com/kenichi/angelo"
+  gem.files            = `git ls-files | grep -Ev '^example'`.split("\n")
+  gem.test_files       = `git ls-files -- spec/*`.split("\n")
+  gem.name             = "angelo"
+  gem.require_paths    = ["lib"]
+  gem.version          = Angelo::VERSION
+  gem.license          = 'apache'
+  gem.required_ruby_version = '>= 2.1.0'
   gem.add_runtime_dependency 'reel', '~>0.5'
+  gem.add_runtime_dependency 'tilt', '~>2.0'
+  gem.add_runtime_dependency 'mustermann', '~>0.4'
   gem.add_runtime_dependency 'mime-types', '~>2.4'
 end

data/lib/angelo.rb

@@ -1,5 +1,7 @@
 require 'reel'
 require 'json'
+require 'tilt'
+require 'mustermann'
 
 # require 'ruby-prof'
 #
@@ -128,11 +130,12 @@ end
 require 'angelo/version'
 require 'angelo/params_parser'
 require 'angelo/server'
-require 'angelo/base'
-require 'angelo/stash'
 require 'angelo/responder'
 require 'angelo/responder/eventsource'
 require 'angelo/responder/websocket'
+require 'angelo/tilt/erb'
+require 'angelo/base'
+require 'angelo/stash'
 
 # trap "INT" do
 #   result = RubyProf.stop

data/lib/angelo/base.rb

@@ -1,11 +1,13 @@
 module Angelo
 
   class Base
+    extend Forwardable
     include ParamsParser
     include Celluloid::Logger
+    include Tilt::ERB
+    include Mustermann
 
-    extend Forwardable
-    def_delegators :@responder, :content_type, :headers, :redirect, :request, :transfer_encoding
+    def_delegators :@responder, :content_type, :headers, :mustermann, :redirect, :request, :transfer_encoding
     def_delegators :@klass, :public_dir, :report_errors?, :sse_event, :sse_message, :sses, :websockets
 
     attr_accessor :responder
@@ -16,9 +18,15 @@ module Angelo
 
       def inherited subclass
 
-        # set app_file from caller stack
+        # Set app_file by groveling up the caller stack until we find
+        # the first caller from a directory different from __FILE__.
+        # This allows base.rb to be required from an arbitrarily deep
+        # nesting of require "angelo/<whatever>" and still set
+        # app_file correctly.
         #
-        subclass.app_file = caller(1).map {|l| l.split(/:(?=|in )/, 3)[0,1]}.flatten[0]
+        subclass.app_file = caller_locations.map(&:absolute_path).find do |f|
+          !f.start_with?(File.dirname(__FILE__) + File::SEPARATOR)
+        end
 
         # bring RequestError into this namespace
         #
@@ -30,6 +38,12 @@ module Angelo
         subclass.ping_time DEFAULT_PING_TIME
         subclass.log_level DEFAULT_LOG_LEVEL
 
+        # Parse command line options if angelo/main has been required.
+        # They could also be parsed in run, but this makes them
+        # available to and overridable by the DSL.
+        #
+        subclass.parse_options(ARGV.dup) if @angelo_main
+
         class << subclass
 
           def root
@@ -39,7 +53,12 @@ module Angelo
         end
 
       end
+    end
 
+    # Methods defined in module DSL will be available in the DSL both
+    # in Angelo::Base subclasses and in the top level DSL.
+
+    module DSL
       def addr a = nil
         @addr = a if a
         @addr
@@ -76,42 +95,25 @@ module Angelo
         @report_errors = true
       end
 
-      def report_errors?
-        !!@report_errors
-      end
-
-      def compile! name, &block
-        define_method name, &block
-        method = instance_method name
-        remove_method name
-        method
-      end
-
-      def routes
-        @routes ||= Hash.new{|h,k| h[k] = {}}
+      HTTPABLE.each do |m|
+        define_method m do |path, opts = {}, &block|
+          path = ::Mustermann.new path, opts
+          routes[m][path] = Responder.new &block
+        end
       end
 
-      def filters
-        @filters ||= {before: {default: []}, after: {default: []}}
+      def websocket path, &block
+        path = ::Mustermann.new path
+        routes[:websocket][path] = Responder::Websocket.new &block
       end
 
-      def filter which, opts = {}, &block
-        f = compile! :filter, &block
-        case opts
-        when String
-          filter_by which, opts, f
-        when Hash
-          if opts[:path]
-            filter_by which, opts[:path], f
-          else
-            filters[which][:default] << f
-          end
-        end
+      def eventsource path, headers = nil, &block
+        path = ::Mustermann.new path
+        routes[:get][path] = Responder::Eventsource.new headers, &block
       end
 
-      def filter_by which, path, meth
-        filters[which][path] ||= []
-        filters[which][path] << meth
+      def task name, &block
+        Angelo::Server.define_task name, &block
       end
 
       def before opts = {}, &block
@@ -122,26 +124,47 @@ module Angelo
         filter :after, opts, &block
       end
 
-      HTTPABLE.each do |m|
-        define_method m do |path, &block|
-          routes[m][path] = Responder.new &block
-        end
+      def on_pong &block
+        Responder::Websocket.on_pong = block
       end
 
-      def websocket path, &block
-        routes[:websocket][path] = Responder::Websocket.new &block
+    end
+
+    # Make the DSL methods available to subclass-level code.
+    # main.rb makes them available to the top level.
+
+    extend DSL
+
+    class << self
+      def report_errors?
+        !!@report_errors
       end
 
-      def eventsource path, headers = nil, &block
-        routes[:get][path] = Responder::Eventsource.new headers, &block
+      def routes
+        @routes ||= Hash.new{|h,k| h[k] = RouteMap.new}
       end
 
-      def on_pong &block
-        Responder::Websocket.on_pong = block
+      def filters
+        @filters ||= {before: {default: []}, after: {default: []}}
       end
 
-      def task name, &block
-        Angelo::Server.define_task name, &block
+      def filter which, opts = {}, &block
+        case opts
+        when String
+          filter_by which, opts, block
+        when Hash
+          if opts[:path]
+            filter_by which, opts[:path], block
+          else
+            filters[which][:default] << block
+          end
+        end
+      end
+
+      def filter_by which, path, block
+        pattern = ::Mustermann.new path
+        filters[which][pattern] ||= []
+        filters[which][pattern] << block
       end
 
       def websockets reject = true
@@ -215,8 +238,8 @@ module Angelo
                   when GET, DELETE, OPTIONS
                     parse_query_string
                   when POST, PUT
-                    parse_post_body
-                  end
+                    parse_query_string_and_post_body
+                  end.merge mustermann.params(request.path)
     end
 
     def request_headers
@@ -319,17 +342,76 @@ module Angelo
       Celluloid.sleep time
     end
 
-    def filter which
-      fs = self.class.filters[which][:default]
-      fs += self.class.filters[which][request.path] if self.class.filters[which][request.path]
-      fs.each {|f| f.bind(self).call}
-    end
-
     def chunked_response &block
       transfer_encoding :chunked
       ChunkedResponse.new &block
     end
 
+    def filter which
+      self.class.filters[which].each do |pattern, filters|
+        case pattern
+        when :default
+          filters.each {|filter| instance_eval &filter}
+        when ::Mustermann
+          if pattern.match request.path
+            @pre_filter_params = params
+            @params = @pre_filter_params.merge pattern.params(request.path)
+            filters.each {|filter| instance_eval &filter}
+            @params = @pre_filter_params
+          end
+        end
+      end
+    end
+
+    # It seems more sensible to put this in main.rb since it's used
+    # only if angelo/main is required, but it's here so it can be
+    # tested, since requiring angelo/main doesn't play well with the
+    # test code.
+
+    def self.parse_options(argv)
+      require "optparse"
+
+      optparse = OptionParser.new do |op|
+        op.banner = "Usage: #{$0} [options]"
+
+        op.on('-p port', OptionParser::DecimalInteger, "set the port (default is #{port})") {|val| port val}
+        op.on('-o addr', "set the host (default is #{addr})") {|val| addr val}
+        op.on('-h', '--help', "Show this help") do
+          puts op
+          exit
+        end
+      end
+
+      begin
+        optparse.parse(argv)
+      rescue OptionParser::ParseError => ex
+        $stderr.puts ex
+        $stderr.puts optparse
+        exit 1
+      end
+    end
+
+    class RouteMap
+
+      def initialize
+        @hash = Hash.new
+      end
+
+      def []= route, responder
+        @hash[route] = responder
+      end
+
+      def [] route
+        responder = nil
+        if mustermann = @hash.keys.select {|k| k.match(route)}.first
+          responder = @hash.fetch mustermann
+          responder.mustermann = mustermann
+        end
+        responder
+      end
+
+    end
+
     class EventSource
       extend Forwardable