plezi 0.10.17 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c509d0a1c5c9aa5fec5827c0f7b6a27dbf143840
-  data.tar.gz: c1cef78d006408e83140295a0a392553ee8b1521
+  metadata.gz: 7faa8f51c3d95810d3e7a315b970d55276d5f3dc
+  data.tar.gz: ac93d924d781fe4dd9c9e388a8405a971b76f623
 SHA512:
-  metadata.gz: edfc62fc655f782518bc355b0fd83b6784e141b445867f4307c948b8d92dd79d5d20dbb7b843143cc4e45f4cf0a9a1867b7a9df433e952c57b117644a6c2453c
-  data.tar.gz: 46af810bb76558461e3933645e9e6064109228257e57aea3f09063425a3676fcf61a06d5cb96b6849aed99376f56dc29f14f794ae628b981a98d2d0e7eb774e6
+  metadata.gz: 6e8ec22249a50788ace60a4f12af6a589264cd3d91d6e2c2873002915be5c3a0a14ece6301f39306b293de65129f620f64c04c7b38984ac0234187237cef4d06
+  data.tar.gz: 8c23d6ac45147933bb294e97b266ee49b10481ce1747d1649b7866e8ff6e1f087201083607b53557a85b6d60632c0b5d9154e3a2b7028bbc7ae86d3a145c0730

data/.yardopts

