plezi 0.10.12 → 0.10.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 160e5060bd9cf3f8ec6acf8caa7d672ae238f3c7
-  data.tar.gz: d2816045210ac66cec18b0c5f37060a9ec5ae271
+  metadata.gz: 7f37f01622fbcda6cf86ca9575aafb2145b5479f
+  data.tar.gz: cbdf67890ad9995b11d058cbe821c62fad863995
 SHA512:
-  metadata.gz: 59691c8ce5b334a0e1b7223aaeb4e0ae74f5f800e24e803e8ad6e8aeb9492f299c71c50c46ca740a8a1940c7c50e4a28f332365ff40853b9221864cb8e3b2769
-  data.tar.gz: f738389e77c3bdc471e6000db4bfd83f8cbb0133814074c0ba4cbc69c5ecae229a18904f5cd3a8ca32253c7266637563c356cda8ca1cb1f2db4936c09d1a3c15
+  metadata.gz: f940d9e1731e9708228c8519a3be967762c427db4d3644aac6ceb439db8a9e44ac1de7bdfd4d3e998039f70452e1e2ffe02dc4ab444c4445793a017c1c02b432
+  data.tar.gz: 9a336108299a74946dd97b6718f2440f80df3d5ec6dc33a925c35e5f82eb0d15c21571bbdd6a79c7c1b3cbfafd7ee79a89b3b449773e467018667a21948be1c0

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 #Change Log
 
+Change log v.0.10.13
+
+**Fix**: The Placebo API was tested and an issue with the new Placebo class broadcast method was fixed.
+
+**Update**: Websocket code refactoring unified Placebo and Controller's API and bahavior.
+
+**Update**: Unicasting performance using Redis was improved by creating a different Redis channel for each process, so that the unicast is only sent to the process containing the receiver.
+
+this should mean that apps using unicasting can scale freely while apps using broadcasting need to address boradcasting considirations (broadcasting causes ALL the websocket connections - in ALL processes - to answer a broadcast, which raises scaling considirations).
+
+***
+
+Change log v.0.10.12
+
+**Placebo API**: The Placebo API was reviews and revamped slightly, to allow you a better experience and better error feedback.
+
+**Template**: The template's error pages were restyled with Plezi's new color scheme.
+
 ***
 
 Change log v.0.10.12

data/README.md

@@ -4,11 +4,15 @@
 
 Plezi is an easy to use Ruby Websocket Framework, with full RESTful routing support and HTTP streaming support. It's name comes from the word "fun", or "pleasure", since Plezi is a pleasure to work with.
 
-I Believe that Plezi is a wonderful backend solution for developing SPAs, both with it's real-time native Websocket API and with it's RESTful routes that work great for writing easy AJAX requests.
+With Plezi, you can easily:
 
-Plezi can both provide a wonderful alternative to existing complex platforms (i.e. Rails/Sinatra/Faye/EM) and augment an existing Rails/Sinatra app, by providing it with easy Websocket and Asynchronous Events support. It's also great as an alternative to socket.io, allowing for both websockets and long pulling.
+1. Add Websocket services and RESTful HTTP Streaming to your existing Web-App, (Rails/Sinatra or any other Rack based Ruby app).
 
