sockjs 0.2.1

data/LICENCE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 VMware, Inc.
+
+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.textile

@@ -0,0 +1,118 @@
+h1. About
+
+_*Disclaimer:* This library is still work in progress._
+
+SockJS is WebSocket emulation library. It means that you use the WebSocket API, only instead of @WebSocket@ class you instantiate @SockJS@ class. I highly recommend to read "SockJS: WebSocket emulation":http://www.rabbitmq.com/blog/2011/09/13/sockjs-websocket-emulation on the RabbitMQ blog for more info.
+
+h2. Prerequisites
+
+Even though this library uses Rack interface, *Thin is required* as "it supports asynchronous callback":http://macournoyer.com/blog/2009/06/04/pusher-and-async-with-thin. For Websockets, we use "faye-websocket":http://blog.jcoglan.com/2011/11/28/announcing-faye-websocket-a-standards-compliant-websocket-library gem.
+
+h2. The Client-Side Part
+
+For the client-side part you have to use JS library "sockjs-client":http://sockjs.github.com/sockjs-client which provides WebSocket-like API. Here's an example:
+
+<pre>
+<script src="http://cdn.sockjs.org/sockjs-0.2.1.min.js"></script>
+
+<script>
+  var sock = new SockJS("http://mydomain.com/my_prefix");
+
+  sock.onopen = function() {
+    console.log("open");
+  };
+
+  sock.onmessage = function(e) {
+    console.log("message", e.data);
+  };
+
+  sock.onclose = function() {
+    console.log("close");
+  };
+</script>
+</pre>
+
+h2. The Server-Side Part
+
+Now in order to have someone to talk to, we need to run a server. That's exactly what is sockjs-ruby good for:
+
+<pre>
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rack"
+require "rack/sockjs"
+require "eventmachine"
+
+# Your custom app.
+class MyHelloWorld
+  def call(env)
+    body = "This is the app, not SockJS."
+    headers = {
+      "Content-Type" => "text/plain; charset=UTF-8",
+      "Content-Length" => body.bytesize.to_s
+    }
+
+    [200, headers, [body]]
+  end
+end
+
+
+app = Rack::Builder.new do
+  # Run one SockJS app on /echo.
+  use SockJS, "/echo" do |connection|
+    connection.subscribe do |session, message|
+      session.send(message)
+    end
+  end
+
+  # ... and the other one on /close.
+  use SockJS, "/close" do |connection|
+    connection.session_open do |session|
+      session.close(3000, "Go away!")
+    end
+  end
+
+  # This app will run on other URLs than /echo and /close,
+  # as these has already been assigned to SockJS.
+  run MyHelloWorld.new
+end
+
+
+EM.run do
+  thin = Rack::Handler.get("thin")
+  thin.run(app.to_app, Port: 8081)
+end
+</pre>
+
+For more complex example check "examples/sockjs_apps_for_sockjs_protocol_tests.rb":https://github.com/sockjs/sockjs-ruby/blob/master/examples/sockjs_apps_for_sockjs_protocol_tests.rb
+
+
+h2. SockJS Family
+
+* "SockJS-client":https://github.com/sockjs/sockjs-client JavaScript client library.
+* "SockJS-node":https://github.com/sockjs/sockjs-node Node.js server.
+* "SockJS-ruby":https://github.com/sockjs/sockjs-ruby Ruby server.
+* "SockJS-protocol":https://github.com/sockjs/sockjs-protocol protocol tests and documentation.
+* "SockJS-protocol spec":http://sockjs.github.com/sockjs-protocol/sockjs-protocol-0.2.1.html
+
+h1. Development
+
+Get "sockjs-protocol":https://github.com/sockjs/sockjs-protocol (installation information are in its README) and run @rake protocol_test@. Now you can run the tests against it, for instance:
+
+<pre>
+# Run all the tests.
+./venv/bin/python sockjs-protocol-0.2.1.py
+
+# Run all the tests defined in XhrStreaming.
+./venv/bin/python sockjs-protocol-0.2.1.py XhrStreaming
+
+# Run only XhrStreaming.test_transport test.
+./venv/bin/python sockjs-protocol-0.2.1.py XhrStreaming.test_transport
+</pre>
+
+h1. Links
+
+* "SockJS: WebSocket emulation":http://www.rabbitmq.com/blog/2011/09/13/sockjs-websocket-emulation
+* "SockJS: web messaging ain't easy":http://www.rabbitmq.com/blog/2011/08/22/sockjs-web-messaging-aint-easy
+* "PubSubHuddle Realtime Web talk":http://www.rabbitmq.com/blog/2011/09/26/pubsubhuddle-realtime-web-talk