@@ -0,0 +1 @@
+yardoc lib/**/*.rb ext/**/*.c - docs/*.md

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ***
 
+Change log v.0.11.0
+
+**Update**: Requires GRHttp server and GReactor version 0.1.0 or above, adjusted to the updated API.
+
+**Update**: Better pinging and timout support courtesy of the updated GRHttp server. 
+
+**Update**: The default number of threads is now 30. It seems that once we move beyond 1 thread (which is also supported), the added threads are adding more security against blocking code without effecting performance as much. It is expected that advanced users will consider moving away from multi-threading to muli-processing while avoiding blocking code. All these options are supported by Plezi, GRHttp and GReactor.
+
+**Fix**: Fixed an issue where requests for folders within the assets folder (folder indexing) would fail with an internal error message (error 500) instead of a not found message (error 404).
+
+**Fix**: fixed an issue that caused the static file service to fail when using the preferred `:public` vs. the older `:root` option used to set the public folder's path. 
+
+**Minor**: minor adjustments and improvements, such as: auto-setting the `content-type` header when using `render`.
+
+***
+
 Change log v.0.10.17
 
 **Update**: Requires a newer version of the GRHttp server and GReactor, building on it's WSClient and HTTP decoding improvements.

data/README.md

@@ -1,6 +1,4 @@
 # [Plezi](https://github.com/boazsegev/plezi), The Ruby framework for realtime web-apps
-[![Gem Version](https://badge.fury.io/rb/plezi.svg)](http://badge.fury.io/rb/plezi)
-[![Inline docs](http://inch-ci.org/github/boazsegev/plezi.svg?branch=master)](http://www.rubydoc.info/github/boazsegev/plezi/master)
 
 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.
 
@@ -14,6 +12,12 @@ With Plezi, you can easily:
 
 Plezi leverages [GRHttp server's](https://github.com/boazsegev/GRHttp) 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).
 
+### Plezi version data
+[![Gem Version](https://badge.fury.io/rb/plezi.svg)](http://badge.fury.io/rb/plezi)
+[![Inline docs](http://inch-ci.org/github/boazsegev/plezi.svg?branch=master)](http://www.rubydoc.info/github/boazsegev/plezi/master)
+
+The `master` branch always refers to the latest edge version, which might also be a broken version. Please refer to the relevent version by using the version's `tag` in the branch selector.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -115,7 +119,9 @@ Remember to connect to the service from at least two browser windows - to truly
     route '/', BroadcastCtrl
 ```
 
-method names starting with an underscore ('_') will NOT be made public by the router: so while both '/hello' and '/humans.txt' are public ( [try it](http://localhost:3000/humans.txt) ), '/_send_message' will return a 404 not found error ( [try it](http://localhost:3000/_send_message) ).
+method names starting with an underscore ('_') will NOT be made public by the router.
+
+This is why even though both '/hello' and '/humans.txt' are public ( [try it](http://localhost:3000/humans.txt) ), '/_send_message' will return a 404 not found error ( [try it](http://localhost:3000/_send_message) ).
 
 ## Adding Websockets to your existing Rails/Sinatra/Rack application
 

data/bin/plezi

@@ -65,7 +65,7 @@ if ARGV[0] == 'new' || ARGV[0] == 'n' || ARGV[0] == "force" || ARGV[0] == 'mini'
 
 	# building
 	template = Plezi::AppBuilder.new
-	(ARGV[0] == 'mini' || ARGV[0] == 'm' ) ? template.build_mini : template.build
+	(ARGV[0] == 'mini' || ARGV[0] == 'm' ) ? template.build_mini(ARGV[1]) : template.build(ARGV[1])
 elsif ARGV[0] == 'server' || ARGV[0] == 'start' || ARGV[0] == 's'
 	ARGV.shift
 	load File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last) ) rescue load( File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last ) ) )

data/docs/async_helpers.md

@@ -0,0 +1,195 @@
+# Plezi's Asynchronous Engine
+
+(todo: write documentation)
+
+Inside Plezi's core code is a pure Ruby IO reactor called [GReactor](https://github.com/boazsegev/GReactor) (Generic Reactor), a very powerful Asynchronous Workflow Engine that allows us to enjoy both Multi-Threading and Multi-Processing.
+
+Although multi-threading is highly regarded, it should be pointed out that using the GReactor with just one thread is both faster and more efficient. But, since some tasks that take more time (blocking tasks) can't be broken down into smaller tasks, using a number of threads (and/or processes) is a better practice.
+
+You can read more about the [GReactor](https://github.com/boazsegev/GReactor) and it's amazing features in it's [documentation](http://www.rubydoc.info/github/boazsegev/GReactor/master).
+
+Here we will discuss the methods used for asynchronous processing of different tasks that allow us to break big heavy tasks into smaller bits, allowing our application to 'flow' and stay responsive even while under heavy loads.
+
+## Asynchronous HTTP responses
+
+Inside Plezi's core code is a pure Ruby HTTP and Websocket Server (and client) called [GRHttp](https://github.com/boazsegev/GRHttp) (Generic HTTP), which allows for native HTTP streaming.
+
+Asynchronous HTTP method calls can be nested, but shouldn't be called on after the other.
+
+i.e.:
+
+```ruby
+# right
+response.stream_async {  response.stream_async {'do after'}; 'do first'  }
+# wrong
+response.stream_async {  "who's first?"  }
+response.stream_async {  "I don't know..."  }
+```
+
+Since streaming is done asynchronously, and since Plezi is multi-threaded by default (this can be changed to single threaded, but is less recomended unless you know your code doesn't block - see `Plezi::Settings.max_threads = number`), Asynchronous HTTP method nesting makes sure that the code doesn't conflict and that race conditions don't occure within the same HTTP response.
+
+
+#### GRHttp's `response.stream_async &block`
+
+GRHttp's response object, which is accessed by the controller using the `response` method (or the `@response` object), allows easy access to HTTP streaming.
+
+For example (run this in the terminal using `irb`):
+
+```ruby
+require `plezi`
+
+class MyController
+    def index
+        response.stream_async do
+            response << "This will stream.\n"
+            response.stream_async do
+                response << "Streaming can be nested."
+            end
+        end
+    end
+end
+
+listen
+route '/', MyController
+
+exit
+```
+
+As noted above, `response.stream_async` calls should always be nested and never called in 'parallel'.
+
+Calling `response.stream_async`
+
+#### GRHttp's `response.stream_array enum, &block`
+
+To make nesting easier, GRHttp's response object provides the `response.stream_array enum, &block` method.
+
+Here's our modified example:
+
+```ruby
+require `plezi`
+
+class MyController
+    def index
+        data = ["This will stream.\n", "Streaming can be nested."]
+        response.stream_array(data) {|s| response << s}
+    end
+end
+
+listen
+route '/', MyController
+
+exit
+```
+
+You can also add data to the array while 'looping', which allows you to use the array as a 'flag' for looped streaming. The following is a very limited example, which could be used for "lazy loading" data from a database, in order to save on system resources or send large table data using JSON "packets".
+
+```ruby
+require `plezi`
+
+class MyController
+    def index
+        data = ["This will stream.\n", "Streaming can be nested."]
+        flag = [true]
+        response.stream_array(flag) do
+            response << data.shift
+            flag << true unless data.empty?
+        end
+    end
+end
+
+listen
+route '/', MyController
+
+exit
+```
+
+## Asynchronous code execution
+
+[GReactor](https://github.com/boazsegev/GReactor) (Generic Reactor), a very powerful Asynchronous Workflow Engine which offers a very intuitve and easy to use API both for queuing code snippets (blocks / methods) and for schedualing non-persistent timed events (future timed events are discarded during shutdown and need to be re-initiated).
+
+### The Asynchronous "Queue"
+
+`GReactor` (in short: `GR`) offers a number of methods that allow us to easily queue code execution.
+
+
+#### `GR.run_async(arg1, arg2, arg3...) {block}`
+
+`GR.run_async` takes arguments to be passed to a block of code prior to execution. This allows us to seperate the `Proc` object creation fron the data handling and possibly (but not always) optimize our code.
+
+For example:
+
+```ruby
+require `plezi`
+
+class MyController
+    def index
+        GR.run_async(Time.now) {|t| puts "Someone poked me at: #{t}"} # maybe send an email?
+        "Hello World"
+    end
+end
+
+listen
+route '/', MyController
+
+exit
+```
+
+#### `GR.callback(object, method, arg1, arg2...) {|returned_value| callback block}`
+
+Another common method imployed is the `GR.callback`, which allows us to layer asynchronous code:
+
+```ruby
+require `plezi`
+
+class MyController
+    def index
+        GR.callback(self, :print_poke, Time.now) { puts "Printed poke."}
+        "Hello World"
+    end
+    protected
+    def print_poke time
+        puts "Someone poked me at: #{time}"
+    end
+end
+
+listen
+route '/', MyController
+
+exit
+```
+
+#### `GR.queue(proc, arguments_array)`
+
+GReactor's asynchronous engine is, in it's core, based off this simple method which accepts two elements:
+
+1. An object that answers to `call`
+2. An array of arguments to be passed to that object (or `nil`).
+
+This method allows us to easily reuse Proc objects without constantly creating new Proc objects and releasing them from memory.
+
+For example:
+
+```ruby
+require `plezi`
+
+class MyController
+
+    POKE_TASK = -> {|time| puts "Someone poked me at: #{time}"}
+
+    def index
+        GR.queue POKE_TASK, [Time.now]
+        "Hello World"
+    end
+end
+
+listen
+route '/', MyController
+
+exit
+```
+
+
+### Timed events
+
+## The Graceful Shutdown
+

data/docs/http_helpers.md

@@ -0,0 +1,9 @@
+# HTTP Helpers inherited from GRHttp
+
+Inside Plezi's core code is a pure Ruby HTTP and Websocket Server (and client) called [GRHttp](https://github.com/boazsegev/GRHttp) (Generic HTTP), a very powerful server that [isn't limited by Rack's API](https://github.com/boazsegev/GRHttp/blob/master/HTTP.md).
+
+
+(todo: write documentation)
+
+
+

data/docs/logging.md

@@ -0,0 +1,14 @@
+# Plezi's Logging
+
+(todo: write documentation)
+
+Inside Plezi's core code is a pure Ruby IO reactor called [GReactor](https://github.com/boazsegev/GReactor) (Generic Reactor), a very powerful Asynchronous Workflow Engine that allows us to enjoy both Multi-Threading and Multi-Processing.
+
+Plezi leverages [GReactor's](https://github.com/boazsegev/GReactor) logging support to help you log to both files and STDOUT (terminal screen) - either one or both
+
+You can read more about [GReactor](https://github.com/boazsegev/GReactor) and it's amazing features in it's [documentation](http://www.rubydoc.info/github/boazsegev/GReactor/master).
+
+## Setting up a Logger
+
+
+## Logging Helpers Methods

data/docs/routes.md

@@ -0,0 +1,37 @@
+# Plezi's Smart Routing System
+
+In the core of Plezi's framework is a smart Object Oriented Router which actls like a "virtual folder" with RESTful routing and Websocket support.
+
+RESTful routing and Websocket callback support both allow us to use conventionally named methods in our Controller to achive common tasks. Such names methods, as will be explored further on, include the `update`, `save` and `show` RESTful method names, as well as the `on_open`, `on_message(data)` and `on_close` Websocket callbacks.
+
+## Defining a Route
+
+(todo: write documentation)
+
+### The `:id` parameter
+
+(todo: write documentation)
+
+### More inline parameters
+
+(todo: write documentation)
+
+### Re-Write Routes and Proc Controllers
+
+## The Controller
+
+(todo: write documentation)
+
+### A Virtual Folder
+
+(todo: write documentation)
+
+### RESTful methods
+
+(todo: write documentation)
+
+### Websocket Callbacks
+
+(todo: write documentation)
+
+

data/docs/websockets.md

@@ -0,0 +1,9 @@
+# Plezi Websockets
+
+
+(todo: write documentation)
+
+
+
+
+

data/lib/plezi/builders/app_builder.rb

@@ -11,28 +11,28 @@ module Plezi
 		def app_tree
 			@app_tree ||= {}
 		end
-		def build_mini
+		def build_mini app_name = ARGV[1]
 			require 'plezi/version'
-			@app_tree["#{ARGV[1]}"] ||= IO.read( File.join(@root, "resources" ,"mini_exec.rb")).gsub('appname', ARGV[1])
-			@app_tree["#{ARGV[1]}.rb"] ||= IO.read( File.join(@root, "resources" ,"mini_app.rb")).gsub('appname', ARGV[1]).gsub('appsecret', "#{ARGV[1]}_#{SecureRandom.hex}")
+			app_tree["#{app_name}"] ||= IO.read( File.join(@root, "resources" ,"mini_exec.rb")).gsub('appname', app_name)
+			app_tree["#{app_name}.rb"] ||= IO.read( File.join(@root, "resources" ,"mini_app.rb")).gsub('appname', app_name).gsub('appsecret', "#{app_name}_#{SecureRandom.hex}")
 			app_tree["Procfile"] ||= ""
-			app_tree["Procfile"] << "\nweb: bundle exec ruby ./#{ARGV[1]} -p $PORT\n"		
+			app_tree["Procfile"] << "\nweb: bundle exec ruby ./#{app_name} -p $PORT\n"		
 			app_tree["Gemfile"] ||= ''
 			app_tree["Gemfile"] << "source 'https://rubygems.org'\n\n####################\n# core gems\n\n# include the basic plezi framework and server\ngem 'plezi', '~> #{Plezi::VERSION}'\n"
 			app_tree["Gemfile"] << "\n\n\nruby '#{RUBY_VERSION}'\n"
 			app_tree["templates"] ||= {}
 			app_tree["templates"]["404.html.erb"] ||= IO.read(File.join(@root, "resources" ,"404.erb"))
 			app_tree["templates"]["500.html.erb"] ||= IO.read(File.join(@root, "resources" ,"500.erb"))
-			app_tree["templates"]["welcome.html.erb"] ||= IO.read(File.join(@root, "resources" ,"mini_welcome_page.html")).gsub('appname', ARGV[1])
+			app_tree["templates"]["welcome.html.erb"] ||= IO.read(File.join(@root, "resources" ,"mini_welcome_page.html")).gsub('appname', app_name)
 			app_tree["assets"] ||= {}
-			app_tree["assets"]["websocket.js"] ||= IO.read(File.join(@root, "resources" ,"websockets.js")).gsub('appname', ARGV[1])
-			finalize
+			app_tree["assets"]["websocket.js"] ||= IO.read(File.join(@root, "resources" ,"websockets.js")).gsub('appname', app_name)
+			finalize app_name
 		end
 
-		def build
+		def build app_name = ARGV[1]
 			require 'plezi/version'
 			# plezi run script
-			@app_tree["#{ARGV[1]}"] ||= IO.read File.join(@root,"resources" ,"code.rb")
+			app_tree["#{app_name}"] ||= IO.read File.join(@root,"resources" ,"code.rb")
 
 			# set up application files
 			app_tree["app"] ||= {}
@@ -55,15 +55,15 @@ module Plezi
 			app_tree["assets"] ||= {}
 			app_tree["assets"]["stylesheets"] ||= {}
 			app_tree["assets"]["javascripts"] ||= {}
-			app_tree["assets"]["javascripts"]["websocket.js"] ||= IO.read(File.join(@root,"resources" ,"websockets.js")).gsub('appname', ARGV[1])
-			app_tree["assets"]["welcome.html"] ||= IO.read(File.join(@root,"resources" ,"welcome_page.html")).gsub('appname', ARGV[1])
+			app_tree["assets"]["javascripts"]["websocket.js"] ||= IO.read(File.join(@root,"resources" ,"websockets.js")).gsub('appname', app_name)
+			app_tree["assets"]["welcome.html"] ||= IO.read(File.join(@root,"resources" ,"welcome_page.html")).gsub('appname', app_name)
 
 			# app core files.
 			app_tree["environment.rb"] ||= IO.read File.join(@root,"resources" ,"environment.rb")
 			app_tree["routes.rb"] ||= IO.read File.join(@root,"resources" ,"routes.rb")
 			app_tree["rakefile"] ||= IO.read File.join(@root,"resources" ,"rakefile")
 			app_tree["Procfile"] ||= ""
-			app_tree["Procfile"] << "\nweb: bundle exec ruby ./#{ARGV[1]} -p $PORT\n"
+			app_tree["Procfile"] << "\nweb: bundle exec ruby ./#{app_name} -p $PORT\n"
 			app_tree["Gemfile"] ||= ''
 			app_tree["Gemfile"] << "source 'https://rubygems.org'\n\n####################\n# core gems\n\n# include the basic plezi framework and server\ngem 'plezi', '~> #{Plezi::VERSION}'\n"
 			app_tree["Gemfile"] << IO.read( File.join(@root,"resources" ,"Gemfile"))
@@ -78,7 +78,7 @@ module Plezi
 			app_tree["config"]["haml.rb"] ||= IO.read(File.join(@root,"resources" ,"haml_config.rb"))
 			app_tree["config"]["slim.rb"] ||= IO.read(File.join(@root,"resources" ,"slim_config.rb"))
 			app_tree["config"]["i18n.rb"] ||= IO.read(File.join(@root,"resources" ,"i18n_config.rb"))
-			app_tree["config"]["redis.rb"] ||= (IO.read(File.join(@root,"resources" ,"redis_config.rb"))).gsub('appsecret', "#{ARGV[1]}_#{SecureRandom.hex}")
+			app_tree["config"]["redis.rb"] ||= (IO.read(File.join(@root,"resources" ,"redis_config.rb"))).gsub('appsecret', "#{app_name}_#{SecureRandom.hex}")
 
 			#set up database stub folders
 			app_tree["db"] ||= {}
@@ -106,29 +106,29 @@ module Plezi
 			app_tree["public"]["assets"]["stylesheets"] ||= {}		
 			app_tree["public"]["assets"]["javascripts"] ||= {}		
 			app_tree["public"]["images"] ||= {}
-			finalize
+			finalize app_name
 		end
-		def finalize
+		def finalize app_name = ARGV[1]
 			begin
-				Dir.mkdir ARGV[1]
-				puts "created the #{ARGV[1]} application directory.".green
+				Dir.mkdir app_name
+				puts "created the #{app_name} application directory.".green
 			rescue Exception => e
-				puts "the #{ARGV[1]} application directory exists - trying to rebuild (no overwrite).".pink
+				puts "the #{app_name} application directory exists - trying to rebuild (no overwrite).".pink
 			end
-			Dir.chdir ARGV[1]
+			Dir.chdir app_name
 			puts "starting to write template data...".red
 			puts ""
 			Builder.write_files app_tree
-			File.chmod 0775, "#{ARGV[1]}"
+			File.chmod 0775, "#{app_name}"
 			puts "tried to update execution permissions. this is system dependent and might have failed.".pink
-			puts "use: chmod +x ./#{ARGV[1]} to set execution permissions on Unix machines."
+			puts "use: chmod +x ./#{app_name} to set execution permissions on Unix machines."
 			puts ""
 			puts "done."
 			puts "\n#{@end_comments.join("\n")}" unless @end_comments.empty?
 			puts ""
-			puts "please change directory into the app directory: cd #{ARGV[1]}"
+			puts "please change directory into the app directory: cd #{app_name}"
 			puts ""
-			puts "run the #{ARGV[1]} app using: ./#{ARGV[1]} or using: plezi s"
+			puts "run the #{app_name} app using: ./#{app_name} or using: plezi s"
 			puts ""
 		end
 	end

data/lib/plezi/common/api.rb

@@ -109,9 +109,9 @@ module Plezi
 	def start_async
 		Object.const_set("NO_PLEZI_AUTO_START", true) unless defined?(NO_PLEZI_AUTO_START)
 		return GReactor.start if GReactor.running?
-		puts "Starting Plezi #{Plezi::VERSION} Services using the GRHttp #{GRHttp::VERSION} server."
+		puts "Starting Plezi #{Plezi::VERSION} Services using GRHttp #{GRHttp::VERSION} and GReactor #{GReactor::VERSION}."
 		GReactor.on_shutdown { puts "Plezi shutdown. It was fun to serve you."  }
-		GReactor.start Plezi::Settings.max_threads
+		GReactor.start ::Plezi::Settings.max_threads
 	end
 	# This allows you to run the Plezi framework along side another framework - WITHOUT running the actual server.
 	#
@@ -136,4 +136,4 @@ end
 Encoding.default_internal = 'utf-8'
 Encoding.default_external = 'utf-8'
 
-NO_PLEZI_AUTO_START = true if defined?(::Rack::Builder)
+Object.const_set("NO_PLEZI_AUTO_START", true) if defined?(::Rack::Builder) && !defined?(NO_PLEZI_AUTO_START)

data/lib/plezi/common/dsl.rb

@@ -105,5 +105,4 @@ unless defined? PLEZI_NON_DSL
 
 	# sets to start the services once dsl script is finished loading.
 	at_exit { start_services }
-	GReactor::Settings.force_graceful = false
 end

data/lib/plezi/common/settings.rb

@@ -8,7 +8,7 @@ module Plezi
 
 		# The maximum number of threads that are used for concurrency.
 		def max_threads
-			@max_threads ||= 8
+			@max_threads ||= 30
 		end
 		# Sets the maximum number of threads that are used for concurrency.
 		def max_threads=val

data/lib/plezi/handlers/controller_magic.rb

@@ -13,6 +13,12 @@ module Plezi
 	# response:: the HTTPResponse **OR** the WSResponse object that formats the response and sends it. use `response << data`. This object can be used to send partial data (such as headers, or partial html content) in blocking mode as well as sending data in the default non-blocking mode.
 	# host_params:: a copy of the parameters used to create the host and service which accepted the request and created this instance of the controller class.
 	#
+	# For Controller Class menthods, please read the documentation about {Plezi::ControllerMagic::ClassMethods}.
+	#
+	# For Controller Instance methods, please read the documentation about {Plezi::ControllerMagic::InstanceMethods}.
+	#
+	# {include: Plezi::ControllerMagic::InstanceMethods}
+	# 
 	module ControllerMagic
 		def self.included base
 			base.send :include, InstanceMethods
@@ -38,7 +44,7 @@ module Plezi
 			#
 			# The first time this method is called, the session object will be created. The session object must be created BEFORE the headers are set , if it is to be used.
 			#
-			# Sessions are not automatically created, because they are memory hogs. The one exception is the Websocket connection that will force a session object into existence.
+			# Sessions are not automatically created, because they require more resources. The one exception is the Websocket connection that will force a session object into existence, as it's very common to use session data in Websocket connections and the extra connection time is less relevant for a long term connection.
 			def session
 				response.session
 			end
@@ -73,14 +79,14 @@ module Plezi
 			#
 			def redirect_to url, options = {}
 				return super *[] if defined? super
-				raise 'Cannot redirect after headers were sent' if response.headers_sent?
+				raise 'Cannot redirect once a Websocket connection was established.' if response.is_a?(::GRHttp::WSEvent)
+				raise 'Cannot redirect after headers were sent.' if response.headers_sent?
 				url = "#{request.base_url}/#{url.to_s.gsub('_', '/')}" if url.is_a?(Symbol) || ( url.is_a?(String) && url.empty? ) || url.nil?
 				# redirect
 				response.status = options.delete(:status) || 302
 				response['Location'] = url
 				response['content-length'] ||= 0
 				flash.update options
-				response.finish
 				true
 			end
 
@@ -123,6 +129,8 @@ module Plezi
 			# filename:: sets a filename for the browser to "save as". defaults to empty.
 			#
 			def send_data data, options = {}
+				raise 'Cannot use "send_data" once a Websocket connection was established.' if response.is_a?(::GRHttp::WSEvent)
+				# return response.write(data) if response.is_a?(::GRHttp::WSEvent)
 				raise 'Cannot use "send_data" after headers were sent' if response.headers_sent?
 				Plezi.warn 'HTTP response buffer is cleared by `#send_data`' if response.body && response.body.any? && response.body.clear
 				response << data
@@ -131,15 +139,15 @@ module Plezi
 				content_disposition = options[:inline] ? 'inline' : 'attachment'
 				content_disposition << "; filename=#{options[:filename]}" if options[:filename]
 
-				response['content-type'] = options[:type] ||= MimeTypeHelper::MIME_DICTIONARY[::File.extname(options[:filename])] if options[:filename]
+				response['content-type'] = (options[:type] ||= MimeTypeHelper::MIME_DICTIONARY[::File.extname(options[:filename])])
 				response['content-length'] = data.bytesize rescue true
 				response['content-disposition'] = content_disposition
-				response.finish
 				true
 			end
 
-			# renders a template file (.slim/.erb/.haml) or an html file (.html) to text
-			# for example, to render the file `body.html.slim` with the layout `main_layout.html.haml`:
+			# Renders a template file (.slim/.erb/.haml) or an html file (.html) to text and attempts to set the response's 'content-type' header (if it's still empty).
+			#
+			# For example, to render the file `body.html.slim` with the layout `main_layout.html.haml`:
 			#   render :body, layout: :main_layout
 			#
 			# or, for example, to render the file `json.js.slim`
@@ -171,14 +179,16 @@ module Plezi
 				# set up defaults
 				options[:type] ||= 'html'
 				options[:locale] ||= params[:locale].to_sym if params[:locale]
+				#update content-type header
+				response['content-type'] ||= (MimeTypeHelper::MIME_DICTIONARY[options[:type]] + "; charset=utf-8".freeze)
 				# options[:locals] ||= {}
 				I18n.locale = options[:locale] || I18n.default_locale if defined?(I18n) # sets the locale to nil for default behavior even if the locale was set by a previous action - removed: # && options[:locale]
 				# find template and create template object
 				filename = template.is_a?(String) ? File.join( host_params[:templates].to_s, template) : (File.join( host_params[:templates].to_s, *template.to_s.split('_')) + (options[:type].empty? ? '': ".#{options[:type]}") + '.slim')
 				return ( Plezi.cache_needs_update?(filename) ? Plezi.cache_data( filename, ( Slim::Template.new() { IO.binread filename } ) )  : (Plezi.get_cached filename) ).render(self, &block) if defined?(::Slim) && Plezi.file_exists?(filename)
-				filename.gsub! /\.slim$/, '.haml'
+				filename.sub! /\.slim$/, '.haml'
 				return ( Plezi.cache_needs_update?(filename) ? Plezi.cache_data( filename, ( Haml::Engine.new( IO.binread(filename) ) ) )  : (Plezi.get_cached filename) ).render(self, &block) if defined?(::Haml) && Plezi.file_exists?(filename)
-				filename.gsub! /\.haml$/, '.erb'
+				filename.sub! /\.haml$/, '.erb'
 				return ( Plezi.cache_needs_update?(filename) ? Plezi.cache_data( filename, ( ERB.new( IO.binread(filename) ) ) )  : (Plezi.get_cached filename) ).result(binding, &block) if defined?(::ERB) && Plezi.file_exists?(filename)
 				return false
 			end

data/lib/plezi/handlers/http_router.rb

@@ -107,42 +107,41 @@ module Plezi
 				source_file = File.join(params[:assets], *(request.path.match(/^#{params[:assets_public]}\/(.+)/)[1].split('/')))
 
 				# stop if file name is reserved / has security issues
-				return false if source_file.match(/(scss|sass|coffee|\.\.\/)$/)
+				return false if File.directory?(source_file) || source_file.match(/(scss|sass|coffee|\.\.\/)$/)
 
 				# set where to store the rendered asset
-				target_file = false
-				target_file = File.join( params[:root], params[:assets_public], *request.path.match(/^#{params[:assets_public]}\/(.*)/)[1].split('/') ) if params[:root]
+				target_file = File.join( params[:public].to_s, params[:assets_public].to_s, *request.path.match(/^#{params[:assets_public]}\/(.*)/)[1].split('/') )
 
 				# send the file if it exists (no render needed)
 				if File.exists?(source_file)
-					data = Plezi.cache_needs_update?(source_file) ? Plezi.save_file(target_file, Plezi.reload_file(source_file), params[:save_assets]) : Plezi.load_file(source_file)
+					data = Plezi.cache_needs_update?(source_file) ? Plezi.save_file(target_file, Plezi.reload_file(source_file), (params[:public] && params[:save_assets])) : Plezi.load_file(source_file)
 					return (data ? Base::HTTPSender.send_raw_data(request, response, data, MimeTypeHelper::MIME_DICTIONARY[::File.extname(source_file)]) : false)
 				end
 
 				# render supported assets
 				case source_file
 				when /\.css$/
-					sass = source_file.gsub /css$/, 'sass'
-					sass.gsub! /sass$/, 'scss' unless Plezi.file_exists?(sass)
+					sass = source_file.sub /css$/, 'sass'
+					sass.sub! /sass$/, 'scss' unless Plezi.file_exists?(sass)
 					return false unless Plezi.file_exists?(sass)
 					# review mtime and render sass if necessary
 					if defined?(::Sass) && refresh_sass?(sass)
 						eng = Sass::Engine.for_file(sass, cache_store: @sass_cache)
 						Plezi.cache_data sass, eng.dependencies
 						css, map = eng.render_with_sourcemap(params[:assets_public])
-						Plezi.save_file target_file, css, params[:save_assets]
-						Plezi.save_file (target_file + ".map"), map, params[:save_assets]
+						Plezi.save_file target_file, css, (params[:public] && params[:save_assets])
+						Plezi.save_file (target_file + ".map"), map, (params[:public] && params[:save_assets])
 					end
 					# try to send the cached css file which started the request.
 					return Base::HTTPSender.send_file request, response, target_file
 				when /\.js$/
-					coffee = source_file.gsub /js$/i, 'coffee'
+					coffee = source_file.sub /js$/i, 'coffee'
 					return false unless Plezi.file_exists?(coffee)
 					# review mtime and render coffee if necessary
 					if defined?(::CoffeeScript) && Plezi.cache_needs_update?(coffee)
 						# render coffee to cache
 						Plezi.cache_data coffee, nil
-						Plezi.save_file target_file, CoffeeScript.compile(IO.binread coffee), params[:save_assets]
+						Plezi.save_file target_file, CoffeeScript.compile(IO.binread coffee), (params[:public] && params[:save_assets])
 					end
 					# try to send the cached js file which started the request.
 					return Base::HTTPSender.send_file request, response, target_file

data/lib/plezi/handlers/placebo.rb

@@ -68,7 +68,7 @@ module Plezi
 					self.read
 					GR.warn "Placebo IO recieved IO signal - this is unexpected..."
 				end
-				def on_disconnect
+				def on_close
 					@params[:out].close rescue nil
 					@cache[:websocket_handler].on_close if @cache[:websocket_handler]
 				end
@@ -86,8 +86,7 @@ module Plezi
 				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
+			io = Placebo::Base::PlaceboIO.new i, out: o, reactor: ::GReactor
 			new_class.new(io)
 		end
 	end

data/lib/plezi/handlers/route.rb

@@ -17,7 +17,7 @@ module Plezi
 			fill_parameters = match request.path
 			return false unless fill_parameters
 			old_params = request.params.dup
-			fill_parameters.each {|k,v| GRHttp::HTTP.add_param_to_hash k, v, request.params }
+			fill_parameters.each {|k,v| Plezi::Base::Helpers.add_param_to_hash k, v, request.params }
 			ret = false
 			if controller
 				ret = controller.new(request, response)._route_path_to_methods_and_set_the_response_
@@ -112,7 +112,7 @@ module Plezi
 				param_name = param_name[1].to_sym if param_name
 
 				if param_name && dest[param_name]
-					url << GRHttp::HTTP.encode_url(dest.delete(param_name))
+					url << Plezi::Base::Helpers.encode_url(dest.delete(param_name))
 					url << '/' 
 				elsif !param_name
 					url << sec
@@ -125,7 +125,7 @@ module Plezi
 			end
 			unless dest.empty?
 				add = '?'
-				dest.each {|k, v| url << "#{add}#{GRHttp::HTTP.encode_url k}=#{GRHttp::HTTP.encode_url v}"; add = '&'}
+				dest.each {|k, v| url << "#{add}#{Plezi::Base::Helpers.encode_url k}=#{Plezi::Base::Helpers.encode_url v}"; add = '&'}
 			end
 			url
 
@@ -229,7 +229,7 @@ module Plezi
 			# m = nil
 			# unless @fill_parameters.values.include?("format")
 			# 	if (m = path.match /([^\.]*)\.([^\.\/]+)$/)
-			# 		GRHttp::HTTP.add_param_to_hash 'format', m[2], hash
+			# 		Plezi::Base::Helpers.add_param_to_hash 'format', m[2], hash
 			# 		path = m[1]
 			# 	end
 			# end

data/lib/plezi/handlers/session.rb

@@ -5,9 +5,8 @@ module Plezi
 			# returns a session object
 			def fetch id
 				return Plezi::Session.new(id) if Plezi.redis # avoid a local cache if Redis is used.
-				@session_cache[id] || (@session_cache[id] = Plezi::Session.new(id))
+				GRHttp::Base::FileSessionStorage.fetch id # use the tmp-file-session logic if Redis isn't present
 			end
-			@session_cache = {}
 		end
 	end
 	# A hash like interface for storing request session data.
@@ -22,9 +21,9 @@ module Plezi
 		def initialize id
 			@id = id
 			if id && (conn=Plezi.redis)
-				@data=conn.hgetall(id)
+				return self
 			end
-			@data ||= {}
+			failed
 		end
 		# Get a key from the session data store. If a Redis server is supplied, it will be used to synchronize session data.
 		#
@@ -34,9 +33,9 @@ module Plezi
 			key = key.to_s
 			if conn=Plezi.redis
 				conn.expire @id, SESSION_LIFETIME
-				@data[key] = conn.hget @id, key
+				return conn.hget @id, key
 			end
-			@data[key]
+			failed
 		end
 		alias :fetch :[]
 
@@ -49,8 +48,9 @@ module Plezi
 			if (conn=Plezi.redis)
 				conn.hset @id, key, value
 				conn.expire @id, SESSION_LIFETIME
+				return value
 			end
-			@data[key] = value
+			failed
 		end
 		alias :store :[]=
 
@@ -58,9 +58,9 @@ module Plezi
 		def to_h
 			if (conn=Plezi.redis) 
 				conn.expire @id, SESSION_LIFETIME
-				return (@data=conn.hgetall(@id)).dup
+				return conn.hgetall(@id)
 			end
-			@data.dup
+			failed
 		end
 
 		# Removes a key from the session's data store.
@@ -68,17 +68,26 @@ module Plezi
 			key = key.to_s
 			if (conn=Plezi.redis)
 				conn.expire @id, SESSION_LIFETIME
+				ret = conn.hget @id, key
 				conn.hdel @id, key
+				return ret
 			end				
-			@data.delete key	
+			failed
 		end
 
 		# Clears the session's data.
 		def clear
 			if (conn=Plezi.redis)
-				conn.del @id
+				return conn.del @id
 			end
-			@data.clear
+			failed
+		end
+
+		protected
+
+		def failed
+			raise 'Redis connection failed while using Redis Session Storage.'
+			
 		end
 	end
 	GRHttp::SessionManager.storage = Plezi::Base::SessionStorage

data/lib/plezi/helpers/http_sender.rb

@@ -24,7 +24,7 @@ module Plezi
 					elsif Plezi.file_exists?(fn = File.join(base_code_path, "#{code}.html"))
 						return send_file(request, response, fn, code, headers)
 					end
-					return true if send_raw_data(request, response, GRHttp::HTTPResponse::STATUS_CODES[code], 'text/plain', code, headers)
+					return true if send_raw_data(request, response, response.class::STATUS_CODES[code], 'text/plain', code, headers)
 				rescue Exception => e
 					Plezi.error e
 				end

data/lib/plezi/helpers/magic_helpers.rb

@@ -1,8 +1,5 @@
 module Plezi
 
-	# use GRHttp's helpers for escaping data etc'.
-	HTTP = GRHttp::HTTP
-
 	module Base
 		# some helper methods used internally.
 		module Helpers
@@ -12,7 +9,7 @@ module Plezi
 			 HASH_SYM_PROC = Proc.new {|h,k| k = (Symbol === k ? k.to_s : k.to_s.to_sym); h[k] if h.has_key?(k) }
 
 			# tweeks a hash object to read both :symbols and strings (similar to Rails but without).
-			def make_hash_accept_symbols hash
+			def self.make_hash_accept_symbols hash
 				@magic_hash_proc ||= Proc.new do |hs,k|
 					if k.is_a?(Symbol) && hs.has_key?( k.to_s)
 						hs[k.to_s]
@@ -29,6 +26,71 @@ module Plezi
 					end
 				end
 			end
+
+			# encodes URL data
+			def self.encode_url str
+				(str.to_s.gsub(/[^a-z0-9\*\.\_\-]/i) {|m| '%%%02x'.freeze % m.ord }).force_encoding(::Encoding::ASCII_8BIT)
+			end
+
+			# Adds paramaters to a Hash object, according to the GRHttp's server conventions.
+			def self.add_param_to_hash name, value, target
+				begin
+					c = target
+					val = rubyfy! value
+					a = name.chomp('[]'.freeze).split('['.freeze)
+
+					a[0...-1].inject(target) do |h, n|
+						n.chomp!(']'.freeze);
+						n.strip!;
+						raise "malformed parameter name for #{name}" if n.empty?
+						n = (n.to_i.to_s == n) ?  n.to_i : n.to_sym            
+						c = (h[n] ||= {})
+					end
+					n = a.last
+					n.chomp!(']'); n.strip!;
+					n = n.empty? ? nil : ( (n.to_i.to_s == n) ?  n.to_i : n.to_sym )
+					if n
+						if c[n]
+							c[n].is_a?(Array) ? (c[n] << val) : (c[n] = [c[n], val])
+						else
+							c[n] = val
+						end
+					else
+						if c[n]
+							c[n].is_a?(Array) ? (c[n] << val) : (c[n] = [c[n], val])
+						else
+							c[n] = [val]
+						end
+					end
+					val
+				rescue => e
+					GReactor.error e
+					GReactor.error "(Silent): parameters parse error for #{name} ... maybe conflicts with a different set?"
+					target[name] = val
+				end
+			end
+			# Changes String to a Ruby Object, if it's a special string...
+			def self.rubyfy!(string)
+				return string unless string.is_a?(String)
+				try_utf8! string
+				if string == 'true'.freeze
+					string = true
+				elsif string == 'false'.freeze
+					string = false
+				elsif string.to_i.to_s == string
+					string = string.to_i
+				end
+				string
+			end
+
+			# re-encodes a string into UTF-8 unly when the encoding will remail valid.
+			def self.try_utf8!(string, encoding= ::Encoding::UTF_8)
+				return false unless string
+				string.force_encoding(::Encoding::ASCII_8BIT) unless string.force_encoding(encoding).valid_encoding?
+				string
+			end
+
+
 		end
 	end
 

data/lib/plezi/oauth/auth_controller.rb

@@ -139,7 +139,7 @@ module Plezi
 		#             @user ||= app_login || OAuth2Ctrl.auth(:facebook, fb_token, self) || OAuth2Ctrl.auth(:google, google_token, self) || ....
 		def self.auth service_name, service_token, controller
 			service = SERVICES[service_name]
-			retrun false unless service
+			return false unless service
 			# auth_res = controller.cookies[c_name] ? (JSON.parse URI.parse("#{service[:profile_url]}?access_token=#{controller.cookies[c_name]}").read rescue ({}) ) : {}
 			# controller.cookies[c_name] = nil unless auth_res['id']
 			# auth_res['id'] ? controller.instance_exec( service_name, auth_res['id'], auth_res['email'], auth_res, &auth_callback) : ( controller.instance_exec( service_name, nil, nil, auth_res, &auth_callback) && false)
@@ -156,7 +156,7 @@ module Plezi
 		def update
 			service_name = params[:id].to_s.to_sym
 			service = SERVICES[service_name]
-			retrun false unless service
+			return false unless service
 			if params[:error]
 				instance_exec( service_name, nil, nil, nil, {}, &self.class.auth_callback)
 				return redirect_to(flash[:redirect_after])
@@ -190,7 +190,7 @@ module Plezi
 		def _auth_url_for service_name
 			service = SERVICES[service_name]
 			return nil unless service
-			redirect_uri = HTTP::encode "#{request.base_url}/auth/#{service_name.to_s}", :url #response_type
+			redirect_uri = Plezi::Base::Helpers.encode_url "#{request.base_url}/auth/#{service_name.to_s}", :url #response_type
 			return "#{service[:auth_url]}?client_id=#{service[:app_id]}&redirect_uri=#{redirect_uri}&scope=#{service[:scope]}&response_type=code"
 		end
 

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.10.17"
+    VERSION = "0.11.0"
 end

data/plezi.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "grhttp", "~> 0.0.23"
+  spec.add_dependency "grhttp", "~> 0.1.0"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 

data/resources/config.ru

@@ -22,7 +22,7 @@
 # 2. you have better control over Middleware then you could have with Plezi.
 # ("wait", you might say, "there is no Middleware in Plezi!"... "Ahhh", I will answer, "so much to discover...")
 
-NO_PLEZI_AUTO_START = true
+Object.const_set("NO_PLEZI_AUTO_START", true) unless defined?(NO_PLEZI_AUTO_START)
 
 # load all framework and gems
 load ::File.expand_path(File.join("..", "environment.rb"),  __FILE__)
@@ -31,11 +31,15 @@ load ::File.expand_path(File.join("..", "environment.rb"),  __FILE__)
 load ::File.expand_path(File.join("..", "routes.rb"),  __FILE__)
 
 # start the plezi EM, to make sure that the plezi async code doesn't break.
-GReactor.clear_listeners
-GReactor.start Plezi::Settings.max_threads
+if Rack::Handler.default == GRHttp::Base::Rack
+	run(Proc.new { [404, {}, []] })
+else
+	GReactor.clear_listeners
+	GReactor.start Plezi::Settings.max_threads
 
-# run the Rack app - not yet supported
-# run Plezi::Base::Rack
+	# run the Rack app - not yet supported
+	# run Plezi::Base::Rack
 
-# # exit rack to start the plezi server
-# Process.kill 'TERM'
+	# # exit rack to start the plezi server
+	# Process.kill 'TERM'
+end

data/resources/mini_app.rb

@@ -6,27 +6,26 @@
 	## Set up root object, it might be used by the environment and\or the plezi extension gems.
 	Root ||= Pathname.new(File.dirname(__FILE__)).expand_path
 	## Set a persistent session token id name
-	GRHttp.session_token = 'appname_uui'
-	## make sure all file access and file loading is relative to the application's root folder
-	# Dir.chdir Root.to_s
-	## load code from a subfolder called 'code'
-	# Dir[File.join "{code}", "**" , "*.rb"].each {|file| load File.expand_path(file)}
-	## OR load code from all the ruby files in the main forlder (subfolder inclussion will fail on PaaS)
-	# Dir[File.join File.dirname(__FILE__), "*.rb"].each {|file| load File.expand_path(file) unless file == __FILE__}
-
 	## If this app is independant, use bundler to load gems (including the plezi gem).
 	## Else, use the original app's Gemfile and start Plezi's Rack mode.
 		require 'bundler'
 		Bundler.require(:default, ENV['ENV'].to_s.to_sym)
 		## OR:
 		# Plesi.start_rack # remember 
+	GRHttp.session_token = 'appname_uui'
+	## make sure all file access and file loading is relative to the application's root folder
+	# Dir.chdir Root.to_s
+	## load code from a subfolder called 'app'
+	# Dir[File.join "{app}", "**" , "*.rb"].each {|file| load File.expand_path(file)}
+	## OR load code from all the ruby files in the main forlder (subfolder inclussion will fail on PaaS)
+	# Dir[File.join File.dirname(__FILE__), "*.rb"].each {|file| load File.expand_path(file) unless file == __FILE__}
 
 	## Uncomment to create a log file
 	# GReactor.create_logger File.expand_path(Root.join('server.log').to_s)
 
 ## Options for Scaling the app (across processes or machines):
-	## uncomment to set up forking.
-	# GReactor::Settings.set_forking 4
+	## uncomment to set up forking for 3 more processes (total of 4).
+	# GReactor.forking 3
 	## Redis scaling
 	# Plezi::Settings.redis_channel_name = 'appsecret'
 	# ENV['PL_REDIS_URL'] ||= ENV['REDIS_URL'] || ENV['REDISCLOUD_URL'] || ENV['REDISTOGO_URL'] || "redis://username:password@my.host:6389"

data/resources/mini_welcome_page.html

@@ -248,10 +248,10 @@ function send_text()
             <p class="bold">Reviewing the sample code and feeding <a href="https://github.com/boazsegev/plezi">Plezi</a> your code:</p>
             <ul>
                 <li>Review and update MyController in your 'appname.rb'.</li>
-                <li>Delete this file (appname/templates/welcome.html.erb).</li>
-                <li>Write your own controller and code, using a sub-foler as suggested in the 'appname.rb' file.</li>
+                <li>Edit or delete this file (appname/templates/welcome.html.erb).</li>
+                <li>Write your own controller and code, maybe using a sub-foler as suggested in the 'appname.rb' file.</li>
                 <li>Set up your routes in the 'appname.rb' file.</li>
-                <li>Edit the javascript for the client in your 'appname/websockets.js' file.</li>
+                <li>Edit the javascript for the client in your 'appname/websockets.js' file and link to it from your html.</li>
             </ul>
         </li>
         <li>

data/test/plezi_tests.rb

@@ -88,7 +88,7 @@ class TestCtrl
 		true
 	end
 	def _stream_out
-		response.send "streamed"
+		response << "streamed"
 		true
 	end
 	def file_test
@@ -303,7 +303,11 @@ module PleziTestTasks
 			puts e.message
 		end
 		remote = GRHttp::WSClient.connect_to("wss://echo.websocket.org/") {|ws| puts "    * Extra Websocket Remote test (SSL: echo.websocket.org): #{RESULTS[ws.data == 'Hello websockets!']}"; response.close}
-		remote << "Hello websockets!"
+		if remote.closed?
+			puts "    * Extra Websocket Remote test (SSL: echo.websocket.org): #{RESULTS[false]}"
+		else
+			remote << "Hello websockets!"
+		end
 		sleep 0.5
 		[ws1, ws2, ws3, ws4, remote].each {|ws| ws.close}
 		PL.on_shutdown {puts "    * Websocket connection message test: #{RESULTS[connection_test]}" unless connection_test}
@@ -475,7 +479,7 @@ Plezi.start_async
 PleziTestTasks.run_tests
 
 # ENV['PL_REDIS_URL'] ||= ENV['REDIS_URL'] || ENV['REDISCLOUD_URL'] || ENV['REDISTOGO_URL'] || "redis://test:1234@pub-redis-11008.us-east-1-4.5.ec2.garantiadata.com:11008"
-# GReactor::Settings.set_forking 4
+# GReactor.forking 4
 # GR.run_async { PleziTestTasks.run_tests }
 # start_services
 

data/websocket chatroom.md

@@ -109,7 +109,7 @@ Last, but not least, we tell Plezi to connect the root of our web application to
 route '/', ChatController
 ```
 
-Plezi controller classes are like virtual folders with special support for RESTful methods (`index`, `new`, `save`, `update`, `delete`), HTTP filters and helpers (`before`, `after`, `redirect_to`, `send_data`), WebSockets methods (`on_connect`, `on_message(data)`, `on_disconnect`), and WebSockets filters and helpers (`pre-connect`, `broadcast`, `collect`).
+Plezi controller classes are like virtual folders with special support for RESTful methods (`index`, `new`, `save`, `update`, `delete`), HTTP filters and helpers (`before`, `after`, `redirect_to`, `send_data`), WebSockets methods (`on_open`, `on_message(data)`, `on_close`), and WebSockets filters and helpers (`pre-connect`, `broadcast`, `unicast` etc').
 
 Plezi uses a common special parameter called 'id' to help with all this magic... if we don't define this parameter ourselves, Plezi will try to append this parameter to the end our route's path. So, actually, our route looks like this:
 
@@ -213,11 +213,11 @@ end
 To design a chatroom we will need a few things:
 
 1. We will need to force people identify themselves by choosing nicknames - to do this we will define the `on_connect` method to refuse any connections that don't have a nickname.
-2. We will want to make sure these nicknames are unique and don't give a wrong sense of authority (nicknames such as 'admin' should be forbidden) - for now, we will simply collect the nicknames from all the other active connections using the `collect` method and use that in our `on_connect` method.
+2. We will want to make sure these nicknames are unique and don't give a wrong sense of authority (nicknames such as 'admin' should be forbidden) - for now, we will simply refuse the 'wrong' type of nicknames and leave uniqieness for another time.
 3. We will want to push messages we recieve to all the other chatroom members - to do this we will use the `broadcast` method in our `on_message(data)` method.
 4. We will also want to tell people when someone left the chatroom - to do this we can define an `on_disconnect` method and use the `broadcast` method in there.
 
-We can use the :id parameter to collect the nickname.
+We can use the :id parameter to set the nickname.
 
 the :id is an automatic parameter that Plezi appended to our path like already explained and it's perfect for our simple needs.
 
@@ -225,9 +225,9 @@ We could probably rewrite our route to something like this: `route '/(:id)/(:nic
 
 ####Broadcasting chat (websocket) messages
 
-When we get a chat message, with `on_message(data)`, we will want to broadcast this message to all  the _other_ ChatController connections.
+When we get a chat message, with `on_message(data)`, we will want to broadcast this message to all the _other_ ChatController connections.
 
-Using JSON, our new  `on_message(data)` method can look something like this:
+Using JSON, our new `on_message(data)` method can look something like this:
 
 ```ruby
 def on_message data
@@ -239,7 +239,7 @@ def on_message data
 		return false
 	end
 	message = {}
-	message[:message] = data["message"]
+	message[:message] = GRHttp.HTTP.escape data['message'] # we should sanitize the data
 	message[:event] = :chat
 	message[:from] = params[:id]
 	message[:at] = Time.now
@@ -258,11 +258,11 @@ def on_message data
 		response.close
 		return false
 	end
-	broadcast :_send_message, {event: :chat, from: params[:id], message: data["message"], at: Time.now}.to_json
+	broadcast :_send_message, {event: :chat, from: params[:id], message: GRHttp.HTTP.escape(data['message']), at: Time.now}.to_json
 end
 ```
 
-Now that the code is shorter, let's look at that last line - the one that calls `broadcast`
+Now that the boring stuff is condenced, let's look at that last line - the one that calls `broadcast`
 
 `broadcast` is an interesing Plezi feature that allows us to tell all the _other_ connection to run a method. It is totally asynchroneos, so we don't wait for it to complete.
 
@@ -274,9 +274,9 @@ Let's start with the name - why the underscore at the beginning?
 
 Plezi knows that sometimes we will want to create public methods that aren't available as a path - remember the `people` method, it was automatically recognized as an HTTP path...
 
-Plezi allows us to 'exclude' some methods from this auto-recogntion. protected methods and methods starting with an underscore (\_) aren't recognized by the Plezi router.
+Plezi allows us to 'exclude' some methods from this auto-recogntion. protected methods and methods starting with an underscore (\_) are ignored by the Plezi router.
 
-Since we want the `_send_message` to be called by the `broadcast` method - it must be a public method (otherwise, we will not be able to call it for _other_ connections, only for our own connection).
+Since I was too lzy to write the `protected` keyword, I just added an underscore at the begining of the name.
 
 This will be our `_send_message` method:
 
@@ -288,7 +288,7 @@ end
 
 Did you notice the difference between WebSocket responses and HTTP?
 
-In WebSockets, we don't automatically send string data (this is an important safeguard) and we must use the `<<` method to add data to the response stream.
+Many times, Websockets are used to do internal work. This is why information is safeguarded and isn't automatically sent back (unlike HTTP, where a response is expected). In WebSockets, we must use the `<<` method to add data to the response stream.
 
 
 ####Telling people that we left the chatroom
@@ -322,7 +322,7 @@ If we ever write a real chatroom, our login process will look somewhat different
 First, we will ensure the new connection has a nickname (the connection was made to '/nickname' rather then the root of our application '/'):
 
 ```ruby
-def on_connect
+def on_open
 	if params[:id].nil?
 		response << {event: :error, from: :system, at: Time.now, message: "Error: cannot connect without a nickname!"}.to_json
 		response.close
@@ -331,18 +331,26 @@ def on_connect
 end
 ```
 
-Easy.
+Easy?
+
+There's an even easier and safer way to do this, which doesn't send an error message back, it looks like this:
+
+```ruby
+def pre_connect
+	return false if params[:id].nil?
+	true
+end
+```
 
-Next, we will ask everybody else who is connected to tell us their nicknames - we will test the new nickname against this list and make sure the nickname is unique.
+Since Websocket connections start as an HTTP GET request, the pre-connect is called while still in 'HTTP mode', allowing us to use HTTP logic and refuse connections even before any websocket data can be sent by the 'client'. This is definitly the safer approach.
 
-We will also add some reserved names to this list, to make sure nobody impersonates a system administrator... let's add this code to our `on_connect` method:
+Next, we will check if the nickname is on the reserved names list, to make sure nobody impersonates a system administrator... let's add this code to our `on_open` method:
 
 ```ruby
 	message = {from: '', at: Time.now}
-	list = collect(:_ask_nickname)
-	if (list + ['admin', 'system', 'sys', 'administrator']).include? params[:id]
+	if params[:id].match /admin|admn|system/i
 		message[:event] = :error
-		message[:message] = "The nickname '#{params[:id]}' is already taken."
+		message[:message] = "The nickname '#{params[:id]}' is refused."
 		response << message.to_json
 		params[:id] = false
 		response.close
@@ -350,20 +358,11 @@ We will also add some reserved names to this list, to make sure nobody impersona
 	end
 ```
 
-Hmm.. **collect**? what is the `collect` method? - well, this is a little bit of more Plezi magic that allows us to ask and collect information from all the _other_ active connections. This method returns an array of all the responses.
-
-We will use `collect` to get an array of all the connected nicknames - we will write the `_ask_nickname` method in just a bit.
-
 Then, if all is good, we will welcome the new connection to our chatroom. We will also tell the new guest who is already connected and broadcast their arrivale to everybody else...:
 
 ```ruby
 		message = {from: '', at: Time.now}
 		message[:event] = :chat
-		if list.empty?
-			message[:message] = "Welcome! You're the first one here."
-		else
-			message[:message] = "Welcome! #{list[0..-2].join(', ')} #{list[1] ? 'and' : ''} #{list.last} #{list[1] ? 'are' : 'is'} already here."
-		end
 		response << message.to_json
 		message[:message] = "#{params[:id]} joined the chatroom."
 		broadcast :_send_message, message.to_json

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.10.17
+  version: 0.11.0
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-10 00:00:00.000000000 Z
+date: 2015-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grhttp
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.23
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.23
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -62,12 +62,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".yardopts"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/plezi
+- docs/async_helpers.md
+- docs/http_helpers.md
+- docs/logging.md
+- docs/routes.md
+- docs/websockets.md
 - lib/plezi.rb
 - lib/plezi/builders/app_builder.rb
 - lib/plezi/builders/builder.rb
@@ -148,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Plezi - the easy way to add Websockets, RESTful routing and HTTP streaming