webrocket 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6f34536b978cbb71a56ae12ea296681c3f09e1d1
+  data.tar.gz: 210d6e96989a3657513fabc93278250800bfe491
+SHA512:
+  metadata.gz: 0e2587f050883ca1fee5a31c50b9a2c2e863aa2f4268e0bada83d66ddb159ef44be21aa1d8e8ff5e9cd358309f1b7f2654ce3283ad413647b82b6980625d58fb
+  data.tar.gz: 9aafb6ae9a6ae54dcd78a04e36222a06f7022c51bad724669d01b8d7c05ba5ee9be354455fffef982287d5536ea9298ff8127308b7bdbecc29ce13438c280c4e

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.1.1
+  - 2.0.0
+  - 1.9.3
+script:
+  - bundle exec rake build test

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in WEBrocket.gemspec
+gemspec

data/README.md

@@ -0,0 +1,104 @@
+[![Build Status](https://img.shields.io/travis/unak/WEBrocket.svg)](https://travis-ci.org/unak/WEBrocket)
+[![Version     ](https://img.shields.io/gem/v/webrocket.svg)](https://rubygems.org/gems/webrocket)
+
+WEBrocket
+=========
+
+WebSocket extension for WEBrick.
+This library is under development.
+
+WebSocket specification is based on [RFC6455](http://www.rfc-editor.org/rfc/rfc6455.txt).
+
+
+Requirements
+------------
+
++ Ruby 1.9.3 or later.
+
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+    gem 'WEBrocket'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install WEBrocket
+
+
+How to use
+----------
+
+    require "webrick"
+    require "webrocket"
+    
+    # write listner
+    class Listener
+      def on_open(websocket)
+        # do somthing
+      end
+    
+      def on_close(websocket)
+        # do somthing
+      end
+    
+      def on_recv(websocket, data, type)
+        # do something
+      end
+    
+      def on_shutdown
+        # do something
+      end
+    end
+    
+    server = WEBrick::HTTPServer.new
+    server.mount_websocket("sample", Listener.new, "test")
+    server.start
+
+See sample directory for more details.
+
+
+Limitations
+-----------
+
++ Fragmentation is not supported yet.
++ TLS is not supported yet.
+
+
+License
+-------
+
+Copyright (c) 2013 NAKAMURA Usaku usa@garbagecollect.jp
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Supplimentary
+-------------
+
+I've found that there are many projects named webrocket, but, sorry, I can't
+stop naming this one the same name :)

data/Rakefile

@@ -0,0 +1,7 @@
+# -*- Ruby -*-
+require "bundler/gem_tasks"
+
+desc "Runs test"
+task :test do
+  ruby 'test/test_webrocket.rb', '-v'
+end

data/lib/webrocket.rb

@@ -0,0 +1,56 @@
+require "base64"
+require "digest/sha1"
+require "webrocket/webrick-extender"
+require "webrocket/websocket"
+require "webrocket/version"
+
+module WEBrocket
+  def self.attach(server, req, res, listener, subprotocol)
+    key = req["Sec-WebSocket-Key"]
+    unless key
+      res.status = WEBrick::HTTPStatus::RC_BAD_REQUEST
+      return
+    end
+    key += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+    res["Sec-WebSocket-Accept"] = Base64.strict_encode64(Digest::SHA1.digest(key))
+
+    if req["Sec-WebSocket-Version"].to_i < 13
+      res.status = WEBrick::HTTPStatus::RC_BAD_REQUEST
+      res["Sec-WebSocket-Version"] = 13
+      return
+    end
+
+    if req["Sec-WebSocket-Protocol"]
+      protocols = req["Sec-WebSocket-Protocol"].split(/\s*,\s*/)
+      if protocols.include?(subprotocol)
+        res["Sec-WebSocket-Protocol"] = subprotocol
+      elsif protocols.include?("null")
+        res["Sec-WebSocket-Protocol"] = "null"
+      end
+    end
+
+    res.status = WEBrick::HTTPStatus::RC_SWITCHING_PROTOCOLS
+    res["Upgrade"] = "websocket"
+    #res["Connection"] = "Upgrade"
+
+    @keep_alive = true
+
+    res.define_singleton_method(:send_response) do |sock|
+      begin
+        setup_header
+        @header["connection"] = "Upgrade"
+        send_header(sock)
+        ws = WEBrocket::WebSocket.new(sock, listener, subprotocol)
+        server.add_shutdown_listener(ws.method(:on_shutdown))
+        ws.start
+        @keep_alive = false
+      rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN => ex
+        @logger.debug(ex)
+        @keep_alive = false
+      rescue StandardError => ex
+        @logger.error(ex)
+        @keep_alive = false
+      end
+    end
+  end
+end

data/lib/webrocket/version.rb

@@ -0,0 +1,3 @@
+module WEBrocket
+  VERSION = "0.0.1"
+end

data/lib/webrocket/webrick-extender.rb

@@ -0,0 +1,27 @@
+require "webrick/httpserver"
+require "webrocket"
+
+module WEBrick
+  class HTTPServer
+    def mount_websocket(path, listener, subprotocol)
+      mount_proc(path) do |req, res|
+        WEBrocket.attach(self, req, res, listener, subprotocol)
+      end
+    end
+
+    def add_shutdown_listener(prc = nil, &block)
+      @shutdown_listeners ||= []
+      @shutdown_listeners.push(prc || block)
+    end
+
+    alias _original_shutdown shutdown
+    def shutdown
+      if @shutdown_listeners
+        @shutdown_listeners.each do |listener|
+          listener.call
+        end
+      end
+      _original_shutdown
+    end
+  end
+end

data/lib/webrocket/websocket.rb

@@ -0,0 +1,164 @@
+require "webrocket"
+
+module WEBrocket
+  class WebSocket
+    class InternalError < StandardError; end
+
+    OP_CONTINUE = 0x0
+    OP_TEXT = 0x1
+    OP_BINARY = 0x2
+    OP_CLOSE = 0x8
+    OP_PING = 0x9
+    OP_PONG = 0xA
+
+    CLOSE_OK = [1000].pack("n")
+    CLOSE_CLOSED = [1001].pack("n")
+    CLOSE_PROTOCOL_ERROR = [1002].pack("n")
+    CLOSE_BROKEN_DATA = [1003].pack("n")
+    CLOSE_BROKEN_MESSAGE = [1007].pack("n")
+    CLOSE_POLICY_ERROR = [1008].pack("n")
+    CLOSE_TOO_BIG = [1009].pack("n")
+    CLOSE_UNKNOWN_ERROR = [1011].pack("n")
+
+    def initialize(sock, listener, subprotocol)
+      @sock = sock
+      @listener = listener
+      @subprotocol = subprotocol
+      @type = nil
+      @reason = nil
+    end
+
+    attr_reader :subprotocol
+
+    def start
+      @listener.on_open(self) if @listener.respond_to?(:on_open)
+      begin
+        while true
+          r = IO.select([@sock])
+          recv_frame if r
+        end
+      rescue IOError
+        @reason ||= CLOSE_CLOSED
+      ensure
+        @reason ||= CLOSE_UNKNOWN_ERROR
+        send_close_frame(@reason) unless @sock.closed?
+        @listener.on_close(self) if @listener.respond_to?(:on_close)
+      end
+    end
+
+    def send(data, type = :text)
+      nil until IO.select([], [@sock])
+      case type
+      when :text
+        op = OP_TEXT
+      when :binary
+        op = OP_BINARY
+      else
+        raise InternalError, "unknown type: #{type}"
+      end
+      send_frame(op, data)
+    end
+
+    def on_shutdown
+      send_close_frame unless @sock.closed?
+      @listener.on_shutdown if @listener.respond_to?(:on_shutdown)
+    end
+
+    private
+    def send_close_frame(data = "")
+      send_frame(OP_CLOSE, data)
+    end
+
+    def send_frame(opcode, data = "")
+      data = data.dup.force_encoding('binary')
+      if data.bytesize <= 125
+        @sock.write([0x80 | opcode, data.bytesize].pack("cc") + data)
+      elsif data.bytesize <= 0xffff
+        @sock.write([0x80 | opcode, 126, data.bytesize].pack("ccn") + data)
+      else # under 64bit
+        @sock.write([0x80 | opcode, 127, data.bytesize / 0x1_0000_0000, data.bytesize % 0x1_0000_0000].pack("ccNN") + data)
+      end
+    end
+
+    def recv_frame
+      header = @sock.read(2)
+      return unless header
+      if header.bytesize != 2
+        @reason = CLOSE_PROTOCOL_ERROR
+        raise InternalError, "something wrong: header = '#{header}'"
+      end
+      h0, h1 = header.unpack("cc")
+      len = h1 & 0x7F
+      if len == 126
+        tmp = @sock.read(2)
+        if !tmp || tmp.bytesize != 2
+          @reason = CLOSE_PROTOCOL_ERROR
+          raise InternalError, "something wrong: size = '#{tmp}'"
+        end
+        len = tmp.unpack("n")
+      elsif len == 127
+        tmp = @sock.read(8)
+        if !tmp || tmp.bytesize != 8
+          @reason = CLOSE_PROTOCOL_ERROR
+          raise InternalError, "something wrong: size = '#{tmp}'"
+        end
+        l0, l1 = tmp.unpack("NN")
+        len = l0 * 0x1_0000_0000 + l1
+      end
+      if len > 0
+        if h1 & 0x80 != 0
+          key = @sock.read(4)
+          if !key || key.bytesize != 4
+            @reason = CLOSE_PROTOCOL_ERROR
+            raise InternalError, "something wrong: key = '#{key}'"
+          end
+        end
+
+        data = @sock.read(len)
+        if !data || data.bytesize != len
+          @reason = CLOSE_PROTOCOL_ERROR
+          raise InternalError, "something wrong"
+        end
+
+        if h1 & 0x80 != 0
+          data = data.bytes.map.with_index{|b, i| (b ^ (key[i % 4].ord)).chr}.join
+        end
+      end
+
+      op = h0 & 0xF
+
+      if h0 & 0x80 == 0
+        # XXX
+        @reason = CLOSE_TOO_BIG
+        raise InternalError, "fragmented data is not supported yet"
+      end
+
+      case op
+      when OP_CONTINUE, OP_TEXT, OP_BINARY
+        if op == OP_TEXT
+          @type = :text
+        elsif op == OP_BINARY
+          @type = :binary
+        elsif !@type
+          @reason = CLOSE_PROTOCOL_ERROR
+          raise InternalError, "continued data at the first"
+        end
+        if @type == :text
+          data.force_encoding('utf-8')
+          raise InternalError, "invalid encoding" unless data.valid_encoding?
+        end
+        @listener.on_message(self, data, @type) if @listener.respond_to?(:on_message)
+      when OP_CLOSE
+        @reason = CLOSE_OK
+        raise IOError
+      when OP_PING
+        send_frame(OP_PONG, data)
+      when OP_PONG
+        # nothing to do
+      else
+        @reason = CLOSE_PROTOCOL_ERROR
+        raise InternalError, "unknown opcode: 0x%x" % op
+      end
+    end
+  end
+end

data/sample/chat.html

@@ -0,0 +1,47 @@
+<html lang="ja">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<title>chat sample</title>
+<script type="text/javascript"><!--
+var conn;
+
+function escapeHTML(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+function login() {
+  console.log("login");
+  var user = document.getElementById("text").value;
+  if (user != "") {
+    document.getElementById("text").value = "";
+    document.getElementById("send").innerHTML = "send";
+    document.getElementById("send").setAttribute("onclick", "message();");
+
+    conn = new WebSocket("ws://localhost:10080/chat", "chat");
+    conn.onopen = function() {
+      conn.send("\uFEFF" + user);
+    };
+    conn.onerror = function(error) {
+      var elem = document.getElementById("server");
+      elem.innerHTML = "<b>WebSocket error: " + escapeHTML(error) + "</b><br>\n" + elem.innerHTML;
+    };
+    conn.onmessage = function(v) {
+      var elem = document.getElementById("server");
+      elem.innerHTML = escapeHTML(v.data) + "<br>\n" + elem.innerHTML;
+    };
+  }
+}
+
+function message() {
+  console.log("message");
+  conn.send(document.getElementById("text").value);
+  document.getElementById("text").value = "";
+}
+--></script>
+</head>
+<body>
+<input id="text" value=""/><button id="send" onclick="login();">login</button>
+<p id="server">
+</p>
+</body>
+</html>

data/sample/chat.rb

@@ -0,0 +1,60 @@
+#!ruby
+$LOAD_PATH.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
+require "webrick"
+require "webrocket"
+
+# write listner
+class Listener
+  def initialize
+    @clients = []
+    @m = Mutex.new
+  end
+
+  def on_open(websocket)
+    p [:open, websocket]
+    @m.synchronize do
+      @clients.push(websocket)
+    end
+  end
+
+  def on_close(websocket)
+    p [:close, websocket]
+    @m.synchronize do
+      user = websocket.instance_variable_get(:@chat_user)
+      if user
+        @clients.each do |cl|
+          cl.send("logout #{user}", :text)
+        end
+      end
+      @clients.delete(websocket)
+    end
+  end
+
+  def on_message(websocket, data, type)
+    user = websocket.instance_variable_get(:@chat_user)
+    @m.synchronize do
+      @clients.each do |cl|
+        if user
+          cl.send("#{user}: #{data}", :text)
+        else
+          cl.send("login #{data}", :text)
+        end
+      end
+    end
+    unless user
+      websocket.instance_variable_set(:@chat_user, data)
+    end
+  end
+
+  def on_shutdown
+    p [:shutdown]
+    # nothing to do
+  end
+end
+
+server = WEBrick::HTTPServer.new(Port: 10080)
+server.mount_websocket("/chat", Listener.new, "chat")
+trap(:INT) do
+  server.shutdown
+end
+server.start

data/sample/echo.html

@@ -0,0 +1,29 @@
+<html lang="ja">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<script type="text/javascript"><!--
+function escapeHTML(str){
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+var conn = new WebSocket("ws://localhost:10080/echo", "echo");
+conn.onopen = function(){
+  var elem = document.getElementById("server");
+  elem.innerHTML = "<b>connected</b><br>\n" + elem.innerHTML;
+};
+conn.onerror = function(error){
+  var elem = document.getElementById("server");
+  elem.innerHTML = "<b>WebSocket error: " + escapeHTML(error) + "</b><br>\n" + elem.innerHTML;
+};
+conn.onmessage = function(v){
+  var elem = document.getElementById("server");
+  elem.innerHTML = escapeHTML(v.data) + "<br>\n" + elem.innerHTML;
+}
+--></script>
+</head>
+<body>
+<input id="text" value="hello!"/><button onclick="conn.send(document.getElementById('text').value);">send</button>
+<p id="server">
+</p>
+</body>
+</html>

data/sample/echo.rb

@@ -0,0 +1,35 @@
+#!ruby
+$LOAD_PATH.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
+require "webrick"
+require "webrocket"
+
+# write listner
+class Listener
+  def on_open(websocket)
+    # do somthing
+    p :open
+  end
+
+  def on_close(websocket)
+    # do somthing
+    p :close
+  end
+
+  def on_message(websocket, data, type)
+    # do something
+    p [:message, data, type]
+    websocket.send(data, type)
+  end
+
+  def on_shutdown
+    # do something
+    p :shutdown
+  end
+end
+
+server = WEBrick::HTTPServer.new(Port: 10080)
+server.mount_websocket("/echo", Listener.new, "echo")
+trap(:INT) do
+  server.shutdown
+end
+server.start

data/test/test_webrocket.rb

@@ -0,0 +1,115 @@
+require 'base64'
+require 'net/http'
+require 'socket'
+require 'test/unit'
+require 'webrick'
+$LOAD_PATH.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+require 'webrocket'
+
+class TestWEBrocket < Test::Unit::TestCase
+  def start_test_server(&block)
+    logger = Object.new
+    logger.instance_eval do
+      def <<(msg)
+        @log ||= ''
+        @log << msg
+      end
+
+      def log
+        @log ||= ''
+      end
+    end
+
+    server = WEBrick::HTTPServer.new(
+      :BindAddress => "127.0.0.1",
+      :Port => 0,
+      :DocumentRoot => File.dirname(__FILE__),
+      :ShutdownSocketWithoutClose => true,
+      :ServerType => Thread,
+      :Logger => WEBrick::Log.new(logger),
+      :AccessLog => [[logger, ""]]
+    )
+
+    begin
+      th = server.start
+      addr = server.listeners[0].addr
+      block.call(server, addr[3], addr[1], logger)
+    ensure
+      server.shutdown
+      th.join
+    end
+
+    logger.log
+  end
+
+  class Listener
+    def initialize(open = proc{}, close = proc{}, message = proc{}, shutdown = proc{})
+      @open = open
+      @close = close
+      @message = message
+      @shutdown = shutdown
+    end
+
+    def on_open(websocket)
+      @open.call(websocket)
+    end
+
+    def on_close(websocket)
+      @close.call(websocket)
+    end
+
+    def on_message(websocket, data, type)
+      @message.call(websocket, data, type)
+    end
+
+    def on_shutdown
+      @shutdown.call
+    end
+  end
+
+  def test_websocket
+    shutdowned = false # yes, I know shutdown is a noun
+    start_test_server do |server, host, port, logger|
+      http = Net::HTTP.new(host, port)
+
+      req = Net::HTTP::Get.new('/')
+      http.request(req) do |res|
+        assert_kind_of Net::HTTPOK, res.response
+      end
+
+      opened = false
+      open = lambda {|websocket|
+        opened = true
+      }
+      close = lambda {|websocket|
+        opened = false
+      }
+      message = lambda {|websocket, data, type|
+      }
+      shutdown = lambda {
+        shutdowned = true
+      }
+      server.mount_websocket('/test', Listener.new(open, close, message, shutdown), 'test')
+
+      req = Net::HTTP::Get.new('/test')
+      req['Upgrade'] = 'websocket'
+      req['Connection'] = 'Upgrade'
+      req['Sec-WebSocket-Version'] = '13'
+      req['Sec-WebSocket-Key'] = Base64.encode64('0'*16)
+
+      refute opened
+      sock = nil
+      http.request(req) do |res|
+        assert_kind_of Net::HTTPSwitchProtocol, res.response
+        sock = http.instance_variable_get(:@socket).io.dup
+      end
+
+      assert opened
+
+      sock.shutdown
+
+      refute shutdowned
+    end
+    assert shutdowned
+  end
+end

data/webrocket.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'webrocket/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "webrocket"
+  spec.version       = WEBrocket::VERSION
+  spec.authors       = ["U.Nakamura"]
+  spec.email         = ["usa@garbagecollect.jp"]
+  spec.description   = %q{WebSocket extension for WEBrick}
+  spec.summary       = %q{WebSocket extension for WEBrick}
+  spec.homepage      = "https://github.com/unak/WEBRocket"
+  spec.license       = "BSD-2-Clause"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "test-unit"
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: webrocket
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- U.Nakamura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: WebSocket extension for WEBrick
+email:
+- usa@garbagecollect.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/webrocket.rb
+- lib/webrocket/version.rb
+- lib/webrocket/webrick-extender.rb
+- lib/webrocket/websocket.rb
+- sample/chat.html
+- sample/chat.rb
+- sample/echo.html
+- sample/echo.rb
+- test/test_webrocket.rb
+- webrocket.gemspec
+homepage: https://github.com/unak/WEBRocket
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: WebSocket extension for WEBrick
+test_files:
+- test/test_webrocket.rb