data/lib/meta-state.rb

@@ -0,0 +1,151 @@
+
+
+module MetaState
+  class Error < ::StandardError; end
+  class WrongStateError < Error; end
+  class InvalidStateError < Error; end
+
+  class Machine
+    NON_MESSAGES = [:on_exit, :on_enter]
+
+    class << self
+      def add_state(state)
+        @default_state ||= state
+        states
+        @states[state] = true
+        name = state.name.sub(/.*::/,'').downcase
+        state_names
+        @state_names[name] = state
+        @state_names[name.to_sym] = state
+        include state
+        @void_state_module = nil
+      end
+
+      def state(name, &block)
+        mod = Module.new(&block)
+        const_set(name, mod)
+        add_state(mod)
+      end
+
+      def default_state
+        @default_state || superclass.default_state
+      end
+
+      def void_state_module
+        if @void_state_module.nil?
+          build_void_state
+        end
+        @void_state_module
+      end
+
+      #Explicitly set the default (i.e. initial state) for an FSM
+      #Normally, this defaults to the first state defined, but some folks like
+      #to be explicit
+      def default_state=(state)
+        @default_state = state
+      end
+
+      def state_names
+        @state_names ||= {}
+        if Machine > superclass
+          superclass.state_names.merge(@state_names)
+        else
+          @state_names
+        end
+      end
+
+      def states
+        @states ||= {}
+        if Machine > superclass
+          superclass.states.merge(@states)
+        else
+          @states
+        end
+      end
+
+      def build_void_state
+        methods = (self.states.keys.map do |state|
+          state.instance_methods
+        end.flatten + NON_MESSAGES).uniq
+
+        @void_state_module = Module.new do
+          methods.each do |method|
+            if NON_MESSAGES.include?(method)
+              define_method(method){}
+            else
+              define_method(method) do
+                raise WrongStateError, "Message #{method} received in state #{current_state}"
+              end
+            end
+          end
+        end
+
+        include @void_state_module
+      end
+    end
+
+    #Explicitly put an FSM into a particular state.  Simultaneously enters a
+    #state of sin.  Use sparingly if at all.
+    def state=(state)
+      mod = state_module(state)
+      assign_state(mod)
+    end
+
+    def debug_with(&block)
+      @debug_block = block
+    end
+
+    attr_reader :current_state
+    def initialize
+      @debug_block = nil
+      assign_state(self.class.default_state)
+    end
+
+    protected
+
+    def debug
+      return if @debug_block.nil?
+      message = yield
+      @debug_block[message]
+    end
+
+    def assign_state(mod)
+      force_extend(self.class.void_state_module)
+      force_extend(mod)
+      @current_state = mod
+    end
+
+    def force_extend(mod)
+      mod.instance_methods.each do |method_name|
+        define_singleton_method(method_name, mod.instance_method(method_name))
+      end
+    end
+
+    def state_module(state)
+      unless state.is_a? Module
+        state = self.class.state_names[state] unless state.is_a? Module
+      end
+      raise InvalidStateError unless self.class.states[state]
+      return state
+    end
+
+    def transition_to(state)
+      target_state = state_module(state)
+      return true if target_state == current_state
+      source_state = current_state
+
+      debug{ "Transitioning from #{source_state.inspect} to #{target_state.inspect}" }
+
+      on_exit
+
+      warn "State changed after on_exit method.  Became: #{current_state.inspect}" unless source_state == current_state
+
+      assign_state(target_state)
+
+      on_enter
+
+      warn "State changed after on_enter method.  Became: #{current_state.inspect}" unless target_state == current_state
+    end
+
+  end
+end

data/lib/rack/sockjs.rb

