simplepub 1.0.4

data/lib/simplepub/interface_methods.rb

@@ -0,0 +1,61 @@
+module Simplepub
+  module InterfaceMethods
+    # Publish the given data to a specific channel. This ends up sending
+    # a Net::HTTP POST request to the Faye server.
+    def publish_to(channel, data)
+      publish_message(message(channel, data))
+    end
+
+    # Sends the given message hash to the Faye server using Net::HTTP.
+    def publish_message(message)
+      raise Error, "No server specified, ensure simplepub.yml was loaded properly." unless config[:server]
+      url = URI.parse(config[:server])
+
+      form = Net::HTTP::Post.new(url.path.empty? ? '/' : url.path)
+      form.set_form_data(:message => message.to_json)
+
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = url.scheme == "https"
+
+      http.ca_path = config.ca_path if config.ca_path?
+      http.ca_file = config.ca_file if config.ca_file?
+
+      http.start {|h| h.request(form)}
+    end
+
+    # Returns a message hash for sending to Faye
+    def message(channel, data)
+      message = {:channel => channel, :data => {:channel => channel}, :ext => {:simplepub_token => config[:secret_token]}}
+      if data.kind_of? String
+        message[:data][:eval] = data
+      else
+        message[:data][:data] = data
+      end
+      message
+    end
+
+    # Returns a subscription hash to pass to the Simplepub.sign call in JavaScript.
+    # Any options passed are merged to the hash.
+    def subscription(options = {})
+      sub = {:server => config[:server], :timestamp => (Time.now.to_f * 1000).round}.merge(options)
+      sub[:signature] = Digest::SHA1.hexdigest([config[:secret_token], sub[:channel], sub[:timestamp]].join)
+      sub
+    end
+
+    # Determine if the signature has expired given a timestamp.
+    def signature_expired?(timestamp)
+      timestamp < ((Time.now.to_f - config[:signature_expiration])*1000).round if config[:signature_expiration]
+    end
+
+    # Returns the Faye Rack application.
+    # Any options given are passed to the Faye::RackAdapter.
+    def faye_app(options = {})
+      options = {:mount => "/faye", :timeout => 45, :extensions => [FayeExtension.new]}.merge(options)
+      Faye::RackAdapter.new(options)
+    end
+
+    def rackup_file
+      File.expand_path('../rack_config.ru', __FILE__)
+    end
+  end
+end

data/lib/simplepub/rack_config.ru

@@ -0,0 +1,10 @@
+# Run with: rackup simplepub.ru -s thin -E production
+require "bundler/setup"
+require "faye"
+require "simplepub"
+
+Faye::WebSocket.load_adapter('thin')
+
+Simplepub.load_config
+
+run Simplepub.faye_app

data/lib/simplepub/version.rb

@@ -0,0 +1,3 @@
+module Simplepub
+  VERSION = "1.0.4"
+end

data/lib/simplepub/view_helpers.rb

@@ -0,0 +1,22 @@
+module Simplepub
+  module ViewHelpers
+    # Publish the given data or block to the client by sending
+    # a Net::HTTP POST request to the Faye server. If a block
+    # or string is passed in, it is evaluated as JavaScript
+    # on the client. Otherwise it will be converted to JSON
+    # for use in a JavaScript callback.
+    def publish_to(channel, data = nil, &block)
+      Simplepub.publish_to(channel, data || capture(&block))
+    end
+
+    # Subscribe the client to the given channel. This generates
+    # some JavaScript calling Simplepub.sign with the subscription
+    # options.
+    def subscribe_to(channel)
+      subscription = Simplepub.subscription(:channel => channel)
+      content_tag "script", :type => "text/javascript" do
+        raw("Simplepub.sign(#{subscription.to_json});")
+      end
+    end
+  end
+end

data/lib/simplepub.rb

@@ -0,0 +1,24 @@
+require "simplepub/version"
+require 'json'
+require "digest/sha1"
+require "net/http"
+require "net/https"
+
+require "simplepub/error"
+require "simplepub/configuration"
+require "simplepub/interface_methods"
+require "simplepub/faye_extension"
+require "simplepub/engine" if defined? Rails
+
+module Simplepub
+  extend Configuration
+  extend InterfaceMethods
+
+  reset_config
+
+  def self.templates_root
+    File.dirname(__FILE__) + "/templates"
+  end
+
+  autoload :Cli, 'simplepub/cli'
+end

