RubyGems - faye - Versions diffs - 0.8.11 → 1.0.0 - Mend

faye 0.8.11 → 1.0.0

Potentially problematic release.

This version of faye might be problematic. Click here for more details.

Files changed (73) hide show

data/{History.txt → CHANGELOG.md} +126 -105
data/README.md +36 -0
data/lib/faye-browser-min.js +2 -1
data/lib/faye-browser-min.js.map +1 -8
data/lib/faye-browser.js +923 -607
data/lib/faye.rb +11 -5
data/lib/faye/adapters/rack_adapter.rb +80 -85
data/lib/faye/engines/connection.rb +7 -9
data/lib/faye/engines/memory.rb +1 -0
data/lib/faye/engines/proxy.rb +7 -6
data/lib/faye/mixins/deferrable.rb +15 -0
data/lib/faye/mixins/logging.rb +11 -22
data/lib/faye/mixins/publisher.rb +9 -20
data/lib/faye/protocol/channel.rb +2 -1
data/lib/faye/protocol/client.rb +70 -48
data/lib/faye/protocol/envelope.rb +24 -0
data/lib/faye/protocol/extensible.rb +7 -4
data/lib/faye/protocol/publication.rb +1 -1
data/lib/faye/protocol/server.rb +8 -11
data/lib/faye/protocol/socket.rb +6 -4
data/lib/faye/protocol/subscription.rb +1 -1
data/lib/faye/transport/http.rb +20 -27
data/lib/faye/transport/local.rb +5 -5
data/lib/faye/transport/transport.rb +42 -12
data/lib/faye/transport/web_socket.rb +71 -38
metadata +169 -137
checksums.yaml +0 -7
data/README.rdoc +0 -83
data/spec/browser.html +0 -45
data/spec/encoding_helper.rb +0 -7
data/spec/install.sh +0 -78
data/spec/javascript/channel_spec.js +0 -15
data/spec/javascript/client_spec.js +0 -729
data/spec/javascript/dispatcher_spec.js +0 -122
data/spec/javascript/engine/memory_spec.js +0 -7
data/spec/javascript/engine_spec.js +0 -417
data/spec/javascript/faye_spec.js +0 -34
data/spec/javascript/grammar_spec.js +0 -66
data/spec/javascript/node_adapter_spec.js +0 -314
data/spec/javascript/publisher_spec.js +0 -27
data/spec/javascript/server/connect_spec.js +0 -168
data/spec/javascript/server/disconnect_spec.js +0 -121
data/spec/javascript/server/extensions_spec.js +0 -60
data/spec/javascript/server/handshake_spec.js +0 -145
data/spec/javascript/server/integration_spec.js +0 -131
data/spec/javascript/server/publish_spec.js +0 -85
data/spec/javascript/server/subscribe_spec.js +0 -247
data/spec/javascript/server/unsubscribe_spec.js +0 -245
data/spec/javascript/server_spec.js +0 -121
data/spec/javascript/transport_spec.js +0 -135
data/spec/node.js +0 -55
data/spec/phantom.js +0 -17
data/spec/ruby/channel_spec.rb +0 -17
data/spec/ruby/client_spec.rb +0 -741
data/spec/ruby/engine/memory_spec.rb +0 -7
data/spec/ruby/engine_examples.rb +0 -427
data/spec/ruby/faye_spec.rb +0 -30
data/spec/ruby/grammar_spec.rb +0 -68
data/spec/ruby/publisher_spec.rb +0 -27
data/spec/ruby/rack_adapter_spec.rb +0 -241
data/spec/ruby/server/connect_spec.rb +0 -170
data/spec/ruby/server/disconnect_spec.rb +0 -120
data/spec/ruby/server/extensions_spec.rb +0 -68
data/spec/ruby/server/handshake_spec.rb +0 -143
data/spec/ruby/server/integration_spec.rb +0 -133
data/spec/ruby/server/publish_spec.rb +0 -81
data/spec/ruby/server/subscribe_spec.rb +0 -247
data/spec/ruby/server/unsubscribe_spec.rb +0 -247
data/spec/ruby/server_spec.rb +0 -121
data/spec/ruby/transport_spec.rb +0 -136
data/spec/spec_helper.rb +0 -11
data/spec/testswarm +0 -42
data/spec/thin_proxy.rb +0 -37

data/spec/javascript/server/publish_spec.js DELETED

@@ -1,85 +0,0 @@
-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() {})
-      }})
-    }})
-  }})
-}})

data/spec/javascript/server/subscribe_spec.js DELETED

