danthes 1.0.1

data/lib/generators/danthes/redis_install_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/danthes'
+
+module Danthes
+  module Generators
+    class RedisInstallGenerator < Base
+      desc 'Create sample redis config file and add faye-redis gem to Gemfile'
+
+      def copy_files
+        template "danthes_redis.yml", "config/danthes_redis.yml"
+      end
+      
+      def add_redis_gem
+        add_gem 'faye-redis'
+      end
+    end
+  end
+end

data/lib/generators/danthes.rb

@@ -0,0 +1,25 @@
+require 'rails/generators/base'
+
+module Danthes
+  module Generators
+    class Base < Rails::Generators::Base
+      def self.source_root
+        File.dirname(__FILE__) + "/templates"
+      end
+      
+      def self.banner
+        "rails generate danthes:#{generator_name}"
+      end
+      
+    private
+      
+      def add_gem(name, options = {})
+        gemfile_path = File.join(destination_root, 'Gemfile')
+        gemfile_content = File.read(gemfile_path)
+        File.open(gemfile_path, 'a') { |f| f.write("\n") } unless gemfile_content =~ /\n\Z/
+        gem name, options unless gemfile_content.include? name
+      end
+
+    end
+  end
+end

data/lib/generators/templates/danthes.ru

@@ -0,0 +1,16 @@
+# Run with: rackup private_pub.ru -s thin -E production
+require "bundler/setup"
+require "yaml"
+require "faye"
+require "danthes"
+require "thin"
+
+Danthes.load_config(File.expand_path("../config/danthes.yml", __FILE__))
+Faye::WebSocket.load_adapter(Danthes.config[:adapter])
+
+path = File.expand_path("../config/danthes_redis.yml", __FILE__)
+if File.exist?(path)
+  Danthes.load_redis_config(path)
+end
+
+run Danthes.faye_app

data/lib/generators/templates/danthes.yml

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

data/lib/generators/templates/danthes_redis.yml

@@ -0,0 +1,14 @@
+development:
+  host: localhost
+  port: 6379
+  namespace: '/danthes'
+test:
+  host: localhost
+  port: 6379
+  namespace: '/danthes'
+production:
+  host: redis_host
+  port: redis_port
+  password: redis_password
+  database: redis_database
+  namespace: '/namespace'

data/spec/coffeescripts/danthes_spec.js.coffee

