faye 0.7.2 → 0.8.0

data/lib/faye/transport/http.rb

@@ -8,45 +8,67 @@ module Faye
     def request(message, timeout)
       retry_block = retry_block(message, timeout)
       
-      @client.cookies ||= CookieJar::Jar.new
-      cookies = @client.cookies.get_cookies(@endpoint)
+      content = Faye.to_json(message)
+      cookies = @cookies.get_cookies(@endpoint)
+      params  = build_params(URI.parse(@endpoint), content, cookies)
+      request = create_request(params)
       
-      content = JSON.unparse(message)
-      params = {
+      request.callback do
+        handle_response(request.response, retry_block)
+        store_cookies([*request.response_header['SET_COOKIE']].compact)
+      end
+      request.errback do
+        retry_block.call
+        trigger(:down)
+      end
+    end
+    
+  private
+    
+    def build_params(uri, content, cookies)
+      {
         :head => {
-          'Content-Length'  => content.length,
+          'Content-Length'  => content.bytesize,
           'Content-Type'    => 'application/json',
           'Cookie'          => cookies * '; ',
-          'Host'            => URI.parse(@endpoint).host
-        },
+          'Host'            => uri.host
+        }.merge(@headers),
+        
         :body    => content,
         :timeout => -1  # for em-http-request < 1.0
       }
-      if EventMachine::HttpRequest::VERSION.split('.')[0].to_i >= 1
-        options = {   # for em-http-request >= 1.0
-          :inactivity_timeout => 0,    # connection inactivity (post-setup) timeout (0 = disable timeout)
-        }
-        request = EventMachine::HttpRequest.new(@endpoint, options).post(params)
+    end
+    
+    def create_request(params)
+      version = EventMachine::HttpRequest::VERSION.split('.')[0].to_i
+      client  = if version >= 1
+                  options = {                 # for em-http-request >= 1.0
+                    :inactivity_timeout => 0  # connection inactivity (post-setup) timeout (0 = disable timeout)
+                  }
+                  EventMachine::HttpRequest.new(@endpoint, options)
+                else
+                  EventMachine::HttpRequest.new(@endpoint)
+                end
+      
+      client.post(params)
+    end
+    
+    def handle_response(response, retry_block)
+      message = Yajl::Parser.parse(response) rescue nil
+      if message
+        receive(message)
+        trigger(:up)
       else
-        request = EventMachine::HttpRequest.new(@endpoint).post(params)
-      end
-      request.callback do
-        begin
-          cookies = [*request.response_header['SET_COOKIE']]
-          cookies.each do |cookie|
-            @client.cookies.set_cookie(@endpoint, cookie)
-          end
-          receive(JSON.parse(request.response))
-          trigger(:up)
-        rescue
-          retry_block.call
-        end
-      end
-      request.errback do
         retry_block.call
         trigger(:down)
       end
     end
+    
+    def store_cookies(cookies)
+      cookies.each do |cookie|
+        @cookies.set_cookie(@endpoint, cookie)
+      end
+    end
   end
   
   Transport.register 'long-polling', Transport::Http

data/lib/faye/transport/transport.rb

@@ -5,6 +5,8 @@ module Faye
     include Publisher
     include Timeouts
     
+    attr_accessor :cookies, :headers
+    
     def initialize(client, endpoint)
       debug('Created new ? transport for ?', connection_type, endpoint)
       @client   = client
@@ -60,7 +62,7 @@ module Faye
     
     def retry_block(message, timeout)
       lambda do
-        EventMachine.add_timer(timeout) { request(message, 2 * timeout) }
+        EventMachine.add_timer(@client.retry) { request(message, timeout) }
       end
     end
     

data/lib/faye/transport/web_socket.rb

@@ -37,10 +37,9 @@ module Faye
     end
     
     def request(messages, timeout = nil)
-      @timeout    = timeout || @timeout
       @messages ||= {}
       messages.each { |message| @messages[message['id']] = message }
-      with_socket { |socket| socket.send(JSON.unparse(messages)) }
+      with_socket { |socket| socket.send(Faye.to_json(messages)) }
     end
     
     def with_socket(&resume)
@@ -71,7 +70,7 @@ module Faye
       end
       
       @socket.onmessage = lambda do |event|
-        messages = [JSON.parse(event.data)].flatten
+        messages = [Yajl::Parser.parse(event.data)].flatten
         messages.each { |message| @messages.delete(message['id']) }
         receive(messages)
       end
