private_pub 0.2.0 → 0.3.0

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+## 0.3.0 (January 14, 2012)
+
+* adding `PrivatePub.publish_to` method for publishing from anywhere - issue #15
+
+* rewriting `private_pub.js` so it is framework agnostic
+
+* Rails 3.1 compatibility (thanks BinaryMuse) - issue #25
+
+* adding faye gem dependency so it doesn't need to be installed separately
+
+* renaming `faye.ru` to `private_pub.ru`
+
+* truncate token for client for security (thanks jameshuynh) - issue #19
+
+
+## 0.2.0 (April 7, 2011)
+
+* switched to YAML file for config. BACKWARDS INCOMPATIBLE: you will need to remove config/initializers/private_pub.rb
+
+* moved view helpers into Railtie so helper file is no longer generated
+
+* error out when signature has expired
+
+
+## 0.1.0 (April 4, 2011)
+
+* initial release

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Ryan Bates
+Copyright (c) 2012 Ryan Bates
  
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,115 @@
+# Private Pub
+
+Private Pub is a Ruby gem for use with Rails to publish and subscribe to messages through [Faye](http://faye.jcoglan.com/). It allows you to easily provide real-time updates through an open socket without tying up a Rails process. All channels are private so users can only listen to events you subscribe them to.
+
+This project was motivated by [RailsCasts episode #260](http://railscasts.com/episodes/260-messaging-with-faye).
+
+
+## Setup
+
+Add the gem to your Gemfile and run the `bundle` command to install it.
+
+```ruby
+gem "private_pub"
+```
+
+Run the generator to create the initial files.
+
+```
+rails g private_pub:install
+```
+
+Next, start up Faye using the rackup file that was generated.
+
+```
+rackup private_pub.ru -s thin -E production
+```
+
+**In Rails 3.1** add the JavaScript file to your application.js file manifest.
+
+```javascript
+//= require private_pub
+```
+
+**In Rails 3.0** add the generated private_pub.js file to your layout.
+
+```rhtml
+<%= javascript_include_tag "private_pub" %>
+```
+
+It's not necessary to include faye.js since that will be handled automatically for you.
+
+
+## Usage
+
+Use the `subscribe_to` helper method on any page to subscribe to a channel.
+
+```rhtml
+<%= subscribe_to "/messages/new" %>
+```
+
+Use the `publish_to` helper method to send JavaScript to that channel. This is usually done in a JavaScript AJAX template (such as a create.js.erb file).
+
+```rhtml
+<% publish_to "/messages/new" do %>
+  $("#chat").append("<%= j render(@messages) %>");
+<% end %>
+```
+
+This JavaScript will be immediately evaluated on all clients who have subscribed to that channel. In this example they will see the new chat message appear in real-time without reloading the browser.
+
+
+## Alternative Usage
+
+If you prefer to work through JSON instead of JavaScript templates to handle AJAX responses, you can pass an argument to `publish_to` instead of a block and it will be converted `to_json` behind the scenes. This can also be done anywhere (such as the controller).
+
+```ruby
+PrivatePub.publish_to "/messages/new", :chat_message => "Hello, world!"
+```
+
+And then handle this through JavaScript on the client side.
+
+```javascript
+PrivatePub.subscribe("/messages/new", function(data, channel) {
+  $("#chat").append(data.chat_message);
+});
+```
+
+The Ruby `subscribe_to` call is still necessary with this approach to grant the user access to the channel. The JavaScript is just a callback for any custom behavior.
+
+
+## Security
+
+Security is handled automatically for you. Only the Rails app is able to publish messages. Users are only able to receive messages on the channels you subscribe them to so every channel is private.
+
+Here's how it works. The `subscribe_to` helper will output a script element containing data information about the channel.
+
+```html
+<script type="text/javascript">
+  PrivatePub.sign({
+    channel: "/messages/new",
+    timestamp: 1302306682972,
+    signature: "dc1c71d3e959ebb6f49aa6af0c86304a0740088d",
+    server: "http://localhost:9292/faye"
+  });
+</script>
+```
+
+The signature is a combination of the channel, timestamp, and secret token set in the Rails app. This is checked by the Faye extension when subscribing to a channel to ensure the signature is correct. The signature automatically expires after 1 hour but this can be configured in the generated YAML config file.
+
+```yaml
+signature_expiration: 600 # 10 minutes, expressed in seconds
+```
+
+Or use a blank value for no expiration.
+
+```yaml
+signature_expiration:
+```
+
+Note: if Faye is on a separate server from the Rails app it's important that the system clocks be in sync so the expiration works properly.
+
+
+## Development & Feedback
+
+Questions or comments? Please use the [issue tracker](https://github.com/ryanb/private_pub/issues). If you would like to contribue to this project, clone this repository and run `bundle` and `rake` to run the tests.

data/Rakefile

@@ -1,10 +1,12 @@
 require 'rubygems'
 require 'rake'
 require 'rspec/core/rake_task'
+require 'jasmine'
+load 'jasmine/tasks/jasmine.rake'
 
 desc "Run RSpec"
 RSpec::Core::RakeTask.new do |t|
   t.verbose = false
 end
 
-task :default => :spec
+task :default => [:spec, "jasmine:ci"]

data/app/assets/javascripts/private_pub.js

@@ -0,0 +1,72 @@
+function buildPrivatePub(doc) {
+  var self = {
+    connecting: false,
+    fayeClient: null,
+    fayeCallbacks: [],
+    subscriptions: {},
+    subscriptionCallbacks: {},
+
+    faye: function(callback) {
+      if (self.fayeClient) {
+        callback(self.fayeClient);
+      } else {
+        self.fayeCallbacks.push(callback);
+        if (self.subscriptions.server && !self.connecting) {
+          self.connecting = true;
+          var script = doc.createElement("script");
+          script.type = "text/javascript";
+          script.src = self.subscriptions.server + ".js";
+          script.onload = self.connectToFaye;
+          doc.documentElement.appendChild(script);
+        }
+      }
+    },
+
+    connectToFaye: function() {
+      self.fayeClient = new Faye.Client(self.subscriptions.server);
+      self.fayeClient.addExtension(self.fayeExtension);
+      for (var i=0; i < self.fayeCallbacks.length; i++) {
+        self.fayeCallbacks[i](self.fayeClient);
+      };
+    },
+
+    fayeExtension: {
+      outgoing: function(message, callback) {
+        if (message.channel == "/meta/subscribe") {
+          // Attach the signature and timestamp to subscription messages
+          var subscription = self.subscriptions[message.subscription];
+          if (!message.ext) message.ext = {};
+          message.ext.private_pub_signature = subscription.signature;
+          message.ext.private_pub_timestamp = subscription.timestamp;
+        }
+        callback(message);
+      }
+    },
+
+    sign: function(options) {
+      if (!self.subscriptions.server) {
+        self.subscriptions.server = options.server;
+      }
+      self.subscriptions[options.channel] = options;
+      self.faye(function(faye) {
+        faye.subscribe(options.channel, self.handleResponse);
+      });
+    },
+
+    handleResponse: function(message) {
+      if (message.eval) {
+        eval(message.eval);
+      }
+      if (callback = self.subscriptionCallbacks[message.channel]) {
+        callback(message.data, message.channel);
+      }
+    },
+
+    subscribe: function(channel, callback) {
+      self.subscriptionCallbacks[channel] = callback;
+    }
+  };
+  return self;
+}
+
+var PrivatePub = buildPrivatePub(document);

data/lib/generators/private_pub/install_generator.rb

@@ -6,11 +6,11 @@ module PrivatePub
       end
 
       def copy_files
-        remove_file "config/initializers/private_pub.rb"
-        remove_file "app/helpers/private_pub_helper.rb"
         template "private_pub.yml", "config/private_pub.yml"
-        copy_file "private_pub.js", "public/javascripts/private_pub.js"
-        copy_file "faye.ru", "faye.ru"
+        if ::Rails.version < "3.1"
+          copy_file "../../../../app/assets/javascripts/private_pub.js", "public/javascripts/private_pub.js"
+        end
+        copy_file "private_pub.ru", "private_pub.ru"
       end
     end
   end

data/lib/generators/private_pub/templates/private_pub.ru

@@ -0,0 +1,8 @@
+# Run with: rackup private_pub.ru -s thin -E production
+require "bundler/setup"
+require "yaml"
+require "faye"
+require "private_pub"
+
+PrivatePub.load_config(File.expand_path("../config/private_pub.yml", __FILE__), ENV["RAILS_ENV"] || "development")
+run PrivatePub.faye_app

data/lib/private_pub/{railtie.rb → engine.rb}

@@ -1,7 +1,7 @@
 require "private_pub/view_helpers"
 
 module PrivatePub
-  class Railtie < Rails::Railtie
+  class Engine < Rails::Engine
     initializer "private_pub.config" do
       path = Rails.root.join("config/private_pub.yml")
       PrivatePub.load_config(path, Rails.env) if path.exist?

data/lib/private_pub/faye_extension.rb

@@ -9,7 +9,7 @@ module PrivatePub
       callback.call(message)
     end
 
-    private
+  private
 
     def authenticate_subscribe(message)
       subscription = PrivatePub.subscription(:channel => message["subscription"], :timestamp => message["ext"]["private_pub_timestamp"])
@@ -25,6 +25,8 @@ module PrivatePub
         raise Error, "No secret_token config set, ensure private_pub.yml is loaded properly."
       elsif message["ext"]["private_pub_token"] != PrivatePub.config[:secret_token]
         message["error"] = "Incorrect token."
+      else
+        message["ext"]["private_pub_token"] = nil
       end
     end
   end

data/lib/private_pub/view_helpers.rb

@@ -1,17 +1,15 @@
 module PrivatePub
   module ViewHelpers
-    def publish_to(channel, &block)
-      message = {:channel => channel, :data => {:_eval => capture(&block)}, :ext => {:private_pub_token => PrivatePub.config[:secret_token]}}
-      PrivatePub.publish(:message => message.to_json)
+    def publish_to(channel, data = nil, &block)
+      PrivatePub.publish_to(channel, data || capture(&block))
     end
 
     def subscribe_to(channel)
       subscription = PrivatePub.subscription(:channel => channel)
-      content_tag :span, "", :class => "private_pub_subscription",
-        "data-server" => PrivatePub.config[:server],
-        "data-channel" => subscription[:channel],
-        "data-signature" => subscription[:signature],
-        "data-timestamp" => subscription[:timestamp]
+      subscription[:server] = PrivatePub.config[:server]
+      content_tag "script", :type => "text/javascript" do
+        raw("PrivatePub.sign(#{subscription.to_json});")
+      end
     end
   end
 end

data/lib/private_pub.rb

@@ -2,7 +2,7 @@ require "digest/sha1"
 require "net/http"
 
 require "private_pub/faye_extension"
-require "private_pub/railtie" if defined? Rails
+require "private_pub/engine" if defined? Rails
 
 module PrivatePub
   class Error < StandardError; end
@@ -29,17 +29,32 @@ module PrivatePub
       sub
     end
 
-    def publish(data)
-      Net::HTTP.post_form(URI.parse(config[:server]), data)
+    def publish_to(channel, data)
+      publish_message(message(channel, data))
     end
 
-    def faye_extension
-      FayeExtension.new
+    def message(channel, data)
+      message = {:channel => channel, :data => {:channel => channel}, :ext => {:private_pub_token => config[:secret_token]}}
+      if data.kind_of? String
+        message[:data][:eval] = data
+      else
+        message[:data][:data] = data
+      end
+      message
+    end
+
+    def publish_message(message)
+      Net::HTTP.post_form(URI.parse(config[:server]), :message => message.to_json)
     end
 
     def signature_expired?(timestamp)
       timestamp < ((Time.now.to_f - config[:signature_expiration])*1000).round if config[:signature_expiration]
     end
+
+    def faye_app(options = {})
+      options = {:mount => "/faye", :timeout => 45, :extensions => [FayeExtension.new]}.merge(options)
+      Faye::RackAdapter.new(options)
+    end
   end
 
   reset_config

data/spec/javascripts/private_pub_spec.js

@@ -0,0 +1,108 @@
+describe("PrivatePub", function() {
+  var pub, doc;
+  beforeEach(function() {
+    Faye = {}; // To simulate global Faye object
+    doc = {};
+    pub = buildPrivatePub(doc);
+  });
+
+  it("adds a subscription callback", function() {
+    pub.subscribe("hello", "callback");
+    expect(pub.subscriptionCallbacks["hello"]).toEqual("callback");
+  });
+
+  it("has a fayeExtension which adds matching subscription signature and timestamp to outgoing message", function() {
+    var called = false;
+    var message = {channel: "/meta/subscribe", subscription: "hello"}
+    pub.subscriptions["hello"] = {signature: "abcd", timestamp: "1234"}
+    pub.fayeExtension.outgoing(message, function(message) {
+      expect(message.ext.private_pub_signature).toEqual("abcd");
+      expect(message.ext.private_pub_timestamp).toEqual("1234");
+      called = true;
+    });
+    expect(called).toBeTruthy();
+  });
+
+  it("evaluates javascript in message response", function() {
+    pub.handleResponse({eval: 'self.subscriptions.foo = "bar"'});
+    expect(pub.subscriptions.foo).toEqual("bar");
+  });
+
+  it("triggers callback matching message channel in response", function() {
+    var called = false;
+    pub.subscribe("test", function(data, channel) {
+      expect(data).toEqual("abcd");
+      expect(channel).toEqual("test");
+      called = true;
+    });
+    pub.handleResponse({channel: "test", data: "abcd"});
+    expect(called).toBeTruthy();
+  });
+
+  it("adds a faye subscription with response handler when signing", function() {
+    var faye = {subscribe: jasmine.createSpy()};
+    spyOn(pub, 'faye').andCallFake(function(callback) {
+      callback(faye);
+    });
+    var options = {server: "server", channel: "somechannel"};
+    pub.sign(options);
+    expect(faye.subscribe).toHaveBeenCalledWith("somechannel", pub.handleResponse);
+    expect(pub.subscriptions.server).toEqual("server");
+    expect(pub.subscriptions.somechannel).toEqual(options);
+  });
+
+  it("adds a faye subscription with response handler when signing", function() {
+    var faye = {subscribe: jasmine.createSpy()};
+    spyOn(pub, 'faye').andCallFake(function(callback) {
+      callback(faye);
+    });
+    var options = {server: "server", channel: "somechannel"};
+    pub.sign(options);
+    expect(faye.subscribe).toHaveBeenCalledWith("somechannel", pub.handleResponse);
+    expect(pub.subscriptions.server).toEqual("server");
+    expect(pub.subscriptions.somechannel).toEqual(options);
+  });
+
+  it("triggers faye callback function immediately when fayeClient is available", function() {
+    var called = false;
+    pub.fayeClient = "faye";
+    pub.faye(function(faye) {
+      expect(faye).toEqual("faye");
+      called = true;
+    });
+    expect(called).toBeTruthy();
+  });
+
+  it("adds fayeCallback when client and server aren't available", function() {
+    pub.faye("callback");
+    expect(pub.fayeCallbacks[0]).toEqual("callback");
+  });
+
+  it("adds a script tag loading faye js when the server is present", function() {
+    script = {};
+    doc.createElement = function() { return script; };
+    doc.documentElement = {appendChild: jasmine.createSpy()};
+    pub.subscriptions.server = "path/to/faye";
+    pub.faye("callback");
+    expect(pub.fayeCallbacks[0]).toEqual("callback");
+    expect(script.type).toEqual("text/javascript");
+    expect(script.src).toEqual("path/to/faye.js");
+    expect(script.onload).toEqual(pub.connectToFaye);
+    expect(doc.documentElement.appendChild).toHaveBeenCalledWith(script);
+  });
+
+  it("connects to faye server, adds extension, and executes callbacks", function() {
+    callback = jasmine.createSpy();
+    client = {addExtension: jasmine.createSpy()};
+    Faye.Client = function(server) {
+      expect(server).toEqual("server")
+      return client;
+    };
+    pub.subscriptions.server = "server";
+    pub.fayeCallbacks.push(callback);
+    pub.connectToFaye();
+    expect(pub.fayeClient).toEqual(client);
+    expect(client.addExtension).toHaveBeenCalledWith(pub.fayeExtension);
+    expect(callback).toHaveBeenCalledWith(client);
+  });
+});

data/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,73 @@
+# src_files
+#
+# Return an array of filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# src_files:
+#   - lib/source1.js
+#   - lib/source2.js
+#   - dist/**/*.js
+#
+src_files:
+  - app/assets/javascripts/private_pub.js
+
+# stylesheets
+#
+# Return an array of stylesheet filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# stylesheets:
+#   - css/style.css
+#   - stylesheets/*.css
+#
+stylesheets:
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:
+
+# spec_files
+#
+#  Return an array of filepaths relative to spec_dir to include.
+# Default: ["**/*[sS]pec.js"]
+#
+# EXAMPLE:
+#
+# spec_files:
+#   - **/*[sS]pec.js
+#
+spec_files:
+
+# src_dir
+#
+# Source directory path. Your src_files must be returned relative to this path. Will use root if left blank.
+# Default: project root
+#
+# EXAMPLE:
+#
+# src_dir: public
+#
+src_dir:
+
+# spec_dir
+#
+# Spec directory path. Your spec_files must be returned relative to this path.
+# Default: spec/javascripts
+#
+# EXAMPLE:
+#
+# spec_dir: spec/javascripts
+#
+spec_dir:

data/spec/javascripts/support/jasmine_config.rb

@@ -0,0 +1,23 @@
+module Jasmine
+  class Config
+
+    # Add your overrides or custom config code here
+
+  end
+end
+
+
+# Note - this is necessary for rspec2, which has removed the backtrace
+module Jasmine
+  class SpecBuilder
+    def declare_spec(parent, spec)
+      me = self
+      example_name = spec["name"]
+      @spec_ids << spec["id"]
+      backtrace = @example_locations[parent.description + " " + example_name]
+      parent.it example_name, {} do
+        me.report_spec(spec["id"])
+      end
+    end
+  end
+end

data/spec/javascripts/support/jasmine_runner.rb

@@ -0,0 +1,32 @@
+$:.unshift(ENV['JASMINE_GEM_PATH']) if ENV['JASMINE_GEM_PATH'] # for gem testing purposes
+
+require 'rubygems'
+require 'jasmine'
+jasmine_config_overrides = File.expand_path(File.join(File.dirname(__FILE__), 'jasmine_config.rb'))
+require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
+if Jasmine::Dependencies.rspec2?
+  require 'rspec'
+else
+  require 'spec'
+end
+
+jasmine_config = Jasmine::Config.new
+spec_builder = Jasmine::SpecBuilder.new(jasmine_config)
+
+should_stop = false
+
+if Jasmine::Dependencies.rspec2?
+  RSpec.configuration.after(:suite) do
+    spec_builder.stop if should_stop
+  end
+else
+  Spec::Runner.configure do |config|
+    config.after(:suite) do
+      spec_builder.stop if should_stop
+    end
+  end
+end
+
+spec_builder.start
+should_stop = true
+spec_builder.declare_suites

data/spec/private_pub/faye_extension_spec.rb

@@ -54,4 +54,13 @@ describe PrivatePub::FayeExtension do
     message = @faye.incoming(@message, lambda { |m| m })
     message["error"].should be_nil
   end
+  
+  it "should not let message carry the private pub token after server's validation" do
+    PrivatePub.config[:secret_token] = "good"
+    @message["channel"] = "/custom/channel"
+    @message["ext"]["private_pub_token"] = PrivatePub.config[:secret_token]
+    message = @faye.incoming(@message, lambda { |m| m })
+    message['ext']["private_pub_token"].should be_nil    
+  end
+    
 end

data/spec/private_pub_spec.rb

@@ -49,13 +49,44 @@ describe PrivatePub do
     subscription[:signature].should == Digest::SHA1.hexdigest("tokenchannel123")
   end
 
-  it "publishes to server using Net::HTTP" do
-    Net::HTTP.should_receive(:post_form).with(URI.parse(PrivatePub.config[:server]), "hello world").and_return(:result)
-    PrivatePub.publish("hello world").should == :result
+  it "formats a message hash given a channel and a string for eval" do
+    PrivatePub.config[:secret_token] = "token"
+    PrivatePub.message("chan", "foo").should eq(
+      :ext => {:private_pub_token => "token"},
+      :channel => "chan",
+      :data => {
+        :channel => "chan",
+        :eval => "foo"
+      }
+    )
+  end
+
+  it "formats a message hash given a channel and a hash" do
+    PrivatePub.config[:secret_token] = "token"
+    PrivatePub.message("chan", :foo => "bar").should eq(
+      :ext => {:private_pub_token => "token"},
+      :channel => "chan",
+      :data => {
+        :channel => "chan",
+        :data => {:foo => "bar"}
+      }
+    )
+  end
+
+  it "publish message as json to server using Net::HTTP" do
+    message = stub(:to_json => "message_json")
+    Net::HTTP.should_receive(:post_form).with(URI.parse(PrivatePub.config[:server]), :message => "message_json").and_return(:result)
+    PrivatePub.publish_message(message).should == :result
+  end
+
+  it "publish_to passes message to publish_message call" do
+    PrivatePub.should_receive(:message).with("chan", "foo").and_return("message")
+    PrivatePub.should_receive(:publish_message).with("message").and_return(:result)
+    PrivatePub.publish_to("chan", "foo").should == :result
   end
 
-  it "has a FayeExtension instance" do
-    PrivatePub.faye_extension.should be_kind_of(PrivatePub::FayeExtension)
+  it "has a Faye rack app instance" do
+    PrivatePub.faye_app.should be_kind_of(Faye::RackAdapter)
   end
 
   it "says signature has expired when time passed in is greater than expiration" do

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'bundler/setup'
+require 'faye'
 Bundler.require(:default)
 
 RSpec.configure do |config|

metadata

@@ -1,82 +1,109 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: private_pub
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.3.0
   prerelease: 
-  version: 0.2.0
 platform: ruby
-authors: 
+authors:
 - Ryan Bates
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-07 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rspec
+date: 2012-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faye
+  requirement: &70172946940680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70172946940680
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70172946940000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: *70172946940000
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70172946939000 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        version: 2.1.0
+      - !ruby/object:Gem::Version
+        version: 2.8.0
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: *70172946939000
+- !ruby/object:Gem::Dependency
+  name: jasmine
+  requirement: &70172946936820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :development
+  prerelease: false
+  version_requirements: *70172946936820
 description: Private pub/sub messaging in Rails through Faye.
 email: ryan@railscasts.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- app/assets/javascripts/private_pub.js
 - lib/generators/private_pub/install_generator.rb
-- lib/generators/private_pub/templates/faye.ru
-- lib/generators/private_pub/templates/private_pub.js
+- lib/generators/private_pub/templates/private_pub.ru
 - lib/generators/private_pub/templates/private_pub.yml
+- lib/private_pub/engine.rb
 - lib/private_pub/faye_extension.rb
-- lib/private_pub/railtie.rb
 - lib/private_pub/view_helpers.rb
 - lib/private_pub.rb
 - spec/fixtures/private_pub.yml
+- spec/javascripts/private_pub_spec.js
+- spec/javascripts/support/jasmine.yml
+- spec/javascripts/support/jasmine_config.rb
+- spec/javascripts/support/jasmine_runner.rb
 - spec/private_pub/faye_extension_spec.rb
 - spec/private_pub_spec.rb
 - spec/spec_helper.rb
-- CHANGELOG.rdoc
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - Rakefile
-- README.rdoc
-has_rdoc: true
+- README.md
 homepage: http://github.com/ryanb/private_pub
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.3.4
 requirements: []
-
 rubyforge_project: private_pub
-rubygems_version: 1.5.0
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Private pub/sub messaging in Rails.
 test_files: []
-

data/CHANGELOG.rdoc

@@ -1,12 +0,0 @@
-0.2.0 (April 7, 2011)
-
-* switched to YAML file for config. BACKWARDS INCOMPATIBLE: you will need to remove config/initializers/private_pub.rb
-
-* moved view helpers into Railtie so helper file is no longer generated
-
-* error out when signature has expired
-
-
-0.1.0 (April 4, 2011)
-
-* initial release

data/README.rdoc

@@ -1,66 +0,0 @@
-= Private Pub
-
-This is a Ruby gem for use with Rails to publish and subscribe to messages through {Faye}[http://faye.jcoglan.com/]. All channels are automatically made private.
-
-This project was motivated by {Railscasts episode #260}[http://railscasts.com/episodes/260-messaging-with-faye].
-
-
-== Setup
-
-Add the gem to your Gemfile and run +bundle+.
-
-  gem "private_pub"
-
-Run the generator to create the initial files.
-
-  rails g private_pub:install
-
-Add the generated JavaScript to your layout file. Currently this uses jQuery, so you will need to customize it if you aren't using jQuery.
-
-  <%= javascript_include_tag "private_pub" %>
-
-Next, install and start up Faye using the rackup file that was generated.
-
-  gem install faye
-  rackup faye.ru -s thin -E production
-
-It's not necessary to include faye.js since that will be handled automatically.
-
-
-== Usage
-
-Use the +subscribe_to+ helper method on any page to subscribe to a channel.
-
-  <%= subscribe_to "/messages/new" %>
-
-Use the +publish_to+ helper method to publish messages to that channel. If a block of JavaScript is passed it will be evaluated automatically. This is usually done in a JavaScript AJAX response (such as a <tt>create.js.erb</tt> file).
-
-  <% publish_to "/messages/new" do %>
-    $("#chat").append("<%= escape_javascript render(@messages) %>");
-  <% end %>
-
-There will be alternative ways to publish/subscribe to channels in the future.
-
-
-== Security
-
-Security is handled automatically for you. Only the Rails app is able to publish. Users are only able to receive messages on the channels you subscribe them to. This means every channel is private.
-
-Here's how it works. The +subscribe_to+ helper will output an element containing data information about the channel.
-
-  <span class="private_pub_subscription" data-channel="/messages/new" data-signature="2aae6c35c94fcfb415dbe95f408b9ce91ee846ed" data-timestamp="13019431281234"></span>
-
-The data-signature is a combination of the channel, timestamp, and secret token set in the Rails app. This is checked by the Faye extension when subscribing to a channel to ensure the signature is correct. The signature is automatically expired after 1 hour but this can be configured in the generated YAML file.
-
-  signature_expiration: 600 # 10 minutes, expressed in seconds
-
-Or use a blank value for no expiration.
-
-  signature_expiration:
-
-Note: if Faye is on a separate server from the Rails app it's important that the system clocks be in sync.
-
-
-== Development & Feedback
-
-Questions or comments? Please use the {issue tracker}[https://github.com/ryanb/private_pub/issues]. If you would like to contribue to this project, clone this repository and run +bundle+ and +rake+ to run the tests.

data/lib/generators/private_pub/templates/faye.ru

@@ -1,12 +0,0 @@
-# Run with: rackup faye.ru -s thin -E production
-require "yaml"
-require "faye"
-begin
-  require "private_pub"
-rescue LoadError
-  require "bundler/setup"
-  require "private_pub"
-end
-
-PrivatePub.load_config(File.expand_path("../config/private_pub.yml", __FILE__), ENV["RAILS_ENV"] || "development")
-run Faye::RackAdapter.new(:mount => "/faye", :timeout => 45, :extensions => [PrivatePub.faye_extension])

data/lib/generators/private_pub/templates/private_pub.js

@@ -1,27 +0,0 @@
-PrivatePubExtension = {
-  outgoing: function(message, callback) {
-    if (message.channel == "/meta/subscribe") {
-      // Attach the signature and timestamp to subscription messages
-      var subscription = $(".private_pub_subscription[data-channel='" + message.subscription + "']");
-      if (!message.ext) message.ext = {};
-      message.ext.private_pub_signature = subscription.data("signature");
-      message.ext.private_pub_timestamp = subscription.data("timestamp");
-    }
-    callback(message);
-  }
-};
-
-jQuery(function() {
-  var faye;
-  if ($(".private_pub_subscription").length > 0) {
-    jQuery.getScript($(".private_pub_subscription").data("server") + ".js", function() {
-      faye = new Faye.Client($(".private_pub_subscription").data("server"));
-      faye.addExtension(PrivatePubExtension);
-      $(".private_pub_subscription").each(function(index) {
-        faye.subscribe($(this).data("channel"), function(data) {
-          if (data._eval) eval(data._eval);
-        });
-      });
-    });
-  }
-});