@@ -0,0 +1,127 @@
+describe "Danthes", ->
+  window.Faye = undefined
+  pub = undefined
+  
+  signToChannel = (channel) ->
+    faye = {subscribe: jasmine.createSpy()}
+    spyOn(pub, 'faye').andCallFake (callback) ->
+      callback(faye)
+    options = {server: "server", channel: "#{channel}"}
+    pub.sign(options)
+    return [faye, options]
+  
+  beforeEach ->
+    pub = window.Danthes
+    pub.reset()
+    script = document.getElementById('faye-connection-script')
+    if script?
+      script.parentNode.removeChild(script)
+  
+  it "not adds a subscription callback without signing", ->
+    expect(pub.subscribe("hello", "callback")).toBe(false)
+    expect(pub.subscriptions).toEqual({})
+
+  it "adds a subscription callback", ->
+    signToChannel('hello')
+    pub.subscribe("hello", "callback")
+    expect(pub.subscriptions["hello"]['callback']).toEqual("callback")
+
+  it "has a fayeExtension which adds matching subscription signature and timestamp to outgoing message", ->
+    called = false
+    message = {channel: "/meta/subscribe", subscription: "hello"}
+    pub.subscriptions['hello'] = {}
+    pub.subscriptions['hello']['opts'] = {signature: "abcd", timestamp: "1234"}
+    pub.fayeExtension.outgoing message, (message) ->
+      expect(message.ext.danthes_signature).toEqual("abcd")
+      expect(message.ext.danthes_timestamp).toEqual("1234")
+      called = true
+    expect(called).toBeTruthy()
+
+  it "evaluates javascript in message response", ->
+    pub.handleResponse(eval: 'this.subscriptions.foo = "bar"')
+    expect(pub.subscriptions.foo).toEqual("bar")
+
+  it "triggers callback matching message channel in response", ->
+    called = false
+    signToChannel('test')
+    pub.subscribe "test", (data, channel) ->
+      expect(data).toEqual("abcd")
+      expect(channel).toEqual("test")
+      called = true
+    pub.handleResponse(channel: "test", data: "abcd")
+    expect(called).toBeTruthy()
+
+  it "triggers faye callback function immediately when fayeClient is available", ->
+    called = false
+    pub.fayeClient = "faye"
+    pub.faye (faye) ->
+      expect(faye).toEqual("faye")
+      called = true
+    expect(called).toBeTruthy()
+
+  it "adds fayeCallback when client and server aren't available", ->
+    pub.faye("callback")
+    expect(pub.fayeCallbacks[0]).toEqual("callback")
+
+  it "adds a script tag loading faye js when the server is present", ->
+    client = {addExtension: jasmine.createSpy()}
+    callback = jasmine.createSpy()
+    pub.server = "path/to/faye"
+    pub.faye(callback)
+    expect(pub.fayeCallbacks[0]).toEqual(callback)
+    script = document.getElementById('faye-connection-script')
+    expect(script).toBeDefined()
+    expect(script.type).toEqual("text/javascript")
+    expect(script.src).toMatch("path/to/faye/client.js")
+  
+  it "adds a faye subscription with response handler when signing", ->
+    pub.fayeClient = 'string'
+    [faye, options] = signToChannel('somechannel')
+    expect(faye.subscribe).toHaveBeenCalled()
+    expect(pub.server).toEqual("server")
+    expect(pub.subscriptions.somechannel.opts).toEqual(options)
+
+  it "connects to faye server, adds extension, and executes callbacks", ->
+    callback = jasmine.createSpy()
+    client = {addExtension: jasmine.createSpy()}
+    window.Faye = {}
+    window.Faye.Client = (server) ->
+      expect(server).toEqual("server")
+      return client
+    pub.server = "server"
+    pub.fayeCallbacks.push(callback)
+    spyOn(pub, 'fayeExtension')
+    pub.connectToFaye()
+    expect(pub.fayeClient).toEqual(client)
+    expect(client.addExtension).toHaveBeenCalledWith(pub.fayeExtension)
+    expect(callback).toHaveBeenCalledWith(client)
+    
+  it "adds subscription faye object into channel object", ->
+    sub = {callback: jasmine.createSpy(), errback: jasmine.createSpy()}
+    pub.fayeClient = {subscribe: jasmine.createSpy().andReturn(sub)}
+    options = {server: "server", channel: 'somechannel'}
+    pub.sign(options)
+    expect(sub.callback).toHaveBeenCalled()
+    expect(sub.errback).toHaveBeenCalled()
+    expect(pub.subscriptions.somechannel.sub).toEqual(sub)
+    
+  it "removes subscription to the channel", ->
+    sub = {callback: jasmine.createSpy(), errback: jasmine.createSpy(), cancel: jasmine.createSpy()}
+    pub.fayeClient = {subscribe: jasmine.createSpy().andReturn(sub)}
+    options = {server: "server", channel: 'somechannel'}
+    pub.sign(options)
+    pub.unsubscribe('somechannel')
+    expect(sub.cancel).toHaveBeenCalled()
+    expect(pub.subscriptions.somechannel).toBeUndefined()
+    expect(pub.subscriptions).toEqual({})
+    
+  it "removes all subscription to the channels", ->
+    sub = {callback: jasmine.createSpy(), errback: jasmine.createSpy(), cancel: jasmine.createSpy()}
+    pub.fayeClient = {subscribe: jasmine.createSpy().andReturn(sub)}
+    options = {server: "server", channel: 'somechannel'}
+    pub.sign(options)
+    pub.unsubscribeAll()
+    expect(sub.cancel).toHaveBeenCalled()
+    expect(pub.subscriptions.somechannel).toBeUndefined()
+    expect(pub.subscriptions).toEqual({})
+    

