ttapi 0.0.1 → 0.0.2

data/.gitignore

@@ -0,0 +1,49 @@
+# rcov generated
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+#*~
+#\#*
+#.\#*
+
+# For vim:
+#*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc

data/Gemfile

@@ -1,7 +1,7 @@
 source "http://rubygems.org"
 # Add dependencies required to use your gem here.
 # Example:
-#   gem "activesupport", ">= 2.3.5"
+gem "json", ">= 0.0.0"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.

data/Rakefile

@@ -15,7 +15,7 @@ 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 = "ttapi"
-  gem.homepage = "http://github.com/alaingilbert/ttapi"
+  gem.homepage = "http://github.com/alaingilbert/Turntable-API"
   gem.license = "MIT"
   gem.summary = %Q{Turntable-API}
   gem.description = %Q{A simple ruby wrapper for the turntable API}

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/examples/chat_bot.rb

@@ -0,0 +1,16 @@
+require "ttapi"
+
+$b = Bot.new("auth+live+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXX")
+
+def speak(data)
+   name = data["name"]
+   text = data["text"]
+
+   if /\/hello/.match(text)
+      $b.speak("Hello %s" % name)
+   end
+end
+
+$b.on("speak", method(:speak))
+
+$b.start

data/lib/bot.rb

@@ -0,0 +1,459 @@
+require "websocket"
+require "set"
+require "uri"
+require "net/http"
+require "rubygems"
+require "json"
+
+class Bot
+   attr_accessor :debug, :speak
+
+   def initialize(auth, userId, roomId)
+      @auth          = auth
+      @userId        = userId
+      @roomId        = roomId
+      @debug         = false
+      @callback      = nil
+      @currentDjId   = nil
+      @currentSongId = nil
+      @lastHeartbeat = Time.now
+      @lastActivity  = Time.now
+      @clientId      = '%s-0.59633534294921572' % Time.now.to_i
+      @_msgId        = 0
+      @_cmds         = []
+      @_isConnected  = false
+      @fanOf         = Set.new
+      @currentStatus = "available"
+      @signals       = {}
+
+      connect(@roomId)
+   end
+
+
+   def connect(roomId)
+      uri = URI.parse("http://turntable.fm:80/api/room.which_chatserver?roomid=%s" % @roomId)
+      response = Net::HTTP.get_response(uri)
+      data = JSON.parse(response.body)
+      host, port = data[1]["chatserver"][0], data[1]["chatserver"][1]
+      url = "ws://%s:%s/socket.io/websocket" % [host, port]
+      @ws = WebSocket.new(url)
+      if @roomId
+         def clb
+            rq = { "api" => "room.register", "roomid" => @roomId }
+            _send(rq, nil)
+         end
+         @callback = method(:clb)
+      end
+   end
+
+
+   def setTmpSong(data)
+      tmpSong = { "command" => "endsong", "room" => data["room"], "success" => true }
+   end
+
+
+   def on_message(msg)
+      heartbeat_rgx = /~m~[0-9]+~m~(~h~[0-9]+)/
+      if heartbeat_rgx.match(msg)
+         _heartbeat(heartbeat_rgx.match(msg)[1])
+         @lastHeartbeat = Time.now
+         updatePresence()
+         return
+      end
+
+      if @debug
+         puts "> %s" % msg
+      end
+
+      if msg == "~m~10~m~no_session"
+         def clb(obj)
+            if not @isConnected
+               def fanof(data)
+                  @fanOf |= Set.new(data["fanof"])
+                  updatePresence()
+                  # TODO: setInterval ????
+                  emit("ready")
+               end
+               getFanOf(method(:fanof))
+            end
+            @callback.call()
+            @isConnected = true
+         end
+         userAuthenticate(method(:clb))
+         return
+      end
+
+      @lastActivity = Time.now
+      len_rgx = /~m~([0-9]+)~m~/
+      len = len_rgx.match(msg)[1]
+      obj = JSON.parse(msg[msg.index("{"), msg.length])
+      for id, rq, clb in @_cmds
+         if id == obj["msgid"]
+            if rq["api"] == "room.info"
+               if obj["success"]
+                  currentDj = obj["room"]["metadata"]["current_dj"]
+                  currentSong = obj["room"]["metadata"]["current_song"]
+                  if currentDj
+                     @currentDj = currentDj
+                  end
+                  if currentSong
+                     @currentSongId = currentSong["_id"]
+                  end
+               end
+
+            elsif rq["api"] == "room.register"
+               if obj["success"]
+                  @roomId = rq["roomid"]
+                  def info_clb(data)
+                     setTmpSong(data)
+                     emit("roomChanged", data)
+                  end
+                  roomInfo(method(:info_clb))
+               else
+                  emit("roomChanged", obj)
+               end
+               clb = nil
+
+            elsif rq["api"] == "room.deregister"
+               if obj["success"]
+                  @roomId = nil
+               end
+            end
+
+            if clb
+               clb.call(obj)
+            end
+
+            @_cmds.delete([id, rq, clb])
+            break
+         end
+      end
+
+      if obj["command"] == "registered"
+         emit("registered", obj)
+      elsif obj["command"] == "deregistered"
+         emit("deregistered", obj)
+      elsif obj["command"] == "speak"
+         emit("speak", obj)
+      elsif obj["command"] == "pmmed"
+         emit("pmmed", obj)
+      elsif obj["command"] == "nosong"
+         @currentDjId = nil
+         @currentSongId = nil
+         emit("endsong", @tmpSong)
+         emit("nosong", obj)
+      elsif obj["command"] == "newsong"
+         if @currentSongId
+            emit("endsong", @tmpSong)
+         end
+         @currentDjId = obj["room"]["metadata"]["current_dj"]
+         @currentSongId = obj["room"]["metadata"]["current_song"]["_id"]
+         setTmpSong(obj)
+         emit("newsong", obj)
+      elsif obj["command"] == "update_votes"
+         if @tmpSong
+            @tmpSong["room"]['metadata']['upvotes']   = obj['room']['metadata']['upvotes']
+            @tmpSong['room']['metadata']['downvotes'] = obj['room']['metadata']['downvotes']
+            @tmpSong['room']['metadata']['listeners'] = obj['room']['metadata']['listeners']
+         end
+         emit("update_votes", obj)
+      elsif obj["command"] == "booted_user"
+         emit('booted_user', obj)
+      elsif obj["command"] == "update_user"
+         emit('update_user', obj)
+      elsif obj["command"] == "add_dj"
+         emit('add_dj', obj)
+      elsif obj["command"] == "rem_dj"
+         emit('rem_dj', obj)
+      elsif obj["command"] == "new_moderator"
+         emit('new_moderator', obj)
+      elsif obj["command"] == "rem_moderator"
+         emit('rem_moderator', obj)
+      elsif obj["command"] == "snagged"
+         emit('snagged', obj)
+      end
+   end
+
+
+   def _heartbeat(msg)
+      @ws.send('~m~%s~m~%s' % [msg.length, msg])
+      @_msgId += 1
+   end
+
+
+   def _send(rq, callback=nil)
+      rq["msgid"] = @_msgId
+      rq["clientid"] = @clientId
+      if not rq["userid"]
+         rq["userid"] = @userId
+      end
+      rq["userauth"] = @auth
+
+      msg = JSON.generate(rq)
+
+      if @debug
+         puts "< %s" % msg
+      end
+
+      @ws.send('~m~%s~m~%s' % [msg.length, msg])
+      @_cmds.push([@_msgId, rq, callback])
+      @_msgId += 1
+   end
+
+
+   def roomNow(callback=nil)
+      rq = { "api" => "room.now" }
+      _send(rq, callback)
+   end
+
+
+   def updatePresence(callback=nil)
+      rq = { "api": "presence.update", "status": @currentStatus }
+      _send(rq, callback)
+   end
+
+
+   def listRooms(skip=nil, callback=nil)
+      if not skip
+         skip = 0
+      end
+      rq = { "api" => "room.list_rooms", "skip" => skip }
+      _sned(rq, callback)
+   end
+
+
+   def directoryGraph(callback=nil)
+      rq = { "api" => "room.directory_graph" }
+      _send(rq, callback)
+   end
+
+
+   # TODO
+   def stalk(*args)
+   end
+
+
+   def getFavorites(callback=nil)
+      rq = { "api" => "room.get_favorites" }
+      _send(rq, callback)
+   end
+
+
+   def addFavorite(roomId, callback=nil)
+      rq = { "api" => "room.add_favorite", "roomid" => roomId }
+      _send(rq, callback)
+   end
+
+
+   def remFavorite(roomId, callback=nil)
+      rq = { "api" => "room.rem_favorite", "roomid" => roomId }
+      _send(rq, callback)
+   end
+
+
+   # TODO
+   def roomRegister(callback=nil)
+   end
+
+
+   def roomDeregister(callback=nil)
+      rq = { "api" => "room.deregister", "roomid" => @roomId }
+      _send(rq, callback)
+   end
+
+
+   def roomInfo(*args)
+      rq = { "api" => "room.info", "roomid" => @roomId }
+      callback = args[0]
+      _send(rq, callback)
+   end
+
+
+   def speak(msg, callback=nil)
+      rq = { "api" => "room.speak", "roomid" => @roomId, "text" => msg.to_s }
+      _send(rq, callback)
+   end
+
+
+   def pm(msg, userid, callback=nil)
+      rq = { "api" => "pm.send", "receiverid" => userid, "text" => msg.to_s }
+      _send(rq, callback)
+   end
+
+
+   def pmHistory(userid, callback=nil)
+      rq = { "api" => "pm.history", "receiverid" => userid }
+      _send(rq, callback)
+   end
+
+
+   def bootUser(userId, reason="", callback=nil)
+      rq = { "api" => "room.boot_user", "roomid" => @roomId, "target_userid" => userId, "reason" => reason }
+      _send(rq, callback)
+   end
+
+
+   def boot(userId, reason="", callback=nil)
+      bootUser(userId, reason, callback)
+   end
+
+
+   def addModerator(userId, callback=nil)
+      rq = { "api" => "room.add_moderator", "roomid" => @roomId, "target_userid" => userId }
+      _send(rq, callback)
+   end
+
+
+   def remModerator(userId, callback=nil)
+      rq = { "api" => "room.rem_moderator", "roomid" => @roomId, "target_userid" => userId }
+      _send(rq, callback)
+   end
+
+
+   def addDj(callback=nil)
+      rq = { "api" => "room.add_dj", "roomid" => @roomId }
+      _send(rq, callback)
+   end
+
+
+   # TODO
+   def remDj(*args)
+   end
+
+
+   def stopSong(callback=nil)
+      rq = { "api" => "room.stop_song", "roomid" => @roomId }
+      _send(rq, callback)
+   end
+
+
+   def skip(callback=nil)
+      stopSong(callback)
+   end
+
+
+   # TODO
+   def snag(callback=nil)
+   end
+
+
+   # TODO
+   def vote
+   end
+
+
+   # TODO
+   def bop
+   end
+
+
+   def userAuthenticate(callback)
+      rq = { "api" => "user.authenticate" }
+      _send(rq, callback)
+   end
+
+
+   def userInfo(callback=nil)
+      rq = { "api" => "user.info" }
+      _send(rq, callback)
+   end
+
+
+   def getFanOf(callback=nil)
+      rq = { "api" => "user.get_fan_of" }
+      _send(rq, callback)
+   end
+
+
+   # TODO
+   def getProfile
+   end
+
+
+   # TODO
+   def modifyProfile
+   end
+
+
+   def modifyLaptop(laptop="linux", callback=nil)
+      rq = { "api" => "user.modify", "laptop" => laptop }
+      _send(rq, callback)
+   end
+
+
+   def modifyName(name, callback=nil)
+      rq = { "api" => "user.modify", "name" => name }
+      _send(rq, callback)
+   end
+
+
+   def setAvatar(avatarId, callback=nil)
+      rq = { "api" => "user.set_avatar", "avatarid" => avatarId }
+      _send(rq, callback)
+   end
+
+
+   def becomeFan(userId, callback=nil)
+      rq = { "api" => "user.become_fan", "djid" => userId }
+      _send(rq, callback)
+   end
+
+
+   def removeFan(userId, callback=nil)
+      rq = { "api" => "user.remove_fan", "djid" => userId }
+      _send(rq, callback)
+   end
+
+
+   # TODO
+   def playlistAll
+   end
+
+
+   # TODO
+   def playlistAdd
+   end
+
+
+   # TODO
+   def playlistRemove
+   end
+
+
+   # TODO
+   def playlistReorder
+   end
+
+
+   def setStatus(st, callback)
+      @currentStatus = st
+      updatePresence()
+      if callback
+         callback({ "success" => true })
+      end
+   end
+
+
+   def emit(signal, data=nil)
+      callbacks = @signals[signal]
+      callbacks = [] if not callbacks
+      for clb in callbacks
+         clb.call(data)
+      end
+   end
+
+
+   def on(signal, callback)
+      if not @signals[signal]
+         @signals[signal] = []
+      end
+      @signals[signal].push(callback)
+   end
+
+
+   def start
+      while data = @ws.receive()
+         on_message(data)
+      end
+   end
+end