-Plezi runs over the [GRHttp server](https://github.com/boazsegev/GRHttp), which is a pure Ruby HTTP and Websocket Generic Server build using [GReactor](https://github.com/boazsegev/GReactor) - a multi-threaded pure ruby alternative to EventMachine with basic process forking support (enjoy it, if your code is scaling ready).
+2. Create an easily scalable backend for your SPA.
+
+3. Create a full fledged Ruby web application, taking full advantage of RESTful routing, HTTP streaming and scalable Websocket features.
+
+Plezi leverages [GRHttp server](https://github.com/boazsegev/GRHttp)'s new architecture. GRHttp is a pure Ruby HTTP and Websocket Generic Server built using [GReactor](https://github.com/boazsegev/GReactor) - a multi-threaded pure ruby alternative to EventMachine with basic process forking support (enjoy forking, if your code is scaling ready).
 
 ## Installation
 
@@ -43,21 +47,11 @@ the default first port for the app is 3000. you can set the first port to listen
 
 you now have a smart framework app that will happily assimilate any gem you feed it. it responds extra well to Haml, Sass and Coffee-Script, which you can enable in it's Gemfile.
 
-## Barebones Web Service
-
-This example is basic, useless, but required for every doc out there...
-
-"Hello World!" in 3 lines - try it in irb (exit irb to start server):
-
-		require 'plezi'
-		listen
-		route(/.?/) { |req, res| res << "Hello World!" }
-
-After you exit irb, the Plezi server will start up. Go to http://localhost:3000/ and see it run :)
-
 ## Plezi Controller classes
 
-One of the best things about the Plezi is it's ability to take in any class as a controller class and route to the classes methods with special support for RESTful methods (`index`, `show`, `new`, `save`, `update`, `delete`, `before` and `after`) and for WebSockets (`pre_connect`, `on_open`, `on_message(data)`, `on_close`, `broadcast`, `unicast`, `on_broadcast(data)`):
+One of the best things about the Plezi is it's ability to take in any class as a controller class and route to the classes methods with special support for RESTful methods (`index`, `show`, `new`, `save`, `update`, `delete`, `before` and `after`) and for WebSockets (`pre_connect`, `on_open`, `on_message(data)`, `on_close`, `broadcast`, `unicast`, `multicast`, `on_broadcast(data)`).
+
+Here is a Hello World using a Controller class (run in `irb`):
 
         require 'plezi'
 
@@ -70,11 +64,13 @@ One of the best things about the Plezi is it's ability to take in any class as a
         listen
         route '*' , Controller
 
-Except for WebSockets, returning a String will automatically add the string to the response before sending the response - which makes for cleaner code. It's also possible to send the response as it is (by returning true).
+        exit # Plezi will autostart once you exit irb.
+
+Except while using WebSockets, returning a String will automatically add the string to the response before sending the response - which makes for cleaner code. It's also possible to use the `response` object to set the response or stream HTTP (return true instead of a stream when you're done).
 
-Controllers can even be nested (order matters) or have advanced uses that are definitly worth exploring.
+It's also possible to define a number of controllers for a similar route. The controllers will answer in the order in which the routes are defined (this allows to group code by logic instead of url).
 
-\* please read the demo code for Plezi::StubRESTCtrl and Plezi::StubWSCtrl to learn more. Also, read more about the [GRHttp server](GRHttp websocket and HTTP server) at the core of Plezi to get more information about the amazing [HTTPRequest](http://www.rubydoc.info/gems/grhttp/0.0.6/GRHttp/HTTPRequest) and [HTTPResponse](http://www.rubydoc.info/gems/grhttp/GRHttp/HTTPResponse) objects.
+\* please read the demo code for Plezi::StubRESTCtrl and Plezi::StubWSCtrl to learn more. Also, read more about the [GRHttp Websocket and HTTP server](https://github.com/boazsegev/GRHttp) at the core of Plezi to get more information about the amazing [HTTPRequest](http://www.rubydoc.info/github/boazsegev/GRHttp/master/GRHttp/HTTPRequest) and [HTTPResponse](http://www.rubydoc.info/github/boazsegev/GRHttp/master/GRHttp/HTTPResponse) objects.
 
 ## Native Websocket and Redis support
 

data/lib/plezi.rb

@@ -45,6 +45,7 @@ require 'plezi/helpers/mime_types.rb'
 ### HTTP and WebSocket Handlers
 require 'plezi/handlers/http_router.rb'
 require 'plezi/handlers/route.rb'
+require 'plezi/handlers/ws_object.rb'
 require 'plezi/handlers/controller_magic.rb'
 require 'plezi/handlers/controller_core.rb'
 require 'plezi/handlers/placebo.rb'

data/lib/plezi/common/api.rb

@@ -10,9 +10,9 @@ module Plezi
 	# port:: port number. defaults to 3000 or the port specified when the script was called.
 	# host:: the host name. defaults to any host not explicitly defined (a catch-all). NOTICE: in order to allow for hostname aliases, this is host emulation and the listening socket will bind to all the addresses available. To limit the actual binding use the `:bind` parameter as set by the GReactor's API - in which case host aliases might not work.
 	# alias:: a String or an Array of Strings which represent alternative host names (i.e. `alias: ["admin.google.com", "admin.gmail.com"]`).
-	# root:: the public root folder. if this is defined, static files will be served from the location.
+	# public:: the public root folder. if this is defined, static files will be served from this folder and all it's sub-folders. Plezi does NOT support file indexing.
 	# assets:: the assets root folder. defaults to nil (no assets support). if the path is defined, assets will be served from `/assets/...` (or the public_asset path defined) before any static files. assets will not be served if the file in the /public/assets folder if up to date (a rendering attempt will be made for systems that allow file writing).
-	# assets_public:: the assets public uri location (uri format, NOT a file path). defaults to `/assets`. assets will be saved (or rendered) to the assets public folder and served as static files.
+	# assets_public:: the assets public uri location (uri format, NOT a file path). defaults to `/assets`. `save_assets` will set if assets should be saved to the assets public folder as static files (defaults to false).
 	# assets_callback:: a method that accepts two parameters: (request, response) and renders any custom assets. the method should return `false` unless it had set the response.
 	# save_assets:: saves the rendered assets to the filesystem, under the public folder. defaults to false.
 	# templates:: the templates root folder. defaults to nil (no template support). templates can be rendered by a Controller class, using the `render` method.
@@ -20,14 +20,16 @@ module Plezi
 	# ssl_key:: the public key for the SSL service.
 	# ssl_cert:: the certificate for the SSL service.
 	#
-	# assets:
+	# Assets:
 	#
-	# assets support will render `.sass`, `.scss` and `.coffee` and save them as local files (`.css`, `.css`, and `.js` respectively)
+	# Assets support will render `.sass`, `.scss` and `.coffee` and save them as local files (`.css`, `.css`, and `.js` respectively)
 	# before sending them as static files.
 	#
+	# Should you need to render a different type of asset, you can define an assets_callback (or submit a pull request with a patch). 
+	# 
 	# templates:
 	#
-	# ERB, Slim and Haml are natively supported. Otherwise define an assets_callback (or submit a pull request with a patch). 
+	# Plezi's controller.render ERB, Slim and Haml are natively supported.
 	#
 	# @returns [Plezi::Router]
 	#
@@ -36,6 +38,8 @@ module Plezi
 		parameters[:index_file] ||= 'index.html'
 		parameters[:assets_public] ||= '/assets'
 		parameters[:assets_public].chomp! '/'
+		parameters[:public] ||= parameters[:root] # backwards compatability
+		puts "Warning: 'root' option is being depracated. use 'public' instead." if parameters[:root]
 
 		# check if the port is used twice.
 		@routers_locker.synchronize do

data/lib/plezi/common/redis.rb

@@ -21,7 +21,7 @@ module Plezi
 			raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless @redis
 			@redis_sub_thread = Thread.new do
 				begin
-				Redis.new(host: @redis_uri.host, port: @redis_uri.port, password: @redis_uri.password).subscribe(Plezi::Settings.redis_channel_name) do |on|
+				Redis.new(host: @redis_uri.host, port: @redis_uri.port, password: @redis_uri.password).subscribe(Plezi::Settings.redis_channel_name, Plezi::Settings.uuid) do |on|
 						on.message do |channel, msg|
 							begin
 								data = YAML.load(msg)

data/lib/plezi/common/settings.rb

@@ -51,7 +51,7 @@ module Plezi
 			GRHttp.ws_message_size_limit
 		end
 
-		# This Server's UUID
+		# This Server's UUID, for Redis and unicasting identification.
 		def uuid
 			@uuid ||= SecureRandom.uuid
 		end

data/lib/plezi/handlers/controller_core.rb

@@ -4,6 +4,7 @@ module Plezi
 		# the methods defined in this module will be injected into the Controller's Core class (inherited from the controller).
 		module ControllerCore
 			def self.included base
+				base.send :include, Plezi::Base::WSObject
 				base.send :include, InstanceMethods
 				base.extend ClassMethods
 			end
@@ -65,7 +66,7 @@ module Plezi
 						return false
 					end
 					return false if data[:type] && data[:type] != :all && !self.is_a?(data[:type])
-					return false if data[:target] && data[:target] != ws.uuid
+					# return false if data[:target] && data[:target] != ws.uuid + Plezi::Settings.uuid # already reviewed by the GRHttp
 					return false unless self.class.has_method?(data[:method])
 					self.method(data[:method]).call *data[:data]
 				end
@@ -90,43 +91,6 @@ module Plezi
 			end
 
 			module ClassMethods
-				public
-
-				def reset_routing_cache
-					@methods_list = nil
-					@exposed_methods_list = nil
-					@super_methods_list = nil
-					has_method? nil
-					has_exposed_method? nil
-					has_super_method? nil
-				end
-				def has_method? method_name
-					@methods_list ||= self.instance_methods.to_set
-					@methods_list.include? method_name
-				end
-				def has_exposed_method? method_name
-					@exposed_methods_list ||= ( (self.public_instance_methods - Class.new.instance_methods - Plezi::ControllerMagic::InstanceMethods.instance_methods - [:before, :after, :save, :show, :update, :delete, :initialize, :on_message, :on_broadcast, :pre_connect, :on_open, :on_close]).delete_if {|m| m.to_s[0] == '_'} ).to_set
-					@exposed_methods_list.include? method_name
-				end
-				def has_super_method? method_name
-					@super_methods_list ||= self.superclass.instance_methods.to_set
-					@super_methods_list.include? method_name
-				end
-
-				protected
-
-				# a callback that resets the class router whenever a method (a potential route) is added
-				def method_added(id)
-					reset_routing_cache
-				end
-				# a callback that resets the class router whenever a method (a potential route) is removed
-				def method_removed(id)
-					reset_routing_cache
-				end
-				# a callback that resets the class router whenever a method (a potential route) is undefined (using #undef_method).
-				def method_undefined(id)
-					reset_routing_cache
-				end
 			end
 		end
 	end

data/lib/plezi/handlers/controller_magic.rb

@@ -204,106 +204,11 @@ module Plezi
 				end
 				false
 			end
-
-			## WebSockets Magic
-
-			# Get's the websocket's unique identifier for unicast transmissions.
-			#
-			# This UUID is also used to make sure Radis broadcasts don't triger the
-			# boadcasting object's event.
-			def uuid
-				return @response.uuid if @response.is_a?(GRHttp::WSEvent)
-				nil
-			end
-			alias :unicast_id :uuid
-
-			# WebSockets.
-			#
-			# Use this to brodcast an event to all 'sibling' websockets (websockets that have been created using the same Controller class).
-			#
-			# Accepts:
-			# method_name:: a Symbol with the method's name that should respond to the broadcast.
-			# args*:: The method's argumenst - It MUST be possible to stringify the arguments into a YAML string, or broadcasting and unicasting will fail when scaling beyond one process / one machine.
-			#
-			# The method will be called asynchrnously for each sibling instance of this Controller class.
-			#
-			def broadcast method_name, *args
-				return false unless self.class.has_method? method_name
-				self.class._inner_broadcast({ method: method_name, data: args, type: self.class}, @response.io)
-			end
-
-			# {include:ControllerMagic::ClassMethods#unicast}
-			def unicast target_uuid, method_name, *args
-				self.class._inner_broadcast method: method_name, data: args, target: target_uuid
-			end
-
-			# Use this to multicast an event to ALL websocket connections on EVERY controller, including Placebo controllers.
-			#
-			# Accepts:
-			# method_name:: a Symbol with the method's name that should respond to the broadcast.
-			# args*:: The method's argumenst - It MUST be possible to stringify the arguments into a YAML string, or broadcasting and unicasting will fail when scaling beyond one process / one machine.
-			#
-			# The method will be called asynchrnously for ALL websocket connections.
-			#
-			def multicast method_name, *args
-				self.class._inner_broadcast({ method: method_name, data: args, type: :all}, @response.io)
-			end
-
-
-			# # will (probably NOT), in the future, require authentication or, alternatively, return an Array [user_name, password]
-			# #
-			# #
-			# def request_http_auth realm = false, auth = 'Digest'
-			# 	return request.service.handler.hosts[request[:host] || :default].send_by_code request, 401, "WWW-Authenticate" => "#{auth}#{realm ? "realm=\"#{realm}\"" : ''}" unless request['authorization']
-			# 	request['authorization']
-			# end
 		end
 
 		module ClassMethods
 			public
 
-			# WebSockets: fires an event on all of this controller's active websocket connections.
-			#
-			# Class method.
-			#
-			# Use this to brodcast an event to all connections.
-			#
-			# accepts:
-			# method_name:: a Symbol with the method's name that should respond to the broadcast.
-			# *args:: any arguments that should be passed to the method (IF REDIS IS USED, LIMITATIONS APPLY).
-			#
-			# this method accepts and optional block (NON-REDIS ONLY) to be used as a callback for each sibling's event.
-			#
-			# the method will be called asynchrnously for each sibling instance of this Controller class.
-			def broadcast method_name, *args
-				return false unless has_method? method_name
-				_inner_broadcast method: method_name, data: args, type: self
-			end
-
-			# WebSockets: fires an event on a specific websocket connection using it's UUID.
-			#
-			# Use this to unidcast an event to specific websocket connection using it's UUID.
-			#
-			# accepts:
-			# target_uuid:: the target's unique UUID.
-			# method_name:: a Symbol with the method's name that should respond to the broadcast.
-			# *args:: any arguments that should be passed to the method (IF REDIS IS USED, LIMITATIONS APPLY).
-			def unicast target_uuid, method_name, *args
-				_inner_broadcast method: method_name, data: args, target: target_uuid
-			end
-
-			# Use this to multicast an event to ALL websocket connections on EVERY controller, including Placebo controllers.
-			#
-			# Accepts:
-			# method_name:: a Symbol with the method's name that should respond to the broadcast.
-			# args*:: The method's argumenst - It MUST be possible to stringify the arguments into a YAML string, or broadcasting and unicasting will fail when scaling beyond one process / one machine.
-			#
-			# The method will be called asynchrnously for ALL websocket connections.
-			#
-			def multicast method_name, *args
-				_inner_broadcast({ method: method_name, data: args, type: :all}, @response.io)
-			end
-
 			# This class method behaves the same way as the instance method #url_for. See the instance method's documentation for more details.
 			def url_for dest
 				get_pl_route.url_for dest				
@@ -311,7 +216,7 @@ module Plezi
 
 			# resets the routing cache
 			def reset_routing_cache
-				@inheritance.each {|sub| sub.reset_routing_cache}
+				@inheritance.each {|sub| sub.reset_routing_cache} if @inheritance
 			end
 
 			protected
@@ -346,29 +251,6 @@ module Plezi
 			def inherited sub
 				(@inheritance ||= [].to_set) << sub
 			end
-
-			public
-
-
-			# WebSockets
-
-			# sends the broadcast
-			def _inner_broadcast data, ignore_io = nil
-				if data[:target]
-					__inner_redis_broadcast data unless GRHttp::Base::WSHandler.unicast data[:target], data
-				else
-					GRHttp::Base::WSHandler.broadcast data, ignore_io
-					__inner_redis_broadcast data				
-				end
-				true
-			end
-
-			def __inner_redis_broadcast data
-				conn = Plezi.redis_connection
-				data[:server] = Plezi::Settings.uuid
-				return conn.publish( Plezi::Settings.redis_channel_name, data.to_yaml ) if conn
-				false
-			end
 		end
 
 	end

data/lib/plezi/handlers/placebo old.rb

@@ -0,0 +1,161 @@
+module Plezi
+
+	# This API wil allows you to listen to Websocket Broadcasts sent to any object and to accept unicasts
+	# even when NOT connected to a websocket.
+	#
+	# Simpley create a class to handle any events and call `Plezi::Placebo.new ClassName` :
+	#
+	#       class MyListener
+	#          def _my_method_name *args
+	#             #logic
+	#          end
+	#       end
+	#
+	#       Plezi::Placebo.new MyListener
+	#
+	# A new instance will be created and that instance will answer any broadcasts, for ALL possible
+	# Plezi controllers, as long as it had a method defined that is capable to handle the broadcast.
+	#
+	# The new instance will also accept unicasts sent to it's unique UUID.
+	#
+	# Returns an instance that is a member of the class passed, after that class was inherited by Plezi and
+	# more methods were injected into it's subclass.
+	module Placebo
+
+		# the base module exposes some of the core functionality, but shouldn't be relied upon as far as it's API goes.
+		module Base
+			#the methods here will be injected to the Placebo controller.
+			module Core
+				def self.included base
+					base.send :include, InstanceMethods
+					base.extend ClassMethods
+					base.superclass.instance_eval {extend SuperClassMethods}
+				end
+
+				#the methods here will be injected to the Placebo controller as Instance methods.
+				module InstanceMethods
+					public
+					attr_accessor :io
+					def initialize io
+						@io = io
+						@io[:websocket_handler] = self
+						super()
+					end
+					# notice of disconnect
+					def on_close
+						return super() if defined? super
+						GR.warn "Placebo #{self.class.superclass.name} disconnected. Ignore if this message appears during shutdown."
+					end
+
+					# handles broadcasts / unicasts
+					def on_broadcast ws
+						data = ws.data
+						unless (data[:type] || data[:target]) && data[:method] && data[:data]
+							GReactor.warn "Broadcast message unknown... falling back on base broadcasting"
+							return super(data) if defined? super
+							return false
+						end
+						return false if data[:type] && data[:type] != :all && !self.is_a?(data[:type])
+						return ((data[:type] == :all) ? false : (raise "Placebo Broadcasting recieved but no method can handle it - dump:\r\n #{data.to_s}") ) unless self.class.has_super_method?(data[:method])
+						self.method(data[:method]).call *data[:data]
+					end
+					# Returns the websocket connection's UUID, used for unicasting.
+					def uuid
+						return (@uuid ||= @response.uuid + Plezi::Settings.uuid) if @response.is_a?(GRHttp::WSEvent)
+					end
+
+					# Performs a websocket unicast to the specified target.
+					def unicast target_uuid, method_name, *args
+						self.class.unicast target_uuid, method_name, *args
+					end
+					# broadcast to a specific controller
+					def broadcast controller_class, method_name, *args
+						GRHttp::Base::WSHandler.broadcast({data: args, type: controller_class, method: method_name}, self)
+						self.class.__send_to_redis data: args, type: controller_class, method: method_name
+					end
+					# multicast to all handlers.
+					def multicast method_name, *args
+						self.class.multicast method_name, *args
+					end
+				end
+				#the methods here will be injected to the Placebo controller as class methods.
+				module ClassMethods
+					public
+					def has_super_method? method_name
+						@super_methods_list ||= self.superclass.instance_methods.to_set
+						@super_methods_list.include? method_name
+					end
+				end
+				module SuperClassMethods
+					# multicast to all handlers.
+					def multicast method_name, *args
+						GRHttp::Base::WSHandler.broadcast({method: method_name, data: args, type: :all}, self)
+						__send_to_redis method: method_name, data: args, type: :all
+					end
+					# Broadcast to all instances (usually one instance) of THIS placebo controller.
+					#
+					# This should be used by the real websocket connections to forward messages to the placebo controller classes.
+					def broadcast method_name, *args
+						@methods_list ||= self.public_instance_methods.to_set
+						raise "No mothod defined to accept this broadcast." unless @methods_list.include? method_name
+						GRHttp::Base::WSHandler.broadcast data: args, type: self, method: method_name
+						__send_to_redis data: args, type: self, method: method_name
+					end
+					# Performs a websocket unicast to the specified target.
+					def unicast target_uuid, method_name, *args
+						GRHttp::Base::WSHandler.unicast target_uuid, data: args, target: target_uuid, method: method_name
+						__send_to_redis data: args, target: target_uuid, method: method_name
+					end
+					protected
+					def __send_to_redis data
+						raise "Wrong method name for websocket broadcasting - expecting type Symbol" unless data[:method].is_a?(Symbol) || data[:method].is_a?(Symbol)
+						conn = Plezi.redis_connection
+						data[:server] = Plezi::Settings.uuid
+						return conn.publish( Plezi::Settings.redis_channel_name, data.to_yaml ) if conn
+						false
+					end
+				end
+			end
+			class PlaceboIO < GReactor::BasicIO
+				def clear?
+					io.closed?
+				end
+				def call
+					self.read
+					GR.warn "Placebo IO recieved IO signal - this is unexpected..."
+				end
+				def on_disconnect
+					@params[:out].close rescue nil
+					@cache[:websocket_handler].on_close if @cache[:websocket_handler]
+				end
+			end
+		end
+		module_function
+		def new placebo_class
+			new_class_name = "PlaceboPlezi__#{placebo_class.name.gsub /[\:\-\#\<\>\{\}\(\)\s]/, '_'}"
+			new_class = nil
+			new_class =  Module.const_get new_class_name if Module.const_defined? new_class_name
+			unless new_class
+				new_class = Class.new(placebo_class) do
+					include Placebo::Base::Core
+				end
+				Object.const_set(new_class_name, new_class)
+			end
+			i, o = IO.pipe
+			io = Placebo::Base::PlaceboIO.new i, out: o
+			io = GReactor.add_raw_io i, io
+			new_class.new(io)
+		end
+	end
+end
+
+
+# class A
+# def _hi
+# 'hi'
+# end
+# end
+# Plezi::Placebo.new A
+# a = nil
+# GReactor.each {|h| a= h}
+# a[:websocket_handler].on_broadcast GRHttp::WSEvent.new(nil, type: true, data: [], method: :_hi)