angelo 0.1.14 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab8dc2d9fc7243d0fafec32530e5509351ecfcec
-  data.tar.gz: 37488c61321c6ffd9d4524371eb295fd2b425a8b
+  metadata.gz: e3fe7e1fbbed26101e7b8204067db4e0cf8d8b24
+  data.tar.gz: 0d80c3741af219d78fdd2273717588ad286afa4a
 SHA512:
-  metadata.gz: 07c8b7aef24a27aece1e2d012bfd910598445241943b24714f21739cfbef8ac686c7594c873331fb4f71702af1dd11d7161db74861fdc79464bcea2abb822f81
-  data.tar.gz: 32ffbf2ce2540b29be61110aeaf7b14aef8d21fb50634ee07692e32eac0cb3a25ec7b0a356cdd5804ffb748df7e8e2b7cae5a8d2efaaee867154ba4be54ee616
+  metadata.gz: 34fea99d0f4f8c0b4e10eaf2d1903df121d1ba541fb354e87f9b61caacfbcc4741894f6ec7bd8b4ccf1b7aab27770bf19d830b8a588afed113363c44d74fe26d
+  data.tar.gz: 52ee6e7b8111bdcf75c77ee828b061d831c921d27f50181d8f6d6f2b69abf1164498f23a0d01a846f920375214400330ce8ab880242cf3c50786e3ea780557b2

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 changelog
 =========
 
+### 0.1.15 24 jul 2014
+
+* WebsocketResponder -> Responder::Websocket
+* add Responder::Eventsource
+* split Stash into module with Websocket and SSE classes
+* add SSE eventsource route builder and helper
+* add #event and #message to Stash::SSE
+* add .sse_event and .sse_message to Base
+
 ### 0.1.14 3 jul 2014
 
 * add send_file with disposition support

data/Gemfile.lock

@@ -15,7 +15,7 @@ GEM
     httpclient (2.4.0)
     method_source (0.8.2)
     mime-types (2.3)
-    minitest (5.3.5)
+    minitest (5.4.0)
     mustermann (0.2.0)
     nio4r (1.0.0)
     nio4r (1.0.0-java)
@@ -37,13 +37,13 @@ GEM
       http_parser.rb (>= 0.6.0)
       websocket_parser (>= 0.1.6)
     ruby-prof (0.15.1)
-    slop (3.5.0)
+    slop (3.6.0)
     spoon (0.0.4)
       ffi
     tilt (2.0.1)
     timers (1.1.0)
-    websocket-driver (0.3.3)
-    websocket-driver (0.3.3-java)
+    websocket-driver (0.3.4)
+    websocket-driver (0.3.4-java)
     websocket_parser (0.1.6)
 
 PLATFORMS

data/README.md