@@ -82,13 +81,10 @@ module Faye
         @state = UNCONNECTED
         @socket = nil
         
-        if was_connected
-          resend
-        else
-          EventMachine.add_timer(@timeout) { connect }
-          @timeout = @timeout * 2
-          trigger(:down)
-        end
+        next resend if was_connected
+        
+        EventMachine.add_timer(@client.retry) { connect }
+        trigger(:down)
       end
     end
     

data/lib/faye/util/namespace.rb

@@ -10,8 +10,8 @@ module Faye
     end
     
     def generate
-      name = Faye.random
-      name = Faye.random while @used.has_key?(name)
+      name = Engine.random
+      name = Engine.random while @used.has_key?(name)
       @used[name] = name
     end
     

data/spec/browser.html

@@ -3,7 +3,7 @@
   <head>
     <meta http-equiv="Content-type" content="text/html; charset=utf-8">
     <title>Faye test suite</title>
-    <script type="text/javascript" src="../vendor/js.class/build/min/loader.js"></script>
+    <script type="text/javascript" src="../node_modules/jsclass/min/loader.js"></script>
   </head>
   <body>
     <script type="text/javascript">
@@ -16,6 +16,8 @@
           heartbeat: function() {}
         }
       
+      JS.cacheBust = true
+      
       JS.Packages(function() { with(this) {
         file('../build/faye-browser-min.js').provides('Faye')
         autoload(/.*Spec/, {from: './javascript'})

data/spec/encoding_helper.rb

@@ -0,0 +1,7 @@
+module EncodingHelper
+  def encode(string)
+    return string unless string.respond_to?(:force_encoding)
+    string.force_encoding("UTF-8")
+  end
+end
+

data/spec/javascript/client_spec.js

@@ -583,11 +583,6 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
       client.publish("/messages/foo", {hello: "world"})
     }})
     
