socketio-client 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in socket.io-client.gemspec
+gemspec

data/README.md

@@ -0,0 +1,58 @@
+# Simple Socket IO client
+
+Quick and kinda dirty socket.io client using web sockets
+
+## Features
+
+This client currently supports:
+
+* Listeners for all 9 possible message
+* Send messages of the type:
+  * message
+  * json
+  * event
+
+## How to use:
+
+```ruby
+require 'socketIO'
+
+client = SocketIO.connect("localhost") do
+  before_start do
+    on_message {|message| puts "incoming message: #{message}"}
+    on_event('news') { |data| puts data.first} # data is an array fo things.
+  end
+
+end
+```
+
+## Sync vs Async
+
+You can start the socket io syncronously and then continue with your work
+this crates threads so be careful.
+
+```ruby
+require 'socketIO'
+
+client = SocketIO.connect("localhost", sync: true) do
+  before_start do
+    on_message {|message| puts message}
+    on_disconnect {puts "I GOT A DISCONNECT"}
+  end
+
+  after_start do
+    emit("loadLogs", "/var/www/rails_app/log/production.log")
+  end
+end
+
+puts "socket still running"
+loop do
+  sleep 10
+  puts 'zzz'
+end
+```
+
+## Examples
+
+examples can be found in the examples/ folder. 
+A corrosponding server can be found in the examples/servers

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.rspec_opts = ['--colour --format documentation']
+end

data/example/complex.rb

@@ -0,0 +1 @@
+#  not yet implemented

data/example/remote_log.rb

@@ -0,0 +1,14 @@
+require 'socketIO'
+
+client = SocketIO.connect("localhost") do
+  before_start do
+    on_message {|message| puts "incoming message: #{message}"}
+    on_disconnect {puts "I GOT A TDISCONNECT"}
+  end
+
+  after_start do
+    emit("loadLogs", "/Users/lyon/test/rails_app/log/development.log")
+  end
+end
+
+puts "thread exited and I have the power back"

data/example/servers/complex.js

@@ -0,0 +1 @@
+//  not yet implemented

data/example/servers/remote_log.js

@@ -0,0 +1,18 @@
+var io = require('socket.io').listen(80)
+  ,spawn = require('child_process').spawn
+
+console.log("Up and running. waiting on connections")
+io.sockets.on('connection', function(socket){
+  console.log("new connection.")
+
+  socket.on("loadLogs", function(path){
+    var tail = spawn("tail", ["-F", path])
+
+    console.log("Begining tail on: " + path)
+    tail.stdout.on("data", function(data){
+      console.log(data.toString("utf8"))
+      socket.send(data.toString("utf8"))
+    })
+  })
+
+})

data/example/servers/simple.js

@@ -0,0 +1,10 @@
+var io = require('socket.io').listen(80);
+
+io.sockets.on('connection', function (socket) {
+
+  setInterval(function(){
+    socket.send('got something for ya');
+    socket.emit('news', { hello: 'world'});
+  }, 10000)
+
+});

data/example/simple.rb

@@ -0,0 +1,10 @@
+require 'socketIO'
+
+client = SocketIO.connect("localhost") do
+  before_start do
+    on_message {|message| puts "incoming message: #{message}"}
+    on_event('news') { |data| puts data.first} # data is an array fo things.
+  end
+
+end
+

data/lib/SocketIO.rb