data/spec/danthes/faye_extension_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe Danthes::FayeExtension do
+  before(:each) do
+    Danthes.startup
+    @faye = Danthes::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"]["danthes_signature"] = "bad"
+    @message["ext"]["danthes_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 = Danthes.subscription(:channel => "hello")
+    @message["subscription"] = sub[:channel]
+    @message["ext"]["danthes_signature"] = sub[:signature]
+    @message["ext"]["danthes_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
+    Danthes.config[:signature_expiration] = 1
+    sub = Danthes.subscription(:timestamp => 123, :channel => "hello")
+    @message["subscription"] = sub[:channel]
+    @message["ext"]["danthes_signature"] = sub[:signature]
+    @message["ext"]["danthes_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
+    Danthes.config[:secret_token] = "good"
+    @message["channel"] = "/custom/channel"
+    @message["ext"]["danthes_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"]["danthes_token"] = "bad"
+    lambda {
+      message = @faye.incoming(@message, lambda { |m| m })
+    }.should raise_error("No secret_token config set, ensure danthes.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
+    Danthes.config[:secret_token] = "good"
+    @message["channel"] = "/custom/channel"
+    @message["ext"]["danthes_token"] = Danthes.config[:secret_token]
+    message = @faye.incoming(@message, lambda { |m| m })
+    message['ext']["danthes_token"].should be_nil
+  end
+
+end

data/spec/danthes_spec.rb

@@ -0,0 +1,183 @@
+require "spec_helper"
+
+describe Danthes do
+  before(:each) do
+    Danthes.startup
+  end
+  
+  let(:config) { Danthes.config }
+
+  it "defaults server to nil" do
+    config[:server].should be_nil
+  end
+
+  it "defaults signature_expiration to nil" do
+    config[:signature_expiration].should be_nil
+  end
+
+  it "defaults subscription timestamp to current time in milliseconds" do
+    time = Time.now
+    Time.stub!(:now).and_return(time)
+    Danthes.subscription[:timestamp].should eq((time.to_f * 1000).round)
+  end
+
+  it "loads a simple configuration file via load_config" do
+    Danthes.env = 'production'
+    Danthes.load_config("spec/fixtures/danthes.yml")
+    config[:server].should eq("http://example.com/faye")
+    config[:secret_token].should eq("PRODUCTION_SECRET_TOKEN")
+    config[:signature_expiration].should eq(600)
+    config[:adapter].should eq('thin')
+  end
+
+  context "when redis config exists" do
+    before do
+      Danthes.env = 'test'
+      Danthes.load_redis_config("spec/fixtures/danthes_redis.yml")
+    end
+
+    it "passes redis config to faye engine options" do
+      config[:engine][:type].should eq Faye::Redis
+      config[:engine][:host].should eq 'redis_host'
+      config[:engine][:port].should eq 'redis_port'
+      config[:engine][:password].should eq 'redis_password'
+      config[:engine][:database].should eq 'redis_database'
+      config[:engine][:namespace].should eq '/namespace'
+    end
+
+    it "should pass redis config and default options to faye" do
+      Faye::RackAdapter.should_receive(:new) do |options|
+        options[:engine].should eq Danthes.config[:engine]
+        options[:mount].should eq '/faye'
+      end
+      Danthes.faye_app
+    end
+  end
+
+  context "when redis config does not exist" do
+    it "should not have :engine inside of config hash" do
+      config.should_not include :engine
+    end
+
+    it "should have mount point" do
+      config[:mount].should eq '/faye'
+    end
+  end
+
+  it "raises an exception if an invalid environment is passed to load_config" do
+    lambda {
+      Danthes.load_config("spec/fixtures/danthes.yml", 'foo')
+    }.should raise_error ArgumentError
+  end
+
+  it "includes channel, server, and custom time in subscription" do
+    Danthes.config[:server] = "server"
+    Danthes.config[:mount] = '/faye'
+    subscription = Danthes.subscription(:timestamp => 123, :channel => "hello")
+    subscription[:timestamp].should eq(123)
+    subscription[:channel].should eq("hello")
+    subscription[:server].should eq("server/faye")
+  end
+  
+  it "returns full server url from server and mount configs" do
+    Danthes.config[:server] = "server.com"
+    Danthes.config[:mount] = '/faye'
+    Danthes.server_url.should == 'server.com/faye'
+  end
+
+  it "does a sha1 digest of channel, timestamp, and secret token" do
+    Danthes.config[:secret_token] = "token"
+    subscription = Danthes.subscription(:timestamp => 123, :channel => "channel")
+    subscription[:signature].should eq(Digest::SHA1.hexdigest("tokenchannel123"))
+  end
+
+  it "formats a message hash given a channel and a string for eval" do
+    Danthes.config[:secret_token] = "token"
+    Danthes.message("chan", "foo").should eq(
+      :ext => {:danthes_token => "token"},
+      :channel => "chan",
+      :data => {
+        :channel => "chan",
+        :eval => "foo"
+      }
+    )
+  end
+
+  it "formats a message hash given a channel and a hash" do
+    Danthes.config[:secret_token] = "token"
+    Danthes.message("chan", :foo => "bar").should eq(
+      :ext => {:danthes_token => "token"},
+      :channel => "chan",
+      :data => {
+        :channel => "chan",
+        :data => {:foo => "bar"}
+      }
+    )
+  end
+
+  it "publish message as json to server using Net::HTTP" do
+    Danthes.config[:server] = "http://localhost"
+    Danthes.config[:mount] = '/faye/path'
+    message = 'foo'
+    faye = stub_request(:post, "http://localhost/faye/path").
+             with(:body => {"message"=>"\"foo\""},
+                  :headers => {'Accept'=>'*/*', 'Content-Type'=>'application/x-www-form-urlencoded', 'User-Agent'=>'Ruby'}).
+             to_return(:status => 200, :body => "", :headers => {})
+    Danthes.publish_message(message)
+    faye.should have_been_made.once
+  end
+
+  it "it should use HTTPS if the server URL says so" do
+    Danthes.config[:server] = "https://localhost"
+    Danthes.config[:mount] = '/faye/path'
+    http = mock(:http).as_null_object
+
+    Net::HTTP.should_receive(:new).and_return(http)
+    http.should_receive(:use_ssl=).with(true)
+
+    Danthes.publish_message('foo')
+  end
+
+  it "it should not use HTTPS if the server URL says not to" do
+    Danthes.config[:server] = "http://localhost"
+    http = mock(:http).as_null_object
+
+    Net::HTTP.should_receive(:new).and_return(http)
+    http.should_receive(:use_ssl=).with(false)
+
+    Danthes.publish_message('foo')
+  end
+
+  it "raises an exception if no server is specified when calling publish_message" do
+    lambda {
+      Danthes.publish_message("foo")
+    }.should raise_error(Danthes::Error)
+  end
+
+  it "publish_to passes message to publish_message call" do
+    Danthes.should_receive(:message).with("chan", "foo").and_return("message")
+    Danthes.should_receive(:publish_message).with("message").and_return(:result)
+    Danthes.publish_to("chan", "foo").should eq(:result)
+  end
+
+  it "has a Faye rack app instance" do
+    Danthes.faye_app.should be_kind_of(Faye::RackAdapter)
+  end
+
+  it "says signature has expired when time passed in is greater than expiration" do
+    Danthes.config[:signature_expiration] = 30*60
+    time = Danthes.subscription[:timestamp] - 31*60*1000
+    Danthes.signature_expired?(time).should be_true
+  end
+
+  it "says signature has not expired when time passed in is less than expiration" do
+    Danthes.config[:signature_expiration] = 30*60
+    time = Danthes.subscription[:timestamp] - 29*60*1000
+    Danthes.signature_expired?(time).should be_false
+  end
+
+  it "says signature has not expired when expiration is nil" do
+    Danthes.config[:signature_expiration] = nil
+    Danthes.signature_expired?(0).should be_false
+  end
+end

data/spec/fixtures/danthes.yml

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

data/spec/fixtures/danthes_redis.yml

@@ -0,0 +1,6 @@
+test:
+  host: redis_host
+  port: redis_port
+  password: redis_password
+  database: redis_database
+  namespace: '/namespace'

data/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,6 @@
+src_dir: app/assets/javascripts/compiled
+
+src_files:
+  - danthes.js
+
+spec_dir: spec/coffeescripts/compiled

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/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'faye'
+require 'faye/redis'
+Bundler.require(:default)
+require 'webmock/rspec'
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: danthes
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alexander Simonov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faye
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+description: Private pub/sub messaging in Rails through Faye. More Faye features supported.
+  Based on PrivatePub.
+email:
+- alex@simonov.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- app/assets/javascripts/danthes.js.coffee
+- danthes.gemspec
+- lib/danthes.rb
+- lib/danthes/engine.rb
+- lib/danthes/faye_extension.rb
+- lib/danthes/version.rb
+- lib/danthes/view_helpers.rb
+- lib/generators/danthes.rb
+- lib/generators/danthes/install_generator.rb
+- lib/generators/danthes/redis_install_generator.rb
+- lib/generators/templates/danthes.ru
+- lib/generators/templates/danthes.yml
+- lib/generators/templates/danthes_redis.yml
+- spec/coffeescripts/danthes_spec.js.coffee
+- spec/danthes/faye_extension_spec.rb
+- spec/danthes_spec.rb
+- spec/fixtures/danthes.yml
+- spec/fixtures/danthes_redis.yml
+- spec/javascripts/support/jasmine.yml
+- spec/javascripts/support/jasmine_config.rb
+- spec/javascripts/support/jasmine_runner.rb
+- spec/spec_helper.rb
+homepage: http://github.com/phenomena/danthes
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Private pub/sub messaging through Faye.
+test_files:
+- spec/coffeescripts/danthes_spec.js.coffee
+- spec/danthes/faye_extension_spec.rb
+- spec/danthes_spec.rb
+- spec/fixtures/danthes.yml
+- spec/fixtures/danthes_redis.yml
+- spec/javascripts/support/jasmine.yml
+- spec/javascripts/support/jasmine_config.rb
+- spec/javascripts/support/jasmine_runner.rb
+- spec/spec_helper.rb
+has_rdoc: