async-websocket 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ba6df1f81d1727db806e398e804b402a821f138e46298fe501c49462a68d5fd
-  data.tar.gz: 898bd7a5f9dc2ca60b4d0b4f3ca94a8e5488a18161543002a0cbf5b397d5d7d0
+  metadata.gz: 43a7d40f381a9a3874e3fda412627762d30d2354975e94b6550bda29f75fd26d
+  data.tar.gz: 197f5ba2209b7bcc8d2eec2e600265ca1b5e59b264967a64da7f416761b9c6a4
 SHA512:
-  metadata.gz: bc6798196531c1994e077f41c090851c7e3de09347672f26fd913a5a4e6ebf97986d3113d0caa4a49de56060104ebbbe4528854fa77b4dfcf6d72a5d1d27a6be
-  data.tar.gz: 29693d7fe7ae34a21a5105d4231512181f611bfd51ff25e7a66b2feba53a309aee952bc5e6bf9d95b9d01a51ecc83b873275911a096786032dd6e090a170e637
+  metadata.gz: 26a221435af1324568f92f7ab2317c16add07196a8eeca36108d226cfccf79cc5f8ad264c3a22b41cf245725e3bb20c148b37e3d71b644bd8ea4ff1373e149e0
+  data.tar.gz: 982f6ca5dce50b3e230850d298f23cf1410c7c084a503ca52da60b6edcde2efc0f2e9143a500a165de482b72fb32cdfd1b6c71434e44be07b36c6669001195e1

data/README.md

@@ -24,7 +24,8 @@ Or install it yourself as:
 
 There are [examples](examples/) which include:
 
-- [A command line chat client and application server](examples/chat/client.rb) which can read input from `stdin` and send messages to the server.
+- [A command line chat client/server](examples/chat) which can read input from `stdin` and send messages to the server.
+- [A small MUD client/server](examples/mud) which uses JSON for communation between client/server.
 - [A utopia-based web application](examples/utopia) which uses a JavaScript client to connect to a web application server.
 
 ### Client Side with Async
@@ -38,23 +39,33 @@ require 'async/http/url_endpoint'
 require 'async/websocket/client'
 
 USER = ARGV.pop || "anonymous"
-URL = ARGV.pop || "ws://localhost:9292"
+URL = ARGV.pop || "http://localhost:7070"
 
 Async do |task|
+	stdin = Async::IO::Stream.new(
+		Async::IO::Generic.new($stdin)
+	)
+	
 	endpoint = Async::HTTP::URLEndpoint.parse(URL)
-	headers = {'token' => 'wubalubadubdub'}
 	
-	endpoint.connect do |socket|
-		connection = Async::WebSocket::Client.new(socket, URL, headers)
+	Async::WebSocket::Client.open(endpoint) do |connection|
+		input_task = task.async do
+			while line = stdin.read_until("\n")
+				connection.write({user: USER, text: line})
+				connection.flush
+			end
+		end
 		