data/lib/websocket.rb

@@ -0,0 +1,584 @@
+# Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
+# Lincense: New BSD Lincense
+# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
+# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+# Reference: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07
+# Reference: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10
+
+require "base64"
+require "socket"
+require "uri"
+require "digest/md5"
+require "digest/sha1"
+require "openssl"
+require "stringio"
+
+
+class WebSocket
+
+    class << self
+
+        attr_accessor(:debug)
+
+    end
+
+    class Error < RuntimeError
+
+    end
+    
+    WEB_SOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+    OPCODE_CONTINUATION = 0x00
+    OPCODE_TEXT = 0x01
+    OPCODE_BINARY = 0x02
+    OPCODE_CLOSE = 0x08
+    OPCODE_PING = 0x09
+    OPCODE_PONG = 0x0a
+
+    def initialize(arg, params = {})
+      if params[:server] # server
+
+        @server = params[:server]
+        @socket = arg
+        line = gets().chomp()
+        if !(line =~ /\AGET (\S+) HTTP\/1.1\z/n)
+          raise(WebSocket::Error, "invalid request: #{line}")
+        end
+        @path = $1
+        read_header()
+        if @header["sec-websocket-version"]
+          @web_socket_version = @header["sec-websocket-version"]
+          @key3 = nil
+        elsif @header["sec-websocket-key1"] && @header["sec-websocket-key2"]
+          @web_socket_version = "hixie-76"
+          @key3 = read(8)
+        else
+          @web_socket_version = "hixie-75"
+          @key3 = nil
+        end
+        if !@server.accepted_origin?(self.origin)
+          raise(WebSocket::Error,
+            ("Unaccepted origin: %s (server.accepted_domains = %p)\n\n" +
+              "To accept this origin, write e.g. \n" +
+              "  WebSocketServer.new(..., :accepted_domains => [%p]), or\n" +
+              "  WebSocketServer.new(..., :accepted_domains => [\"*\"])\n") %
+            [self.origin, @server.accepted_domains, @server.origin_to_domain(self.origin)])
+        end
+        @handshaked = false
+
+      else # client
+        
+        @web_socket_version = "hixie-76"
+        uri = arg.is_a?(String) ? URI.parse(arg) : arg
+
+        if uri.scheme == "ws"
+          default_port = 80
+        elsif uri.scheme = "wss"
+          default_port = 443
+        else
+          raise(WebSocket::Error, "unsupported scheme: #{uri.scheme}")
+        end
+
+        @path = (uri.path.empty? ? "/" : uri.path) + (uri.query ? "?" + uri.query : "")
+        host = uri.host + ((!uri.port || uri.port == default_port) ? "" : ":#{uri.port}")
+        origin = params[:origin] || "http://#{uri.host}"
+        key1 = generate_key()
+        key2 = generate_key()
+        key3 = generate_key3()
+
+        socket = TCPSocket.new(uri.host, uri.port || default_port)
+
+        if uri.scheme == "ws"
+          @socket = socket
+        else
+          @socket = ssl_handshake(socket)
+        end
+
+        write(
+          "GET #{@path} HTTP/1.1\r\n" +
+          "Upgrade: WebSocket\r\n" +
+          "Connection: Upgrade\r\n" +
+          "Host: #{host}\r\n" +
+          "Origin: #{origin}\r\n" +
+          "Sec-WebSocket-Key1: #{key1}\r\n" +
+          "Sec-WebSocket-Key2: #{key2}\r\n" +
+          "\r\n" +
+          "#{key3}")
+        flush()
+
+        line = gets().chomp()
+        raise(WebSocket::Error, "bad response: #{line}") if !(line =~ /\AHTTP\/1.1 101 /n)
+        read_header()
+        if (@header["sec-websocket-origin"] || "").downcase() != origin.downcase()
+          raise(WebSocket::Error,
+            "origin doesn't match: '#{@header["sec-websocket-origin"]}' != '#{origin}'")
+        end
+        reply_digest = read(16)
+        expected_digest = hixie_76_security_digest(key1, key2, key3)
+        if reply_digest != expected_digest
+          raise(WebSocket::Error,
+            "security digest doesn't match: %p != %p" % [reply_digest, expected_digest])
+        end
+        @handshaked = true
+
+      end
+      @received = []
+      @buffer = ""
+      @closing_started = false
+    end
+
+    attr_reader(:server, :header, :path)
+
+    def handshake(status = nil, header = {})
+      if @handshaked
+        raise(WebSocket::Error, "handshake has already been done")
+      end
+      status ||= "101 Switching Protocols"
+      def_header = {}
+      case @web_socket_version
+        when "hixie-75"
+          def_header["WebSocket-Origin"] = self.origin
+          def_header["WebSocket-Location"] = self.location
+          extra_bytes = ""
+        when "hixie-76"
+          def_header["Sec-WebSocket-Origin"] = self.origin
+          def_header["Sec-WebSocket-Location"] = self.location
+          extra_bytes = hixie_76_security_digest(
+            @header["Sec-WebSocket-Key1"], @header["Sec-WebSocket-Key2"], @key3)
+        else
+          def_header["Sec-WebSocket-Accept"] = security_digest(@header["sec-websocket-key"])
+          extra_bytes = ""
+      end
+      header = def_header.merge(header)
+      header_str = header.map(){ |k, v| "#{k}: #{v}\r\n" }.join("")
+      # Note that Upgrade and Connection must appear in this order.
+      write(
+        "HTTP/1.1 #{status}\r\n" +
+        "Upgrade: websocket\r\n" +
+        "Connection: Upgrade\r\n" +
+        "#{header_str}\r\n#{extra_bytes}")
+      flush()
+      @handshaked = true
+    end
+
+    def send(data)
+      if !@handshaked
+        raise(WebSocket::Error, "call WebSocket\#handshake first")
+      end
+      case @web_socket_version
+        when "hixie-75", "hixie-76"
+          data = force_encoding(data.dup(), "ASCII-8BIT")
+          write("\x00#{data}\xff")
+          flush()
+        else
+          send_frame(OPCODE_TEXT, data, !@server)
+      end
+    end
+    
+    def receive()
+      if !@handshaked
+        raise(WebSocket::Error, "call WebSocket\#handshake first")
+      end
+      case @web_socket_version
+        
+        when "hixie-75", "hixie-76"
+          packet = gets("\xff")
+          return nil if !packet
+          if packet =~ /\A\x00(.*)\xff\z/nm
+            return force_encoding($1, "UTF-8")
+          elsif packet == "\xff" && read(1) == "\x00" # closing
+            close(1005, "", :peer)
+            return nil
+          else
+            raise(WebSocket::Error, "input must be either '\\x00...\\xff' or '\\xff\\x00'")
+          end
+        
+        else
+          begin
+            bytes = read(2).unpack("C*")
+            fin = (bytes[0] & 0x80) != 0
+            opcode = bytes[0] & 0x0f
+            mask = (bytes[1] & 0x80) != 0
+            plength = bytes[1] & 0x7f
+            if plength == 126
+              bytes = read(2)
+              plength = bytes.unpack("n")[0]
+            elsif plength == 127
+              bytes = read(8)
+              (high, low) = bytes.unpack("NN")
+              plength = high * (2 ** 32) + low
+            end
+            if @server && !mask
+              # Masking is required.
+              @socket.close()
+              raise(WebSocket::Error, "received unmasked data")
+            end
+            mask_key = mask ? read(4).unpack("C*") : nil
+            payload = read(plength)
+            payload = apply_mask(payload, mask_key) if mask
+            case opcode
+              when OPCODE_TEXT
+                return force_encoding(payload, "UTF-8")
+              when OPCODE_BINARY
+                raise(WebSocket::Error, "received binary data, which is not supported")
+              when OPCODE_CLOSE
+                close(1005, "", :peer)
+                return nil
+              when OPCODE_PING
+                raise(WebSocket::Error, "received ping, which is not supported")
+              when OPCODE_PONG
+              else
+                raise(WebSocket::Error, "received unknown opcode: %d" % opcode)
+            end
+          rescue EOFError
+            return nil
+          end
+        
+      end
+    end
+    
+    def tcp_socket
+      return @socket
+    end
+
+    def host
+      return @header["host"]
+    end
+
+    def origin
+      case @web_socket_version
+        when "7", "8"
+          name = "sec-websocket-origin"
+        else
+          name = "origin"
+      end
+      if @header[name]
+        return @header[name]
+      else
+        raise(WebSocket::Error, "%s header is missing" % name)
+      end
+    end
+
+    def location
+      return "ws://#{self.host}#{@path}"
+    end
+    
+    # Does closing handshake.
+    def close(code = 1005, reason = "", origin = :self)
+      if !@closing_started
+        case @web_socket_version
+          when "hixie-75", "hixie-76"
+            write("\xff\x00")
+          else
+            if code == 1005
+              payload = ""
+            else
+              payload = [code].pack("n") + force_encoding(reason.dup(), "ASCII-8BIT")
+            end
+            send_frame(OPCODE_CLOSE, payload, false)
+        end
+      end
+      @socket.close() if origin == :peer
+      @closing_started = true
+    end
+    
+    def close_socket()
+      @socket.close()
+    end
+
+  private
+
+    NOISE_CHARS = ("\x21".."\x2f").to_a() + ("\x3a".."\x7e").to_a()
+
+    def read_header()
+      @header = {}
+      while line = gets()
+        line = line.chomp()
+        break if line.empty?
+        if !(line =~ /\A(\S+): (.*)\z/n)
+          raise(WebSocket::Error, "invalid request: #{line}")
+        end
+        @header[$1] = $2
+        @header[$1.downcase()] = $2
+      end
+      if !@header["upgrade"]
+        raise(WebSocket::Error, "Upgrade header is missing")
+      end
+      if !(@header["upgrade"] =~ /\AWebSocket\z/i)
+        raise(WebSocket::Error, "invalid Upgrade: " + @header["upgrade"])
+      end
+      if !@header["connection"]
+        raise(WebSocket::Error, "Connection header is missing")
+      end
+      if @header["connection"].split(/,/).grep(/\A\s*Upgrade\s*\z/i).empty?
+        raise(WebSocket::Error, "invalid Connection: " + @header["connection"])
+      end
+    end
+
+    def send_frame(opcode, payload, mask)
+      payload = force_encoding(payload.dup(), "ASCII-8BIT")
+      # Setting StringIO's encoding to ASCII-8BIT.
+      buffer = StringIO.new(force_encoding("", "ASCII-8BIT"))
+      write_byte(buffer, 0x80 | opcode)
+      masked_byte = mask ? 0x80 : 0x00
+      if payload.bytesize <= 125
+        write_byte(buffer, masked_byte | payload.bytesize)
+      elsif payload.bytesize < 2 ** 16
+        write_byte(buffer, masked_byte | 126)
+        buffer.write([payload.bytesize].pack("n"))
+      else
+        write_byte(buffer, masked_byte | 127)
+        buffer.write([payload.bytesize / (2 ** 32), payload.bytesize % (2 ** 32)].pack("NN"))
+      end
+      if mask
+        mask_key = Array.new(4){ rand(256) }
+        buffer.write(mask_key.pack("C*"))
+        payload = apply_mask(payload, mask_key)
+      end
+      buffer.write(payload)
+      write(buffer.string)
+    end
+
+    def gets(rs = $/)
+      line = @socket.gets(rs)
+      $stderr.printf("recv> %p\n", line) if WebSocket.debug
+      return line
+    end
+
+    def read(num_bytes)
+      str = @socket.read(num_bytes)
+      $stderr.printf("recv> %p\n", str) if WebSocket.debug
+      if str && str.bytesize == num_bytes
+        return str
+      else
+        raise(EOFError)
+      end
+    end
+
+    def write(data)
+      if WebSocket.debug
+        data.scan(/\G(.*?(\n|\z))/n) do
+          $stderr.printf("send> %p\n", $&) if !$&.empty?
+        end
+      end
+      @socket.write(data)
+    end
+
+    def flush()
+      @socket.flush()
+    end
+    
+    def write_byte(buffer, byte)
+      buffer.write([byte].pack("C"))
+    end
+    
+    def security_digest(key)
+      return Base64.encode64(Digest::SHA1.digest(key + WEB_SOCKET_GUID)).gsub(/\n/, "")
+    end
+
+    def hixie_76_security_digest(key1, key2, key3)
+      bytes1 = websocket_key_to_bytes(key1)
+      bytes2 = websocket_key_to_bytes(key2)
+      return Digest::MD5.digest(bytes1 + bytes2 + key3)
+    end
+
+    def apply_mask(payload, mask_key)
+      orig_bytes = payload.unpack("C*")
+      new_bytes = []
+      orig_bytes.each_with_index() do |b, i|
+        new_bytes.push(b ^ mask_key[i % 4])
+      end
+      return new_bytes.pack("C*")
+    end
+
+    def generate_key()
+      spaces = 1 + rand(12)
+      max = 0xffffffff / spaces
+      number = rand(max + 1)
+      key = (number * spaces).to_s()
+      (1 + rand(12)).times() do
+        char = NOISE_CHARS[rand(NOISE_CHARS.size)]
+        pos = rand(key.size + 1)
+        key[pos...pos] = char
+      end
+      spaces.times() do
+        pos = 1 + rand(key.size - 1)
+        key[pos...pos] = " "
+      end
+      return key
+    end
+
+    def generate_key3()
+      return [rand(0x100000000)].pack("N") + [rand(0x100000000)].pack("N")
+    end
+
+    def websocket_key_to_bytes(key)
+      num = key.gsub(/[^\d]/n, "").to_i() / key.scan(/ /).size
+      return [num].pack("N")
+    end
+
+    def force_encoding(str, encoding)
+      if str.respond_to?(:force_encoding)
+        return str.force_encoding(encoding)
+      else
+        return str
+      end
+    end
+
+    def ssl_handshake(socket)
+      ssl_context = OpenSSL::SSL::SSLContext.new()
+      ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+      ssl_socket.sync_close = true
+      ssl_socket.connect()
+      return ssl_socket
+    end
+
+end
+
+
+class WebSocketServer
+
+    def initialize(params_or_uri, params = nil)
+      if params
+        uri = params_or_uri.is_a?(String) ? URI.parse(params_or_uri) : params_or_uri
+        params[:port] ||= uri.port
+        params[:accepted_domains] ||= [uri.host]
+      else
+        params = params_or_uri
+      end
+      @port = params[:port] || 80
+      @accepted_domains = params[:accepted_domains]
+      if !@accepted_domains
+        raise(ArgumentError, "params[:accepted_domains] is required")
+      end
+      if params[:host]
+        @tcp_server = TCPServer.open(params[:host], @port)
+      else
+        @tcp_server = TCPServer.open(@port)
+      end
+    end
+
+    attr_reader(:tcp_server, :port, :accepted_domains)
+
+    def run(&block)
+      while true
+        Thread.start(accept()) do |s|
+          begin
+            ws = create_web_socket(s)
+            yield(ws) if ws
+          rescue => ex
+            print_backtrace(ex)
+          ensure
+            begin
+              ws.close_socket() if ws
+            rescue
+            end
+          end
+        end
+      end
+    end
+
+    def accept()
+      return @tcp_server.accept()
+    end
+
+    def accepted_origin?(origin)
+      domain = origin_to_domain(origin)
+      return @accepted_domains.any?(){ |d| File.fnmatch(d, domain) }
+    end
+
+    def origin_to_domain(origin)
+      if origin == "null" || origin == "file://"  # local file
+        return "null"
+      else
+        return URI.parse(origin).host
+      end
+    end
+
+    def create_web_socket(socket)
+      ch = socket.getc()
+      if ch == ?<
+        # This is Flash socket policy file request, not an actual Web Socket connection.
+        send_flash_socket_policy_file(socket)
+        return nil
+      else
+        socket.ungetc(ch)
+        return WebSocket.new(socket, :server => self)
+      end
+    end
+
+  private
+
+    def print_backtrace(ex)
+      $stderr.printf("%s: %s (%p)\n", ex.backtrace[0], ex.message, ex.class)
+      for s in ex.backtrace[1..-1]
+        $stderr.printf("        %s\n", s)
+      end
+    end
+
+    # Handles Flash socket policy file request sent when web-socket-js is used:
+    # http://github.com/gimite/web-socket-js/tree/master
+    def send_flash_socket_policy_file(socket)
+      socket.puts('<?xml version="1.0"?>')
+      socket.puts('<!DOCTYPE cross-domain-policy SYSTEM ' +
+        '"http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">')
+      socket.puts('<cross-domain-policy>')
+      for domain in @accepted_domains
+        next if domain == "file://"
+        socket.puts("<allow-access-from domain=\"#{domain}\" to-ports=\"#{@port}\"/>")
+      end
+      socket.puts('</cross-domain-policy>')
+      socket.close()
+    end
+
+end
+
+
+if __FILE__ == $0
+  Thread.abort_on_exception = true
+
+  if ARGV[0] == "server" && ARGV.size == 3
+
+    server = WebSocketServer.new(
+      :accepted_domains => [ARGV[1]],
+      :port => ARGV[2].to_i())
+    puts("Server is running at port %d" % server.port)
+    server.run() do |ws|
+      puts("Connection accepted")
+      puts("Path: #{ws.path}, Origin: #{ws.origin}")
+      if ws.path == "/"
+        ws.handshake()
+        while data = ws.receive()
+          printf("Received: %p\n", data)
+          ws.send(data)
+          printf("Sent: %p\n", data)
+        end
+      else
+        ws.handshake("404 Not Found")
+      end
+      puts("Connection closed")
+    end
+
+  elsif ARGV[0] == "client" && ARGV.size == 2
+
+    client = WebSocket.new(ARGV[1])
+    puts("Connected")
+    Thread.new() do
+      while data = client.receive()
+        printf("Received: %p\n", data)
+      end
+    end
+    $stdin.each_line() do |line|
+      data = line.chomp()
+      client.send(data)
+      printf("Sent: %p\n", data)
+    end
+
+  else
+
+    $stderr.puts("Usage:")
+    $stderr.puts("  ruby web_socket.rb server ACCEPTED_DOMAIN PORT")
+    $stderr.puts("  ruby web_socket.rb client ws://HOST:PORT/")
+    exit(1)
+
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ttapi
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - alaingilbert
@@ -17,82 +17,8 @@ cert_chain: []
 
 date: 2012-04-25 00:00:00 -04:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  name: shoulda
