chrome_remote_debug 0.0.1

data/lib/chrome_remote_debug/client.rb

@@ -0,0 +1,16 @@
+require "net/http"
+require "json"
+
+module ChromeRemoteDebug
+  class Client
+    def initialize(host, port)
+      @host = host
+      @port = port
+    end
+
+    def pages
+      json = Net::HTTP.get(@host, "/json", @port)
+      JSON.parse(json).map {|page_spec| Page.new(page_spec)}
+    end
+  end
+end

data/lib/chrome_remote_debug/command.rb

@@ -0,0 +1,22 @@
+require "json"
+
+module ChromeRemoteDebug
+  class Command
+    @@id = 1
+
+    def initialize(method, params = {})
+      @method = method
+      @params = params
+      @id = @@id
+      @@id += 1
+    end
+
+    def id
+      @id
+    end
+
+    def to_json(*a)
+      { "id" => id, "method" => @method, "params" => @params }.to_json(*a)
+    end
+  end
+end

data/lib/chrome_remote_debug/page.rb

@@ -0,0 +1,35 @@
+require "json"
+require_relative "../../vendor/web-socket-ruby/lib/web_socket"
+
+
+module ChromeRemoteDebug
+  class Page
+    def initialize(spec)
+      @spec = spec
+    end
+
+    def url
+      @spec["url"]
+    end
+
+    def favicon
+      @spec["faviconUrl"]
+    end
+
+    def title
+      @spec["title"]
+    end
+
+    def reload
+      ws = ::WebSocket.new(@spec["webSocketDebuggerUrl"])
+      ws.send(JSON.generate(Command.new("Page.reload")))
+      ws.close()
+    end
+
+    def navigate(url)
+      ws = ::WebSocket.new(@spec["webSocketDebuggerUrl"])
+      ws.send(JSON.generate(Command.new("Page.navigate", :url => url)))
+      ws.close()
+    end
+  end
+end

data/lib/chrome_remote_debug.rb

@@ -0,0 +1,3 @@
+require_relative "chrome_remote_debug/command"
+require_relative "chrome_remote_debug/page"
+require_relative "chrome_remote_debug/client"

data/spec/chrome_remote_debug_client_spec.rb

@@ -0,0 +1,34 @@
+require_relative "spec_helper.rb"
+
+describe ChromeRemoteDebug::Client do
+
+  describe "creation" do
+    it "should be created with host and port" do
+      expect { ChromeRemoteDebug::Client.new("127.0.0.1", 9222) }.not_to raise_error
+    end
+  end
+
+  describe "pages" do
+    before do
+      stub_request(:get, "127.0.0.1:9222/json").to_return({
+        :body => File.new("spec/fixtures/google_twitter_pages.txt")
+      })
+      @chrome = ChromeRemoteDebug::Client.new("127.0.0.1", 9222)
+      @pages = @chrome.pages
+    end
+
+    it "should list all of them" do
+      expect(@pages.count).to eq(2)
+    end
+
+    it "should return pages" do
+      @pages.all? {|page| expect(page).to be_instance_of(ChromeRemoteDebug::Page)}
+    end
+
+    it "should return google and twitter pages" do
+      expect(@pages[0].url).to match(/google/)
+      expect(@pages[1].url).to match(/twitter/)
+    end
+  end
+
+end

data/spec/chrome_remote_debug_command_spec.rb

@@ -0,0 +1,72 @@
+require_relative "spec_helper.rb"
+
+describe ChromeRemoteDebug::Command do
+
+  describe "creation" do
+    it "should created with method" do
+      expect {
+        ChromeRemoteDebug::Command.new(
+          "method"
+        )
+      }.not_to raise_error
+    end
+
+    it "should be created with method and params" do
+      expect {
+        ChromeRemoteDebug::Command.new(
+          "method", :param1 => "1", :params2 => "2"
+        )
+      }.not_to raise_error
+    end
+  end
+
+  describe "id" do
+    before do
+      ChromeRemoteDebug::Command.class_variable_set :@@id, 1
+      @command = ChromeRemoteDebug::Command.new(
+        "method", :param1 => "1", :param2 => "2"
+      )
+    end
+
+    it "should start at 1" do
+      expect(@command.id).to eq(1)
+    end
+
+    it "should increase monotonically" do
+      command2 = ChromeRemoteDebug::Command.new("method")
+      command3 = ChromeRemoteDebug::Command.new("method")
+      expect(command2.id).to eq(2)
+      expect(command3.id).to eq(3)
+    end
+  end
+
+  describe "serialization" do
+    before do
+      ChromeRemoteDebug::Command.class_variable_set :@@id, 1
+    end
+
+    it "should be serializable to json" do
+      command = ChromeRemoteDebug::Command.new(
+        "method", :param1 => "1", :param2 => "2"
+      )
+      expect(command.to_json).to eq(
+        JSON.generate({
+          "id" => 1,
+          "method" => "method",
+          "params" => {
+            "param1" => "1",
+            "param2" => "2"
+          }
+        })
+    )
+    end
+
+    it "should consider params optional" do
+      command = ChromeRemoteDebug::Command.new("method")
+      expect(command.to_json).to eq(
+        JSON.generate({ "id" => 1, "method" => "method", "params" => {} })
+    )
+    end
+  end
+
+end

data/spec/chrome_remote_debug_page_spec.rb