-    it("throws an error when publishing to an invalid channel", function() { with(this) {
-      expect(transport, "send").given(objectIncluding({channel: "/messages/*"}), 60).exactly(0)
-      assertThrows(Error, function() { client.publish("/messages/*", {hello: "world"}) })
-    }})
-    
     describe("on publish failure", function() { with(this) {
       before(function() { with(this) {
         stubResponse({channel:    "/messages/foo",

data/spec/javascript/engine/memory_spec.js

@@ -0,0 +1,7 @@
+JS.ENV.Engine.MemorySpec = JS.Test.describe("Memory engine", function() { with(this) {
+  before(function() {
+    this.engineOpts = {type: Faye.Engine.Memory}
+  })
+  
+  itShouldBehaveLike("faye engine")
+}})

data/spec/javascript/engine_spec.js

@@ -12,11 +12,11 @@ JS.ENV.EngineSteps = JS.Test.asyncSteps({
   connect: function(name, engine, resume) {
     var clientId = this._clients[name]
     var inboxes  = this._inboxes
-    engine.connect(clientId, {}, function(m) {
-      Faye.each(m, function(message) {
-        delete message.id
-        inboxes[name].push(message)
-      })
+    engine.connect(clientId, {}, function(messages) {
+      for (var i = 0, n = messages.length; i < n; i++) {
+        delete messages[i].id
+        inboxes[name].push(messages[i])
+      }
     })
     setTimeout(resume, 10)
   },
@@ -32,7 +32,7 @@ JS.ENV.EngineSteps = JS.Test.asyncSteps({
   
   check_num_clients: function(n, resume) {
     var ids = new JS.Set()
-    Faye.each(this._clients, function(name, id) { ids.add(id) })
+    for (var key in this._clients) ids.add(this._clients[key])
     this.assertEqual(n, ids.count())
     resume()
   },
@@ -55,10 +55,10 @@ JS.ENV.EngineSteps = JS.Test.asyncSteps({
   
   publish: function(messages, resume) {
     messages = [].concat(messages)
-    Faye.each(messages, function(message) {
-      message = Faye.extend({id: Faye.random()}, message)
+    for (var i = 0, n = messages.length; i < n; i++) {
+      var message = Faye.extend({id: Faye.random()}, messages[i])
       this.engine.publish(message)
-    }, this)
+    }
     setTimeout(resume, 20)
   },
   
@@ -108,29 +108,18 @@ JS.ENV.EngineSteps = JS.Test.asyncSteps({
   check_different_messages: function(a, b, resume) {
     this.assertNotSame(this._inboxes[a][0], this._inboxes[b][0])
     resume()
-  },
-  
-  clean_redis_db: function(resume) {
-    this.engine.disconnect()
-    var redis = require('redis').createClient(6379, 'localhost', {no_ready_check: true})
-    redis.auth(this.engineOpts.password)
-    redis.flushall(function() {
-      redis.end()
-      resume()
-    })
   }
 })
 
 JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this) {
-  include(JS.Test.Helpers)
-  
-  define("create_engine", function() { with(this) {
-    var opts = Faye.extend(options(), engineOpts)
-    return new engineKlass(opts)
-  }})
-  
   sharedExamplesFor("faye engine", function() { with(this) {
+    include(JS.Test.Helpers)
     include(EngineSteps)
+  
+    define("create_engine", function() { with(this) {
+      var opts = Faye.extend(options(), engineOpts)
+      return new Faye.Engine.Proxy(opts)
+    }})
     
     define("options", function() { return {timeout: 1} })
     
@@ -390,7 +379,14 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
   }})
   
   sharedBehavior("distributed engine", function() { with(this) {
+    include(JS.Test.Helpers)
     include(EngineSteps)
+  
+    define("create_engine", function() { with(this) {
+      var opts = Faye.extend(options(), engineOpts)
+      return new Faye.Engine.Proxy(opts)
+    }})
+    
     define("options", function() { return {timeout: 1} })
     
     before(function() { with(this) {
@@ -418,35 +414,4 @@ JS.ENV.EngineSpec = JS.Test.describe("Pub/sub engines", function() { with(this)
       }})
     }})
   }})
-  
-  describe("Faye.Engine.Memory", function() { with(this) {
-    before(function() {
-      this.engineKlass = Faye.Engine.Memory
-      this.engineOpts  = {}
-    })
-    
-    itShouldBehaveLike("faye engine")
-  }})
-  
-  describe("Faye.Engine.Redis", function() { with(this) {
-    before(function() {
-      this.engineKlass = Faye.Engine.Redis
-      this.engineOpts  = {password: "foobared", namespace: new Date().getTime().toString()}
-    })
-    after(function() { this.clean_redis_db() })
-    
-    itShouldBehaveLike("faye engine")
-    
-    describe("distribution", function() { with(this) {
-      itShouldBehaveLike("distributed engine")
-    }})
-    
-    describe("using a Unix socket", function() { with(this) {
-      before(function() { with(this) {
-        this.engineOpts.socket = "/tmp/redis.sock"
-      }})
-      
-      itShouldBehaveLike("faye engine")
-    }})
-  }})
 }})

data/spec/javascript/server/handshake_spec.js

@@ -3,6 +3,10 @@ JS.ENV.Server.HandshakeSpec = JS.Test.describe("Server handshake", function() {
     this.engine = {}
     stub(Faye.Engine, "get").returns(engine)
     this.server = new Faye.Server()
+    
+    this.connectionTypes = ["long-polling", "cross-origin-long-polling",
+                            "callback-polling","websocket",
+                            "eventsource","in-process"]
   }})
   
   describe("#handshake", function() { with(this) {
@@ -25,7 +29,7 @@ JS.ENV.Server.HandshakeSpec = JS.Test.describe("Server handshake", function() {
               channel:    "/meta/handshake",
               successful: true,
               version:    "1.0",
-              supportedConnectionTypes: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket","in-process"],
+              supportedConnectionTypes: connectionTypes,
               clientId:   "clientid"
             }, response)
         })
@@ -41,7 +45,7 @@ JS.ENV.Server.HandshakeSpec = JS.Test.describe("Server handshake", function() {
                 channel:    "/meta/handshake",
                 successful: true,
                 version:    "1.0",
-                supportedConnectionTypes: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket","in-process"],
+                supportedConnectionTypes: connectionTypes,
                 clientId:   "clientid",
                 id:         "foo"
               }, response)
@@ -65,7 +69,7 @@ JS.ENV.Server.HandshakeSpec = JS.Test.describe("Server handshake", function() {
               successful: false,
               error:      "402:version:Missing required parameter",
               version:    "1.0",
-              supportedConnectionTypes: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket","in-process"]
+              supportedConnectionTypes: connectionTypes
             }, response)
         })
       }})
@@ -86,7 +90,7 @@ JS.ENV.Server.HandshakeSpec = JS.Test.describe("Server handshake", function() {
               successful: false,
               error:      "402:supportedConnectionTypes:Missing required parameter",
               version:    "1.0",
-              supportedConnectionTypes: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket","in-process"]
+              supportedConnectionTypes: connectionTypes
             }, response)
         })
       }})
@@ -109,7 +113,7 @@ JS.ENV.Server.HandshakeSpec = JS.Test.describe("Server handshake", function() {
               successful: false,
               error:      "301:iframe,flash:Connection types not supported",
               version:    "1.0",
-              supportedConnectionTypes: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket","in-process"]
+              supportedConnectionTypes: connectionTypes
             }, response)
         })
       }})
