talker 0.0.1

data/README.md

@@ -0,0 +1,97 @@
+# Talker Ruby Client
+A real-time Talker Ruby client.
+
+# Usage
+1) Get a Talker account at https://talkerapp.com/signup
+
+2) Get your Talker Token on https://myaccount.talkerapp.com/settings
+
+3) Find the Room ID you want to connect to. This is the last part of the URL:
+
+     https://myaccount.talkerapp.com/rooms/<room_id>
+
+4) Serve hot and enjoy
+
+    Talker.connect(:room => ROOM_ID, :token => YOUR_TALKER_TOKEN) do |client|
+      client.on_connected do
+        client.send_message "hello!"
+      end
+      
+      client.on_message do |user, message|
+        puts user["name"] + ": " + message
+      end
+      
+      trap("INT") { client.close }
+    end
+
+# Callbacks
+All arguments are optional.
+
+## <code>on_connected</code>
+Called when the user is authenticated and ready to receive events.
+
+## <code>on_presence(users)</code>
+Called after <code>on_connected</code> with the list of connected users.
+With <code>users</code> being something like this:
+
+    [{"id"=>1, "name"=>"macournoyer", "email"=>"macournoyer@talkerapp.com"},
+     {"id"=>2, "name"=>"gary", "email"=>"gary@talkerapp.com"}]
+
+## <code>on_message(user, message, event)</code>
+Called when a new message is received.
+<code>user</code> is the sender. <code>event</code> contains the full event sent by the server.
+
+## <code>on_join(user)</code>
+Called when a user joins the room.
+
+## <code>on_idle(user)</code>
+Called when a user becomes idle (closed connection without leaving).
+
+## <code>on_back(user)</code>
+Called when a user is back from idle.
+
+## <code>on_leave(user)</code>
+Called when a user leaves.
+
+## <code>on_close</code>
+Called when the connection is closed.
+
+## <code>on_error(error_message)</code>
+Called an error is received from the Talker server.
+
+# Methods
+Methods of an instance of Talker class.
+
+## <code>users</code>
+Array of users currently in the room. In the form:
+
+    [{"id"=>1, "name"=>"macournoyer", "email"=>"macournoyer@talkerapp.com"},
+     {"id"=>2, "name"=>"gary", "email"=>"gary@talkerapp.com"}]
+
+## <code>leave</code>
+Leave the room and close the connection.
+
+## <code>close</code>
+Close the connection without leaving the room.
+
+## <code>send_message(message)</code>
+Send a message.
+
+## <code>send_private_message(user_name, message)</code>
+Send a private message to <code>user_name</code>.
+
+# Running the specs
+Howdy brave lil' one! To run the specs you'll need courage, hard work and some luck:
+
+1) Install from source my "special" fork of em-spec at http://github.com/macournoyer/em-spec.
+
+2) Edit the file spec/talker.example.yml with your info and rename it to spec/talker.yml.
+
+3) Run <code>rake</code> and everything should be green, birds should start signing and someone will make you a chocolate cake
+
+(results may vary).
+
+# Credits & License
+Released under the Ruby License, (c) Talker
+
+Thanks to http://github.com/raggi for kicking this off.

data/Rakefile

@@ -0,0 +1,8 @@
+require "spec/rake/spectask"
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = %w(-fs -c)
+  t.spec_files = FileList["spec/**_spec.rb"]
+end

data/bin/talker-cat

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require "talker"
+require "talker/cli"
+
+token = Talker::CLI.load_token
+room = ARGV.first
+
+abort <<-EOS unless room
+usage: echo 'something' | talker-cat <room_id>
+
+  Send a message to a room:
+  
+    echo 'something' | talker-cat 1
+  
+  Send a file to a room:
+  
+    talker-cat 1 < site_fixer.rb
+  
+  Room ID is the last part of the URL:
+    https://myaccount.talkerapp.com/rooms/<room_id>
+  
+EOS
+
+Talker.connect(:room => room, :token => token) do |client|
+  client.on_connected do
+    client.send_message STDIN.read
+    client.close
+  end
+  client.on_error do |error|
+    puts error
+  end
+end

