danthes 1.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.swp
+**/*.swp
+*.gem
+Gemfile.lock
+.bundle
+app/assets/javascripts/compiled
+spec/coffeescripts/compiled

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@danthes --create

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+bundler_args: --without development
+before_script:
+  - "export DISPLAY=:99.0"
+  - "sh -e /etc/init.d/xvfb start"

data/CHANGELOG.md

@@ -0,0 +1,54 @@
+# d'Anthès
+
+## 1.0.1 (August 26 2012)
+
+* Generator for redis config file
+* Fixes for rackup file
+* Fixes for full server url
+* CoffeeScript class documentation
+
+## 1.0 (August 25 2012)
+
+* initial release
+
+
+# PrivatePub
+
+## 1.0.0 (January 25, 2012)
+
+* Rails 3.2 compatibility with SecureRandom fix (thanks windigo) - issue #26
+
+## 1.0.0 (January 15, 2012)
+
+* setting config defaults to nil so everything must be set in `private_pub.yml`
+
+* Documentation improvements
+
+
+## 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/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'rake'
+gem 'faye-redis'
+gem 'guard'
+gem 'guard-coffeescript'
+gem 'jasmine', '1.2.0.rc3'
+gem 'rspec', '2.10.0'
+gem 'rspec-mocks', '2.10.0'
+gem 'webmock'

data/Guardfile

@@ -0,0 +1,7 @@
+guard 'coffeescript', :output => 'app/assets/javascripts/compiled' do
+  watch /^app\/assets\/javascripts\/(.*)\.coffee/
+end
+
+guard 'coffeescript', :output => 'spec/coffeescripts/compiled' do
+  watch /^spec\/coffeescripts\/(.*)\.coffee/
+end

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012 Alexander Simonov
+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
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,153 @@
+# d'Anthès [![Build Status](https://secure.travis-ci.org/phenomena/danthes.png?branch=master)](http://travis-ci.org/phenomena/danthes)
+
+d'Anthès 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. Based on PrivatePub gem.
+
+## Docs
+
+[Ruby](http://rubydoc.info/github/phenomena/danthes/frames)
+
+[CoffeeScript](https://github.com/phenomena/danthes/wiki/CoffeeScript-documentation)
+
+## Setup
+
+Add the gem to your Gemfile and run the `bundle` command to install it.
+
+```ruby
+gem 'danthes'
+```
+
+Run the generator to create the initial files.
+
+```
+rails g danthes:install
+```
+
+Next, start up Faye using the rackup file that was generated.
+
+```
+rackup danthes.ru -s thin -E production
+```
+
+**In Rails 3.1** add the JavaScript file to your application.js file manifest.
+
+```javascript
+//= require danthes
+```
+
+
+It's not necessary to include faye's connect.js since that will be handled automatically for you.
+
+## Serving Faye over HTTPS (with Thin)
+
+To serve Faye over HTTPS you could create a thin configuration file `config/private_pub_thin.yml` similar to the following:
+
+```yaml
+---
+port: 4443
+ssl: true
+ssl_key_file: /path/to/server.pem
+ssl_cert_file: /path/to/certificate_chain.pem
+environment: production
+rackup: danthes.ru
+```
+
+The `certificate_chain.pem` file should contain your signed certificate, followed by intermediate certificates (if any) and the root certificate of the CA that signed the key.
+
+Next reconfigure the URL in `config/danthes.yml` to look like `https://your.hostname.com:4443/faye`
+
+Finally start up Thin from the project root.
+
+```
+thin -C config/danthes_thin.yml start
+```
+
+## Serving Faye with Redis engine
+
+Run the generator to create the initial redis config file.
+
+```
+rails g danthes:redis_install
+```
+
+## 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 `.js.erb` templates, you can pass a hash to `publish_to` instead of a block and it will be converted `to_json` behind the scenes. This can be done anywhere (such as the controller).
+
+```ruby
+Danthes.publish_to "/messages/new", :chat_message => "Hello, world!"
+```
+
+And then handle this through JavaScript on the client side.
+
+```javascript
+Danthes.subscribe("/messages/new", function(data, channel) {
+  $("#chat").append(data.chat_message);
+});
+```
+
+The Ruby `subscribe_to` helper 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.
+
+## Debugging
+
+To enable debugging for faye connection process set `debug` to true before first `sign` call.
+
+``` javascript
+Danthes.debug = true
+```
+
+## Configuration
+
+The configuration is set separately for each environment in the generated `config/danthes.yml` file. Here are the options.
+
+* `server`: The URL to use for the Faye server such as `http://localhost:9292`.
+* `mount`: The mount path for Faye
+* `secret_token`: A secret hash to secure the server. Can be any string.
+* `signature_expiration`: The length of time in seconds before a subscription signature expires. If this is not set there is no expiration. Note: if Faye is on a separate server from the Rails app, the system clocks must be in sync for the expiration to work properly.
+* `adapter`: Adapter for the Rack application
+
+
+## How It Works
+
+The `subscribe_to` helper will output the following script which subscribes the user to a specific channel and server.
+
+```html
+<script type="text/javascript">
+  Danthes.sign({
+    channel: "/messages/new",
+    timestamp: 1302306682972,
+    signature: "dc1c71d3e959ebb6f49aa6af0c86304a0740088d",
+    server: "http://localhost:9292/faye"
+  });
+</script>
+```
+
+The signature and timestamp checked on the Faye server to ensure users are only able to access channels you subscribe them to. The signature will automatically expire after the time specified in the configuration.
+
+The `publish_to` method will send a post request to the Faye server (using `Net::HTTP`) instructing it to send the given data back to the browser.
+
+## Development & Feedback
+
+Questions or comments? Please use the [issue tracker](https://github.com/phenomena/danthes/issues). Tests can be run with `bundle` and `rake` commands.
+
+## TODO
+
+- Add support for faye subscribe callbacks

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'rake'
+require 'rspec/core/rake_task'
+require 'jasmine'
+require 'coffee-script'
+load 'jasmine/tasks/jasmine.rake'
+
+desc "Run RSpec"
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = false
+end
+
+task :default => [:compile_js, :spec, "jasmine:ci"]
+
+def compile_coffee_script(file, path)
+  source = File.read File.expand_path("#{path}/#{file}.coffee", __FILE__)
+  compiled_path = File.expand_path("#{path}/compiled/", __FILE__)
+  if !(File.exists?(compiled_path) && File.directory?(compiled_path))
+    Dir.mkdir compiled_path
+  end
+  destination = File.open File.join(compiled_path, file), 'w+'
+  destination.write CoffeeScript.compile(source)
+end
+
+desc "Compile coffeescript"
+task :compile_js do
+  compile_coffee_script('danthes.js', '../app/assets/javascripts')
+  compile_coffee_script('danthes_spec.js', '../spec/coffeescripts')
+end

data/app/assets/javascripts/danthes.js.coffee

@@ -0,0 +1,142 @@
+# Danthes Privat pub/sub Faye wrapper
+#
+# @example Howto enable debug
+#   Danthes.debug = true
+# @example reset all internal data
+#   Danthes.reset()
+# @example Howto sign and subscribe on channel with callback function
+#   Danthes.sign
+#     server: 'faye.example.com'
+#     channel: 'somechannel'
+#     signature: 'dc1c71d3e959ebb6f49aa6af0c86304a0740088d'
+#     timestamp: 1302306682972
+#     callback: (data) ->
+#       console.log(data)
+
+window.Danthes = class Danthes
+  
+  @debug: false    
+
+  @debugMessage: (message) ->
+    console.log(message) if @debug
+  
+  # Reset all
+  @reset: ->
+    @connecting = false
+    @fayeClient = null
+    @fayeCallbacks = []
+    @subscriptions = {}
+    @server = null
+    @disables = []
+    @connectionSettings =
+      timeout: 120
+      retry: 5
+      endpoints: {}
+
+  # Connect to faye
+  @faye: (callback) =>
+    if @fayeClient?
+      callback(@fayeClient)
+    else
+      @fayeCallbacks.push(callback)
+      if @server && !@connecting
+        @connecting = true
+        unless Faye?
+          script = document.createElement 'script'
+          script.type = 'text/javascript'
+          script.src = "#{@server}/client.js"
+          script.id = "faye-connection-script"
+          complete = false
+          script.onload = script.onreadystatechange = () =>
+            if !complete && (!this.readyState || this.readyState is "loaded" || this.readyState is "complete")
+              complete = true
+              script.onload = script.onreadystatechange = null
+              @debugMessage 'connect to faye after script loaded'
+              @connectToFaye()
+          @debugMessage 'faye script init'
+          document.documentElement.appendChild script
+      else
+        @debugMessage 'faye already inited'
+        @connectToFaye()
+  
+  # Faye extension for incoming and outgoing messages
+  @fayeExtension:
+    incoming : (message, callback) =>
+      @debugMessage "incomming message #{JSON.stringify(message)}"
+      callback(message)
+    outgoing : (message, callback) =>
+      @debugMessage "outgoing message #{JSON.stringify(message)}"
+      if message.channel == "/meta/subscribe"
+        subscription = @subscriptions[message.subscription]['opts']
+        # Attach the signature and timestamp to subscription messages
+        message.ext = {} unless message.ext?
+        message.ext.danthes_signature = subscription.signature
+        message.ext.danthes_timestamp = subscription.timestamp
+      callback(message)
+  
+  # Initialize Faye client
+  @connectToFaye: ->
+    if @server && Faye?
+      @debugMessage 'trying to connect faye'
+      @fayeClient = new Faye.Client(@server, @connectionSettings)
+      @fayeClient.addExtension(@fayeExtension)
+      # Disable any features what we want
+      @fayeClient.disable(key) for key in @disables
+      @debugMessage 'faye connected'
+      callback(@fayeClient) for callback in @fayeCallbacks
+
+  # Sign to channel
+  # @param [Object] options for signing
+  @sign: (options) ->
+    @debugMessage 'sign to faye'
+    @server = options.server unless @server
+    channel = options.channel
+    unless @subscriptions[channel]?
+      @subscriptions[channel] = {}
+      @subscriptions[channel]['opts'] = options
+      @faye (faye) =>
+        subscription = faye.subscribe channel, (message) =>
+          @handleResponse(message)
+        if subscription?
+          @subscriptions[channel]['sub'] = subscription
+          subscription.callback =>
+            @debugMessage "subscription for #{channel} is active now"
+          subscription.errback (error) =>
+            @debugMessage "error for #{channel}: #{error.message}"
+  
+  # Handle response from Faye
+  # @param [Object] message from Faye
+  @handleResponse: (message) ->
+    if message.eval
+      eval(message.eval)
+    channel = message.channel
+    return unless @subscriptions[channel]?
+    if callback = @subscriptions[channel]['callback']
+      callback(message.data, channel)
+  
+  # Subscribe to channel with callback
+  # @param channel [String] Channel name
+  # @param callback [Function] Callback function
+  @subscribe: (channel, callback) ->
+    @debugMessage "subscribing to #{channel}"
+    if @subscriptions[channel]?
+      # Changing callback on every call
+      @subscriptions[channel]['callback'] = callback
+    else
+      @debugMessage "Cannot subscribe on channel '#{channel}'. You need sign to channel first."
+      return false
+    true
+  
+  # Unsubscribe from channel
+  # @param [String] Channel name
+  @unsubscribe: (channel) ->
+    @debugMessage "unsubscribing from #{channel}"
+    if @subscriptions[channel]
+      @subscriptions[channel]['sub'].cancel()
+      delete @subscriptions[channel]
+  
+  # Unsubscribe from all channels 
+  @unsubscribeAll: ->
+    @unsubscribe(channel) for channel, _ of @subscriptions
+
+window.Danthes.reset()

data/danthes.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+require 'danthes/version'
+Gem::Specification.new do |s|
+  s.name        = "danthes"
+  s.version     = Danthes::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.author      = ["Alexander Simonov"]
+  s.email       = ["alex@simonov.me"]
+  s.homepage    = "http://github.com/phenomena/danthes"
+  s.summary     = "Private pub/sub messaging through Faye."
+  s.description = "Private pub/sub messaging in Rails through Faye. More Faye features supported. Based on PrivatePub."
+  s.files         = `git ls-files`.split($\)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.add_dependency 'faye', '>= 0.8.0'
+end

data/lib/danthes/engine.rb

@@ -0,0 +1,16 @@
+require "danthes/view_helpers"
+
+module Danthes
+  class Engine < Rails::Engine
+    # Loads the danthes.yml file if it exists.
+    initializer "danthes.config" do
+      path = Rails.root.join("config/danthes.yml")
+      Danthes.load_config(path) if path.exist?
+    end
+
+    # Adds the ViewHelpers into ActionView::Base
+    initializer "danthes.view_helpers" do
+      ActionView::Base.send :include, ViewHelpers
+    end
+  end
+end

data/lib/danthes/faye_extension.rb

@@ -0,0 +1,40 @@
+module Danthes
+  # This class is an extension for the Faye::RackAdapter.
+  # It is used inside of Danthes.faye_app.
+  class FayeExtension
+    # Callback to handle incoming Faye messages. This authenticates both
+    # subscribe and publish calls.
+    def incoming(message, callback)
+      if message["channel"] == "/meta/subscribe"
+        authenticate_subscribe(message)
+      elsif message["channel"] !~ %r{^/meta/}
+        authenticate_publish(message)
+      end
+      callback.call(message)
+    end
+
+  private
+
+    # Ensure the subscription signature is correct and that it has not expired.
+    def authenticate_subscribe(message)
+      subscription = Danthes.subscription(:channel => message["subscription"], 
+                                          :timestamp => message["ext"]["danthes_timestamp"])
+      if message["ext"]["danthes_signature"] != subscription[:signature]
+        message["error"] = "Incorrect signature."
+      elsif Danthes.signature_expired? message["ext"]["danthes_timestamp"].to_i
+        message["error"] = "Signature has expired."
+      end
+    end
+
+    # Ensures the secret token is correct before publishing.
+    def authenticate_publish(message)
+      if Danthes.config[:secret_token].nil?
+        raise Error, "No secret_token config set, ensure danthes.yml is loaded properly."
+      elsif message["ext"]["danthes_token"] != Danthes.config[:secret_token]
+        message["error"] = "Incorrect token."
+      else
+        message["ext"]["danthes_token"] = nil
+      end
+    end
+  end
+end

data/lib/danthes/version.rb

@@ -0,0 +1,3 @@
+module Danthes
+  VERSION = '1.0.1'
+end

data/lib/danthes/view_helpers.rb

@@ -0,0 +1,22 @@
+module Danthes
+  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)
+      Danthes.publish_to(channel, data || capture(&block))
+    end
+
+    # Subscribe the client to the given channel. This generates
+    # some JavaScript calling Danthes.sign with the subscription
+    # options.
+    def subscribe_to(channel)
+      subscription = Danthes.subscription(:channel => channel)
+      content_tag "script", :type => "text/javascript" do
+        raw("if (typeof Danthes != 'undefined') { Danthes.sign(#{subscription.to_json}) }")
+      end
+    end
+  end
+end

data/lib/danthes.rb

@@ -0,0 +1,109 @@
+require 'digest/sha1'
+require 'net/http'
+require 'net/https'
+require 'yajl/json_gem'
+
+require 'danthes/faye_extension'
+require 'danthes/engine' if defined? Rails
+
+module Danthes
+  class Error < StandardError; end
+
+  class << self
+    attr_reader :config
+    attr_accessor :env
+    
+    # List of accepted options in config file
+    ACCEPTED_KEYS = %w(adapter server secret_token mount signature_expiration timeout)
+    
+    # List of accepted options in redis config file
+    REDIS_ACCEPTED_KEYS = %w(host port password database namespace socket)
+
+    # Default options
+    DEFAULT_OPTIONS = {:mount => "/faye", :timeout => 60, :extensions => [FayeExtension.new]}
+    
+    # Resets the configuration to the default
+    # Set environment
+    def startup
+      @config = DEFAULT_OPTIONS.dup
+      @env = if defined? Rails
+               Rails.env
+             else
+               ENV["RAILS_ENV"] || "development"
+             end
+    end
+    
+    # Loads the configuration from a given YAML file
+    def load_config(filename)
+      yaml = ::YAML.load_file(filename)[env]
+      raise ArgumentError, "The #{environment} environment does not exist in #{filename}" if yaml.nil?
+      (yaml.keys - ACCEPTED_KEYS).each {|k| yaml.delete(k)}
+      yaml.each {|k, v| config[k.to_sym] = v}
+    end
+
+    # Loads the options from a given YAML file
+    def load_redis_config(filename)
+      require 'faye/redis'
+      yaml = YAML.load_file(filename)[env]
+      # default redis options
+      options = {:type => Faye::Redis, :host => 'localhost', :port => 6379}
+      (yaml.keys - REDIS_ACCEPTED_KEYS).each {|k| yaml.delete(k)}
+      yaml.each {|k, v| options[k.to_sym] = v}
+      config[:engine] = options
+    end
+
+    # 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 danthes.yml was loaded properly." unless config[:server]
+      url = URI.parse(server_url)
+
+      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.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 => {:danthes_token => config[:secret_token]}}
+      if data.kind_of? String
+        message[:data][:eval] = data
+      else
+        message[:data][:data] = data
+      end
+      message
+    end
+    
+    def server_url
+      [config[:server], config[:mount].gsub(/^\//,'')].join('/')
+    end
+    
+    # Returns a subscription hash to pass to the PrivatePub.sign call in JavaScript.
+    # Any options passed are merged to the hash.
+    def subscription(options = {})
+      sub = {:server => server_url, :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.
+    def faye_app
+      Faye::RackAdapter.new(config)
+    end
+  end
+
+  startup
+end

data/lib/generators/danthes/install_generator.rb

@@ -0,0 +1,16 @@
+require 'generators/danthes'
+
+module Danthes
+  module Generators
+    class InstallGenerator < Base
+      desc 'Create sample config file and add rackup file'
+      def copy_files
+        template "danthes.yml", "config/danthes.yml"
+        if ::Rails.version < "3.1"
+          copy_file "../../../../app/assets/javascripts/danthes.js.coffee", "public/javascripts/danthes.js.coffee"
+        end
+        copy_file "danthes.ru", "danthes.ru"
+      end
+    end
+  end
+end