@@ -0,0 +1,169 @@
+require 'web_socket'
+require 'rest_client'
+require 'json'
+require 'parser'
+
+module SocketIO
+
+  def self.connect(host, options = {}, &block)
+    response = RestClient.get "http://#{host}/socket.io/1/"
+    # resonse should be in the form of sessionid:heartbeattimeout:closetimeout:supported stuff
+    response_array = response.split(':')
+    response_array = [host] + response_array << options
+    cli = Client.new(*response_array)
+    cli.instance_eval(&block) if block
+    cli.start
+  end
+
+  class Client
+    VERSION = "0.0.1"
+
+    [:INT, :TERM].each do |sig|
+      Signal.trap(sig) do
+        puts
+        puts "bye"
+        exit
+      end
+    end
+
+    # The state of the Socket.IO socket can be disconnected, disconnecting, connected and connecting.
+    # The transport connection can be closed, closing, open, and opening.
+
+    def initialize(host, session_id, heartbeat_timeout, connection_timeout, supported_transports, options = {})
+      @host = host
+      @session_id = session_id
+      @hb_timeout = heartbeat_timeout
+      @connect_timeout = connection_timeout
+      @supported_transports = supported_transports
+      @options = options
+      @reconnect = options[:reconnect]
+      @on_event = {}
+    end
+
+    def start
+      self.instance_eval(&@before_start) if @before_start
+      connect_transport
+      start_recieve_loop
+      self.instance_eval(&@after_start) if @after_start
+      @thread.join unless @options[:sync]
+      self
+    end
+
+    def connect_transport
+      if @supported_transports.include? "websocket"
+        @transport = WebSocket.new("ws://#{@host}/socket.io/1/websocket/#{@session_id}")
+      else
+        raise "We only support WebSockets.. and this server doesnt like web sockets.. O NO!!"
+      end
+    end
+
+    def start_recieve_loop
+      @thread = Thread.new() do
+        while data = @transport.receive()
+          decoded = Parser.decode(data)
+          case decoded[:type]
+          when '0'
+            @on_disconnect.call if @on_disconnect
+          when '1'
+            @on_connect.call if @on_connect
+          when '2'
+            send_heartbeat
+            @on_heartbeat.call if @on_heartbeat
+          when '3'
+            @on_message.call decoded[:data] if @on_message
+          when '4'
+            @on_json_message.call decoded[:data] if @on_json_message
+          when '5'
+            message = JSON.parse(decoded[:data])
+            @on_event[message['name']].call message['args'] if @on_event[message['name']]
+          when '6'
+            @on_error.call decoded[:data] if @on_error
+          when '7'
+            @on_ack.call if @on_ack
+          when '8'
+            @on_noop.call if @on_noop
+          end
+        end
+      end
+      @thread
+    end
+
+    def disconnect
+      @transport.send("0::")
+    end
+
+    def disconnected
+      if @reconnect
+        connect_transport
+        start_recieve_loop
+      end
+    end
+
+    def join
+      @thread.join
+    end
+
+    def send_heartbeat
+      @transport.send("2::") #rescue false
+    end
+
+    def send_message(string)
+      @transport.send("3:::#{string}") #rescue false
+    end
+    alias :send :send_message
+
+    def send_json_message(hash)
+      @transport.send("4:::#{hash.to_json}") # rescue false
+    end
+
+    def send_event(name, hash)
+      @transport.send("5:::#{{name: name, args: [hash]}.to_json}") # rescue false
+    end
+    alias :emit :send_event
+
+    def before_start(&block)
+      @before_start = block
+    end
+
+    def after_start(&block)
+      @after_start = block
+    end
+
+    def on_disconnect(&block)
+      @on_disconnect = block
+    end
+
+    def on_connect(&block)
+      @on_connect = block
+    end
+
+    def on_heartbeat(&block)
+      @on_heartbeat = block
+    end
+
+    def on_message(&block)
+      @on_message = block
+    end
+
+    def on_json_message(&block)
+      @on_json_message = block
+    end
+
+    def on_event(name, &block)
+      @on_event[name] = block
+    end
+
+    def on_ack(&block)
+      @on_ack = block
+    end
+
+    def on_error(&block)
+      @on_error = block
+    end
+
+    def on_noop(&block)
+      @on_noop = block
+    end
+  end
+
+end

data/lib/parser.rb

@@ -0,0 +1,13 @@
+module Parser
+  @regexp = /([^:]+):([0-9]+)?(\+)?:([^:]+)?:?([\s\S]*)?/
+
+  # returns hash as {type: '1', id: '1', end_point: '4', data: [{key: value}]}
+  def self.decode(string)
+    if pieces = string.match(@regexp)
+      {type: pieces[1], id: pieces[2], end_point: pieces[4], data: pieces[5]}
+    else
+      {type: '0'}
+    end
+  end
+
+end

data/lib/web_socket.rb

@@ -0,0 +1,429 @@
+# 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 == 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"] =~ /\AWebSocket\z/i)
+        raise(WebSocket::Error, "invalid Upgrade: " + @header["upgrade"])
+      end
+      if !(@header["connection"] =~ /\AUpgrade\z/i)
+        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

data/socketio-client.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'socketIO'
+
+Gem::Specification.new do |s|
+  s.name        = "socketio-client"
+  s.version     = SocketIO::Client::VERSION
+  s.authors     = ["Lyon"]
+  s.email       = ["lyon@delorum.com"]
+  s.homepage    = "http://github.com/lyondhill/socket.io-ruby-client"
+  s.summary     = %q{A basic Socket.io client implememtation written for ruby}
+  s.description = %q{uses a very simple web socket}
+
+  s.rubyforge_project = "socketio-client"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "rest-client"
+end

