plezi 0.10.11 → 0.10.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ae320b0b94bf0515e804c8f578919e46147d349
-  data.tar.gz: b82256beacdbd56c48b66755d4b086d0293452fb
+  metadata.gz: 160e5060bd9cf3f8ec6acf8caa7d672ae238f3c7
+  data.tar.gz: d2816045210ac66cec18b0c5f37060a9ec5ae271
 SHA512:
-  metadata.gz: ebeaa5a013faf936e694f5d54fd212d1c299f015631f63667c0e0419958321f86086f8087d94111c194656247101d3d65f621fe15177a2931a83199d0ed3be76
-  data.tar.gz: 8df8144823d9be37ecd9d8d89e01b116c5aed875188781ea5953961b022b5c8765ca84b4c312b20fb2c98ca132f819aa8f296140ea718346d3af914227b3a5c2
+  metadata.gz: 59691c8ce5b334a0e1b7223aaeb4e0ae74f5f800e24e803e8ad6e8aeb9492f299c71c50c46ca740a8a1940c7c50e4a28f332365ff40853b9221864cb8e3b2769
+  data.tar.gz: f738389e77c3bdc471e6000db4bfd83f8cbb0133814074c0ba4cbc69c5ecae229a18904f5cd3a8ca32253c7266637563c356cda8ca1cb1f2db4936c09d1a3c15

data/CHANGELOG.md

@@ -2,13 +2,23 @@
 
 ***
 
+Change log v.0.10.12
+
+**BIG Feature**: Run both your existing Rack app and plezi on he same GRHttp server - augment your app with all of Plezi's amasing features (two frameworks in one).
+
+**Updates** updates to the mini template, the testing, the core API code and many more minor updates.
+
+**API published**: Most of the private API in the Plezi::Base::DSL module was just made public (moving the methods to the main Plezi namespace). Your app should work as before unless you used private method calls instead of Plezi's published API.
+
+***
+
 Change log v.0.10.11
 
 **Feature**: added the mini-app template, for quick websocket oriented apps that are meant to be attached to other frameworks (use `$ plezi mini appname` or `$ plezi m appname`).
 
 **Feature**: allow Regexp hosts in the `listen` and `host` methods.
 
-**Fix**: An error in the chache system was introduced when performing slight performance enhancements (two variable names were switched). The issue is now fixed.
+**Fix**: An error in the cache system was introduced when performing slight performance enhancements (two variable names were switched). The issue is now fixed.
 
 **Fix**: Correctly handle multiple `listen` calls with the same port number.
 

data/README.md

@@ -1,16 +1,12 @@
-# Plezi, The Rack Free Ruby framework for realtime web-apps
+# 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)
 
-> People who are serious about their frameworks, should write their own servers...
+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.
 
-Find more info on [Plezi's framework documentation](http://www.rubydoc.info/github/boazsegev/plezi/master)
+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.
 
-## About the Plezi framework
-
-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 can both augment an existing Rails/Sinatra app, by providing it with easy Websocket and Asynchronous Events support, as well as offer an alternative to a Rack/Rails/Sintra/Faye/EM-Websockets combo. It's also great as an alternative to socket.io, allowing for both websockets and long pulling.
+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.
 
 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).
 
@@ -129,7 +125,37 @@ method names starting with an underscore ('_') will NOT be made public by the ro
 
 You already have an amazing WebApp, but now you want to add websocket broadcasting and unicasting support - Plezi makes connection your existing WebApp with your Plezi Websocket backend as easy as it gets.
 
