pusher-client-nc 0.2.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gem "libwebsocket", "~>0.1.3"
+
+group :development do
+  gem "json"
+  gem "ruby-hmac"
+  gem "bacon", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.8)
+    bacon (1.1.0)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    json (1.4.6)
+    json (1.4.6-java)
+    libwebsocket (0.1.3)
+      addressable
+    rake (0.8.7)
+    rcov (0.9.9)
+    rcov (0.9.9-java)
+    ruby-hmac (0.4.0)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  bacon
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  json
+  libwebsocket (~> 0.1.3)
+  rcov
+  ruby-hmac

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Logan Koester
+
+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.rdoc

@@ -0,0 +1,103 @@
+= pusher-client (Ruby)
+
+pusher-client is a ruby gem for consuming WebSockets from the Pusher[http://pusherapp.com] web service.
+
+The connection to Pusher can optionally be maintained in its own thread (see Asynchronous Usage).
+
+This gem is compatible with jruby since 0.2.
+
+== Installation
+
+  gem install pusher-client
+
+== Single-Threaded Usage
+
+The application will pause at socket.connect and handle events from Pusher as they happen.
+
+  require 'pusher-client'
+
+  PusherClient.logger = Logger.new(STDOUT)
+  options = {:secret => YOUR_APP_SECRET}
+  socket = PusherClient::Socket.new(YOUR_APP_KEY, options)
+
+  # Subscribe to a public channel
+  socket.subscribe('channel')
+
+  # Subscribe to an authenticated channel
+  socket.subscribe('presence-channel', 'user_id')
+
+  # Subscribe to an authenticated channel with optional :user_info
+  socket.subscribe('presence-channel', 'user_id', { :name => 'name' })
+
+  # Subscribe to array of channels
+  ['channel1', 'channel2'].each do |c|
+    socket.subscribe("presence-#{c}", 'user_id')
+  end
+
+  # Bind to global events (a catch-all for any 'event' across subscribed channels)
+  socket.bind('event') do |data|
+    puts data
+  end
+
+  # Bind to events that occur on a specific channel
+  socket['channel'].bind('event') do |data|
+    puts data
+  end
+
+  socket.connect
+
+== Asynchronous Usage
+
+The socket will remain open in the background as long as your main application thread is running,
+and you can continue to subscribe/unsubscribe to channels and bind new events.
+
+  require 'pusher-client'
+
+  PusherClient.logger = Logger.new(STDOUT)
+  options = {:secret => YOUR_APP_SECRET}
+  socket = PusherClient::Socket.new(YOUR_APP_KEY, options)
+  socket.connect(true) # Connect asynchronously
+
+  # Subscribe to a channel
+  socket.subscribe('channel')
+
+  # Bind to a global event
+  socket.bind('event') do |data|
+    puts data
+  end
+
+  loop do
+    sleep(1) # Keep your main thread running
+  end
+
+For further documentation, read the source & test suite. Some features of the JavaScript client
+are not yet implemented.
+
+== Gotchas
+
+When binding to a global event, note that you still must be subscribed to the channels the event
+may be sent on. You can't just bind a global event without subscribing to any channels and call it a day.
+
+== Contributing to pusher-client
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== TODOs
+
+* Implement Channel instances associated with Subscription instances.
+* Remove Subscriptions#find_for_bind workaround for lack of Channel instances
+* Remove the duplication between Socket#subscribe and #subscribe_existing
+* Test Socket.rb bind('pusher:connection_disconnected')
+* Identify subscriptions on :channel and :user_id (rather than :user_data).
+
+== Copyright
+
+Copyright (c) 2010 Logan Koester. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "pusher-client-nc"
+  gem.homepage = "http://github.com/logankoester/pusher-client"
+  gem.license = "MIT"
+  gem.summary = %Q{Ruby client for consuming WebSockets from http://pusherapp.com}
+  gem.description = %Q{Ruby client for consuming WebSockets from http://pusherapp.com}
+  gem.email = "support@nur.ph"
+  gem.authors = ["Logan Koester, Neil Cauldwell"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "pusher-client #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/examples/subscribe.rb

@@ -0,0 +1,31 @@
+require 'pusher-client'
+
+PusherClient.logger = Logger.new(STDOUT)
+options = {:secret => YOUR_APP_SECRET}
+socket = PusherClient::Socket.new(YOUR_APP_KEY, options)
+
+# Subscribe to a public channel
+socket.subscribe('channel')
+
+# Subscribe to an authenticated channel (presence or private)
+socket.subscribe('presence-channel', 'user_id')
+
+# Subscribe to an authenticated channel with optional :user_info
+socket.subscribe('presence-channel', 'user_id', { :name => 'name' })
+
+# Subscribe to array of channels
+['channel1', 'channel2'].each do |c|
+  socket.subscribe("presence-#{c}", 'user_id')
+end
+
+# Bind to global events (a catch-all for any 'event' across subscribed channels)
+socket.bind('event') do |data|
+  puts data
+end
+
+# Bind to events that occur on a specific channel
+socket['channel'].bind('event') do |data|
+  puts data
+end
+
+socket.connect

data/examples/subscribe_async.rb

@@ -0,0 +1,18 @@
+require 'pusher-client'
+
+PusherClient.logger = Logger.new(STDOUT)
+options = {:secret => YOUR_APP_SECRET}
+socket = PusherClient::Socket.new(YOUR_APP_KEY, options)
+socket.connect(true) # Connect asynchronously
+
+# Subscribe to a channel
+socket.subscribe('channel')
+
+# Bind to a global event
+socket.bind('event') do |data|
+  puts data
+end
+
+loop do
+  sleep(1) # Keep your main thread running
+end

data/lib/pusher-client.rb

@@ -0,0 +1,26 @@
+autoload :Logger, 'logger'
+
+module PusherClient
+  HOST = 'ws.pusherapp.com'
+  WS_PORT = 80
+  WSS_PORT = 443
+
+  @logger = Logger.new(STDOUT)
+
+  def self.logger
+    @logger
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+end
+
+Thread.abort_on_exception = true
+
+require File.dirname(__FILE__) + '/pusher-client/websocket.rb'
+require File.dirname(__FILE__) + '/pusher-client/socket.rb'
+require File.dirname(__FILE__) + '/pusher-client/channel.rb'
+require File.dirname(__FILE__) + '/pusher-client/channels.rb'
+require File.dirname(__FILE__) + '/pusher-client/subscription.rb'
+require File.dirname(__FILE__) + '/pusher-client/subscriptions.rb'

data/lib/pusher-client/channel.rb

@@ -0,0 +1,53 @@
+module PusherClient
+  class Channel
+    attr_accessor :global, :subscribed
+    attr_reader :name, :callbacks, :global_callbacks
+
+    def initialize(channel_name)
+      @name = channel_name
+      @global = false
+      @callbacks = {}
+      @global_callbacks = {}
+      @subscribed = false
+    end
+
+    def bind(event_name, &callback)
+      @callbacks[event_name] = callbacks[event_name] || []
+      @callbacks[event_name] << callback
+      return self
+    end
+
+    def dispatch_with_all(event_name, data)
+      dispatch(event_name, data)
+      dispatch_global_callbacks(event_name, data)
+    end
+
+    def dispatch(event_name, data)
+      PusherClient.logger.debug "Dispatching callbacks for #{event_name}"
+      if @callbacks[event_name]
+        @callbacks[event_name].each do |callback|
+          callback.call(data)
+        end
+      else
+        PusherClient.logger.debug "No callbacks to dispatch for #{event_name}"
+      end
+    end
+
+    def dispatch_global_callbacks(event_name, data)
+      if @global_callbacks[event_name]
+        PusherClient.logger.debug "Dispatching global callbacks for #{event_name}"
+        @global_callbacks[event_name].each do |callback|
+          callback.call(data)
+        end
+      else
+        PusherClient.logger.debug "No global callbacks to dispatch for #{event_name}"
+      end
+    end
+
+    def acknowledge_subscription(data)
+      @subscribed = true
+    end
+
+  end
+
+end

data/lib/pusher-client/channels.rb

@@ -0,0 +1,37 @@
+module PusherClient
+  class Channels
+    attr_reader :channels
+
+    def initialize
+      @channels = {}
+    end
+
+    def add(channel_name)
+      unless @channels[channel_name]
+        @channels[channel_name] = Channel.new(channel_name)
+      end
+      @channels[channel_name]
+    end
+
+    def find(channel_name)
+      @channels[channel_name]
+    end
+
+    def remove(channel_name)
+      @channels.delete(channel_name)
+      @channels
+    end
+
+    def empty?
+      @channels.empty?
+    end
+
+    def size
+      @channels.size
+    end
+
+    alias :<< :add
+    alias :[] :find
+
+  end
+end

data/lib/pusher-client/socket.rb

@@ -0,0 +1,202 @@
+require 'json'
+require 'hmac-sha2'
+require 'digest/md5'
+
+module PusherClient
+  class Socket
+
+    # Mimick the JavaScript client
+    CLIENT_ID = 'js'
+    VERSION = '1.7.1'
+
+    attr_accessor :encrypted, :secure
+    attr_reader :path, :connected, :subscriptions, :global_channel, :socket_id
+
+    def initialize(application_key, options={})
+      raise ArgumentError if (!application_key.is_a?(String) || application_key.size < 1)
+
+      @path = "/app/#{application_key}?client=#{CLIENT_ID}&version=#{VERSION}"
+      @key = application_key
+      @secret = options[:secret]
+      @socket_id = nil
+      @subscriptions = Subscriptions.new
+      @global_channel = Channel.new('pusher_global_channel')
+      @global_channel.global = true
+      @secure = false
+      @connected = false
+      @encrypted = options[:encrypted] || false
+
+      bind('pusher:connection_established') do |data|
+        socket = JSON.parse(data)
+        @connected = true
+        @socket_id = socket['socket_id']
+        subscribe_all
+      end
+
+      bind('pusher:connection_disconnected') do |data|
+        @subscriptions.subscriptions.each { |s| s.disconnect }
+      end
+
+      bind('pusher:error') do |data|
+        PusherClient.logger.fatal("Pusher : error : #{data.inspect}")
+      end
+    end
+
+    def connect(async = false)
+      if @encrypted || @secure
+        url = "wss://#{HOST}:#{WSS_PORT}#{@path}"
+      else
+        url = "ws://#{HOST}:#{WS_PORT}#{@path}"
+      end
+      PusherClient.logger.debug("Pusher : connecting : #{url}")
+
+      @connection_thread = Thread.new {
+        @connection = WebSocket.new(url)
+        PusherClient.logger.debug "Websocket connected"
+        loop do
+          msg = @connection.receive[0]
+          params  = parser(msg)
+          next if (params['socket_id'] && params['socket_id'] == self.socket_id)
+          event_name   = params['event']
+          event_data   = params['data']
+          channel_name = params['channel']
+          send_local_event(event_name, event_data, channel_name)
+        end
+      }
+
+      @connection_thread.run
+      @connection_thread.join unless async
+      return self
+    end
+
+    def disconnect
+      if @connected
+        PusherClient.logger.debug "Pusher : disconnecting"
+        @connection.close
+        @connection_thread.kill if @connection_thread
+        @connected = false
+      else
+        PusherClient.logger.warn "Disconnect attempted... not connected"
+      end
+    end
+
+    def subscribe(channel_name, user_id = nil, options={})
+      if user_id
+        user_data = {:user_id => user_id, :user_info => options}.to_json
+      else
+        user_data = {:user_id => '', :user_info => ''}.to_json
+      end
+
+      subscription = @subscriptions.add(channel_name, user_data)
+      if @connected
+        authorize(subscription, method(:authorize_callback))
+      end
+      return subscription
+    end
+
+    def subscribe_existing(subscription)
+      if @connected
+        authorize(subscription, method(:authorize_callback))
+      end
+      return subscription
+    end
+
+    def subscribe_all
+      @subscriptions.subscriptions.each{ |s| subscribe_existing(s) }
+    end
+
+    def unsubscribe(channel_name, user_data)
+      subscription = @subscriptions.remove(channel_name, user_data)
+      if @connected
+        send_event('pusher:unsubscribe', {
+          'channel' => channel_name
+        })
+      end
+      return subscription
+    end
+
+    def bind(event_name, &callback)
+      @global_channel.bind(event_name, &callback)
+      return self
+    end
+
+    def [](channel_name)
+      if @subscriptions[channel_name]
+        @subscriptions[channel_name]
+      else
+        @subscriptions << channel_name
+      end
+    end
+
+    def authorize(subscription, callback)
+      if is_private_channel(subscription)
+        auth_data = get_private_auth(subscription)
+      elsif is_presence_channel(subscription)
+        auth_data = get_presence_auth(subscription)
+      end
+      callback.call(subscription, auth_data)
+    end
+
+    def authorize_callback(subscription, auth_data)
+      send_event('pusher:subscribe', {
+        'channel' => subscription.channel,
+        'auth' => auth_data,
+        'channel_data' => subscription.user_data
+      })
+      subscription.acknowledge_subscription(nil)
+    end
+
+    def is_private_channel(subscription)
+      subscription.channel.match(/^private-/)
+    end
+
+    def is_presence_channel(subscription)
+      subscription.channel.match(/^presence-/)
+    end
+
+    def get_private_auth(subscription)
+      string_to_sign = @socket_id + ':' + subscription.channel + ':' + subscription.user_data
+      signature = HMAC::SHA256.hexdigest(@secret, string_to_sign)
+      return "#{@key}:#{signature}"
+    end
+
+    def get_presence_auth(subscription)
+      string_to_sign = @socket_id + ':' + subscription.channel + ':' + subscription.user_data
+      signature = HMAC::SHA256.hexdigest(@secret, string_to_sign)
+      return "#{@key}:#{signature}"
+    end
+
+    # For compatibility with JavaScript client API
+    alias :subscribeAll :subscribe_all
+
+    def send_event(event_name, data)
+      payload = {'event' => event_name, 'data' => data}.to_json
+      @connection.send(payload)
+      PusherClient.logger.debug("Pusher : sending event : #{payload}")
+    end
+
+  protected
+
+    def send_local_event(event_name, event_data, channel_name)
+      if (channel_name)
+        subs = @subscriptions.find_all(channel_name)
+        if (subs)
+          subs.each {|s| s.dispatch_with_all(event_name, event_data)}
+        end
+      end
+
+      @global_channel.dispatch_with_all(event_name, event_data)
+      PusherClient.logger.debug("Pusher : event received : channel: #{channel_name}; event: #{event_name}")
+    end
+
+    def parser(data)
+      begin
+        return JSON.parse(data)
+      rescue => err
+        PusherClient.logger.warn(err)
+        PusherClient.logger.warn("Pusher : data attribute not valid JSON - you may wish to implement your own Pusher::Client.parser")
+        return data
+      end
+    end
+  end
+end