data/lib/templates/simplepub.ru

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

data/lib/templates/simplepub.yml

@@ -0,0 +1,10 @@
+development:
+  server: "http://localhost:9292/faye"
+  secret_token: "secret"
+test:
+  server: "http://localhost:9292/faye"
+  secret_token: "secret"
+production:
+  server: "http://example.com/faye"
+  secret_token: "<%= defined?(SecureRandom) ? SecureRandom.hex(32) : ActiveSupport::SecureRandom.hex(32) %>"
+  signature_expiration: 3600 # one hour

data/simplepub.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'simplepub/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "simplepub"
+  spec.version       = Simplepub::VERSION
+  spec.authors       = ["Jorge Calás Lozano", "Ryan Bates"]
+  spec.email         = ["calas@qvitta.net", "ryan@railscasts.com"]
+  spec.description   = "Simple private pub/sub messaging for Ruby using Faye."
+  spec.summary       = "Simple private pub/sub messaging for Ruby."
+  spec.homepage      = "https://speedyrails.com"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'faye'
+  spec.add_dependency 'thor'
+  spec.add_dependency 'hashie'
+  spec.add_dependency 'thin'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "jasmine"
+end

data/spec/fixtures/simplepub.yml

@@ -0,0 +1,8 @@
+development:
+  server: http://dev.local:9292/faye
+  secret_token: DEVELOPMENT_SECRET_TOKEN
+  signature_expiration: 600
+production:
+  server: http://example.com/faye
+  secret_token: PRODUCTION_SECRET_TOKEN
+  signature_expiration: 600

data/spec/javascripts/helpers/SpecHelper.js

@@ -0,0 +1,15 @@
+beforeEach(function() {
+  this.addMatchers({
+    /**
+    // Example matcher:
+    //
+    // expect(player).not.toBePlaying(song);
+
+    toBePlaying: function(expectedSong) {
+      var player = this.actual;
+      return player.currentlyPlayingSong === expectedSong &&
+             player.isPlaying;
+    }
+    **/
+  });
+});

data/spec/javascripts/simplepub_spec.js