-Simply include the Plezi App in your existing app and call `Plezi.start_placebo` - now you can access all the websocket API that you want from your existing WebApp.
+
+There are two easy ways to augment your existing WebApp, depending on your needs and preferences:
+
+1. Let Plezi and GRHttp run your application as a fallback position, defering to your application for anything Plezi doesn't handle (Plezi Websockets and routes will recieve priority).
+
+2. Run Plezi on a seperate process/server and set up communication between the two apps.
+
+### The super easy augmentation - run together
+
+The easiest way to augment your existing application is to use GRHttp's Rack adapter to run your Rack app, while Plezi will use GRHttp's native features (such as Websockets and HTTP streaming).
+
+You can eaither use your existing Plezi application or create a new mini plezi application inside your existing app folder using:
+
+    $   plezi mini appname
+
+Next, add the `plezi` gem to your `Gemfile` and add the following line somewhere in your apps code:
+
+```ruby
+require './appname/appname.rb'
+Plezi.start_rack
+```
+
+That's it! Now you can use the Plezi API and your existing application's API at the same time and they are both running on the same server.
+
+Plezi's route have priority, so that your app can keep handling the 404 (not found) error page.
+
+In the next section we will explore how to set up the placebo API for cross process apps... since you are sharing the same space, you won't need it - but you can still use most of the Placebo API if you wish to do so (just **don't** call `Plezi.start_placebo`)
+
+### The easy (but not super easy) augmentation - talking from afar
+
+To use Plezi and your App on different processes, without mixing them together, simply include the Plezi App in your existing app and call `Plezi.start_placebo` - now you can access all the websocket API that you want from your existing WebApp.
 
 For instance, add the following code to your environment on a Rails or Sinatra app:
 

data/bin/plezi