@@ -8,7 +8,8 @@ A [Sinatra](https://github.com/sinatra/sinatra)-esque DSL for [Reel](https://git
 ### tl;dr
 
 * websocket support via `websocket('/path'){|s| ... }` route builder
-* contextual websocket stashing via `websockets` helper
+* SSE support via `eventsource('/path'){|s| ... }` route builder
+* contextual websocket/sse stashing via `websockets` and `sses` helpers
 * `task` handling via `async` and `future` helpers
 * no rack
 * optional tilt/erb support
@@ -99,6 +100,105 @@ When a `POST /` with a 'foo' param is received, any value is messaged out to any
 websockets. When a `POST /bar` with a 'bar' param is received, any value is messaged out to all
 websockets that connected to '/bar'.
 
+### SSE - Server-Sent Events
+
+The `eventsource` route builder also accepts a path and a block, and passes the socket to the block,
+just like the `websocket` builder. This socket is actually the raw `Celluloid::IO::TCPSocket` and is
+"detached" from the regular handling. There are no "on-*" methods; the `write` method should suffice.
+To make it easier to deal with creation of the properly formatted Strings to send, Angelo provides
+a couple helpers.
+
+##### `sse_event` helper
+
+To create an "event" that a javascript EventListener on the client can respond to:
+
+```ruby
+eventsource '/sse' do |s|
+  event = sse_event :foo, some_key: 'blah', other_key: 'boo'
+  s.write event
+  s.close
+end
+```
+
+In this case, the EventListener would have to be configured to listen for the `foo` event:
+
+```javascript
+var sse = new EventSource('/sse');
+sse.addEventListener('foo', function(e){ console.log("got foo event!\n" + JSON.parse(e.data)); });
+```
+
+The `sse_event` helper accepts a normal `String` for the data, but will automatically convert a `Hash`
+argument to a JSON object.
+
+##### `sse_message` helper
+
+The `sse_message` helper behaves exactly the same as `sse_event`, but does not take an event name:
+
+```ruby
+eventsource '/sse' do |s|
+  msg = sse_msg some_key: 'blah', other_key: 'boo'
+  s.write msg 
+  s.close
+end
+```
+
+The client javascript would need to be altered to use the `EventSource.onmessage` property as well:
+
+```javascript
+var sse = new EventSource('/sse');
+sse.onmessage = function(e){ console.log("got message!\n" + JSON.parse(e.data)); };
+```
+
+##### `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
+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. 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.**
+
+```ruby
+eventsource '/sse' do |s|
+  sses[:foo] << s
+end
+
+post '/sse_message' do
+  sses[:foo].message params[:data]
+end
+
+post '/sse_event' do
+  sses[:foo].event params[:data]
+end
+```
+
+##### `eventsource` instance helper
+
+Additionally, you can also start SSE handling *conditionally* from inside a GET block:
+
+```ruby
+get '/sse_maybe' do
+  if params[:sse]
+    eventsource do |c|
+      sses << c
+      c.write sse_message 'wooo fancy SSE for you!'
+    end
+  else
+    'boring regular old get response'
+  end
+end
+
+post '/sse_event' do
+  sses.each {|sse| sse.write sse_event(:foo, 'fancy sse event!')}
+end
+```
+
+Handling this on the client may require conditionals for [browsers](http://caniuse.com/eventsource) that
+do not support EventSource yet, since this will respond with a non-"text/event-stream" Content-Type if
+'sse' is not present in the params.
+
 ### Tasks + Async / Future
 
 Angelo is built on Reel and Celluloid::IO, giving your web application class the ability to define

data/lib/angelo/base.rb

@@ -6,6 +6,7 @@ module Angelo
 
     extend Forwardable
     def_delegators :@responder, :content_type, :headers, :redirect, :request
+    def_delegators :@klass, :websockets, :sses, :sse_event, :sse_message
 
     @@addr = DEFAULT_ADDR
     @@port = DEFAULT_PORT
@@ -13,6 +14,8 @@ module Angelo
     @@ping_time = DEFAULT_PING_TIME
     @@log_level = DEFAULT_LOG_LEVEL
 
+    @@report_errors = false
+
     if ARGV.any? and not Kernel.const_defined?('Minitest')
       require 'optparse'
       OptionParser.new { |op|
@@ -87,11 +90,15 @@ module Angelo
       end
 
       def websocket path, &block
-        routes[:websocket][path] = WebsocketResponder.new &block
+        routes[:websocket][path] = Responder::Websocket.new &block
+      end
+
+      def eventsource path, &block
+        routes[:get][path] = Responder::Eventsource.new &block
       end
 
       def on_pong &block
-        WebsocketResponder.on_pong = block
+        Responder::Websocket.on_pong = block
       end
 
       def task name, &block
@@ -99,11 +106,17 @@ module Angelo
       end
 
       def websockets
-        @websockets ||= Stash.new server
+        @websockets ||= Stash::Websocket.new server
         @websockets.reject! &:closed?
         @websockets
       end
 
+      def sses
+        @sses ||= Stash::SSE.new server
+        @sses.reject! &:closed?
+        @sses
+      end
+
       def content_type type
         Responder.content_type type
       end
@@ -126,6 +139,21 @@ module Angelo
         end
       end
 
+      def sse_event event_name, data
+        data = data.to_json if Hash === data
+        SSE_EVENT_TEMPLATE % [event_name.to_s, data]
+      end
+
+      def sse_message data
+        data = data.to_json if Hash === data
+        SSE_DATA_TEMPLATE % data
+      end
+
+    end
+
+    def initialize responder
+      @responder = responder
+      @klass = self.class
     end
 
     def async meth, *args
@@ -144,8 +172,6 @@ module Angelo
                   end
     end
 
-    def websockets; self.class.websockets; end
-
     def request_headers
       @request_headers ||= Hash.new do |hash, key|
         if Symbol === key
@@ -175,6 +201,19 @@ module Angelo
       end
     end
 
+    task :handle_event_source do |socket, block|
+      begin
+        block[socket]
+      rescue Reel::SocketError, IOError, SystemCallError => e
+        # probably closed on client
+        warn e.message if @@report_errors
+        socket.close unless socket.closed?
+      rescue => e
+        error e.inspect
+        socket.close unless socket.closed?
+      end
+    end
+
     def halt status = 400, body = ''
       throw :halt, HALT_STRUCT.new(status, body)
     end
@@ -201,6 +240,20 @@ module Angelo
       halt 200, File.read(lp)
     end
 
+    def eventsource &block
+      headers SSE_HEADER
+      async :handle_event_source, responder.connection.detach.socket, block
+      halt 200, :sse
+    end
+
+    def report_errors?
+      @@report_errors
+    end
+
+    def sleep time
+      Celluloid.sleep time
+    end
+
   end
 
 end

data/lib/angelo/minitest/helpers.rb

@@ -31,14 +31,18 @@ module Angelo
         @hc ||= HTTPClient.new
       end
 
-      def hc_req method, path, params = {}, headers = {}
+      def url path = nil
         url = HTTP_URL % [DEFAULT_ADDR, DEFAULT_PORT]
-        @last_response = hc.__send__ method, url+path, params, headers
+        url += path if path
+        url
+      end
+
+      def hc_req method, path, params = {}, headers = {}
+        @last_response = hc.__send__ method, url(path), params, headers
       end
       private :hc_req
 
       def http_req method, path, params = {}, headers = {}
-        url = HTTP_URL % [DEFAULT_ADDR, DEFAULT_PORT] + path
         params = case params
                  when String; {body: params}
                  when Hash
@@ -51,9 +55,9 @@ module Angelo
                  end
         @last_response = case
                          when !headers.empty?
-                           ::HTTP.with(headers).__send__ method, url, params
+                           ::HTTP.with(headers).__send__ method, url(path), params
                          else
-                           ::HTTP.__send__ method, url, params
+                           ::HTTP.__send__ method, url(path), params
                          end
       end
       private :http_req
@@ -65,6 +69,10 @@ module Angelo
         end
       end
 
+      def get_sse path, params = {}, headers = {}, &block
+        @last_response = hc.get url(path), params, headers, &block
+      end
+
       def websocket_helper path, params = {}
         params = params.keys.reduce([]) {|a,k|
           a << CGI.escape(k) + '=' + CGI.escape(params[k])

data/lib/angelo/mustermann.rb

@@ -12,7 +12,7 @@ module Angelo
         def_delegator :@responder, :mustermann
       end
 
-      [Responder, WebsocketResponder].each do |res|
+      [Responder, Responder::Websocket, Responder::Eventsource].each do |res|
         res.class_eval do
           attr_accessor :mustermann
         end
@@ -33,6 +33,11 @@ module Angelo
         super path, &block
       end
 
+      def eventsource path, &block
+        path = ::Mustermann.new path
+        super path, &block
+      end
+
       def routes
         @routes ||= {}
         ROUTABLE.each do |m|

data/lib/angelo/responder/eventsource.rb

@@ -0,0 +1,48 @@
+module Angelo
+  class Responder
+    class Eventsource < Responder
+
+      def request= request
+        @params = nil
+        @request = request
+        handle_request
+      end
+
+      def handle_request
+        begin
+          if @response_handler
+            @base.before if @base.respond_to? :before
+            @body = catch(:halt) { @base.eventsource &@response_handler.bind(@base) }
+            if HALT_STRUCT === @body
+              raise RequestError.new 'unknown sse error' unless @body.body == :sse
+            end
+
+            # TODO any real reason not to run afters with SSE?
+            # @base.after if @base.respond_to? :after
+
+            respond
+          else
+            raise NotImplementedError
+          end
+        rescue IOError => ioe
+          warn "#{ioe.class} - #{ioe.message}"
+          close_websocket
+        rescue => e
+          error e.message
+          ::STDERR.puts e.backtrace
+          begin
+            @connection.close
+          rescue Reel::StateError => rcse
+            close_websocket
+          end
+        end
+      end
+
+      def respond
+        Angelo.log @connection, @request, nil, :ok
+        @request.respond 200, headers, nil
+      end
+
+    end
+  end
+end

data/lib/angelo/responder/websocket.rb

@@ -1,60 +1,55 @@
 module Angelo
+  class Responder
+    class Websocket < Responder
 
-  class WebsocketResponder < Responder
+      class << self
 
-    class << self
+        attr_writer :on_pong
 
-      attr_writer :on_pong
+        def on_pong
+          @on_pong ||= ->(e){}
+        end
 
-      def on_pong
-        @on_pong ||= ->(e){}
       end
 
-    end
-
-    def params
-      @params ||= parse_query_string
-      @params
-    end
-
-    def request= request
-      @params = nil
-      @request = request
-      @websocket = @request.websocket
-      handle_request
-    end
+      def request= request
+        @params = nil
+        @request = request
+        @websocket = @request.websocket
+        handle_request
+      end
 
-    def handle_request
-      begin
-        if @response_handler
-          Angelo.log @connection, @request, @websocket, :switching_protocols
-          @bound_response_handler ||= @response_handler.bind @base
-          @websocket.on_pong &WebsocketResponder.on_pong
-          @base.before if @base.respond_to? :before
-          @bound_response_handler[@websocket]
-          @base.after if @base.respond_to? :after
-        else
-          raise NotImplementedError
-        end
-      rescue IOError => ioe
-        warn "#{ioe.class} - #{ioe.message}"
-        close_websocket
-      rescue => e
-        error e.message
-        ::STDERR.puts e.backtrace
+      def handle_request
         begin
-          @connection.close
-        rescue Reel::StateError => rcse
+          if @response_handler
+            Angelo.log @connection, @request, @websocket, :switching_protocols
+            @bound_response_handler ||= @response_handler.bind @base
+            @websocket.on_pong &Responder::Websocket.on_pong
+            @base.before if @base.respond_to? :before
+            @bound_response_handler[@websocket]
+            @base.after if @base.respond_to? :after
+          else
+            raise NotImplementedError
+          end
+        rescue IOError => ioe
+          warn "#{ioe.class} - #{ioe.message}"
           close_websocket
+        rescue => e
+          error e.message
+          ::STDERR.puts e.backtrace
+          begin
+            @connection.close
+          rescue Reel::StateError => rcse
+            close_websocket
+          end
         end
       end
-    end
 
-    def close_websocket
-      @websocket.close
-      @base.websockets.remove_socket @websocket
-    end
+      def close_websocket
+        @websocket.close
+        @base.websockets.remove_socket @websocket
+      end
 
+    end
   end
-
 end

data/lib/angelo/responder.rb

@@ -32,18 +32,14 @@ module Angelo
 
     end
 
-    attr_writer :connection
+    attr_accessor :connection
     attr_reader :request
+    attr_writer :base
 
     def initialize &block
       @response_handler = Base.compile! :request_handler, &block
     end
 
-    def base= base
-      @base = base
-      @base.responder = self
-    end
-
     def request= request
       @params = nil
       @redirect = nil
@@ -56,22 +52,32 @@ module Angelo
       if @response_handler
         @base.before if @base.respond_to? :before
         @body = catch(:halt) { @response_handler.bind(@base).call || EMPTY_STRING }
-        @base.after if @base.respond_to? :after
+
+        # TODO any real reason not to run afters with SSE?
+        case @body
+        when HALT_STRUCT
+          if @body.body != :sse and @base.respond_to? :after
+            @base.after
+          end
+        else
+          @base.after if @base.respond_to? :after
+        end
+
         respond
       else
         raise NotImplementedError
       end
     rescue JSON::ParserError => jpe
-      handle_error jpe, :bad_request, false
+      handle_error jpe, :bad_request
     rescue FormEncodingError => fee
-      handle_error fee, :bad_request, false
+      handle_error fee, :bad_request
     rescue RequestError => re
-      handle_error re, re.type, false
+      handle_error re, re.type
     rescue => e
       handle_error e
     end
 
-    def handle_error _error, type = :internal_server_error, report = true
+    def handle_error _error, type = :internal_server_error, report = @base.report_errors?
       err_msg = error_message _error
       Angelo.log @connection, @request, nil, type, err_msg.size
       @connection.respond type, headers, err_msg
@@ -130,6 +136,7 @@ module Angelo
       when HALT_STRUCT
         status = @body.status
         @body = @body.body
+        @body = nil if @body == :sse
         if Hash === @body
           @body = {error: @body} if status != :ok or status < 200 && status >= 300
           @body = @body.to_json if respond_with? :json
@@ -148,11 +155,12 @@ module Angelo
 
       status ||= @redirect.nil? ? :ok : :moved_permanently
       headers LOCATION_HEADER_KEY => @redirect if @redirect
+      size = @body.nil? ? 0 : @body.size
 
-      Angelo.log @connection, @request, nil, status, @body.size
-      @connection.respond status, headers, @body
+      Angelo.log @connection, @request, nil, status, size
+      @request.respond status, headers, @body
     rescue => e
-      handle_error e, :internal_server_error, false
+      handle_error e, :internal_server_error
     end
 
     def redirect url

data/lib/angelo/server.rb

@@ -47,7 +47,7 @@ module Angelo
       rs = @base.routes[meth][request.path]
       if rs
         responder = rs.dup
-        responder.base = @base.new
+        responder.base = @base.new responder
         responder.connection = connection
         responder.request = request
       else
@@ -92,6 +92,9 @@ module Angelo
       OpenSSL::Digest::SHA.hexdigest fs.ino.to_s + fs.size.to_s + fs.mtime.to_s
     end
 
+    def sse_event *a; Base.sse_event *a; end
+    def sse_message *a; Base.sse_message *a; end
+
   end
 
 end

data/lib/angelo/stash.rb

@@ -2,62 +2,75 @@ module Angelo
 
   # utility class for stashing connected websockets in arbitrary contexts
   #
-  class Stash
+  module Stash
     include Celluloid::Logger
 
-    # hold the peeraddr info for use after the socket is closed (logging)
-    #
-    @@peeraddrs = {}
+    module ClassMethods
 
-    # the underlying arrays of websockets, by context
-    #
-    @@stashes = {}
+      # the underlying arrays of websockets, by context
+      #
+      def stashes
+        @stashes ||= {}
+      end
+
+      # hold the peeraddr info for use after the socket is closed (logging)
+      #
+      def peeraddrs
+        @peeraddrs ||= {}
+      end
+
+    end
+
+    def stashes; self.class.stashes; end
+    def peeraddrs; self.class.peeraddrs; end
 
     # create a new instance with a context, creating the array if needed
     #
     def initialize server, context = :default
       raise ArgumentError.new "symbol required" unless Symbol === context
       @context, @server = context, server
-      @@stashes[@context] ||= []
+      stashes[@context] ||= []
     end
 
     # add a websocket to this context's stash, save peeraddr info, start
     # server handle_websocket task to read from the socket and fire events
     # as needed
     #
-    def << ws
-      @@peeraddrs[ws] = ws.peeraddr
-      @server.async.handle_websocket ws
-      @@stashes[@context] << ws
+    def << s
+      peeraddrs[s] = s.peeraddr
+      yield if block_given?
+      stashes[@context] << s
     end
 
     # access the underlying array of this context
     #
     def stash
-      @@stashes[@context]
+      stashes[@context]
     end
 
     # iterate on each connected websocket in this context, handling errors
     # as needed
     #
     def each &block
-      stash.each do |ws|
+      stash.each do |s|
         begin
-          yield ws
+          yield s
         rescue Reel::SocketError, IOError, SystemCallError => e
           debug e.message
-          remove_socket ws
+          remove_socket s
         end
       end
+      nil
     end
 
-    # remove a websocket from the stash, warn user, drop peeraddr info
+    # remove a socket from the stash, warn user, drop peeraddr info
     #
-    def remove_socket ws
-      if stash.include? ws
-        warn "removing socket from context ':#{@context}' (#{@@peeraddrs[ws][2]})"
-        stash.delete ws
-        @@peeraddrs.delete ws
+    def remove_socket s
+      s.close unless s.closed?
+      if stash.include? s
+        warn "removing socket from context ':#{@context}' (#{peeraddrs[s][2]})"
+        stash.delete s
+        peeraddrs.delete s
       end
     end
 
@@ -71,12 +84,12 @@ module Angelo
     # ping_websockets task
     #
     def all_each
-      @@stashes.values.flatten.each do |ws|
+      stashes.values.flatten.each do |s|
         begin
-          yield ws
+          yield s
         rescue Reel::SocketError, IOError, SystemCallError => e
           debug e.message
-          remove_socket ws
+          remove_socket s
         end
       end
     end
@@ -89,8 +102,8 @@ module Angelo
 
     # access the peeraddr info for a given websocket
     #
-    def peeraddr ws
-      @@peeraddrs[ws]
+    def peeraddr s
+      peeraddrs[s]
     end
 
     # return the number of websockets in this context (some are potentially
@@ -100,5 +113,35 @@ module Angelo
       stash.length
     end
 
+    class Websocket
+      extend Stash::ClassMethods
+      include Stash
+
+      def << ws
+        super do
+          @server.async.handle_websocket ws
+        end
+      end
+
+    end
+
+    class SSE
+      extend Stash::ClassMethods
+      include Stash
+
+      def event data
+        raise ArgumentError.new 'use #message method for "messages"' if @context == :default
+        each {|s| s.write Angelo::Base.sse_event(@context, data)}
+        nil
+      end
+
+      def message data
+        each {|s| s.write Angelo::Base.sse_message(data)}
+        nil
+      end
+
+    end
+
   end
+
 end

data/lib/angelo/version.rb

@@ -1,3 +1,3 @@
 module Angelo
-  VERSION = '0.1.14'
+  VERSION = '0.1.15'
 end

data/lib/angelo.rb

@@ -25,6 +25,7 @@ module Angelo
   ETAG_HEADER_KEY = 'ETag'
   IF_NONE_MATCH_HEADER_KEY = 'If-None-Match'
   LOCATION_HEADER_KEY = 'Location'
+  SSE_HEADER = { CONTENT_TYPE_HEADER_KEY => 'text/event-stream' }
 
   HTML_TYPE = 'text/html'
   JSON_TYPE = 'application/json'
@@ -57,6 +58,9 @@ module Angelo
 
   HALT_STRUCT = Struct.new :status, :body
 
+  SSE_DATA_TEMPLATE = "data: %s\n\n"
+  SSE_EVENT_TEMPLATE = "event: %s\ndata: %s\n\n"
+
   class << self
 
     attr_writer :response_log_level
@@ -122,6 +126,7 @@ require 'angelo/server'
 require 'angelo/base'
 require 'angelo/stash'
 require 'angelo/responder'
+require 'angelo/responder/eventsource'
 require 'angelo/responder/websocket'
 
 # trap "INT" do

data/test/angelo/eventsource_spec.rb

@@ -0,0 +1,69 @@
+require_relative '../spec_helper'
+
+describe Angelo::Responder::Eventsource do
+
+  describe 'route builder' do
+
+    define_app do
+
+      eventsource '/msg' do |c|
+        c.write sse_message 'hi'
+        c.close
+      end
+
+      eventsource '/event' do |c|
+        c.write sse_event :sse, 'bye'
+        c.close
+      end
+
+    end
+
+    it 'sends messages' do
+      get_sse '/msg' do |msg|
+        msg.must_equal "data: hi\n\n"
+      end
+    end
+
+    it 'sends events' do
+      get_sse '/event' do |msg|
+        msg.must_equal "event: sse\ndata: bye\n\n"
+      end
+    end
+
+  end
+
+end
+
+describe 'eventsource helper' do
+
+  define_app do
+
+    get '/msg' do
+      eventsource do |c|
+        c.write sse_message 'hi'
+        c.close
+      end
+    end
+
+    get '/event' do
+      eventsource do |c|
+        c.write sse_event :sse, 'bye'
+        c.close
+      end
+    end
+
+  end
+
+  it 'sends messages' do
+    get_sse '/msg' do |msg|
+      msg.must_equal "data: hi\n\n"
+    end
+  end
+
+  it 'sends events' do
+    get_sse '/event' do |msg|
+      msg.must_equal "event: sse\ndata: bye\n\n"
+    end
+  end
+
+end

data/test/angelo/websocket_spec.rb

@@ -1,6 +1,6 @@
 require_relative '../spec_helper'
 
-describe Angelo::WebsocketResponder do
+describe Angelo::Responder::Websocket do
 
   def websocket_wait_for path, latch, expectation, key = :swf, &block
     Reactor.testers[key] = Array.new CONCURRENCY do
@@ -225,8 +225,14 @@ describe Angelo::WebsocketResponder do
   end
 
   describe 'helper contexts' do
-    let(:obj){ {'foo' => 'bar'} }
-    let(:wait_for_block){ ->(e){ assert_equal obj, JSON.parse(e.data) }}
+
+    def obj
+      { 'foo' => 'bar' }
+    end
+
+    def wait_for_block
+      ->(e){ assert_equal obj, JSON.parse(e.data) }
+    end
 
     define_app do
 
@@ -345,4 +351,33 @@ describe Angelo::WebsocketResponder do
 
   end
 
+  describe 'params' do
+
+    def wait_for_block
+      ->(e){ assert_equal({'bar' => 'foo', 'baz' => 'bat'}, JSON.parse(e.data)) }
+    end
+
+    define_app do
+
+      websocket '/' do |ws|
+        websockets[params[:bar].to_sym] << ws
+      end
+
+      post '/' do
+        pj = params.to_json
+        websockets[params[:bar].to_sym].each {|ws| ws.write pj}
+      end
+
+    end
+
+    it 'uses params correctly' do
+      latch = CountDownLatch.new CONCURRENCY
+      websocket_wait_for '/?bar=foo', latch, wait_for_block do
+        post '/', bar: 'foo', baz: 'bat'
+        latch.wait
+      end
+    end
+
+  end
+
 end

data/test/angelo_spec.rb

@@ -31,6 +31,11 @@ describe Angelo::Base do
         redirect '/'
       end
 
+      get '/wait' do
+        sleep 3
+        nil
+      end
+
     end
 
     it 'responds to http requests properly' do
@@ -56,6 +61,36 @@ describe Angelo::Base do
       last_response.headers['Location'].must_equal '/'
     end
 
+    it 'responds to requests concurrently' do
+      wait_end = nil
+      get_end = nil
+      latch = CountDownLatch.new 2
+
+      ActorPool.define_action :do_wait do
+        get '/wait'
+        wait_end = Time.now
+        latch.count_down
+      end
+
+      ActorPool.define_action :do_get do
+        sleep 1
+        get '/'
+        get_end = Time.now
+        latch.count_down
+      end
+
+      ActorPool.unstop!
+      $pool.async :do_wait
+      $pool.async :do_get
+
+      latch.wait
+      get_end.must_be :<, wait_end
+
+      ActorPool.stop!
+      ActorPool.remove_action :do_wait
+      ActorPool.remove_action :do_get
+    end
+
   end
 
   describe 'before filter' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: angelo
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.15
 platform: ruby
 authors:
 - Kenichi Nakamura
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-03 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reel
@@ -60,6 +60,7 @@ files:
 - lib/angelo/mustermann.rb
 - lib/angelo/params_parser.rb
 - lib/angelo/responder.rb
+- lib/angelo/responder/eventsource.rb
 - lib/angelo/responder/websocket.rb
 - lib/angelo/server.rb
 - lib/angelo/stash.rb
@@ -67,6 +68,7 @@ files:
 - lib/angelo/version.rb
 - test/angelo/erb_spec.rb
 - test/angelo/error_spec.rb
+- test/angelo/eventsource_spec.rb
 - test/angelo/mustermann_spec.rb
 - test/angelo/params_spec.rb
 - test/angelo/static_spec.rb