@@ -1,247 +0,0 @@
-JS.ENV.Server.SubscribeSpec = JS.Test.describe("Server subscribe", function() { with(this) {
-  before(function() { with(this) {
-    this.engine = {}
-    stub(Faye.Engine, "get").returns(engine)
-    this.server = new Faye.Server()
-  }})
-  describe("#subscribe", function() { with(this) {
-    before(function() { with(this) {
-      this.clientId = "fakeclientid"
-      this.message = {channel: "/meta/subscribe",
-                      clientId: "fakeclientid",
-                      subscription: "/foo"}
-    }})
-    describe("with valid parameters", function() { with(this) {
-      before(function() { with(this) {
-        expect(engine, "clientExists").given(clientId).yielding([true])
-      }})
-      it("subscribes the client to the channel", function() { with(this) {
-        expect(engine, "subscribe").given(clientId, "/foo")
-        server.subscribe(message, false, function() {})
-      }})
-      it("returns a successful response", function() { with(this) {
-        stub(engine, "subscribe")
-        server.subscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/subscribe",
-              successful:   true,
-              clientId:     clientId,
-              subscription: "/foo"
-            }, response)
-        })
-      }})
-      describe("with a list of subscriptions", function() { with(this) {
-        before(function() { with(this) {
-          message.subscription = ["/foo", "/bar"]
-        }})
-        it("creates multiple subscriptions", function() { with(this) {
-          expect(engine, "subscribe").given(clientId, "/foo")
-          expect(engine, "subscribe").given(clientId, "/bar")
-          server.subscribe(message, false, function() {})
-        }})
-        it("returns a successful response", function() { with(this) {
-          stub(engine, "subscribe")
-          server.subscribe(message, false, function(response) {
-            assertEqual({
-                channel:      "/meta/subscribe",
-                successful:   true,
-                clientId:     clientId,
-                subscription: ["/foo", "/bar"]
-              }, response)
-          })
-        }})
-      }})
-      describe("with a subscription pattern", function() { with(this) {
-        before(function() { with(this) {
-          message.subscription = "/foo/**"
-        }})
-        it("subscribes the client to the channel pattern", function() { with(this) {
-          expect(engine, "subscribe").given(clientId, "/foo/**")
-          server.subscribe(message, false, function() {})
-        }})
-        it("returns a successful response", function() { with(this) {
-          stub(engine, "subscribe")
-          server.subscribe(message, false, function(response) {
-            assertEqual({
-                channel:      "/meta/subscribe",
-                successful:   true,
-                clientId:     clientId,
-                subscription: "/foo/**"
-              }, response)
-          })
-        }})
-      }})
-    }})
-    describe("with an unknown client", function() { with(this) {
-      before(function() { with(this) {
-        expect(engine, "clientExists").given(clientId).yielding([false])
-      }})
-      it("does not subscribe the client to the channel", function() { with(this) {
-        expect(engine, "subscribe").exactly(0)
-        server.subscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.subscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/subscribe",
-              successful:   false,
-              error:        "401:fakeclientid:Unknown client",
-              clientId:     clientId,
-              subscription: "/foo"
-            }, response)
-        })
-      }})
-    }})
-    describe("missing clientId", function() { with(this) {
-      before(function() { with(this) {
-        delete message.clientId
-        expect(engine, "clientExists").given(undefined).yielding([false])
-      }})
-      it("does not subscribe the client to the channel", function() { with(this) {
-        expect(engine, "subscribe").exactly(0)
-        server.subscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.subscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/subscribe",
-              successful:   false,
-              error:        "402:clientId:Missing required parameter",
-              subscription: "/foo"
-            }, response)
-        })
-      }})
-    }})
-    describe("missing subscription", function() { with(this) {
-      before(function() { with(this) {
-        delete message.subscription
-        expect(engine, "clientExists").given(clientId).yielding([true])
-      }})
-      it("does not subscribe the client to the channel", function() { with(this) {
-        expect(engine, "subscribe").exactly(0)
-        server.subscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.subscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/subscribe",
-              successful:   false,
-              error:        "402:subscription:Missing required parameter",
-              clientId:     clientId,
-              subscription: []
-            }, response)
-        })
-      }})
-    }})
-    describe("with an invalid channel", function() { with(this) {
-      before(function() { with(this) {
-        message.subscription = "foo"
-        expect(engine, "clientExists").given(clientId).yielding([true])
-      }})
-      it("does not subscribe the client to the channel", function() { with(this) {
-        expect(engine, "subscribe").exactly(0)
-        server.subscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.subscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/subscribe",
-              successful:   false,
-              error:        "405:foo:Invalid channel",
-              clientId:     clientId,
-              subscription: "foo"
-            }, response)
-        })
-      }})
-    }})
-    describe("with a /meta/* channel", function() { with(this) {
-      before(function() { with(this) {
-        message.subscription = "/meta/foo"
-        expect(engine, "clientExists").given(clientId).yielding([true])
-      }})
-      it("does not subscribe the client to the channel", function() { with(this) {
-        expect(engine, "subscribe").exactly(0)
-        server.subscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.subscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/subscribe",
-              successful:   false,
-              error:        "403:/meta/foo:Forbidden channel",
-              clientId:     clientId,
-              subscription: "/meta/foo"
-            }, response)
-        })
-      }})
-      it("subscribes local clients to the channel", function() { with(this) {
-        expect(engine, "subscribe").given(clientId, "/meta/foo")
-        server.subscribe(message, true, function() {})
-      }})
-      it("returns a successful response for local clients", function() { with(this) {
-        stub(engine, "subscribe")
-        server.subscribe(message, true, function(response) {
-          assertEqual({
-              channel:      "/meta/subscribe",
-              successful:   true,
-              clientId:     clientId,
-              subscription: "/meta/foo"
-            }, response)
-        })
-      }})
-    }})
-    describe("with an error", function() { with(this) {
-      before(function() { with(this) {
-        message.error = "invalid"
-        expect(engine, "clientExists").given(clientId).yielding([true])
-      }})
-      it("does not subscribe the client to the channel", function() { with(this) {
-        expect(engine, "subscribe").exactly(0)
-        server.subscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function(resume) { with(this) {
-        server.subscribe(message, false, function(response) {
-          resume(function() {
-            assertEqual({
-                channel:      "/meta/subscribe",
-                successful:   false,
-                error:        "invalid",
-                clientId:     clientId,
-                subscription: "/foo"
-              }, response)
-          })
-        })
-      }})
-    }})
-  }})
-}})