@@ -99,6 +99,7 @@ class AppTemplate
 		app_tree["config"]["sequel.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_sequel_config.rb"),  __FILE__))
 		app_tree["config"]["datamapper.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_dm_config.rb"),  __FILE__))
 		app_tree["config"]["haml.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"haml_config.rb"),  __FILE__))
+		app_tree["config"]["slim.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"slim_config.rb"),  __FILE__))
 		app_tree["config"]["i18n.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"i18n_config.rb"),  __FILE__))
 		app_tree["config"]["redis.rb"] ||= (IO.read(::File.expand_path(File.join("..", "..", "resources" ,"redis_config.rb"),  __FILE__))).gsub('appsecret', "#{ARGV[1]}_#{SecureRandom.hex}")
 

data/lib/plezi.rb

@@ -30,6 +30,7 @@ require "plezi/version"
 
 require 'plezi/common/defer.rb'
 require 'plezi/common/cache.rb'
+require 'plezi/common/api.rb'
 require 'plezi/common/dsl.rb'
 require 'plezi/common/redis.rb'
 require 'plezi/common/settings.rb'

data/lib/plezi/common/api.rb

@@ -0,0 +1,135 @@
+
+module Plezi
+
+	module_function
+
+	# Defines methods used to set up the Plezi app.
+
+	# public API to add a service to the framework.
+	# accepts a Hash object with any of the following options (Hash keys):
+	# 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.
+	# 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_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.
+	# ssl:: if true, an SSL service will be attempted. if no certificate is defined, an attempt will be made to create a self signed certificate.
+	# ssl_key:: the public key for the SSL service.
+	# ssl_cert:: the certificate for the SSL service.
+	#
+	# assets:
+	#
+	# 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.
+	#
+	# templates:
+	#
+	# ERB, Slim and Haml are natively supported. Otherwise define an assets_callback (or submit a pull request with a patch). 
+	#
+	# @returns [Plezi::Router]
+	#
+	def listen parameters = {}
+		# update default values
+		parameters[:index_file] ||= 'index.html'
+		parameters[:assets_public] ||= '/assets'
+		parameters[:assets_public].chomp! '/'
+
+		# check if the port is used twice.
+		@routers_locker.synchronize do
+			@active_router = GRHttp.listen(parameters)
+			unless @active_router[:upgrade_handler]
+				@routers << (@active_router[:http_handler] = ::Plezi::Base::HTTPRouter.new)
+				@active_router[:upgrade_handler] = @active_router[:http_handler].upgrade_proc
+			else
+				@active_router.delete :alias
+			end
+			@active_router[:http_handler].add_host(parameters[:host], @active_router.merge(parameters) )
+			@active_router = @active_router[:http_handler]
+		end
+		# return the current handler or the protocol..
+		@active_router
+	end
+
+	# clears all the listeners and routes defined
+	def clear_app
+		@routers_locker.synchronize {GReactor.clear_listeners; @routers.clear}
+	end
+	# adds a route to the last server created
+	def route(path, controller = nil, &block)
+		raise "Must define a listener before adding a route - use `Plezi.listen`." unless @active_router
+		@routers_locker.synchronize { @active_router.add_route path, controller, &block }
+	end
+
+
+	# adds a shared route to all existing services and hosts.
+	def shared_route(path, controller = nil, &block)
+		raise "Must have created at least one Pleze service before calling `shared_route` - use `Plezi.listen`." unless @routers
+		@routers_locker.synchronize { @routers.each {|r| r.add_shared_route path, controller, &block } }
+	end
+
+	# adds a host to the last server created
+	#
+	# accepts a host name and a parameter(s) Hash which are the same parameter(s) as {Plezi.listen} accepts:
+	def host(host_name, params)
+		raise "Must define a listener before adding a route - use `Plezi.listen`." unless @active_router
+		@routers_locker.synchronize { @active_router.add_host host_name, params }
+	end
+
+	# starts the Plezi framework server and hangs until the exit signal is given.
+	def start
+		start_async
+		puts "\nPress ^C to exit.\n"
+		GReactor.join { puts "\r\nStarting shutdown sequesnce. Press ^C to force quit."}
+	end
+
+	# Makes sure the GRHttp server will be used by Rack (if Rack is available) and disables Plezi's autostart feature.
+	#
+	# This method is a both a fail safe and a shortcut. Plezi will automatically attempt to diable autostart when discovering Rack
+	# but this method also makes sure that the GRHttp is set as the Rack server by setting the ENV\["RACK_HANDLER"] variable.
+	#
+	# This is used as an alternative to {Plezi.start_placebo}.
+	#
+	# Use {Plezi.start_placebo} to augment an existing app while operating Plezi on a different process or server.
+	#
+	# Use {Plezi.start_rack} to augment an existing Rack app (i.e. Rails/Sinatra) by loading both Plezi and the existing Rack app
+	# to the GRHtto server (it will set up GRHttp as the Rack server).
+	def start_rack
+		Object.const_set("NO_PLEZI_AUTO_START", true) unless defined?(NO_PLEZI_AUTO_START)
+		ENV["RACK_HANDLER"] = 'grhttp'
+	end
+	# starts the Plezi framework and returns immidiately,
+	# allowing you to run the Plezi framework along side another framework. 
+	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."
+		GReactor.on_shutdown { puts "Plezi shutdown. It was fun to serve you."  }
+		GReactor.start Plezi::Settings.max_threads
+	end
+	# This allows you to run the Plezi framework along side another framework - WITHOUT running the actual server.
+	#
+	# The server will not be initiatet and instead you will be able to use Plezi controllers and the Redis auto-config
+	# to broadcast Plezi messages to other Plezi processes - allowing for scalable intigration of Plezi into other frameworks.
+	def start_placebo
+		GReactor.clear_listeners
+		redis_connection # make sure the redis connection is activated
+		puts "* Plezi #{Plezi::VERSION} Services will start with no Server...\n"
+		start_async
+	end
+
+	# this module contains the methods that are used as a DSL and sets up easy access to the Plezi framework.
+	#
+	# use the`listen`, `host` and `route` functions rather then accessing this object.
+	#
+	@active_router = nil
+	@routers_locker = Mutex.new
+	@routers ||= [].to_set
+end
+
+Encoding.default_internal = 'utf-8'
+Encoding.default_external = 'utf-8'
+
+NO_PLEZI_AUTO_START = true if defined?(::Rack)

data/lib/plezi/common/dsl.rb

@@ -1,268 +1,106 @@
+# PL is a shortcut for the Plezi module, so that `PL == Plezi`.
+PL = Plezi
 
-module Plezi
-
-	# this isn't part of the public API.
-	module Base
-
-		# holds methods that are called by the DSL.
-		#
-		# this isn't part of the public API.
-		module DSL
-			module_function
-
-			# this module contains the methods that are used as a DSL and sets up easy access to the Plezi framework.
-			#
-			# use the`listen`, `host` and `route` functions rather then accessing this object.
-			#
-			@active_router = nil
-
-
-			# public API to add a service to the framework.
-			# accepts a Hash object with any of the following options (Hash keys):
-			# 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).
-			# 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.
-			# 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_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.
-			# ssl:: if true, an SSL service will be attempted. if no certificate is defined, an attempt will be made to create a self signed certificate.
-			# ssl_key:: the public key for the SSL service.
-			# ssl_cert:: the certificate for the SSL service.
-			#
-			# assets:
-			#
-			# 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.
-			#
-			# templates:
-			#
-			# ERB, Slim and Haml are natively supported.
-			#
-			# @returns [Plezi::Router]
-			#
-			def listen parameters = {}
-				# update default values
-				parameters[:index_file] ||= 'index.html'
-				parameters[:assets_public] ||= '/assets'
-				parameters[:assets_public].chomp! '/'
-
-				if !parameters[:port] && defined? ARGV
-					if ARGV.find_index('-p')
-						port_index = ARGV.find_index('-p') + 1
-						parameters[:port] ||= ARGV[port_index].to_i
-						ARGV[port_index] = (parameters[:port] + 1).to_s
-					else
-						ARGV << '-p'
-						ARGV << '3001'
-						parameters[:port] ||= 3000
-					end
-				end
-
-				#keeps information of past ports.
-				@listeners ||= {}
-				@listeners_locker = Mutex.new
-
-				# check if the port is used twice.
-				@listeners_locker.synchronize do
-					if @listeners[parameters[:port]]
-						puts "WARNING: port aleady in use! returning existing service and attemptin to add host (maybe multiple hosts? use `host` instead)."
-						@active_router = @listeners[parameters[:port]][:http_handler]
-						@active_router.add_host parameters[:host], parameters if @active_router.is_a?(HTTPRouter)
-						return @active_router
-					end
-				end
-				@listeners[parameters[:port]] = parameters
-
-				# make sure the protocol exists.
-				parameters[:http_handler] = HTTPRouter.new
-				parameters[:upgrade_handler] = parameters[:http_handler].upgrade_proc
-
-				GRHttp.listen parameters
-				# set the active router to the handler or the protocol.
-				@active_router = parameters[:http_handler]
-				@active_router.add_host(parameters[:host], parameters)
-
-				# return the current handler or the protocol..
-				@active_router
-			end
-			# adds a route to the last server created
-			def route(path, controller = nil, &block)
-				raise "Must define a listener before adding a route - use `Plezi.listen`." unless @active_router
-				@active_router.add_route path, controller, &block
-			end
-
-
-			# adds a shared route to all existing services and hosts.
-			def shared_route(path, controller = nil, &block)
-				raise "Must have created at least one Pleze service before calling `shared_route` - use `Plezi.listen`." unless @listeners
-				@listeners.values.each {|p| p[:http_handler].add_shared_route path, controller, &block }
-			end
-
-			# adds a host to the last server created
-			#
-			# accepts a host name and a parameter(s) Hash which are the same parameter(s) as {Plezi.listen} accepts:
-			def host(host_name, params)
-				raise "Must define a listener before adding a route - use `Plezi.listen`." unless @active_router
-				@active_router.add_host host_name, params
-			end
-
+unless defined? PLEZI_NON_DSL
 
-			# tweeks a hash object to read both :symbols and strings (similar to Rails but without).
-			def 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]
-					elsif k.is_a?(String) && hs.has_key?( k.to_sym)
-						hs[k.to_sym]
-					elsif k.is_a?(Numeric) && hs.has_key?(k.to_s.to_sym)
-						hs[k.to_s.to_sym]
-					end
-				end
-				hash.default_proc = @magic_hash_proc
-				hash.values.each do |v|
-					if v.is_a?(Hash)
-						make_hash_accept_symbols v
-					end
-				end
-			end
-		end
+	# shortcut for Plezi.listen.
+	#
+	def listen(params = {})
+		Plezi.listen params
 	end
 
-	# starts the Plezi framework server and hangs until the exit signal is given.
-	def self.start
-		start_async
-		puts "\nPress ^C to exit.\n"
-		GReactor.join { puts "\r\nStarting shutdown sequesnce. Press ^C to force quit."}
-	end
-	# starts the Plezi framework and returns immidiately,
-	# allowing you to run the Plezi framework along side another framework. 
-	def self.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."
-		GReactor.on_shutdown { puts "Plezi shutdown. It was fun to serve you."  }
-		GReactor.start Plezi::Settings.max_threads
-	end
-	# This allows you to run the Plezi framework along side another framework - WITHOUT running the actual server.
+	# adds a virtul host to the current service (the last `listen` call) or switches to an existing host within the active service.
 	#
-	# The server will not be initiatet and instead you will be able to use Plezi controllers and the Redis auto-config
-	# to broadcast Plezi messages to other Plezi processes - allowing for scalable intigration of Plezi into other frameworks.
-	def self.start_placebo
-		GReactor.clear_listeners
-		redis_connection # make sure the redis connection is activated
-		puts "* Plezi #{Plezi::VERSION} Services will start with no Server...\n"
-		start_async
+	# accepts:
+	# host_name: a String with the full host name (i.e. "www.google.com" / "mail.google.com")
+	# params:: any of the parameters accepted by the `listen` command, except `protocol`, `handler`, and `ssl` parameters.
+	def host(host_name = false, params = {})
+		Plezi.host host_name, params
 	end
-end
 
-Encoding.default_internal = 'utf-8'
-Encoding.default_external = 'utf-8'
-
-# PL is a shortcut for the Plezi module, so that `PL == Plezi`.
-PL = Plezi
-
-# shortcut for Plezi::DSL.listen.
-#
-def listen(params = {})
-	Plezi::Base::DSL.listen params
-end
-
-# adds a virtul host to the current service (the last `listen` call) or switches to an existing host within the active service.
-#
-# accepts:
-# host_name: a String with the full host name (i.e. "www.google.com" / "mail.google.com")
-# params:: any of the parameters accepted by the `listen` command, except `protocol`, `handler`, and `ssl` parameters.
-def host(host_name = false, params = {})
-	Plezi::Base::DSL.host host_name, params
-end
+	# adds a route to the last server object
+	#
+	# path:: the path for the route
+	# controller:: The controller class which will accept the route.
+	#
+	# `path` parameters has a few options:
+	#
+	# * `path` can be a Regexp object, forcing the all the logic into controller (typically using the before method).
+	#
+	# * simple String paths are assumed to be basic RESTful paths:
+	#
+	#     route "/users", Controller => route "/users/(:id)", Controller
+	#
+	# * routes can define their own parameters, for their own logic:
+	#
+	#     route "/path/:required_paramater/:required_paramater{with_format}/(:optional_paramater)/(:optional){with_format}"
+	#
+	# * routes can define optional or required routes with regular expressions in them:
+	#
+	#     route "(:locale){en|ru}/path"
+	#
+	# * routes which use the special '/' charecter within a parameter's format, must escape this charecter using the '\' charecter. **Notice the single quotes** in the following example:
+	#
+	#     route '(:math){[\d\+\-\*\^\%\.\/]}'
+	#
+	#   * or, with double quotes:
+	#
+	#     route "(:math){[\\d\\+\\-\\*\\^\\%\\.\\/]}"
+	#
+	# magic routes make for difficult debugging - the smarter the routes, the more difficult the debugging.
+	# use with care and avoid complex routes when possible. RESTful routes are recommended when possible.
+	# json serving apps are advised to use required parameters, empty sections indicating missing required parameters (i.e. /path///foo/bar///).
+	#
+	def route(path, controller = nil, &block)
+		Plezi.route(path, controller, &block)
+	end
 
-# adds a route to the last server object
-#
-# path:: the path for the route
-# controller:: The controller class which will accept the route.
-#
-# `path` parameters has a few options:
-#
-# * `path` can be a Regexp object, forcing the all the logic into controller (typically using the before method).
-#
-# * simple String paths are assumed to be basic RESTful paths:
-#
-#     route "/users", Controller => route "/users/(:id)", Controller
-#
-# * routes can define their own parameters, for their own logic:
-#
-#     route "/path/:required_paramater/:required_paramater{with_format}/(:optional_paramater)/(:optional){with_format}"
-#
-# * routes can define optional or required routes with regular expressions in them:
-#
-#     route "(:locale){en|ru}/path"
-#
-# * routes which use the special '/' charecter within a parameter's format, must escape this charecter using the '\' charecter. **Notice the single quotes** in the following example:
-#
-#     route '(:math){[\d\+\-\*\^\%\.\/]}'
-#
-#   * or, with double quotes:
-#
-#     route "(:math){[\\d\\+\\-\\*\\^\\%\\.\\/]}"
-#
-# magic routes make for difficult debugging - the smarter the routes, the more difficult the debugging.
-# use with care and avoid complex routes when possible. RESTful routes are recommended when possible.
-# json serving apps are advised to use required parameters, empty sections indicating missing required parameters (i.e. /path///foo/bar///).
-#
-def route(path, controller = nil, &block)
-	Plezi::Base::DSL.route(path, controller, &block)
-end
+	# adds a route to the all the existing servers and hosts.
+	#
+	# accepts same options as route.
+	def shared_route(path, controller = nil, &block)
+		Plezi.shared_route(path, controller, &block)
+	end
 
-# adds a route to the all the existing servers and hosts.
-#
-# accepts same options as route.
-def shared_route(path, controller = nil, &block)
-	Plezi::Base::DSL.shared_route(path, controller, &block)
-end
+	# defines a method with a special name, such as "humens.txt".
+	#
+	# this could be used in controller classes, to define special routes which might defy
+	# normal Ruby naming conventions, such as "/welcome-home", "/play!", etc'
+	#
+	# could also be used to define methods with special formatting, such as "humans.txt",
+	# until a more refined way to deal with formatting will be implemented.
+	def def_special_method name, obj=self, &block
+		obj.instance_exec { define_method name.to_s.to_sym, &block }
+	end
 
-# defines a method with a special name, such as "humens.txt".
-#
-# this could be used in controller classes, to define special routes which might defy
-# normal Ruby naming conventions, such as "/welcome-home", "/play!", etc'
-#
-# could also be used to define methods with special formatting, such as "humans.txt",
-# until a more refined way to deal with formatting will be implemented.
-def def_special_method name, obj=self, &block
-	obj.instance_exec { define_method name.to_s.to_sym, &block }
-end
 
 
+	# finishes setup of the servers and starts them up. This will hange the proceess.
+	#
+	# this method is called automatically by the Plezi framework.
+	#
+	# it is recommended that you DO NOT CALL this method.
+	# if any post shut-down actions need to be performed, use Plezi.on_shutdown instead.
+	def start_services
+		return 0 if defined?(NO_PLEZI_AUTO_START)
+		undef listen
+		undef host
+		undef route
+		undef shared_route
+		Plezi.start
+	end
 
-# finishes setup of the servers and starts them up. This will hange the proceess.
-#
-# this method is called automatically by the Plezi framework.
-#
-# it is recommended that you DO NOT CALL this method.
-# if any post shut-down actions need to be performed, use Plezi.on_shutdown instead.
-def start_services
-	return 0 if defined?(NO_PLEZI_AUTO_START)
-	undef listen
-	undef host
-	undef route
-	undef shared_route
-	Plezi.start
-end
+	# sets information to be used when restarting
+	$PL_SCRIPT = $0
+	$PL_ARGV = $*.dup
+	# restarts the Plezi app with the same arguments as when it was started.
+	#
+	# EXPERIMENTAL
+	def restart_plezi_app
+		exec "/usr/bin/env ruby #{$PL_SCRIPT} #{$PL_ARGV.join ' '}"
+	end
 
-# restarts the Plezi app with the same arguments as when it was started.
-#
-# EXPERIMENTAL
-def restart_plezi_app
-	exec "/usr/bin/env ruby #{$PL_SCRIPT} #{$PL_ARGV.join ' '}"
+	# sets to start the services once dsl script is finished loading.
+	at_exit { start_services }
+	GReactor::Settings.force_graceful = false
 end
-
-# sets to start the services once dsl script is finished loading.
-at_exit { start_services }
-GReactor::Settings.force_graceful = false
-
-# sets information to be used when restarting
-$PL_SCRIPT = $0
-$PL_ARGV = $*.dup
-# $0="Plezi (Ruby)"

data/lib/plezi/handlers/http_router.rb

@@ -78,7 +78,7 @@ module Plezi
 					# return if a route answered the request
 					host.routes.each {|r| a = r.on_request(request, response); return a if a}
 					#return error code or 404 not found
-					Base::HTTPSender.send_by_code request, response, 404
+					return Base::HTTPSender.send_by_code request, response, 404 unless request[:io].params[:http_handler] == ::GRHttp::Base::Rack
 				rescue => e				
 					# return 500 internal server error.
 					GReactor.error e

data/lib/plezi/helpers/magic_helpers.rb

@@ -10,6 +10,25 @@ module Plezi
 			#
 			# (key type agnostic search Hash proc)
 			 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
+				@magic_hash_proc ||= Proc.new do |hs,k|
+					if k.is_a?(Symbol) && hs.has_key?( k.to_s)
+						hs[k.to_s]
+					elsif k.is_a?(String) && hs.has_key?( k.to_sym)
+						hs[k.to_sym]
+					elsif k.is_a?(Numeric) && hs.has_key?(k.to_s.to_sym)
+						hs[k.to_s.to_sym]
+					end
+				end
+				hash.default_proc = @magic_hash_proc
+				hash.values.each do |v|
+					if v.is_a?(Hash)
+						make_hash_accept_symbols v
+					end
+				end
+			end
 		end
 	end
 

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.10.11"
+    VERSION = "0.10.12"
 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.14"
+  spec.add_dependency "grhttp", "~> 0.0.15"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 

data/resources/Gemfile

@@ -23,6 +23,11 @@
 ## Coffee Script makes Javascript more fun to code.
 # gem "coffee-script"
 
+## Markdown
+# gem 'redcarpet'
+## syntax highlighting
+# gem 'rouge'
+
 ####################
 # Internationalization
 

data/resources/mini_app.rb

@@ -1,16 +1,19 @@
 # encoding: UTF-8
 
 ## Set working directory, load gems and create logs
-	# Using pathname extentions for setting public folder
+	## Using pathname extentions for setting public folder
 	require 'pathname'
-	#set up root object, it might be used by the environment and\or the plezi extension gems.
+	## 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
-	# make sure all file access and file loading is relative to the application's root folder
-	Dir.chdir Root.to_s
-	# using bundler to load gems (including the plezi gem)
+	## make sure all file access and file loading is relative to the application's root folder
+	# Dir.chdir Root.to_s
+
+	## Commet the following in order to use use your original app's Gemfile.
+	## If this app is independant, use bundler to load gems (including the plezi gem).
 	require 'bundler'
 	Bundler.require(:default, ENV['ENV'].to_s.to_sym)
-	## uncomment to create a log 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):

data/resources/slim_config.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+if defined?(Slim)
+	require 'rouge/plugins/redcarpet' if defined?(Redcarpet) && defined?(Rouge)
+	if defined?(Redcarpet::Render::HTML) && defined?(Rouge::Plugins::Redcarpet)
+		Slim::Embedded.options[:markdown] = {
+			fenced_code_blocks: true,
+			renderer: (Class.new(Redcarpet::Render::HTML) {include Rouge::Plugins::Redcarpet} ).new
+		}
+	end
+end

data/resources/websockets.js

@@ -1,22 +1,43 @@
+// Add this file to your html to add websocket support
+
 // Your websocket URI should be an absolute path. The following sets the base URI.
-var ws_uri = 'ws://' + window.location.hostname + (window.location.port == '' ? '' : (':' + window.location.port) );
-// remember to add the specific controller's path to your websocket URI.
-ws_uri += "/";
+// remember to update to the specific controller's path to your websocket URI.
+var ws_controller_path = window.location.pathname; // change to '/controller/path'
+var ws_uri = (window.location.protocol.match(/https/) ? 'wss' : 'ws') + '://' + window.location.hostname + (window.location.port == '' ? '' : (':' + window.location.port) ) + ws_controller_path
 // websocket variable.
 var websocket = NaN
+// count failed attempts
+var websocket_fail_count = 0
+// to limit failed reconnection attempts, set this to a number.
+var websocket_fail_limit = NaN
+
 
 function init_websocket()
 {
 	websocket = new WebSocket(ws_uri);
 	websocket.onopen = function(e) {
+		// reset the count.
+		websocket_fail_count = 0
 		// what do you want to do now?
 	};
 
 	websocket.onclose = function(e) {
+        // If the websocket repeatedly you probably want to reopen the websocket if it closes
+        if(!isNaN(websocket_fail_limit) && websocket_fail_count >= websocket_fail_limit) {
+        	// What to do if we can't reconnect so many times?
+        	return
+        };
 		// you probably want to reopen the websocket if it closes.
-		init_websocket()
+		if(isNaN(websocket_fail_limit) || (websocket_fail_count <= websocket_fail_limit) ) {
+			// update the count
+			websocket_fail_count += 1;
+			// try to reconect
+			init_websocket();
+		};
 	};
 	websocket.onerror = function(e) {
+		// update the count.
+		websocket_fail_limit += 1
 		// what do you want to do now?
 	};
 	websocket.onmessage = function(e) {
@@ -26,4 +47,5 @@ function init_websocket()
 		// msg = JSON.parse(e.data); // remember to use JSON also in your Plezi controller.
 	};
 }
+// setup the websocket connection once the page is done loading
 window.addEventListener("load", init_websocket, false); 

data/resources/welcome_page.html

@@ -175,7 +175,7 @@ input[type=submit]:active
 </style>
 <script type="text/javascript">
 // Your websocket URI should be an absolute path. The following sets the base URI.
-var ws_uri = (window.location.protocol.match(/https/) ? 'wss' : 'ws') + '://' + window.location.hostname + (window.location.port == '' ? '' : (':' + window.location.port) );
+var ws_uri = (window.location.protocol.match(/https/) ? 'wss' : 'ws') + '://' + window.location.hostname + (window.location.port == '' ? '' : (':' + window.location.port) ) + window.location.pathname;
 // remember to add the specific controller's path to your websocket URI.
 ws_uri += "/";
 // websocket variable.

data/test/console

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+Dir.chdir '/Users/2Be/Ruby/plezi/plezi/'
+
+require 'benchmark'
+require "bundler/setup"
+require "plezi"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.10.11
+  version: 0.10.12
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-22 00:00:00.000000000 Z
+date: 2015-07-24 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.14
+        version: 0.0.15
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.14
+        version: 0.0.15
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -69,6 +69,7 @@ files:
 - Rakefile
 - bin/plezi
 - lib/plezi.rb
+- lib/plezi/common/api.rb
 - lib/plezi/common/cache.rb
 - lib/plezi/common/defer.rb
 - lib/plezi/common/dsl.rb
@@ -114,8 +115,10 @@ files:
 - resources/rakefile
 - resources/redis_config.rb
 - resources/routes.rb
+- resources/slim_config.rb
 - resources/websockets.js
 - resources/welcome_page.html
+- test/console
 - test/plezi_tests.rb
 - websocket chatroom.md
 homepage: http://boazsegev.github.io/plezi/
@@ -145,4 +148,5 @@ specification_version: 4
 summary: Plezi is the native Ruby Framework for real time web-apps. An easy way to
   write Websockets, RESTful routing and HTTP streaming apps.
 test_files:
+- test/console
 - test/plezi_tests.rb