plezi 0.7.5 → 0.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 09b7229f402afa705079f518c81040b58b0bcdb9
-  data.tar.gz: 051c27c22d072d67a071f131db12ff81f118b743
+  metadata.gz: ba4ae19c5a61ca23f12826d1e3eabcde4ca8ba21
+  data.tar.gz: 9fa3579011986dc14efbe679a16f867d54e92a2c
 SHA512:
-  metadata.gz: 808a747010627be737fac767f277b650de4ae57ebd28cf3b3098a2b5c44790ddf0f69ffd1bec58ae4018fdb5e67f9953ad768890528627c450436416a0935e74
-  data.tar.gz: 35f5e69c499cb04f1e1e23b3f647ad209f960dae41248ce059a70ad958dca3357dfc79319130854a34c4d5a6735d149933281b0757005395ceed4f424b0e4289
+  metadata.gz: 967cacbbf63c8fcaa6a136051d5894f8cc93a49f38d3d21495dd3cc2ab38bb21121f73dc37de46f96c4d51b5a2203b7c351d7eb6ece02405959b7224687b9cab
+  data.tar.gz: a66e08cb87f9742d756a3c59122f1422474a6a455c1e83bf49f9156cb51bad7d77c8a21a298a762fbe6ac8a7c4dc4983109c4937b11e4632ea66af4f22620277

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ***
 
+Change log v.0.7.7
+(pre-release)
+
+***
+
+Change log v.0.7.6
+
+**performance**: minor performance improvements.
+
+**API**: minor additions to the Plezi API, such as the `Plezi.run_async` method.
+
+**fix**: Some HTTP refinements. for example, keep-alive headers are now enforced for all connections (not standard, but better performance). Patch requests are now pipelined to the controller's RESTful API.
+
+***
+
 Change log v.0.7.5
 
 **fix**: fixed an issue where form data might not be decoded correctly, resulting in remainin '+' signs that weren't properly converted to spaces.

data/README.md