data/bin/talker-shell

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+require "talker"
+require "talker/cli"
+
+token = Talker::CLI.load_token
+room, cmd, process_name = *ARGV
+process_name ||= cmd
+
+abort <<-EOS unless room && cmd
+usage: talker-shell <room_id> <command> [name]
+  Launch an irb session connected to a room:
+  
+    talker-shell 1 irb
+  
+  Room ID is the last part of the URL:
+    https://myaccount.talkerapp.com/rooms/<room_id>
+  
+EOS
+
+
+module Process
+  attr_accessor :name, :client
+  
+  def receive_data(data)
+    log data
+  end
+  
+  def unbind
+    log "exited"
+    @client.close
+  end
+  
+  def log(msg)
+    puts "> #{msg}"
+    @client.send_message("#{name}> #{msg}")
+  end
+end
+
+
+EM.run do
+  Talker.connect(:room => room, :token => token) do |client|
+    @process = nil
+    
+    client.on_connected do
+      EM.popen(cmd, Process) do |process|
+        client.send_message "Connected to process: #{cmd}, prefix commands w/ '#{process_name}: '"
+
+        process.name = process_name
+        process.client = client
+        trap("INT") { process.close_connection_after_writing }
+
+        @process = process
+      end
+    end
+    
+    client.on_message do |user, message|
+      if command = message[/^#{process_name}: (.*)$/, 1]
+        puts "> #{cmd}"
+        @process.send_data command + "\n"
+      end
+    end
+    
+    client.on_error do |error|
+      puts error
+    end
+    
+    client.on_close do
+      EM.stop
+    end
+  end
+end

data/lib/talker/cli.rb

@@ -0,0 +1,16 @@
+class Talker
+  class CLI
+    def self.load_token
+      token_path = File.join(ENV['HOME'], '.talker')
+      
+      unless File.file?(token_path)
+        abort <<-EOS
+      Place your Talker Token in #{token_path}. You can find your
+      token in https://myaccount.talkerapp.com/settings
+      EOS
+      end
+      
+      File.read(token_path).strip
+    end
+  end
+end

data/lib/talker.rb

@@ -0,0 +1,136 @@
+require "eventmachine"
+require "yajl"
+
+class Talker < EM::Connection
+  class Error < RuntimeError; end
+  
+  attr_accessor :room, :token, :thread
+  
+  def self.connect(options={})
+    host = options[:host] || "talkerapp.com"
+    port = (options[:port] || 8500).to_i
+    room = options[:room].to_i
+    token = options[:token]
+    
+    thread = Thread.new { EM.run } unless EM.reactor_running?
+    
+    EM.connect host, port, self do |c|
+      c.thread = thread
+      c.room = room
+      c.token = token
+      yield c if block_given?
+    end
+    
+    thread.join unless thread.nil?
+  end
+  
+  def initialize
+    @users = {}
+  end
+  
+  # Callbacks
+  %w( connected message join idle back leave presence error close ).each do |method|
+    class_eval <<-EOS
+      def on_#{method}(&block)
+        @on_#{method} = block
+      end
+    EOS
+  end
+  
+  def users
+    @users.values
+  end
+  
+  def send_message(message, attributes={})
+    send({ :type => "message", :content => message }.merge(attributes))
+  end
+  
+  def send_private_message(to, message)
+    if to.is_a?(String)
+      user = @users.values.detect { |user| user["name"] == to }
+      raise Error, "User #{to} not found" unless user
+      user_id = user["id"]
+    else
+      user_id = to
+    end
+    send_message message, :to => user_id
+  end
+  
+  
+  ## EventMachine callbacks
+  
+  def connection_completed
+    send :type => "connect", :room => @room, :token => @token
+    EM.add_periodic_timer(20) { send :type => "ping" }
+  end
+  
+  def leave
+    send :type => "close"
+    close
+  end
+  
+  def close
+    close_connection_after_writing
+  end
+  
+  def post_init
+    @parser = Yajl::Parser.new
+    @parser.on_parse_complete = method(:event_parsed)
+  end
+  
+  def receive_data(data)
+    @parser << data
+  end
+  
+  def unbind
+    trigger :close
+    @thread.kill if @thread
+  end
+  
+  
+  private
+    def event_parsed(event)
+      case event["type"]
+      when "connected"
+        trigger :connected
+      when "error"
+        if @on_error
+          @on_error.call(event["message"])
+        else
+          raise Error, event["message"]
+        end
+      when "users"
+        event["users"].each do |user|
+          @users[user["id"]] = user
+        end
+        trigger :presence, @users.values
+      when "join"
+        @users[event["user"]["id"]] = event["user"]
+        trigger :join, event["user"]
+      when "leave"
+        @users.delete(event["user"]["id"])
+        trigger :leave, event["user"]
+      when "idle"
+        trigger :idle, event["user"]
+      when "back"
+        trigger :back, event["user"]
+      when "message"
+        @users[event["user"]["id"]] ||= event["user"]
+        trigger :message, event["user"], event["content"], event
+      else
+        raise Error, "unknown event type received from server: " + event["type"]
+      end
+    rescue
+      close
+      raise
+    end
+    
+    def trigger(callback, *args)
+      callback = instance_variable_get(:"@on_#{callback}")
+      callback.call(*args[0,callback.arity]) if callback
+    end
+    
+    def send(data)
+      send_data Yajl::Encoder.encode(data) + "\n"
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require "rubygems"
+require "yaml"
+require 'spec'
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require "talker"
+
+# Installing em-spec from http://github.com/macournoyer/em-spec
+require 'em/spec'
+require 'em/spec/rspec'
+EM.spec_backend = EM::Spec::Rspec
+
+TALKER_CONFIG = YAML.load_file(File.dirname(__FILE__) + "/talker.yml")
+
+module Helpers
+  def connect(&callback)
+    Talker.connect :room => TALKER_CONFIG["room"].to_i, :token => TALKER_CONFIG["token"], &callback
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include Helpers
+end

data/spec/talker.example.yml

@@ -0,0 +1,7 @@
+# Get your Talker Token on https://myaccount.talkerapp.com/settings
+token: YOUR_TALKER_TOKEN
+# Room ID is the last part of the URL:
+#   https://myaccount.talkerapp.com/rooms/<room_id>
+room: ROOM_ID
+# Make sure it matches or some specs will fail
+user_name: YOUR_USER_NAME

data/spec/talker.yml

@@ -0,0 +1,3 @@
+token: 845a877053137c0bc76acfc027b92ca0e1d3699f
+room: 62
+user_name: ma

data/spec/talker_spec.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+EM.describe Talker do
+  it "should connect" do
+    connect do |client|
+      client.on_connected do
+        done
+      end
+    end
+  end
+  
+  it "should close" do
+    connect do |client|
+      client.on_connected do
+        client.close
+      end
+      client.on_close do
+        done
+      end
+    end
+  end
+  
+  it "should receive presence" do
+    connect do |client|
+      client.on_presence do |users|
+        users.size.should >= 1
+        users.map { |user| user["name"] }.should include(TALKER_CONFIG["user_name"])
+        done
+      end
+    end
+  end
+
+  it "should send and receive message" do
+    connect do |client|
+      client.on_connected do
+        client.send_message "it works, magic!"
+      end
+      client.on_message do |user, message|
+        message.should == "it works, magic!"
+        done
+      end
+    end
+  end
+  
+  it "should send and receive private message" do
+    connect do |client|
+      client.on_presence do
+        client.send_private_message TALKER_CONFIG["user_name"], "private magic"
+      end
+      client.on_message do |user, message|
+        message.should == "private magic"
+        done
+      end
+    end
+  end
+  
+  # Keep at the end, mmmkay?
+  it "should leave" do
+    connect do |client|
+      client.on_connected do
+        client.leave
+      end
+      client.on_close do
+        done
+      end
+    end
+  end
+end

data/talker.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name            = %q{talker}
+  s.version         = "0.0.1"
+ 
+  s.authors         = ["Marc-Andre Cournoyer"]
+  s.email           = "macournoyer@talkerapp.com"
+  s.files           = Dir["**/*"]
+  s.homepage        = "http://github.com/macournoyer/talker.rb"
+  s.require_paths   = ["lib"]
+  s.bindir          = "bin"
+  s.executables     = ["talker-cat", "talker-shell"]
+  s.summary         = "A real-time Talker Ruby client."
+  s.test_files      = Dir["spec/**"]
+  
+  s.add_dependency  "eventmachine"
+  s.add_dependency  "yajl-ruby"
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: talker
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Marc-Andre Cournoyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-12 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: macournoyer@talkerapp.com
+executables: 
+- talker-cat
+- talker-shell
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/talker-cat
+- bin/talker-shell
+- lib/talker/cli.rb
+- lib/talker.rb
+- Rakefile
+- README.md
+- spec/spec_helper.rb
+- spec/talker.example.yml
+- spec/talker.yml
+- spec/talker_spec.rb
+- talker-0.0.1.gem
+- talker.gemspec
+has_rdoc: true
+homepage: http://github.com/macournoyer/talker.rb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A real-time Talker Ruby client.
+test_files: 
+- spec/spec_helper.rb
+- spec/talker.example.yml
+- spec/talker.yml
+- spec/talker_spec.rb