@@ -0,0 +1,173 @@
+# encoding: utf-8
+require "sockjs"
+require 'sockjs/version'
+require "sockjs/transport"
+require "sockjs/servers/request"
+require "sockjs/servers/response"
+
+require 'rack/mount'
+
+require 'sockjs/duck-punch-rack-mount'
+require 'sockjs/duck-punch-thin-response'
+
+# Transports.
+require "sockjs/transports/info"
+require "sockjs/transports/eventsource"
+require "sockjs/transports/htmlfile"
+require "sockjs/transports/iframe"
+require "sockjs/transports/jsonp"
+require "sockjs/transports/websocket"
+require "sockjs/transports/welcome_screen"
+require "sockjs/transports/xhr"
+
+# This is a Rack middleware for SockJS.
+#
+#@example
+#
+#  require 'rack/sockjs'
+#
+#  map "/echo", Rack::SockJS.new do |connection|
+#    connection.subscribe do |session, message|
+#      session.send(message)
+#    end
+#  end
+#
+#  run MyApp
+#
+#
+# #or
+#
+#  run Rack::SockJS.new do |connection|
+#    connection.session_open do |session|
+#      session.close(3000, "Go away!")
+#    end
+#  end
+
+module Rack
+  class SockJS
+    SERVER_SESSION_REGEXP = %r{/([^/]*)/([^/]*)}
+    DEFAULT_OPTIONS = {
+      :sockjs_url => "http://cdn.sockjs.org/sockjs-#{::SockJS::PROTOCOL_VERSION}.min.js"
+    }
+
+
+    class DebugRequest
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = ::SockJS::Request.new(env)
+        headers = request.headers.select { |key, value| not %w{version host accept-encoding}.include?(key.to_s) }
+        ::SockJS.puts "\n~ \e[31m#{request.http_method} \e[32m#{request.path_info.inspect}#{" " + headers.inspect unless headers.empty?} \e[0m(\e[34m#{@prefix} app\e[0m)"
+        headers = headers.map { |key, value| "-H '#{key}: #{value}'" }.join(" ")
+        ::SockJS.puts "\e[90mcurl -X #{request.http_method} http://localhost:8081#{request.path_info} #{headers}\e[0m"
+
+        result = @app.call(env)
+      ensure
+        ::SockJS.debug "Rack response: " + result.inspect
+      end
+    end
+
+    class MissingHandler
+      def initialize(options)
+      end
+
+      def call(env)
+        prefix = env["PATH_INFO"]
+        method = env["REQUEST_METHOD"]
+        body = <<-HTML
+          <!DOCTYPE html>
+          <html>
+            <body>
+              <h1>Handler Not Found</h1>
+              <ul>
+                <li>Prefix: #{prefix.inspect}</li>
+                <li>Method: #{method.inspect}</li>
+              </ul>
+            </body>
+          </html>
+        HTML
+        ::SockJS.debug "Handler not found!"
+        [404, {"Content-Type" => "text/html; charset=UTF-8", "Content-Length" => body.bytesize.to_s}, [body]]
+      end
+    end
+
+    class ResetScriptName
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env["PREVIOUS_SCRIPT_NAME"], env["SCRIPT_NAME"] = env["SCRIPT_NAME"], ''
+        result = @app.call(env)
+      ensure
+        env["SCRIPT_NAME"] = env["PREVIOUS_SCRIPT_NAME"]
+      end
+    end
+
+    class RenderErrors
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env)
+      rescue => err
+        if err.respond_to? :to_html
+          err.to_html
+        else
+          raise
+        end
+      end
+    end
+
+    class ExtractServerAndSession
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        match = SERVER_SESSION_REGEXP.match(env["SCRIPT_NAME"])
+        env["sockjs.server-id"] = match[1]
+        env["sockjs.session-key"] = match[2]
+        old_script_name, old_path_name = env["SCRIPT_NAME"], env["PATH_INFO"]
+        env["SCRIPT_NAME"] = env["SCRIPT_NAME"] + match[0]
+        env["PATH_INFO"] = match.post_match
+
+        return @app.call(env)
+      ensure
+        env["SCRIPT_NAME"], env["PATH_INFO"] = old_script_name, old_path_name
+      end
+    end
+
+    def initialize(session_class, options = nil)
+      #TODO refactor Connection to App
+      connection = ::SockJS::Connection.new(session_class, options)
+
+      options ||= {}
+
+      options = DEFAULT_OPTIONS.merge(options)
+
+      @routing = Rack::Mount::RouteSet.new do |set|
+        ::SockJS::Endpoint.add_routes(set, connection, options)
+
+        set.add_route(MissingHandler.new(options), {}, {}, :missing)
+      end
+
+      routing = @routing
+
+      @app = Rack::Builder.new do
+        use Rack::SockJS::ResetScriptName
+        use DebugRequest
+        run routing
+      end.to_app
+    end
+
+    attr_reader :routing
+
+    def call(env)
+      @app.call(env)
+    end
+  end
+end