-  prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 3
-        - 12
-        version: "3.12"
-  type: :development
-  name: rdoc
-  prerelease: false
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 0
-        - 0
-        version: 1.0.0
-  type: :development
-  name: bundler
-  prerelease: false
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 49
-        segments: 
-        - 1
-        - 8
-        - 3
-        version: 1.8.3
-  type: :development
-  name: jeweler
-  prerelease: false
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  name: rcov
-  prerelease: false
-  version_requirements: *id005
+dependencies: []
+
 description: A simple ruby wrapper for the turntable API
 email: alain.gilbert.15@gmail.com
 executables: []
@@ -100,20 +26,20 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- LICENSE.txt
-- README.rdoc
+- README.md
 files: 
-- .document
+- .gitignore
 - Gemfile
-- LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
-- lib/ttapi.rb
+- examples/chat_bot.rb
+- lib/bot.rb
+- lib/websocket.rb
 - test/helper.rb
 - test/test_ttapi.rb
 has_rdoc: true
-homepage: http://github.com/alaingilbert/ttapi
+homepage: http://github.com/alaingilbert/Turntable-API
 licenses: 
 - MIT
 post_install_message: 

data/.document

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

data/LICENSE.txt

@@ -1,20 +0,0 @@
-Copyright (c) 2012 alaingilbert
-
-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.