@@ -0,0 +1,88 @@
+require_relative "spec_helper.rb"
+
+describe ChromeRemoteDebug::Page do
+  before do
+    @page_spec = JSON.parse( IO.read("spec/fixtures/google_twitter_pages.txt"))[0]
+  end
+
+  describe "creation" do
+    it "should be created with spec" do
+      expect { ChromeRemoteDebug::Page.new(@page_spec) }.not_to raise_error
+    end
+  end
+
+  describe "attributes" do
+    before do
+      @page = ChromeRemoteDebug::Page.new(@page_spec)
+    end
+
+    it "should have an url attribute" do
+      expect(@page.url).to eq(@page_spec["url"])
+    end
+
+    it "should have a favicon attribute" do
+      expect(@page.favicon).to eq(@page_spec["faviconUrl"])
+    end
+
+    it "should have a title attribute" do
+      expect(@page.title).to eq(@page_spec["title"])
+    end
+  end
+
+  describe "reload" do
+    before do
+      @page = ChromeRemoteDebug::Page.new(@page_spec)
+      @websocket = double()
+      @websocket.stub(:send)
+      @websocket.stub(:close)
+    end
+
+    it "should connect to page websocket" do
+      WebSocket.should_receive(:new).with(@page_spec["webSocketDebuggerUrl"]).and_return(@websocket)
+      @page.reload
+    end
+
+    it "should send a reload command" do
+      WebSocket.stub(:new => @websocket)
+      @websocket.should_receive(:send).with(/reload/)
+      @page.reload
+    end
+
+    it "should disconnect" do
+      WebSocket.stub(:new => @websocket)
+      @websocket.should_receive(:send)
+      @websocket.should_receive(:close)
+      @page.reload
+    end
+  end
+
+  # TODO: remove duplication
+  describe "navigate" do
+    before do
+      @page = ChromeRemoteDebug::Page.new(@page_spec)
+      @websocket = double()
+      @websocket.stub(:send)
+      @websocket.stub(:close)
+      @url = "http://www.google.com"
+    end
+
+    it "should connect to page websocket" do
+      WebSocket.should_receive(:new).with(@page_spec["webSocketDebuggerUrl"]).and_return(@websocket)
+      @page.navigate(@url)
+    end
+
+    it "should send a navigate command" do
+      WebSocket.stub(:new => @websocket)
+      @websocket.should_receive(:send).with(/navigate/).with(/#{@url}/)
+      @page.navigate(@url)
+    end
+
+    it "should disconnect" do
+      WebSocket.stub(:new => @websocket)
+      @websocket.should_receive(:send)
+      @websocket.should_receive(:close)
+      @page.navigate(@url)
+    end
+  end
+
+end

data/spec/fixtures/google_twitter_pages.txt

@@ -0,0 +1,15 @@
+[ {
+   "devtoolsFrontendUrl": "/devtools/devtools.html?ws=localhost:9222/devtools/page/16_1",
+   "faviconUrl": "http://www.google.com/favicon.ico",
+   "thumbnailUrl": "/thumb/http://www.google.com/",
+   "title": "Google",
+   "url": "http://www.google.com/",
+   "webSocketDebuggerUrl": "ws://localhost:9222/devtools/page/16_1"
+}, {
+   "devtoolsFrontendUrl": "/devtools/devtools.html?ws=localhost:9222/devtools/page/18_1",
+   "faviconUrl": "http://twitter.com/favicons/favicon.ico",
+   "thumbnailUrl": "/thumb/http://twitter.com/",
+   "title": "Twitter",
+   "url": "http://twitter.com/",
+   "webSocketDebuggerUrl": "ws://localhost:9222/devtools/page/18_1"
+} ]

data/spec/fixtures/no_pages.txt

@@ -0,0 +1 @@
+[  ]

data/spec/fixtures/one_blank_page.txt

@@ -0,0 +1,8 @@
+[ {
+   "devtoolsFrontendUrl": "/devtools/devtools.html?ws=localhost:9222/devtools/page/14_1",
+   "faviconUrl": "",
+   "thumbnailUrl": "/thumb/chrome://newtab/",
+   "title": "New Tab",
+   "url": "chrome://newtab/",
+   "webSocketDebuggerUrl": "ws://localhost:9222/devtools/page/14_1"
+} ]

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--format progress

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require_relative "../lib/chrome_remote_debug.rb"
+require "webmock/rspec"
+
+# force expect syntax
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/vendor/web-socket-ruby/lib/web_socket.rb

@@ -0,0 +1,588 @@
+# 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()
+        if !line
+          raise(WebSocket::Error, "Client disconnected without sending anything.")
+        end
+        line = line.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) if 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

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: chrome_remote_debug
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Federico Galassi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &78620210 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *78620210
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &78619950 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *78619950
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &78619730 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *78619730
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &78619510 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *78619510
+description: Ruby client library for the Google Chrome Remote Debugging Protocol.
+email:
+- federico.galassi@cleancode.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chrome_remote_debug.rb
+- lib/chrome_remote_debug/command.rb
+- lib/chrome_remote_debug/page.rb
+- lib/chrome_remote_debug/client.rb
+- vendor/web-socket-ruby/lib/web_socket.rb
+- spec/chrome_remote_debug_command_spec.rb
+- spec/chrome_remote_debug_page_spec.rb
+- spec/spec_helper.rb
+- spec/fixtures/no_pages.txt
+- spec/fixtures/google_twitter_pages.txt
+- spec/fixtures/one_blank_page.txt
+- spec/chrome_remote_debug_client_spec.rb
+- spec/spec.opts
+homepage: http://github.com/fgalassi/chrome-remote-debug
+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: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: Ruby client library for the Google Chrome Remote Debugging Protocol.
+test_files:
+- spec/chrome_remote_debug_command_spec.rb
+- spec/chrome_remote_debug_page_spec.rb
+- spec/spec_helper.rb
+- spec/fixtures/no_pages.txt
+- spec/fixtures/google_twitter_pages.txt
+- spec/fixtures/one_blank_page.txt
+- spec/chrome_remote_debug_client_spec.rb
+- spec/spec.opts