@@ -132,7 +136,7 @@ JS.ENV.Server.HandshakeSpec = JS.Test.describe("Server handshake", function() {
               successful: false,
               error:      "invalid",
               version:    "1.0",
-              supportedConnectionTypes: ["long-polling", "cross-origin-long-polling", "callback-polling", "websocket","in-process"]
+              supportedConnectionTypes: connectionTypes
             }, response)
         })
       }})

data/spec/javascript/server/integration_spec.js

@@ -28,16 +28,17 @@ JS.ENV.IntegrationSteps = JS.Test.asyncSteps({
     var n = channels.length
     if (n === 0) return this._clients[name].connect(callback)
     
-    Faye.each(channels, function(channel) {
-      var subscription = this._clients[name].subscribe(channel, function(message) {
-        this._inboxes[name][channel] = this._inboxes[name][channel] || []
-        this._inboxes[name][channel].push(message)
-      }, this)
-      subscription.callback(function() {
-        n -= 1
-        if (n === 0) callback()
-      })
-    }, this)
+    for (var i = 0; i < n; i++)
+      (function(channel) {
+        var subscription = this._clients[name].subscribe(channel, function(message) {
+          this._inboxes[name][channel] = this._inboxes[name][channel] || []
+          this._inboxes[name][channel].push(message)
+        }, this)
+        subscription.callback(function() {
+          n -= 1
+          if (n === 0) callback()
+        })
+      }).call(this, channels[i]);
   },
   
   publish: function(name, channel, message, callback) {

data/spec/javascript/server/publish_spec.js

@@ -0,0 +1,85 @@
+JS.ENV.Server.PublishSpec = JS.Test.describe("Server publish", function() { with(this) {
+  before(function() { with(this) {
+    this.engine = {}
+    stub(Faye.Engine, "get").returns(engine)
+    this.server = new Faye.Server()
+    
+    this.message = {channel: "/some/channel",     data: "publish"}
+  }})
+  
+  describe("publishing a message", function() { with(this) {
+    it("tells the engine to publish the message", function() { with(this) {
+      expect(engine, "publish").given(message)
+      server.process(message, false, function() {})
+    }})
+    
+    it("returns a successful response", function() { with(this) {
+      stub(engine, "publish")
+      server.process(message, false, function(response) {
+        assertEqual([
+          { channel:    "/some/channel",
+            successful: true
+          }
+        ], response)
+      })
+    }})
+    
+    describe("with an invalid channel", function() { with(this) {
+      before(function() { with(this) {
+        message.channel = "channel"
+      }})
+      
+      it("does not tell the engine to publish the message", function() { with(this) {
+        expect(engine, "publish").exactly(0)
+        server.process(message, false, function() {})
+      }})
+      
+      it("returns an unsuccessful response", function() { with(this) {
+        stub(engine, "publish")
+        server.process(message, false, function(response) {
+          assertEqual([
+            { channel:    "channel",
+              successful: false,
+              error:      "405:channel:Invalid channel"
+            }
+          ], response)
+        })
+      }})
+    }})
+    
+    describe("with an error", function() { with(this) {
+      before(function() { with(this) {
+        message.error = "invalid"
+      }})
+      
+      it("does not tell the engine to publish the message", function() { with(this) {
+        expect(engine, "publish").exactly(0)
+        server.process(message, false, function() {})
+      }})
+      
+      it("returns an unsuccessful response", function() { with(this) {
+        stub(engine, "publish")
+        server.process(message, false, function(response) {
+          assertEqual([
+            { channel:    "/some/channel",
+              successful: false,
+              error:      "invalid"
+            }
+          ], response)
+        })
+      }})
+    }})
+
+    describe("to an invalid channel", function() { with(this) {
+      before(function() { with(this) {
+        message.channel = "/invalid/*"
+      }})
+
+      it("does not tell the engine to publish the message", function() { with(this) {
+        expect(engine, "publish").exactly(0)
+        server.process(message, false, function() {})
+      }})
+    }})
+  }})
+}})
+