@@ -0,0 +1,165 @@
+describe("Simplepub", function() {
+  var pub, doc;
+  beforeEach(function() {
+    Faye = {}; // To simulate global Faye object
+    doc = {};
+    pub = buildSimplepub(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.simplepub_signature).toEqual("abcd");
+      expect(message.ext.simplepub_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("takes a callback for subscription object when signing", function(){
+    var faye = {subscribe: function(){ return "subscription"; }};
+    spyOn(pub, 'faye').andCallFake(function(callback) {
+      callback(faye);
+    });
+    var options = { server: "server", channel: "somechannel" };
+    options.subscription = jasmine.createSpy();
+    pub.sign(options);
+    expect(options.subscription).toHaveBeenCalledWith("subscription");
+  });
+
+  it("returns the subscription object for a subscribed channel", function(){
+    var faye = {subscribe: function(){ return "subscription"; }};
+    spyOn(pub, 'faye').andCallFake(function(callback) {
+      callback(faye);
+    });
+    var options = { server: "server", channel: "somechannel" };
+    pub.sign(options);
+    expect(pub.subscription("somechannel")).toEqual("subscription")
+  });
+
+  it("unsubscribes a channel by name", function(){
+    var sub = { cancel: jasmine.createSpy() };
+    var faye = {subscribe: function(){ return sub; }};
+    spyOn(pub, 'faye').andCallFake(function(callback) {
+      callback(faye);
+    });
+    var options = { server: "server", channel: "somechannel" };
+    pub.sign(options);
+    expect(pub.subscription("somechannel")).toEqual(sub);
+    pub.unsubscribe("somechannel");
+    expect(sub.cancel).toHaveBeenCalled();
+    expect(pub.subscription("somechannel")).toBeFalsy();
+  });
+
+  it("unsubscribes all channels", function(){
+    var created = 0;
+    var sub = function() {
+      created ++;
+      var sub = { cancel: function(){ created --; } };
+      return sub;
+    };
+    var faye = { subscribe: function(){ return sub(); }};
+    spyOn(pub, 'faye').andCallFake(function(callback) {
+      callback(faye);
+    });
+    pub.sign({server: "server", channel: "firstchannel"});
+    pub.sign({server: "server", channel: "secondchannel"});
+    expect(created).toEqual(2);
+    expect(pub.subscription("firstchannel")).toBeTruthy();
+    expect(pub.subscription("secondchannel")).toBeTruthy();
+    pub.unsubscribeAll()
+    expect(created).toEqual(0);
+    expect(pub.subscription("firstchannel")).toBeFalsy();
+    expect(pub.subscription("secondchannel")).toBeFalsy();
+  });
+
+  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,76 @@
+# 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/simplepub.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:
+  - "**/*[sS]pec.js"
+  - "**/*[sS]pec.coffee"
+  - "**/*[sS]pec.js.coffee"
+
+# 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_helper.rb

@@ -0,0 +1,11 @@
+#Use this file to set/override Jasmine configuration options
+#You can remove it if you don't need it.
+#This file is loaded *after* jasmine.yml is interpreted.
+#
+#Example: using a different boot file.
+#Jasmine.configure do |config|
+#   config.boot_dir = '/absolute/path/to/boot_dir'
+#   config.boot_files = lambda { ['/absolute/path/to/boot_dir/file.js'] }
+#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/simplepub/faye_extension_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe Simplepub::FayeExtension do
+  before(:each) do
+    Simplepub.reset_config
+    @faye = Simplepub::FayeExtension.new
+    @message = {"channel" => "/meta/subscribe", "ext" => {}}
+  end
+
+  it "adds an error on an incoming subscription with a bad signature" do
+    @message["subscription"] = "hello"
+    @message["ext"]["simplepub_signature"] = "bad"
+    @message["ext"]["simplepub_timestamp"] = "123"
+    message = @faye.incoming(@message, lambda { |m| m })
+    message["error"].should eq("Incorrect signature.")
+  end
+
+  it "has no error when the signature matches the subscription" do
+    sub = Simplepub.subscription(:channel => "hello")
+    @message["subscription"] = sub[:channel]
+    @message["ext"]["simplepub_signature"] = sub[:signature]
+    @message["ext"]["simplepub_timestamp"] = sub[:timestamp]
+    message = @faye.incoming(@message, lambda { |m| m })
+    message["error"].should be_nil
+  end
+
+  it "has an error when signature just expired" do
+    Simplepub.config[:signature_expiration] = 1
+    sub = Simplepub.subscription(:timestamp => 123, :channel => "hello")
+    @message["subscription"] = sub[:channel]
+    @message["ext"]["simplepub_signature"] = sub[:signature]
+    @message["ext"]["simplepub_timestamp"] = sub[:timestamp]
+    message = @faye.incoming(@message, lambda { |m| m })
+    message["error"].should eq("Signature has expired.")
+  end
+
+  it "has an error when trying to publish to a custom channel with a bad token" do
+    Simplepub.config[:secret_token] = "good"
+    @message["channel"] = "/custom/channel"
+    @message["ext"]["simplepub_token"] = "bad"
+    message = @faye.incoming(@message, lambda { |m| m })
+    message["error"].should eq("Incorrect token.")
+  end
+
+  it "raises an exception when attempting to call a custom channel without a secret_token set" do
+    @message["channel"] = "/custom/channel"
+    @message["ext"]["simplepub_token"] = "bad"
+    lambda {
+      message = @faye.incoming(@message, lambda { |m| m })
+    }.should raise_error("No secret_token config set, ensure simplepub.yml is loaded properly.")
+  end
+
+  it "has no error on other meta calls" do
+    @message["channel"] = "/meta/connect"
+    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
+    Simplepub.config[:secret_token] = "good"
+    @message["channel"] = "/custom/channel"
+    @message["ext"]["simplepub_token"] = Simplepub.config[:secret_token]
+    message = @faye.incoming(@message, lambda { |m| m })
+    message['ext']["simplepub_token"].should be_nil
+  end
+
+end