data/spec/parser_spec.rb

@@ -0,0 +1,22 @@
+require 'socketIO'
+
+describe Parser do
+  
+  it 'should be able to decode all valid messages' do
+    Parser.decode("0").should == {type: "0"}
+    Parser.decode("1::").should == {type: "1", id: nil, end_point: nil, data: ""}
+    Parser.decode("2::").should == {type: "2", id: nil, end_point: nil, data: ""}
+    Parser.decode("3:::hay you").should == {type: "3", id: nil, end_point: nil, data: "hay you"}
+    Parser.decode("4:::{\"can\":\"youcall\"}").should == {type: "4", id: nil, end_point: nil, data: "{\"can\":\"youcall\"}"}
+    Parser.decode("5:::hay you").should == {type: "5", id: nil, end_point: nil, data: "hay you"}
+    Parser.decode("6:::").should == {type: "6", id: nil, end_point: nil, data: ""}
+    Parser.decode("7:::there is an error").should == {type: "7", id: nil, end_point: nil, data: "there is an error"}
+    Parser.decode("8:::").should == {type: "8", id: nil, end_point: nil, data: ""}
+  end
+
+  it "should give a disconnect if bad input" do
+    Parser.decode("hay dude").should == {type: "0"}
+    Parser.decode("9").should == {type: "0"}
+  end
+
+end

data/spec/setup/echo.js

@@ -0,0 +1,17 @@
+var io = require('socket.io').listen(80);
+
+io.sockets.on('connection', function(socket) {
+
+  socket.on('message', function(msg) {
+    socket.send(msg)
+  })
+
+  socket.on('event', function(data) {
+    socket.emit('event', data);
+  });
+
+  socket.on('dc', function() {
+  	socket.close()
+  })
+
+});

data/spec/setup/start.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+echo_server = fork do
+  puts `pwd`
+  # exec ""
+end
+puts "pid ??? #{echo_server}"
+Process.detach(echo_server)

data/spec/socketio_spec.rb

@@ -0,0 +1,46 @@
+describe SocketIO do
+  
+  before :all do
+    @client = SocketIO.connect("localhost", :sync => true)
+  end
+
+  it "can send a heartbeat" do
+    @client.send_heartbeat
+    # should not bonk. haha
+  end
+
+  it "gets a message back when it sends one" do
+    count = 0
+    @client.on_message do |msg|
+      count += 1 if msg == "hay dude"
+    end
+    @client.send("hay dude")
+    sleep 0.5
+    count.should == 1
+  end
+
+  it "gets an emit back when it hits the echo" do
+    count = 0
+    @client.on_event("event") do |data|
+      count += 1 if data[0] == {"first"=>"element", "second"=>"guy"}
+    end 
+    @client.emit("event", {first: "element", second: "guy"})
+    sleep 0.5
+    count.should == 1
+  end
+
+  it "can have a block for every thing" do
+    @client.on_disconnect { }
+    @client.on_connect { }
+    @client.on_heartbeat { }
+    @client.on_message { |msg| }
+    @client.on_json_message { |json| }
+    @client.on_event('en') { |event_hash| }
+    @client.on_ack { }
+    @client.on_error { |data| }
+    @client.on_noop { }
+  end
+
+  
+
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: socketio-client
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Lyon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-10 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: &2154912940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2154912940
+description: uses a very simple web socket
+email:
+- lyon@delorum.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- example/complex.rb
+- example/remote_log.rb
+- example/servers/complex.js
+- example/servers/remote_log.js
+- example/servers/simple.js
+- example/simple.rb
+- lib/SocketIO.rb
+- lib/parser.rb
+- lib/web_socket.rb
+- pkg/socket.io-client-0.0.1.gem
+- pkg/socketio-client-0.0.1.gem
+- socketio-client.gemspec
+- spec/parser_spec.rb
+- spec/setup/echo.js
+- spec/setup/start.rb
+- spec/setup/stop.rb
+- spec/socketio_spec.rb
+homepage: http://github.com/lyondhill/socket.io-ruby-client
+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: socketio-client
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A basic Socket.io client implememtation written for ruby
+test_files:
+- spec/parser_spec.rb
+- spec/setup/echo.js
+- spec/setup/start.rb
+- spec/setup/stop.rb
+- spec/socketio_spec.rb