-		connection.send_message({
+		connection.write({
 			user: USER,
 			status: "connected",
 		})
 		
-		while message = connection.next_message
+		while message = connection.read
 			puts message.inspect
 		end
+	ensure
+		input_task&.stop
 	end
 end
 ```
@@ -62,26 +73,26 @@ end
 ### Server Side with Rack & Falcon
 
 ```ruby
-#!/usr/bin/env falcon serve --concurrency 1 -c
+#!/usr/bin/env -S falcon serve --bind http://localhost:7070 --count 1 -c
 
-require 'async/websocket/server'
+require 'async/websocket/server/rack'
+require 'set'
 
-$connections = []
+$connections = Set.new
 
 run lambda {|env|
-	# Options for websocket-driver-ruby can be passed as second argument to open
-	# Supported options here: https://github.com/faye/websocket-driver-ruby#driver-api
-	Async::WebSocket::Server.open(env, protocols: ['ws']) do |connection|
+	Async::WebSocket::Server::Rack.open(env, protocols: ['ws']) do |connection|
 		$connections << connection
 		
-		while message = connection.next_message
+		while message = connection.read
 			$connections.each do |connection|
-				connection.send_message(message)
+				connection.write(message)
+				connection.flush
 			end
 		end
-	end
-	
-	[200, {}, ["Hello World"]]
+	ensure
+		$connections.delete(connection)
+	end or [200, {}, ["Hello World"]]
 }
 ```
 

data/async-websocket.gemspec

@@ -16,8 +16,8 @@ Gem::Specification.new do |spec|
 	spec.require_paths = ["lib"]
 	
 	spec.add_dependency "async-io", "~> 1.23"
-	spec.add_dependency "protocol-http1", "~> 0.1"
-	spec.add_dependency "protocol-websocket", "~> 0.3"
+	spec.add_dependency "protocol-http1", "~> 0.4"
+	spec.add_dependency "protocol-websocket", "~> 0.5.0"
 	
 	spec.add_development_dependency "async-rspec"
 	spec.add_development_dependency "falcon", "~> 0.30"

data/examples/chat/client.rb

@@ -17,13 +17,13 @@ Async do |task|
 	Async::WebSocket::Client.open(ENDPOINT) do |connection|
 		input_task = task.async do
 			while line = stdin.read_until("\n")
-				connection.send_message({text: line})
+				connection.write({text: line})
 				connection.flush
 			end
 		end
 		
 		puts "Connected..."
-		while message = connection.next_message
+		while message = connection.read
 			puts "> #{message.inspect}"
 		end
 	ensure

data/examples/chat/config.ru

@@ -70,7 +70,8 @@ class Room
 		
 		@connections.each do |connection|
 			@semaphore.async do
-				connection.send_message(message)
+				connection.write(message)
+				connection.flush
 			end
 		end
 		
@@ -81,18 +82,18 @@ class Room
 	def open(connection)
 		self.connect(connection)
 		
-		while message = connection.next_message
-			if message["text"] =~ /^\/(.*?)$/
+		while message = connection.read
+			if message[:text] =~ /^\/(.*?)$/
 				begin
 					result = self.command($1)
 					
 					if result.is_a? Hash
-						connection.send_message(result)
+						connection.write(result)
 					else
-						connection.send_message({result: result.inspect})
+						connection.write({result: result.inspect})
 					end
 				rescue
-					connection.send_message({error: $!.inspect})
+					connection.write({error: $!.inspect})
 				end
 			else
 				self.broadcast(message)

data/examples/chat/multi-client.rb

@@ -45,9 +45,9 @@ class Command < Samovar::Command
 			task.async do |subtask|
 				while connection = connections.dequeue
 					subtask.async(connection) do |subtask, connection|
-						pp connection.next_message
+						pp connection.read
 						
-						while message = connection.next_message
+						while message = connection.read
 							pp message
 						end
 					ensure

data/examples/mud/client.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'async'
+require 'async/io/stream'
+require 'async/http/url_endpoint'
+require 'async/websocket/client'
+
+USER = ARGV.pop || "anonymous"
+URL = ARGV.pop || "http://127.0.0.1:7070"
+
+Async do |task|
+	stdin = Async::IO::Stream.new(
+		Async::IO::Generic.new($stdin)
+	)
+	
+	endpoint = Async::HTTP::URLEndpoint.parse(URL)
+	
+	Async::WebSocket::Client.open(endpoint) do |connection|
+		task.async do
+			$stdout.write "> "
+			
+			while line = stdin.read_until("\n")
+				connection.write({input: line})
+				connection.flush
+				
+				$stdout.write "> "
+			end
+		end
+		
+		while message = connection.read
+			$stdout.puts message
+		end
+	end
+end

data/examples/mud/config.ru

@@ -0,0 +1,142 @@
+#!/usr/bin/env falcon serve --count 1 --bind http://127.0.0.1:7070 -c
+
+require 'async/websocket/server/rack'
+
+class Room
+	def initialize(name, description = nil)
+		@name = name
+		@description = description
+		
+		@actions = {}
+		@users = []
+	end
+	
+	attr :name
+	attr :description
+	
+	attr :actions
+	
+	def connect(key, room)
+		@actions[key] = lambda do |user|
+			self.exit(user)
+			room.enter(user)
+		end
+		
+		return room
+	end
+	
+	def broadcast(message)
+		@users.each do |user|
+			user.write(message)
+			user.flush
+		end
+	end
+	
+	def enter(user)
+		user.notify("You have entered the #{@name}.")
+		user.room = self
+		
+		@users << user
+		
+		@users.each do |user|
+			user.notify("#{user.name} entered the room.")
+		end
+	end
+	
+	def exit(user)
+		if @users.delete(user)
+			@users.each do |user|
+				user.notify("#{user.name} left the room.")
+			end
+		end
+	end
+	
+	def as_json
+		{
+			name: @name,
+			description: @description,
+			actions: @actions.keys,
+		}
+	end
+end
+
+module Command
+	def self.split(line)
+		line.scan(/(?:"")|(?:"(.*[^\\])")|(\w+)/).flatten.compact
+	end
+end
+
+class User < Async::WebSocket::Connection
+	def initialize(*)
+		super
+		
+		@name = name
+		@room = nil
+		@inventory = []
+	end
+	
+	attr_accessor :room
+	
+	ANONYMOUS = "Anonymous"
+	
+	def name
+		@name || ANONYMOUS
+	end
+	
+	def handle(message)
+		key, *arguments = Command.split(message[:input])
+		case key
+		when "name"
+			@name = arguments.first
+		when "look"
+			self.write({room: @room.as_json})
+		else
+			if action = @room.actions[key]
+				action.call(self, *arguments)
+			else
+				message[:user]
+				@room.broadcast(message)
+			end
+		end
+	end
+	
+	def notify(text)
+		self.write({notify: text})
+		self.flush
+	end
+	
+	def close
+		if @room
+			@room.exit(self)
+		end
+		
+		super
+	end
+end
+
+class Server
+	def initialize(app)
+		@app = app
+		
+		@entrance = Room.new("Portal", "A vast entrance foyer with a flowing portal.")
+		@entrance.connect("forward", Room.new("Training Room"))
+		@entrance.connect("corridor", Room.new("Shop"))
+	end
+	
+	def call(env)
+		Async::WebSocket::Server::Rack.open(env, connect: User) do |user|
+			@entrance.enter(user)
+			
+			while message = user.read
+				user.handle(message)
+			end
+		ensure
+			# Async.logger.error(self, $!) if $!
+			user.close
+		end or @app.call(env)
+	end
+end
+
+use Server
+
+run lambda {|env| [200, {}, []]}

data/examples/utopia/pages/server/controller.rb

@@ -6,16 +6,14 @@ require 'async/websocket/server'
 $connections = []
 
 on 'connect' do |request|
-	Async::WebSocket::Server.open(request.env) do |connection|
+	respond? Async::WebSocket::Server::Rack.open(request.env) do |connection|
 		$connections << connection
 		
-		while message = connection.next_message
+		while message = connection.read
 			$connections.each do |connection|
 				puts "Server sending message: #{message.inspect}"
-				connection.send_message(message)
+				connection.write(message)
 			end
 		end
 	end
-	
-	succeed!
 end

data/examples/utopia/spec/website_spec.rb

@@ -27,8 +27,8 @@ RSpec.describe "my website" do
 		
 		let(:hello_message) do
 			{
-				"user" => "test",
-				"text" => "Hello World",
+				user: "test",
+				text: "Hello World",
 			}
 		end
 		
@@ -46,9 +46,9 @@ RSpec.describe "my website" do
 			endpoint.connect do |socket|
 				connection = Async::WebSocket::Client.new(socket, "ws://localhost/server/connect")
 				
-				connection.send_message(hello_message)
+				connection.write(hello_message)
 				
-				message = connection.next_message
+				message = connection.read
 				expect(message).to be == hello_message
 			end
 		end

data/lib/async/websocket/client.rb

@@ -23,6 +23,8 @@
 require 'protocol/http1/connection'
 require 'protocol/websocket/digest'
 
+require 'securerandom'
+
 require_relative 'connection'
 require_relative 'error'
 
@@ -40,22 +42,30 @@ module Async
 			end
 			
 			# @option protocols [Array] a list of supported sub-protocols to negotiate with the server.
-			def initialize(endpoint, headers: [], protocols: [], version: 13, key: SecureRandom.base64(16))
+			def initialize(endpoint, headers: [], protocols: [], version: 13, key: SecureRandom.base64(16), connect: Connection)
 				@endpoint = endpoint
 				@version = version
 				@headers = headers
 				
 				@protocols = protocols
-				
 				@key = key
+				
+				@connect = connect
+			end
+			
+			def mask
+				# Mask is only required on insecure connections, because of bad proxy implementations.
+				unless @endpoint.secure?
+					SecureRandom.bytes(4)
+				end
 			end
 			
 			attr :headers
 			
 			def connect
-				peer = @endpoint.connect
+				stream = IO::Stream.new(@endpoint.connect)
 				
-				return ::Protocol::HTTP1::Connection.new(IO::Stream.new(peer), false)
+				return ::Protocol::HTTP1::Connection.new(stream, false)
 			end
 			
 			def request_headers
@@ -82,7 +92,7 @@ module Async
 				
 				framer = Protocol::WebSocket::Framer.new(stream)
 				
-				return Connection.new(framer, protocol)
+				return @connect.call(framer, protocol, mask: self.mask)
 			end
 			
 			def call(method, path)

data/lib/async/websocket/connection.rb

@@ -21,7 +21,6 @@
 require 'protocol/websocket/connection'
 
 require 'json'
-require 'securerandom'
 
 module Async
 	module WebSocket
@@ -29,30 +28,31 @@ module Async
 		
 		# This is a basic synchronous websocket client:
 		class Connection < ::Protocol::WebSocket::Connection
-			def initialize(framer, protocol, mask: SecureRandom.bytes(4), format: JSON)
-				super(framer)
-				
+			def self.call(framer, protocol = nil, **options)
+				self.new(framer, protocol, **options)
+			end
+			
+			def initialize(framer, protocol = nil, **options)
+				super(framer, **options)
 				@protocol = protocol
-				@mask = mask
-				@format = format
 			end
 			
 			attr :protocol
 			
-			def next_message
-				if frames = super
-					if frames.first.is_a? Protocol::WebSocket::TextFrame
-						buffer = frames.collect(&:unpack).join
-						
-						return @format.load(buffer)
-					else
-						return frames
-					end
-				end
+			def read
+				parse(super)
+			end
+			
+			def write(object)
+				super(dump(object))
+			end
+			
+			def parse(buffer)
+				JSON.parse(buffer, symbolize_names: true)
 			end
 			
-			def send_message(data)
-				send_text(@format.dump(data))
+			def dump(object)
+				JSON.dump(object)
 			end
 		end
 	end

data/lib/async/websocket/server/rack.rb

@@ -28,26 +28,34 @@ module Async
 	module WebSocket
 		module Server
 			class Rack
+				def self.websocket?(env)
+					env['HTTP_UPGRADE'] == "websocket"
+				end
+				
 				def self.open(env, **options, &block)
+					# Is hijack supported:
 					return nil unless env['rack.hijack?']
 					
-					connection = self.new(env, **options)
+					return nil unless websocket?(env)
+					
+					server = self.new(env, **options)
 					
-					if connection.supported?
-						return connection.response(&block)
+					if server.supported?
+						return server.response(&block)
 					else
 						return nil
 					end
 				end
 				
-				def initialize(env, supported_protocols: [], **options)
-					scheme = env['rack.url_scheme'] == 'https' ? 'wss' : 'ws'
-					@url = "#{scheme}://#{env['HTTP_HOST']}#{env['REQUEST_URI']}"
-					
+				def initialize(env, supported_protocols: [], connect: Connection)
+					# scheme = env['rack.url_scheme'] == 'https' ? 'wss' : 'ws'
+					# @url = "#{scheme}://#{env['HTTP_HOST']}#{env['REQUEST_URI']}"
 					@key = env['HTTP_SEC_WEBSOCKET_KEY']
 					@version = Integer(env['HTTP_SEC_WEBSOCKET_VERSION'])
 					
 					@protocol = negotiate_protocol(env, supported_protocols)
+					
+					@connect = connect
 				end
 				
 				def negotiate_protocol(env, supported_protocols)
@@ -65,7 +73,7 @@ module Async
 				def make_connection(stream)
 					framer = Protocol::WebSocket::Framer.new(stream)
 					
-					Connection.new(framer, @protocol)
+					return @connect.call(framer, @protocol)
 				end
 				
 				def response_headers

data/lib/async/websocket/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module WebSocket
-		VERSION = "0.9.0"
+		VERSION = "0.10.0"
 	end
 end

data/spec/async/websocket/connection_spec.rb

@@ -18,52 +18,17 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'async/websocket'
-require 'async/websocket/client'
+require 'async/websocket/connection'
 
-require 'rack/test'
-require 'falcon/server'
-require 'falcon/adapters/rack'
-require 'async/http/url_endpoint'
-
-RSpec.describe Async::WebSocket::Connection, timeout: nil do
-	include_context Async::RSpec::Reactor
+RSpec.describe Async::WebSocket::Connection do
+	let(:framer) {double}
+	subject {described_class.new(framer)}
 	
-	let(:server_address) {Async::HTTP::URLEndpoint.parse("http://localhost:9000")}
-	let(:app) {Rack::Builder.parse_file(File.expand_path('../connection_spec.ru', __FILE__)).first}
-	let(:server) {Falcon::Server.new(Falcon::Server.middleware(app, verbose: true), server_address)}
-
-	it "should connect to the websocket server" do
-		server_task = reactor.async do
-			server.run
-		end
-		
-		events = []
-		
-		Async::WebSocket::Client.open(server_address) do |connection|
-			while event = connection.next_message
-				expect(event).to include("line")
-				
-				events << event
-			end
-			
-			connection.close # optional
-		end
-		
-		expect(events.size).to be > 0
-		
-		server_task.stop
-	end
-
-	it "should negotiate protocol" do
-		server_task = reactor.async do
-			server.run
-		end
-		
-		Async::WebSocket::Client.open(server_address, protocols: ['ws']) do |connection|
-			expect(connection.protocol).to be == 'ws'
+	it "should use mask if specified" do
+		expect(framer).to receive(:write_frame) do |frame|
+			expect(frame.mask).to be == subject.mask
 		end
 		
-		server_task.stop
+		subject.write({text: "Hello World"})
 	end
 end

data/spec/async/websocket/server/rack/client.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'async'
+require 'async/io/stream'
+require 'async/http/url_endpoint'
+require 'async/websocket/client'
+
+USER = ARGV.pop || "anonymous"
+URL = ARGV.pop || "http://localhost:7070"
+
+Async do |task|
+	stdin = Async::IO::Stream.new(
+		Async::IO::Generic.new($stdin)
+	)
+	
+	endpoint = Async::HTTP::URLEndpoint.parse(URL)
+	headers = {'token' => 'wubalubadubdub'}
+	
+	Async::WebSocket::Client.open(endpoint, headers: headers) do |connection|
+		input_task = task.async do
+			while line = stdin.read_until("\n")
+				connection.write({user: USER, text: line})
+				connection.flush
+			end
+		end
+		
+		connection.write({
+			user: USER,
+			status: "connected",
+		})
+		
+		while message = connection.read
+			puts message.inspect
+		end
+	ensure
+		input_task&.stop
+	end
+end

data/spec/async/websocket/server/rack/config.ru

@@ -0,0 +1,23 @@
+#!/usr/bin/env -S falcon serve --bind http://localhost:7070 --count 1 -c
+
+require 'async/websocket/server/rack'
+require 'set'
+
+$connections = Set.new
+
+run lambda {|env|
+	Async::WebSocket::Server::Rack.open(env, supported_protocols: ['ws']) do |connection|
+		$connections << connection
+		
+		begin
+			while message = connection.read
+				$connections.each do |connection|
+					connection.write(message)
+					connection.flush
+				end
+			end
+		ensure
+			$connections.delete(connection)
+		end
+	end or [200, {}, ["Hello World"]]
+}

data/spec/async/websocket/server/rack_spec.rb

@@ -0,0 +1,83 @@
+# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+require 'async/websocket'
+require 'async/websocket/client'
+require 'async/websocket/server/rack'
+
+require 'rack/test'
+require 'falcon/server'
+require 'falcon/adapters/rack'
+require 'async/http/url_endpoint'
+
+RSpec.describe Async::WebSocket::Server::Rack do
+	include_context Async::RSpec::Reactor
+	
+	let(:server_address) {Async::HTTP::URLEndpoint.parse("http://localhost:7050")}
+	let(:app) {Rack::Builder.parse_file(File.expand_path('rack/config.ru', __dir__)).first}
+	let(:server) {Falcon::Server.new(Falcon::Server.middleware(app), server_address)}
+	let(:client) {Async::HTTP::Client.new(server_address)}
+	
+	let!(:server_task) do
+		reactor.async do
+			server.run
+		end
+	end
+	
+	after do
+		server_task.stop
+	end
+	
+	it "can make non-websocket connection to server" do
+		response = client.get("/")
+		expect(response).to be_success
+		expect(response.read).to be == "Hello World"
+		
+		client.close
+	end
+	
+	let(:message) do
+		{text: "Hello World"}
+	end
+	
+	it "can make websocket connection to server" do
+		Async::WebSocket::Client.open(server_address) do |connection|
+			connection.write(message)
+			
+			expect(connection.read).to be == message
+			
+			connection.close
+		end
+	end
+	
+	it "should use mask over insecure connection" do
+		expect(server_address).to_not be_secure
+		
+		Async::WebSocket::Client.open(server_address) do |connection|
+			expect(connection.mask).to_not be_nil
+		end
+	end
+	
+	it "should negotiate protocol" do
+		Async::WebSocket::Client.open(server_address, protocols: ['ws']) do |connection|
+			expect(connection.protocol).to be == 'ws'
+		end
+	end
+end

data/spec/async/websocket/upgrade.rb

@@ -33,7 +33,7 @@ class Upgrade
 			write.close
 			
 			read.each_line do |line|
-				connection.send_message({line: line})
+				connection.write({line: line})
 			end
 			
 			# Gracefully close the connection:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-websocket
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-10 00:00:00.000000000 Z
+date: 2019-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-io
@@ -30,28 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: protocol-websocket
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -154,8 +154,8 @@ files:
 - examples/chat/client.rb
 - examples/chat/config.ru
 - examples/chat/multi-client.rb
-- examples/middleware/client.rb
-- examples/middleware/config.ru
+- examples/mud/client.rb
+- examples/mud/config.ru
 - examples/utopia/.bowerrc
 - examples/utopia/.gitignore
 - examples/utopia/.rspec
@@ -170,7 +170,6 @@ files:
 - examples/utopia/pages/_heading.xnode
 - examples/utopia/pages/_page.xnode
 - examples/utopia/pages/client/client.js
-- examples/utopia/pages/client/controller.rb
 - examples/utopia/pages/client/index.xnode
 - examples/utopia/pages/errors/exception.xnode
 - examples/utopia/pages/errors/file-not-found.xnode
@@ -199,7 +198,9 @@ files:
 - lib/async/websocket/version.rb
 - spec/async/websocket/client_spec.rb
 - spec/async/websocket/connection_spec.rb
-- spec/async/websocket/connection_spec.ru
+- spec/async/websocket/server/rack/client.rb
+- spec/async/websocket/server/rack/config.ru
+- spec/async/websocket/server/rack_spec.rb
 - spec/async/websocket/upgrade.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -228,6 +229,8 @@ summary: An async websocket library on top of websocket-driver.
 test_files:
 - spec/async/websocket/client_spec.rb
 - spec/async/websocket/connection_spec.rb
-- spec/async/websocket/connection_spec.ru
+- spec/async/websocket/server/rack/client.rb
+- spec/async/websocket/server/rack/config.ru
+- spec/async/websocket/server/rack_spec.rb
 - spec/async/websocket/upgrade.rb
 - spec/spec_helper.rb

data/examples/middleware/client.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'async'
-require 'async/io/stream'
-require 'async/http/url_endpoint'
-require 'async/websocket/client'
-
-USER = ARGV.pop || "anonymous"
-URL = ARGV.pop || "ws://localhost:9292"
-
-Async do |task|
-	stdin = Async::IO::Stream.new(
-		Async::IO::Generic.new($stdin)
-	)
-	
-	endpoint = Async::HTTP::URLEndpoint.parse(URL)
-	
-	endpoint.with(local_address: local_address).connect do |socket|
-		connection = Async::WebSocket::Client.new(socket, URL)
-		
-		connection.send_message({
-			user: USER,
-			status: "connected",
-		})
-		
-		task.async do
-			puts "Waiting for input..."
-			begin
-				while line = stdin.read_until("\n")
-					puts "Sending text: #{line}"
-					connection.send_message({
-						user: USER,
-						text: line,
-					})
-				end
-			rescue
-				puts "Client error: #{$!}"
-			end
-		end
-		
-		while message = connection.next_message
-			puts "From server: #{message.inspect}"
-		end
-	end
-end

data/examples/middleware/config.ru

@@ -1,77 +0,0 @@
-#!/usr/bin/env falcon --verbose serve --concurrency 1 -c
-
-require 'async/websocket/server'
-
-Async.logger.level = Logger::DEBUG
-
-class RackUpgrade
-	def initialize(app)
-		@app = app
-	end
-	
-	def call(env)
-		if ::WebSocket::Driver.websocket?(env)
-			env['rack.upgrade?'] = :websocket
-			
-			response = @app.call(env)
-			
-			if handler = env['rack.upgrade']
-				Async::WebSocket::Server.open(env) do |connection|
-					begin
-						while event = connection.next_event
-							if event.is_a? ::WebSocket::Driver::OpenEvent
-								handler.on_open(connection) if handler.respond_to? :on_open
-							elsif event.is_a? ::WebSocket::Driver::MessageEvent
-								handler.on_message(connection, JSON.parse(event.data))
-							elsif event.is_a? ::WebSocket::Driver::CloseEvent
-								handler.on_close(connection) if handler.respond_to? :on_close
-							end
-						end
-					ensure
-						handler.on_shutdown(connection) if handler.respond_to? :on_shutdown
-					end
-				end
-			end
-		else
-			return @app.call(env)
-		end
-	end
-end
-
-class Chatty
-	def initialize
-		@connections = Set.new
-	end
-	
-	def on_open(connection)
-		Async.logger.info(self) {"on_open: #{connection}"}
-		@connections << connection
-	end
-	
-	def on_message(connection, message)
-		Async.logger.info(self) {"on_message: #{connection} -> #{message}"}
-		
-		@connections.each do |connection|
-			connection.send_message(message)
-		end
-	end
-	
-	def on_shutdown(connection)
-		Async.logger.info(self) {"on_shutdown: #{connection}"}
-		@connections.delete(connection)
-		
-		@connections.each do |connection|
-			connection.send_message(message)
-		end
-	end
-end
-
-use RackUpgrade
-
-CHATTY = Chatty.new
-
-run lambda {|env|
-	env['rack.upgrade'] = CHATTY
-	
-	return [200, {}, []]
-}

data/spec/async/websocket/connection_spec.ru

@@ -1,25 +0,0 @@
-# Copyright, 2019, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# 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.
-
-require_relative 'upgrade'
-
-use Upgrade
-
-run lambda {|env| [404, {}, []]}