data/spec/javascript/server/unsubscribe_spec.js DELETED

@@ -1,245 +0,0 @@
-JS.ENV.Server.UnsubscribeSpec = JS.Test.describe("Server unsubscribe", function() { with(this) {
-  before(function() { with(this) {
-    this.engine = {}
-    stub(Faye.Engine, "get").returns(engine)
-    this.server = new Faye.Server()
-  }})
-  describe("#unsubscribe", function() { with(this) {
-    before(function() { with(this) {
-      this.clientId = "fakeclientid"
-      this.message = {channel: "/meta/unsubscribe",
-                      clientId: "fakeclientid",
-                      subscription: "/foo"}
-    }})
-    describe("with valid parameters", function() { with(this) {
-      before(function() { with(this) {
-        expect(engine, "clientExists").given(clientId).yielding([true])
-      }})
-      it("unsubscribes the client from the channel", function() { with(this) {
-        expect(engine, "unsubscribe").given(clientId, "/foo")
-        server.unsubscribe(message, false, function() {})
-      }})
-      it("returns a successful response", function() { with(this) {
-        stub(engine, "unsubscribe")
-        server.unsubscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/unsubscribe",
-              successful:   true,
-              clientId:     clientId,
-              subscription: "/foo"
-            }, response)
-        })
-      }})
-      describe("with a list of subscriptions", function() { with(this) {
-        before(function() { with(this) {
-          message.subscription = ["/foo", "/bar"]
-        }})
-        it("destroys multiple subscriptions", function() { with(this) {
-          expect(engine, "unsubscribe").given(clientId, "/foo")
-          expect(engine, "unsubscribe").given(clientId, "/bar")
-          server.unsubscribe(message, false, function() {})
-        }})
-        it("returns a successful response", function() { with(this) {
-          stub(engine, "unsubscribe")
-          server.unsubscribe(message, false, function(response) {
-            assertEqual({
-                channel:      "/meta/unsubscribe",
-                successful:   true,
-                clientId:     clientId,
-                subscription: ["/foo", "/bar"]
-              }, response)
-          })
-        }})
-      }})
-      describe("with a subscription pattern", function() { with(this) {
-        before(function() { with(this) {
-          message.subscription = "/foo/**"
-        }})
-        it("destroys the subscription to the channel pattern", function() { with(this) {
-          expect(engine, "unsubscribe").given(clientId, "/foo/**")
-          server.unsubscribe(message, false, function() {})
-        }})
-        it("returns a successful response", function() { with(this) {
-          stub(engine, "unsubscribe")
-          server.unsubscribe(message, false, function(response) {
-            assertEqual({
-                channel:      "/meta/unsubscribe",
-                successful:   true,
-                clientId:     clientId,
-                subscription: "/foo/**"
-              }, response)
-          })
-        }})
-      }})
-    }})
-    describe("with an unknown client", function() { with(this) {
-      before(function() { with(this) {
-        expect(engine, "clientExists").given(clientId).yielding([false])
-      }})
-      it("does not unsubscribe the client from the channel", function() { with(this) {
-        expect(engine, "unsubscribe").exactly(0)
-        server.unsubscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.unsubscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/unsubscribe",
-              successful:   false,
-              error:        "401:fakeclientid:Unknown client",
-              clientId:     clientId,
-              subscription: "/foo"
-            }, response)
-        })
-      }})
-    }})
-    describe("missing clientId", function() { with(this) {
-      before(function() { with(this) {
-        delete message.clientId
-        expect(engine, "clientExists").given(undefined).yielding([false])
-      }})
-      it("does not unsubscribe the client from the channel", function() { with(this) {
-        expect(engine, "unsubscribe").exactly(0)
-        server.unsubscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.unsubscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/unsubscribe",
-              successful:   false,
-              error:        "402:clientId:Missing required parameter",
-              subscription: "/foo"
-            }, response)
-        })
-      }})
-    }})
-    describe("missing subscription", function() { with(this) {
-      before(function() { with(this) {
-        delete message.subscription
-        expect(engine, "clientExists").given(clientId).yielding([true])
-      }})
-      it("does not unsubscribe the client from the channel", function() { with(this) {
-        expect(engine, "unsubscribe").exactly(0)
-        server.unsubscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.unsubscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/unsubscribe",
-              successful:   false,
-              error:        "402:subscription:Missing required parameter",
-              clientId:     clientId,
-              subscription: []
-            }, response)
-        })
-      }})
-    }})
-    describe("with an invalid channel", function() { with(this) {
-      before(function() { with(this) {
-        message.subscription = "foo"
-        expect(engine, "clientExists").given(clientId).yielding([true])
-      }})
-      it("does not unsubscribe the client from the channel", function() { with(this) {
-        expect(engine, "unsubscribe").exactly(0)
-        server.unsubscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.unsubscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/unsubscribe",
-              successful:   false,
-              error:        "405:foo:Invalid channel",
-              clientId:     clientId,
-              subscription: "foo"
-            }, response)
-        })
-      }})
-    }})
-    describe("with a /meta/* channel", function() { with(this) {
-      before(function() { with(this) {
-        message.subscription = "/meta/foo"
-        expect(engine, "clientExists").given(clientId).yielding([true])
-      }})
-      it("does not unsubscribe the client from the channel", function() { with(this) {
-        expect(engine, "unsubscribe").exactly(0)
-        server.unsubscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.unsubscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/unsubscribe",
-              successful:   false,
-              error:        "403:/meta/foo:Forbidden channel",
-              clientId:     clientId,
-              subscription: "/meta/foo"
-            }, response)
-        })
-      }})
-      it("unsubscribes local clients from the channel", function() { with(this) {
-        expect(engine, "unsubscribe").given(clientId, "/meta/foo")
-        server.unsubscribe(message, true, function() {})
-      }})
-      it("returns a successful response for local clients", function() { with(this) {
-        stub(engine, "unsubscribe")
-        server.unsubscribe(message, true, function(response) {
-          assertEqual({
-              channel:      "/meta/unsubscribe",
-              successful:   true,
-              clientId:     clientId,
-              subscription: "/meta/foo"
-            }, response)
-        })
-      }})
-    }})
-    describe("with an error", function() { with(this) {
-      before(function() { with(this) {
-        message.error = "invalid"
-        expect(engine, "clientExists").given(clientId).yielding([true])
-      }})
-      it("does not unsubscribe the client from the channel", function() { with(this) {
-        expect(engine, "unsubscribe").exactly(0)
-        server.unsubscribe(message, false, function() {})
-      }})
-      it("returns an unsuccessful response", function() { with(this) {
-        server.unsubscribe(message, false, function(response) {
-          assertEqual({
-              channel:      "/meta/unsubscribe",
-              successful:   false,
-              error:        "invalid",
-              clientId:     clientId,
-              subscription: "/foo"
-            }, response)
-        })
-      }})
-    }})
-  }})
-}})