@@ -2,7 +2,7 @@
 [![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://inch-ci.org/github/boazsegev/plezi)
 
-> People who are serious about their frameworks, should make their own servers...
+> People who are serious about their frameworks, should write their own servers...
 
 _(if to para-phrase "People who are serious about their software, should make their own hardware.")_
 

data/lib/plezi.rb

@@ -12,6 +12,7 @@ require 'securerandom'
 require 'time'
 require 'json'
 require 'uri'
+require 'set'
 ### version
 
 require "plezi/version"
@@ -70,40 +71,56 @@ end
 
 
 ##############################################################################
-# To make something new, we leap to the unknown.
-##############################################################################
-# Plezi is a stand alone web services app, which supports RESTful HTTP, HTTP Streaming and WebSockets.
+#
+# 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" in Haitian, since Plezi is really fun to work with and it keeps our code clean and streamlined.
 #
 # Plezi is a wonderful alternative to Socket.io which makes writing the server using Ruby a breeze. 
 #
-# Plezi routes accept Regexp's (regular exceptions) for route paths. for example:
+# Plezi is multi-threaded by default (you can change this) and supports asynchronous callbacks,
+# so it will keep going even if some requests take a while to compute.
+#
+# Plezi routes accept controller classes, which makes RESTful and WebSocket applications easy to write.
+# For example, open your Ruby terminal (the `irb` command) and type:
 #
 #    require 'plezi'
 #    listen
-#    route(/[.]*/) {|request, response| response << "Your request, master: #{request.path}."}
+#    route "*", Plezi::StubRESTCtrl
+#    exit # will start the service.
+#
+# Controller classes don't need to inherit anything :-)
 #
-# The catch-all route (/[.]*/) has a shortcut '*', so it's possible to write:
+# Plezi's routing systems inherits the Controller class, allowing you more freedom in your code.
 #
 #    require 'plezi'
+#    class MyController
+#       def index
+#          "Hello World!"
+#       end
+#    end
 #    listen
-#    route('*') {|request, response| response << "Your request, master: #{request.path}."}
+#    route "*", MyController
+#
+#    exit # I'll stop writing this line every time.
 #
+# Amazing(!), right? - You can read more in the documentation for Plezi::StubWSCtrl and Plezi::StubRESTCtrl, which are stub classes used for testing routes.
 #
-# Plezi accepts an optional class object that can be passed using the `route` command. Passing a class object is especially useful for RESTful and WebSocket applications.
-# read more at the Plezi::StubWSCtrl and Plezi::StubRESTCtrl documentation, which are stub classes used for testing routes.
+# Plezi routes accept Regexp's (regular exceptions) for route paths.
+# Plezi also accepts an optional block instead of the conrtoller Class object for example:
 #
 #    require 'plezi'
 #    listen
-#    route "*", Plezi::StubRESTCtrl
+#    route(/[.]*/) {|request, response| response << "Your request, master: #{request.path}."}
+#
+# As you may have noticed before, the catch-all route (/[.]*/) has a shortcut: '*'.
 #
 # class routes that have a specific path (including root, but not a catch-all or Regexp path)
 # accept an implied `params[:id]` variable. the following path ('/'):
 #
 #    require 'plezi'
 #    listen
-#    route "/", Plezi::StubRESTCtrl
-#    # client requests: /1
-#    #  =>  Plezi::StubRESTCtrl.new.show() # where params[:id] == 1
+#    route "/", Plezi::StubWSCtrl
+#    # go to: http://localhost:3000/1
+#    # =>  Plezi::StubRESTCtrl.new.show() # where params[:id] == 1
 #
 # it is possible to use "magic" routes (i.e. `/resource/:type/(:id)/(:date){/[0-9]{8}}/:foo`) and it is also possible to set the appropriate parameters within the `before` method of the Conltroller.
 #
@@ -116,7 +133,30 @@ end
 #    end
 #    route('*') {|request, response| response.body << "Ahhh... I love cats!"}
 #
-# all the examples above shuold be good to run from irb. updated examples can be found at the Readme file in the Github project: https://github.com/boazsegev/plezi
+# The Plezi module (also `PL`) also has methods to help with asynchronous tasking, callbacks, timers and customized shutdown cleanup.
+#
+# Heres a short demo fir asynchronous callbacks (works only while services are active and running):
+#
+#    require 'plezi'
+#
+#    def my_shutdown_proc time_start
+#        puts "Services were running for #{Time.now - time_start} ms."
+#    end
+#
+#    # shutdown callbacks
+#    PL.on_shutdown(Kernel, :my_shutdown_proc, Time.now) { puts "this will run after shutdown." }
+#    PL.on_shutdown() { puts "this will run too." }
+#
+#    # a timer
+#    PL.run_after 2, -> {puts "this will wait 2 seconds to run... too late. for this example"}
+#
+#    # an asynchronous method call with an optional callback block
+#    PL.callback(Kernel, :puts, "Plezi will start eating our code once we exit terminal.") {puts 'first output finished'}
+#
+#    # remember to exit to make it all start
+#    exit
+#
+# all the examples above shoold be good to run from irb. updated examples can be found at the Readme file in the Github project: https://github.com/boazsegev/plezi
 #
 # thanks to Russ Olsen for his ideas for a DSL and his blog post at:
 # http://www.jroller.com/rolsen/entry/building_a_dsl_in_ruby1 

data/lib/plezi/base/engine.rb

@@ -9,24 +9,8 @@ module Plezi
 	end
 	# Plezi event cycle settings: sets how many worker threads Plezi will run.
 	def max_threads= value
-		@max_threads = value
-	end
-
-	# Plezi event cycle settings: how long to wait for IO activity before forcing another cycle.
-	#
-	# No timing methods will be called during this interval.
-	#
-	# get the current idle setting
-	def idle_sleep
-		@idle_sleep ||= 0.1
-	end
-	# Plezi event cycle settings: how long to wait for IO activity before forcing another cycle.
-	#
-	# No timing methods will be called during this interval.
-	#
-	# set the current idle setting
-	def idle_sleep= value
-		@idle_sleep = value
+		raise "Plezi will hang and do nothing if there isn't at least one (1) working thread. Cannot set Plezi.max_threads = #{value}" if value.to_i <= 0
+		@max_threads = value.to_i
 	end
 
 	# Plezi Engine, DO NOT CALL. creates the thread pool and starts cycling through the events.
@@ -45,7 +29,7 @@ module Plezi
 		# set signal tarps
 		trap('INT'){ exit_flag = true; raise "close Plezi" }
 		trap('TERM'){ exit_flag = true; raise "close Plezi" }
-		puts 'Services running. Press ^C to stop'
+		puts "Services running Plezi version #{Plezi::VERSION}. Press ^C to stop"
 		# sleep until trap raises exception (cycling might cause the main thread to ignor signals and lose attention)
 		(sleep unless SERVICES.empty?) rescue true
 		# start shutdown.
@@ -79,8 +63,8 @@ module Plezi
 		true while fire_event
 		fire_timers
 
-		rescue Exception => e
-
-		error e
+		# rescue Exception => e
+		# error e
+		# # raise if e.is_a?(SignalException) || e.is_a?(SystemExit)
 	end
 end

data/lib/plezi/base/events.rb

@@ -33,6 +33,15 @@ module Plezi
 		end
 	end
 
+	# Public API. Runs the block asynchronously by pushin it as an event to the event's stack
+	#
+	# accepts a block to be executed asynchronously.
+	#
+	def run_async *args, &block
+		LOCKER.synchronize {EVENTS << [ block, args ]} if block
+		block
+	end
+
 	# Public API. creates an asynchronous call to a method, with an optional callback:
 	# demo use:
 	# `callback( Kernel, :sleep, 1 ) { puts "this is a demo" }`

data/lib/plezi/base/io_reactor.rb

@@ -3,6 +3,27 @@ module Plezi
 
 	module_function
 
+	# set the default idle waiting time.
+	@idle_sleep = 0.1
+
+	# Plezi event cycle settings: how long to wait for IO activity before forcing another cycle.
+	#
+	# No timing methods will be called during this interval.
+	#
+	# Gets the current idle setting. The default setting is 0.1 seconds.
+	def idle_sleep
+		@idle_sleep
+	end
+	# Plezi event cycle settings: how long to wait for IO activity before forcing another cycle.
+	#
+	# No timing methods will be called during this interval (#run_after / #run_every).
+	# 
+	# It's rare, but it's one of the reasons for the timeout: some connections might wait for the timeout befor being established.
+	#
+	# set the current idle setting
+	def idle_sleep= value
+		@idle_sleep = value
+	end
 
 	# DANGER ZONE - Plezi Engine. the io reactor mutex
 	IO_LOCKER = Mutex.new
@@ -13,13 +34,13 @@ module Plezi
 			return false unless EVENTS.empty?
 			united = SERVICES.keys + IO_CONNECTION_DIC.keys
 			return false if united.empty?
-			io_r = (IO.select(united, nil, united, idle_sleep) ) #rescue false)
+			io_r = (IO.select(united, nil, united, @idle_sleep) ) #rescue false)
 			if io_r
 				io_r[0].each do |io|
 					if SERVICES[io]
 						begin
 							connection = io.accept_nonblock
-							callback Plezi, :add_connection, connection, SERVICES[io]
+							push_event method(:add_connection), connection, SERVICES[io]
 						rescue Errno::EWOULDBLOCK => e
 
 						rescue Exception => e
@@ -27,7 +48,7 @@ module Plezi
 							# SERVICES.delete s if s.closed?
 						end
 					elsif IO_CONNECTION_DIC[io]
-						callback(IO_CONNECTION_DIC[io], :on_message)
+						push_event IO_CONNECTION_DIC[io].method(:on_message)
 					else
 						IO_CONNECTION_DIC.delete(io)
 						SERVICES.delete(io)

data/lib/plezi/base/logging.rb

@@ -21,10 +21,8 @@ module Plezi
 	# log_file:: a log file name to be used for logging
 	# copy_to_stdout:: if false, log will only log to file. defaults to true.
 	def create_logger log_file = STDOUT, copy_to_stdout = false
-		@copy_to_stdout = false
-		@copy_to_stdout = ::Logger.new(STDOUT) if copy_to_stdout
+		@copy_to_stdout = ( copy_to_stdout ? (::Logger.new(STDOUT)) : false )
 		@logger = ::Logger.new(log_file)
-		@logger
 	end
 	alias :set_logger :create_logger
 

data/lib/plezi/base/rack_app.rb

@@ -15,12 +15,12 @@ module Plezi
 		Object.const_set('PLEZI_ON_RACK', true) unless defined? PLEZI_ON_RACK
 
 		# re-encode to utf-8, as it's all BINARY encoding at first
-		env["rack.input"].rewind
-		env['rack.input'] = StringIO.new env["rack.input"].read.encode("utf-8", "binary", invalid: :replace, undef: :replace, replace: '')		 	
+		env['rack.input'].rewind
+		env['rack.input'] = StringIO.new env['rack.input'].read.encode('utf-8', 'binary', invalid: :replace, undef: :replace, replace: '')		 	
 		env.each do |k, v|
 			if k.to_s.match /^[A-Z]/
 				if v.is_a?(String) && !v.frozen?
-					v.force_encoding("binary").encode!("utf-8", "binary", invalid: :replace, undef: :replace, replace: '') unless v.force_encoding("utf-8").valid_encoding?
+					v.force_encoding('binary').encode!('utf-8', 'binary', invalid: :replace, undef: :replace, replace: '') unless v.force_encoding('utf-8').valid_encoding?
 				end
 			end
 		end
@@ -33,11 +33,11 @@ module Plezi
 		make_hash_accept_symbols(env)
 
 		# use Plezi Cookies
-		env["rack.request.cookie_string"] = env["HTTP_COOKIE"]
-		env["rack.request.cookie_hash"] = Plezi::Cookies.new.update(env["rack.request.cookie_hash"] || {})
+		env['rack.request.cookie_string'] = env['HTTP_COOKIE']
+		env['rack.request.cookie_hash'] = Plezi::Cookies.new.update(env['rack.request.cookie_hash'] || {})
 
 		# chomp path
-		env["PATH_INFO"].chomp! '/'
+		env['PATH_INFO'].chomp! '/'
 
 		# get response
 		response = Plezi::SERVICES[0][1][:handler].call env
@@ -51,8 +51,8 @@ module Plezi
 		headers.delete 'transfer-encoding'
 		headers.delete 'connection'
 		unless response.cookies.empty?
-			headers["Set-Cookie"] = []
-			response.cookies.each {|k,v| headers["Set-Cookie"] << ("#{k.to_s}=#{v.to_s}")}
+			headers['Set-Cookie'] = []
+			response.cookies.each {|k,v| headers['Set-Cookie'] << ("#{k.to_s}=#{v.to_s}")}
 		end
 		[response.status, headers, response.body]
 	end

data/lib/plezi/handlers/controller_magic.rb

@@ -106,16 +106,16 @@ module Plezi
 				response << data
 
 				# set headers
-				content_disposition = "attachment"
+				content_disposition = 'attachment'
 
 				options[:type] ||= MimeTypeHelper::MIME_DICTIONARY[::File.extname(options[:filename])] if options[:filename]
 
 				if options[:type]
-					response["content-type"] = options[:type]
+					response['content-type'] = options[:type]
 					options.delete :type
 				end
 				if options[:inline]
-					content_disposition = "inline"
+					content_disposition = 'inline'
 					options.delete :inline
 				end
 				if options[:attachment]
@@ -125,8 +125,8 @@ module Plezi
 					content_disposition << "; filename=#{options[:filename]}"
 					options.delete :filename
 				end
-				response["content-length"] = data.bytesize rescue true
-				response["content-disposition"] = content_disposition
+				response['content-length'] = data.bytesize rescue true
+				response['content-disposition'] = content_disposition
 				response.finish
 				true
 			end
@@ -189,7 +189,7 @@ module Plezi
 				# respond to websocket special case
 				return :pre_connect if request['upgrade'] && request['upgrade'].to_s.downcase == 'websocket' &&  request['connection'].to_s.downcase == 'upgrade'
 				# respond to save 'new' special case
-				return :save if request.request_method.match(/POST|PUT/) && params[:id].nil? || params[:id] == 'new'
+				return :save if request.request_method.match(/POST|PUT|PATCH/) && params[:id].nil? || params[:id] == 'new'
 				# set DELETE method if simulated
 				request.request_method = 'DELETE' if params[:_method].to_s.downcase == 'delete'
 				# respond to special :id routing
@@ -199,7 +199,7 @@ module Plezi
 				when 'GET', 'HEAD'
 					return :index unless params[:id]
 					return :show
-				when 'POST', 'PUT'
+				when 'POST', 'PUT', 'PATCH'
 					return :update
 				when 'DELETE'
 					return :delete
@@ -270,19 +270,19 @@ module Plezi
 			# lists the available methods that will be exposed to HTTP requests
 			def available_public_methods
 				# set class global to improve performance while checking for supported methods
-				Plezi.cached?(self.superclass.name + "_p&rt") ? Plezi.get_cached(self.superclass.name + "_p&rt") : Plezi.cache_data(self.superclass.name + "_p&rt", available_routing_methods - [:before, :after, :save, :show, :update, :delete, :initialize, :on_message, :pre_connect, :on_connect, :on_disconnect])
+				Plezi.cached?(self.superclass.name + '_p&rt') ? Plezi.get_cached(self.superclass.name + "_p&rt") : Plezi.cache_data(self.superclass.name + "_p&rt", (available_routing_methods - [:before, :after, :save, :show, :update, :delete, :initialize, :on_message, :pre_connect, :on_connect, :on_disconnect]).to_set )
 			end
 
 			# lists the available methods that will be exposed to the HTTP router
 			def available_routing_methods
 				# set class global to improve performance while checking for supported methods
-				Plezi.cached?(self.superclass.name + "_r&rt") ? Plezi.get_cached(self.superclass.name + "_r&rt") : Plezi.cache_data(self.superclass.name + "_r&rt",  (((public_instance_methods - Object.public_instance_methods) - Plezi::ControllerMagic::InstanceMethods.instance_methods).delete_if {|m| m.to_s[0] == '_'})  )
+				Plezi.cached?(self.superclass.name + '_r&rt') ? Plezi.get_cached(self.superclass.name + "_r&rt") : Plezi.cache_data(self.superclass.name + "_r&rt",  (((public_instance_methods - Object.public_instance_methods) - Plezi::ControllerMagic::InstanceMethods.instance_methods).delete_if {|m| m.to_s[0] == '_'}).to_set  )
 			end
 
 			# resets this controller's router, to allow for dynamic changes
 			def reset_routing_cache
-				Plezi.clear_cached(self.superclass.name + "_p&rt")
-				Plezi.clear_cached(self.superclass.name + "_r&rt")
+				Plezi.clear_cached(self.superclass.name + '_p&rt')
+				Plezi.clear_cached(self.superclass.name + '_r&rt')
 				available_routing_methods
 				available_public_methods
 			end
@@ -329,10 +329,10 @@ module Plezi
 				# raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless @@redis
 				# @@redis
 				return false unless defined?(Redis) && ENV['PL_REDIS_URL']
-				return Plezi.get_cached(self.superclass.name + "_b") if Plezi.cached?(self.superclass.name + "_b")
+				return Plezi.get_cached(self.superclass.name + '_b') if Plezi.cached?(self.superclass.name + '_b')
 				@@redis_uri ||= URI.parse(ENV['PL_REDIS_URL'])
-				Plezi.cache_data self.superclass.name + "_b", Redis.new(host: @@redis_uri.host, port: @@redis_uri.port, password: @@redis_uri.password)
-				raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless Plezi.cached?(self.superclass.name + "_b")
+				Plezi.cache_data self.superclass.name + '_b', Redis.new(host: @@redis_uri.host, port: @@redis_uri.port, password: @@redis_uri.password)
+				raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless Plezi.cached?(self.superclass.name + '_b')
 				t = Thread.new do
 					begin
 						Redis.new(host: @@redis_uri.host, port: @@redis_uri.port, password: @@redis_uri.password).subscribe(redis_channel_name) do |on|
@@ -347,8 +347,8 @@ module Plezi
 						retry
 					end
 				end
-				Plezi.cache_data self.superclass.name + "_t", t
-				Plezi.get_cached(self.superclass.name + "_b")
+				Plezi.cache_data self.superclass.name + '_t', t
+				Plezi.get_cached(self.superclass.name + '_b')
 			end
 
 			# returns a Redis channel name for this controller.

data/lib/plezi/handlers/http_echo.rb

@@ -6,7 +6,7 @@ module Plezi
 
 		# handles requests by printing out the parsed data. gets the `request` parameter from the HTTP protocol.
 		def on_request request
-			response = HTTPResponse.new request, 200, {"content-type" => "text/plain"}, ["parsed as:\r\n", request.to_s]
+			response = HTTPResponse.new request, 200, {'content-type' => 'text/plain'}, ["parsed as:\r\n", request.to_s]
 			response.body.last << "\n\n params:"
 			request.params.each {|k,v| response.body.last << "\n#{k}: #{v}"}
 			response.send

data/lib/plezi/handlers/http_host.rb

@@ -108,7 +108,7 @@ module Plezi
 						return send_file(request, File.join(params[:root], "#{code}.html"), code, headers)
 					end
 				end
-				return true if send_raw_data(request, HTTPResponse::STATUS_CODES[code], "text/plain", code, headers)
+				return true if send_raw_data(request, HTTPResponse::STATUS_CODES[code], 'text/plain', code, headers)
 			rescue Exception => e
 				Plezi.error e
 			end

data/lib/plezi/handlers/http_router.rb

@@ -50,18 +50,18 @@ module Plezi
 			elsif hosts[:default]
 				hosts[:default].on_request request
 			else
-				HTTPResponse.new( request, 404, {"content-type" => "text/plain", "content-length" => "15"}, ["host not found."]).finish
+				HTTPResponse.new( request, 404, {'content-type' => 'text/plain', 'content-length' => '15'}, ['host not found.']).finish
 			end
 			request.service.timeout = 5
 		end
 		# handles requests send by Rack - dresses up as Middleware, for Rack (if you're don't like WebSockets, go ahead...)
 		def call env
-			if env["HOST"] && hosts[env["HOST"].downcase]
-				hosts[env["HOST"].downcase].call env
+			if env['HOST'] && hosts[env['HOST'].downcase]
+				hosts[env['HOST'].downcase].call env
 			elsif hosts[:default]
 				hosts[:default].call env
 			else
-				[404, {"content-type" => "text/plain", "content-length" => "15"}, ["host not found."] ]
+				[404, {'content-type' => 'text/plain', 'content-length' => '15'}, ['host not found.'] ]
 			end
 		end
 	end

data/lib/plezi/handlers/stubs.rb

@@ -103,6 +103,7 @@ module Plezi
 		# data is a string that contains binary or UTF8 (message dependent) data.
 		def on_message data
 			broadcast :_push, data
+			_push "your message was sent: #{data.to_s}"
 		end
 
 		# called when a disconnect packet has been recieved or the connection has been cut
@@ -116,7 +117,7 @@ module Plezi
 		# BUT, broadcasted methods must be public (or the broadcast will quietly fail)... so we have to use
 		# the _underscore for this method.
 		def _push data
-			response << data		
+			response << data.to_s
 		end
 
 		#####
@@ -125,7 +126,7 @@ module Plezi
 
 		# called when request is GET and params\[:id] isn't defined
 		def index
-			{message: 'index', data: {id: nil, token: nil}}.to_json
+			"This stub controller is used to test websockets.\n\r\n\rVisit http://www.websocket.org/echo.html for WS testing.\n\r\n\rOr add a nickname to the route to view long-pulling stub. i.e.: #{request.base_url}/nickname"
 		end
 
 		# called when request is GET and params\[:id] exists (unless params\[:id] == "new").

data/lib/plezi/server/helpers/http.rb

@@ -99,8 +99,8 @@ module Plezi
 				when :html
 					object.gsub!(/&/i, '&')
 					object.gsub!(/"/i, '"')
-					object.gsub!(/>/i, ">")
-					object.gsub!(/&lt;/i, "<")
+					object.gsub!(/&gt;/i, '>')
+					object.gsub!(/&lt;/i, '<')
 				when :utf8
 
 				else
@@ -126,19 +126,19 @@ module Plezi
 			elsif object.is_a?(String)
 				case decode_method
 				when :uri, :url, :form
-					object.force_encoding "binary"
+					object.force_encoding 'binary'
 					object.gsub!(/[^a-zA-Z0-9\*\.\_\-]/) {|m| m.ord <= 16 ? "%0#{m.ord.to_s(16)}" : "%#{m.ord.to_s(16)}"}
 				when :html
-					object.gsub!('&', "&amp;")
-					object.gsub!('"', "&quot;")
-					object.gsub!(">", "&gt;")
-					object.gsub!("<", "&lt;")
-					object.gsub!(/[^\sa-zA-Z\d\&\;]/) {|m| "&#%04d;" % m.unpack('U')[0] }
+					object.gsub!('&', '&amp;')
+					object.gsub!('"', '&quot;')
+					object.gsub!('>', '&gt;')
+					object.gsub!('<', '&lt;')
+					object.gsub!(/[^\sa-zA-Z\d\&\;]/) {|m| '&#%04d;' % m.unpack('U')[0] }
 					# object.gsub!(/[^\s]/) {|m| "&#%04d;" % m.unpack('U')[0] }
-					object.force_encoding "binary"
+					object.force_encoding 'binary'
 				when :utf8
-					object.gsub!(/[^\sa-zA-Z\d]/) {|m| "&#%04d;" % m.unpack('U')[0] }
-					object.force_encoding "binary"
+					object.gsub!(/[^\sa-zA-Z\d]/) {|m| '&#%04d;' % m.unpack('U')[0] }
+					object.force_encoding 'binary'
 				else
 
 				end
@@ -163,7 +163,7 @@ module Plezi
 		# re-encodes a string into UTF-8
 		def make_utf8!(string, encoding= 'utf-8')
 			return false unless string
-			string.force_encoding("binary").encode!(encoding, "binary", invalid: :replace, undef: :replace, replace: '') unless string.force_encoding(encoding).valid_encoding?
+			string.force_encoding('binary').encode!(encoding, 'binary', invalid: :replace, undef: :replace, replace: '') unless string.force_encoding(encoding).valid_encoding?
 			string
 		end
 

data/lib/plezi/server/protocols/http_protocol.rb

@@ -7,6 +7,7 @@ module Plezi
 	class HTTPProtocol
 
 		HTTP_METHODS = %w{GET HEAD POST PUT DELETE TRACE OPTIONS}
+		HTTP_METHODS_REGEXP = /^#{HTTP_METHODS.join('|')}/
 
 		attr_accessor :service
 
@@ -18,7 +19,7 @@ module Plezi
 			@parser_chunk = ''
 			@parser_length = 0
 			@locker = Mutex.new
-			@@rack_dictionary ||= {"HOST".freeze => :host_name, 'REQUEST_METHOD'.freeze => :method,
+			@@rack_dictionary ||= {'HOST'.freeze => :host_name, 'REQUEST_METHOD'.freeze => :method,
 								'PATH_INFO'.freeze => :path, 'QUERY_STRING'.freeze => :query,
 								'SERVER_NAME'.freeze => :host_name, 'SERVER_PORT'.freeze => :port,
 								'rack.url_scheme'.freeze => :requested_protocol}
@@ -76,7 +77,7 @@ module Plezi
 
 		# parses the method request (the first line in the HTTP request).
 		def parse_method data
-			return false unless data[0] && data[0].match(/^#{HTTP_METHODS.join('|')}/)
+			return false unless data[0] && data[0].match(HTTP_METHODS_REGEXP)
 			@parser_data[:time_recieved] = Time.now
 			@parser_data[:params] = {}
 			@parser_data[:cookies] = Cookies.new
@@ -110,7 +111,7 @@ module Plezi
 			end
 			return false unless data[0]
 			data.shift while data[0] && data[0].match(/^[\r\n]+$/)
-			if @parser_data["transfer-coding"] || (@parser_data["content-length"] && @parser_data["content-length"].to_i != 0) || @parser_data["content-type"]
+			if @parser_data['transfer-coding'] || (@parser_data['content-length'] && @parser_data['content-length'].to_i != 0) || @parser_data['content-type']
 				@parser_stage = 2
 			else					
 				# create request object and hand over to handler
@@ -123,7 +124,7 @@ module Plezi
 		#parses the body of a request.
 		def parse_body data
 			# check for body is needed, if exists and if complete
-			if @parser_data["transfer-coding"] == "chunked"
+			if @parser_data['transfer-coding'] == 'chunked'
 				until data.empty? || data[0].to_s.match(/0(\r)?\n/)
 					if @parser_length == 0
 						@parser_length = data.to_s.shift.match(/^[a-z0-9A-Z]+/).to_i(16)
@@ -141,8 +142,8 @@ module Plezi
 				return false unless data[0].to_s.match(/0(\r)?\n/)
 				true until data.empty? || data.shift.match(/^[\r\n]+$/)
 				data.shift while data[0].to_s.match /^[\r\n]+$/
-			elsif @parser_data["content-length"].to_i
-				@parser_length = @parser_data["content-length"].to_i if @parser_length == 0
+			elsif @parser_data['content-length'].to_i
+				@parser_length = @parser_data['content-length'].to_i if @parser_length == 0
 				@parser_chunk << data.shift while @parser_length > @parser_chunk.bytesize && data[0]
 				return false if @parser_length > @parser_chunk.bytesize
 				@parser_body = @parser_chunk.byteslice(0, @parser_length)
@@ -206,13 +207,13 @@ module Plezi
 
 			#check for server-responses
 			case request.request_method
-			when "TRACE"
+			when 'TRACE'
 				return true
-			when "OPTIONS"
+			when 'OPTIONS'
 				Plezi.push_event Proc.new do
 					response = HTTPResponse.new request
-					response[:Allow] = "GET,HEAD,POST,PUT,DELETE,OPTIONS"
-					response["access-control-allow-origin"] = "*"
+					response[:Allow] = 'GET,HEAD,POST,PUT,DELETE,OPTIONS'
+					response['access-control-allow-origin'] = '*'
 					response['content-length'] = 0
 					response.finish
 				end
@@ -223,14 +224,14 @@ module Plezi
 			if service && service.handler
 				Plezi.callback service.handler, :on_request, request
 			else
-				Plezi.error "No Handler for this HTTP service."
+				Plezi.error 'No Handler for this HTTP service.'
 			end
 		end
 
 		# read the body's data and parse any incoming data.
 		def read_body
 			# parse content
-			case @parser_data["content-type"].to_s
+			case @parser_data['content-type'].to_s
 			when /x-www-form-urlencoded/
 				HTTP.extract_data @parser_body.split(/[&;]/), @parser_data[:params], :form # :uri
 			when /multipart\/form-data/
@@ -243,19 +244,19 @@ module Plezi
 				JSON.parse(HTTP.make_utf8! @parser_data[:body]).each {|k, v| HTTP.add_param_to_hash k, v, @parser_data[:params]}
 			else
 				@parser_data[:body] = @parser_body.dup
-				Plezi.error "POST body type (#{@parser_data["content-type"]}) cannot be parsed. raw body is kept in the request's data as request[:body]: #{@parser_body}"
+				Plezi.error "POST body type (#{@parser_data['content-type']}) cannot be parsed. raw body is kept in the request's data as request[:body]: #{@parser_body}"
 			end
 		end
 
 		# parse a mime/multipart body or part.
 		def read_multipart headers, part, name_prefix = ''
-			if headers["content-type"].to_s.match /multipart/
-				boundry = headers["content-type"].match(/boundary=([^\s]+)/)[1]
-				if headers["content-disposition"].to_s.match /name=/
+			if headers['content-type'].to_s.match /multipart/
+				boundry = headers['content-type'].match(/boundary=([^\s]+)/)[1]
+				if headers['content-disposition'].to_s.match /name=/
 					if name_prefix.empty?
-						name_prefix << HTTP.decode(headers["content-disposition"].to_s.match(/name="([^"]*)"/)[1])
+						name_prefix << HTTP.decode(headers['content-disposition'].to_s.match(/name="([^"]*)"/)[1])
 					else
-						name_prefix << "[#{HTTP.decode(headers["content-disposition"].to_s.match(/name="([^"]*)"/)[1])}]"
+						name_prefix << "[#{HTTP.decode(headers['content-disposition'].to_s.match(/name="([^"]*)"/)[1])}]"
 					end
 				end
 				part.split(/([\r]?\n)?--#{boundry}(--)?[\r]?\n/).each do |p|
@@ -284,14 +285,14 @@ module Plezi
 
 			# convert part to `charset` if charset is defined?
 
-			if !headers["content-disposition"]
+			if !headers['content-disposition']
 				Plezi.error "Wrong multipart format with headers: #{headers} and body: #{part}"
 				return
 			end
 
 			cd = {}
 
-			HTTP.extract_data headers["content-disposition"].match(/[^;];([^\r\n]*)/)[1].split(/[;,][\s]?/), cd, :uri
+			HTTP.extract_data headers['content-disposition'].match(/[^;];([^\r\n]*)/)[1].split(/[;,][\s]?/), cd, :uri
 
 			name = name_prefix.dup
 
@@ -300,9 +301,9 @@ module Plezi
 			else
 				name << "[#{HTTP.decode(cd[:name][1..-2])}]"
 			end
-			if headers["content-type"]
+			if headers['content-type']
 				HTTP.add_param_to_hash "#{name}[data]", part, @parser_data[:params]
-				HTTP.add_param_to_hash "#{name}[type]", HTTP.make_utf8!(headers["content-type"]), @parser_data[:params]
+				HTTP.add_param_to_hash "#{name}[type]", HTTP.make_utf8!(headers['content-type']), @parser_data[:params]
 				cd.each {|k,v|  HTTP.add_param_to_hash "#{name}[#{k.to_s}]", HTTP.make_utf8!(v[1..-2]), @parser_data[:params] unless k == :name}
 			else
 				HTTP.add_param_to_hash name, HTTP.decode(part, :utf8), @parser_data[:params]

data/lib/plezi/server/protocols/http_request.rb

@@ -110,6 +110,14 @@ module Plezi
 		def patch?
 			self[:method] == 'PATCH'
 		end
+		# returns true if the request is of type JSON.
+		def json?
+			self['content-type'].match /application\/json/
+		end
+		# returns true if the request is of type XML.
+		def xml?
+			self['content-type'].match /text\/xml/
+		end
 
 	end
 end

data/lib/plezi/server/protocols/http_response.rb

@@ -43,7 +43,7 @@ module Plezi
 				hs["plezi_flash_#{k.to_s}".to_sym] if hs.has_key? "plezi_flash_#{k.to_s}".to_sym
 			end
 			request.cookies.each do |k,v|
-				@flash[k] = v if k.to_s.start_with? "plezi_flash_"
+				@flash[k] = v if k.to_s.start_with? 'plezi_flash_'
 			end
 		end
 
@@ -122,14 +122,14 @@ module Plezi
 			params[:path] ||= '/'
 			value = HTTP.encode(value.to_s)
 			if params[:max_age]
-				value << ("; Max-Age=%s" % params[:max_age])
+				value << ('; Max-Age=%s' % params[:max_age])
 			else
-				value << ("; Expires=%s" % params[:expires].httpdate)
+				value << ('; Expires=%s' % params[:expires].httpdate)
 			end
 			value << "; Path=#{params[:path]}"
 			value << "; Domain=#{params[:domain]}" if params[:domain]
-			value << "; Secure" if params[:secure]
-			value << "; HttpOnly" if params[:http_only]
+			value << '; Secure' if params[:secure]
+			value << '; HttpOnly' if params[:http_only]
 			@cookies[HTTP.encode(name.to_s).to_sym] = value
 		end
 
@@ -155,7 +155,7 @@ module Plezi
 			body << str if str && body.is_a?(Array)
 			send_headers
 			return if request.head?
-			if headers["transfer-encoding"] == "chunked"
+			if headers['transfer-encoding'] == 'chunked'
 				body.each do |s|
 					service.send "#{s.bytesize.to_s(16)}\r\n"
 					service.send s
@@ -177,8 +177,9 @@ module Plezi
 			return self if defined?(PLEZI_ON_RACK)
 			raise 'HTTPResponse SERVICE MISSING: cannot send http response without a service.' unless service
 			self.send
-			service.send( (headers["transfer-encoding"] == "chunked") ? "0\r\n\r\n" : nil)
+			service.send( (headers['transfer-encoding'] == 'chunked') ? "0\r\n\r\n" : nil)
 			@finished = true
+			# service.disconnect unless headers['keep-alive']
 			# log
 			Plezi.log_raw "#{request[:client_ip]} [#{Time.now.utc}] \"#{request[:method]} #{request[:original_path]} #{request[:requested_protocol]}\/#{request[:version]}\" #{status} #{bytes_sent.to_s} #{"%0.3f" % ((Time.now - request[:time_recieved])*1000)}ms\n"
 		end
@@ -190,13 +191,14 @@ module Plezi
 
 		# Danger Zone (internally used method, use with care): fix response's headers before sending them (date, connection and transfer-coding).
 		def fix_headers
-			# headers['Connection'] ||= "Keep-Alive"
+			headers['connection'] = "Keep-Alive"
+			headers['keep-alive'] = "timeout=5"
 			headers['date'] = Time.now.httpdate
 			headers['transfer-encoding'] ||= 'chunked' if !headers['content-length']
 			headers['cache-control'] ||= 'no-cache'
 			# remove old flash cookies
 			request.cookies.keys.each do |k|
-				if k.to_s.start_with? "plezi_flash_"
+				if k.to_s.start_with? 'plezi_flash_'
 					set_cookie k, nil
 					flash.delete k
 				end

data/lib/plezi/server/protocols/websocket.rb

@@ -45,7 +45,7 @@ module Plezi
 			service.timeout = @timeout_interval
 			# Plezi.callback service, :timeout=, @timeout_interval
 			Plezi.callback @service.handler, :on_connect if @service.handler.methods.include?(:on_connect)
-			Plezi.info "Upgraded HTTP to WebSockets. Logging only errors."
+			Plezi.info 'Upgraded HTTP to WebSockets. Logging only errors.'
 		end
 
 		# called when data is recieved

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.7.5"
+    VERSION = "0.7.6"
 end

data/resources/redis_config.rb

@@ -18,17 +18,21 @@ if defined? Redis
 	# ENV['PL_REDIS_URL'] = ENV['REDISCLOUD_URL'] ||= ENV["REDISTOGO_URL"] ||= "redis://username:password@my.host:6389"
 
 
+	# ## Custom Redis Automation
+	# ## ====
+	# ##
 	# ## create a listening thread - rewrite the following code for your own Redis tailored solution.
 	# ##
 	# ## the following is only sample code for you to change:
-	# RADIS_CHANNEL = appsecret
+	# RADIS_CHANNEL = 'appsecret'
 	# RADIS_URI = URI.parse(ENV['REDISCLOUD_URL'] || "redis://username:password@my.host:6389")
 	# RADIS_CONNECTION = Redis.new(host: RADIS_URI.host, port: RADIS_URI.port, password: RADIS_URI.password)
 	# RADIS_THREAD = Thread.new do
 	# 	Redis.new(host: RADIS_URI.host, port: RADIS_URI.port, password: RADIS_URI.password).subscribe(RADIS_CHANNEL) do |on|
 	# 		on.message do |channel, msg|
 	# 			msg = JSON.parse(msg)
-	# 			# do stuff
+	# 			# do stuff, i.e.:
+	# 			# Plezi.run_async(msg) { |m| Plezi.info m.to_s }
 	# 		end
 	# 	end
 	# end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.7.6
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-29 00:00:00.000000000 Z
+date: 2015-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler