plezi 0.8.3 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e948ea3cceaa995b5dc7a9c496432e5ef1c0660
-  data.tar.gz: 9c70d2dbb9291d65500daa109a751e6228785d50
+  metadata.gz: 5e19a46b1de10e66f183bb5e62328d68762725cd
+  data.tar.gz: 9e7169464ae76ac2fc86387d30d7203a093244c5
 SHA512:
-  metadata.gz: 9ef50d068ce5fb0f806d7216daea2cd458b4aa5d93534ca56d2a15b7f2324e9638f1e7dbf3318accf957bd59f691b2bcfc45a82a3ea0db6e570d479cfa5af3da
-  data.tar.gz: eb1ca84b326181a96bab242927640c1d4fc1663db4ce6f433b1d4d386dd7cc748fc923bf97c948a076c032212c9ddc41931f4254951969db828a8fd85dc36802
+  metadata.gz: 1591203078e67b70960fb20695962f3c2c7e01f5097a6272c1f7dac1d053641e943cbe808c31061c906910b42554333ed2d3f7342614172bb6036bd6031f7103
+  data.tar.gz: 0e5fdf7ca6e8fa261a827cec565ffaf3a1c44d526d346f84c664a9a2ee9a76ee2f473cf07274383509a91d0535a0daea6f6d7be1fac73e7802283e5bb49d98f8

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ***
 
+Change log v.0.8.4
+
+**core routing changes**: moved the Controller's routing cache out of the global cahce store. This might provide a very slight performance increase.
+
+**feature**: a new OAuth2 controller offers an easy support for OAuth2 login services such as facebook and google. to use this feature, require 'plezi/oauth'.
+
+**fix**: fixed an issue where RESTful requests to `new` would be mistakenly routed to the `save` method.
+
+**testing**: some basic testing for the RESTful Plezi framework has been implemented. Please notice that the tests WILL run the Plezi server on ports 3000 (for http) and 3030 (for https) during the test. The test will run Net::HTTP requests against the Plezi server.
+
+***
+
 Change log v.0.8.3
 
 **Auto-ping feature**: WebSocket connections now automatically send a `ping` every ~45 seconds (approximately) before the websocket's connection would timeout. This auto-ping will keep the connection alive even if no data is exchanged.

data/Rakefile

@@ -1 +1,7 @@
 require "bundler/gem_tasks"
+
+# create a default task
+desc "Not yet implemented: Tests most of the basic features for the Plezi framework."
+task :test do
+	load "./test/plezi_tests.rb"
+end

data/bin/plezi

@@ -61,12 +61,13 @@ class AppTemplate
 
 		# set up config files
 		app_tree["config"] ||= {}
-		app_tree["config"]["db_ac_config.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_ac_config.rb"),  __FILE__))
-		app_tree["config"]["db_sequel_config.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_sequel_config.rb"),  __FILE__))
-		app_tree["config"]["db_dm_config.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_dm_config.rb"),  __FILE__))
-		app_tree["config"]["haml_config.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"haml_config.rb"),  __FILE__))
-		app_tree["config"]["i18n_config.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"i18n_config.rb"),  __FILE__))
-		app_tree["config"]["redis_config.rb"] ||= (IO.read(::File.expand_path(File.join("..", "..", "resources" ,"redis_config.rb"),  __FILE__))).gsub('appsecret', "#{ARGV[1]}_#{SecureRandom.hex}")
+		app_tree["config"]["oauth.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"oauth_config.rb"),  __FILE__))
+		app_tree["config"]["db_active_record.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_ac_config.rb"),  __FILE__))
+		app_tree["config"]["db_sequel.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_sequel_config.rb"),  __FILE__))
+		app_tree["config"]["db_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"]["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}")
 
 		#set up database stub folders
 		app_tree["db"] ||= {}

data/lib/plezi/handlers/controller_magic.rb

@@ -198,7 +198,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|PATCH/) && 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
@@ -279,19 +279,18 @@ 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]).to_set )
+				@available_public_methods ||= (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] == '_'}).to_set  )
+				@available_routing_methods ||= ( ( (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')
+				@available_routing_methods = false
+				@available_public_methods = false
 				available_routing_methods
 				available_public_methods
 			end
@@ -308,6 +307,26 @@ module Plezi
 			def method_undefined(id)
 				reset_routing_cache
 			end
+			# # 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]).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] == '_'}).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')
+			# 	available_routing_methods
+			# 	available_public_methods
+			# end
+
 			
 			# reviews the Redis connection, sets it up if it's missing and returns the Redis connection.
 			#
@@ -318,10 +337,10 @@ module Plezi
 			#      ENV['PL_REDIS_URL'] = "redis://username:password@my.host:6379"
 			def redis_connection
 				# return false unless defined?(Redis) && ENV['PL_REDIS_URL']
-				# return @@redis if defined?(@@redis_sub_thread) && @@redis
+				# return @redis if defined?(@redis_sub_thread) && @redis
 				# @@redis_uri ||= URI.parse(ENV['PL_REDIS_URL'])
-				# @@redis ||= Redis.new(host: @@redis_uri.host, port: @@redis_uri.port, password: @@redis_uri.password)
-				# @@redis_sub_thread = Thread.new do
+				# @redis ||= Redis.new(host: @@redis_uri.host, port: @@redis_uri.port, password: @@redis_uri.password)
+				# @redis_sub_thread = Thread.new do
 				# 	begin
 				# 		Redis.new(host: @@redis_uri.host, port: @@redis_uri.port, password: @@redis_uri.password).subscribe(redis_channel_name) do |on|
 				# 			on.message do |channel, msg|
@@ -335,8 +354,8 @@ module Plezi
 				# 		retry
 				# 	end
 				# end
-				# raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless @@redis
-				# @@redis
+				# 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')
 				@@redis_uri ||= URI.parse(ENV['PL_REDIS_URL'])

data/lib/plezi/oauth.rb

@@ -0,0 +1,4 @@
+# requires the open-uri library.
+require 'open-uri'
+# require the OAuth2 controller
+require 'plezi/oauth/auth_controller.rb'

data/lib/plezi/oauth/auth_controller.rb

@@ -0,0 +1,208 @@
+require 'open-uri'
+
+
+
+module Plezi
+
+	#########################################
+	# This is a social Authentication Controller
+	#
+	# This controller currently supports:
+	#
+	# - Facebook authentication using the Graph API, v. 2.3 - [see Facebook documentation](https://developers.facebook.com/docs/facebook-login/manually-build-a-login-flow/v2.3).
+	# - Google authentication using the OAuth 2.0 API - [see Google documentation](https://developers.google.com/identity/protocols/OAuth2WebServer).
+	#
+	# It's also possible to manualy register any OAuth 2.0 authentication service using the `register_service` method.
+	#
+	# To use this Controller in your application, make sure the following variables are set:
+	#       ENV['FB_APP_ID'] = {facebook_app_id}
+	#       ENV['FB_APP_SECRET'] = {facebook_app_secret}
+	#       ENV['GOOGLE_APP_ID'] = {google_app_id}
+	#       ENV['GOOGLE_APP_SECRET'] = {google_app_secret}
+	#
+	# Add the following route to routes.rb file (as always, route placement order effects behavior):
+	#
+	#       create_auth_shared_route do |service, remote_user_id, email, full_remote_response|	
+	#          # perform any specific app authentication logic such as saving the info.
+	#          # return the current user or false if the callback is called with an authentication failure.
+	#       end
+	#
+	# The `create_auth_shared_route` method is a shortcut for calling the `#shared_route` method with the relevant arguments and setting the OAuth2Ctrl callback.
+	#
+	# Use the following links for social authentication:
+	#
+	# - Facebook: "/auth/facebook?redirect_after=/foo/bar"
+	# - Google: "/auth/google?redirect_after=/foo/bar"
+	# - foo_service: "/auth/foo_service?redirect_after=/foo/bar"
+	#
+	class OAuth2Ctrl
+
+		# Sets (or gets) the callback to be called after authentication is attempeted.
+		#
+		# Accepts a block that will be called with the following parameters:
+		# service_name:: the name of the service. i.e. :facebook, :google, etc'.
+		# service_token:: the authentication token returned by the service. This token should be stored for future access
+		# remote_user_id:: service's user id.
+		# remote_user_email:: users primamry email, if registed with the service.
+		# remote_response:: a Hash with the complete user data response (including email and id).
+		#
+		# If the authentication fails for Facebook, the block will be called with the following values `auth_callback.call(nil, ni, {server: :responce, might_be: :empty})`
+		#
+		# The block will be run in the context of the controller and all the controller's methods will be available to it.
+		#
+		# i.e.:
+		#       OAuth2Ctrl.auth_callback |service, service_token, id, email, res|  cookies["#{service}_pl_auth_token".to_sym], cookies["#{service}_user_id".to_sym], cookies["#{service}_user_email".to_sym] = service_token, id, email }
+		#
+		# defaults to the example above, which isn't a very sercure behavior, but allows for easy testing.
+		def self.auth_callback &block
+			block_given? ? (@auth_callback = block) : ( @auth_callback ||= (Proc.new {|service, service_token, id, email, res| Plezi.info "deafult callback called for #{service}, with response: #{res.to_s}";  cookies["#{service}_pl_auth_token".to_sym], cookies["#{service}_user_id".to_sym], cookies["#{service}_user_email".to_sym] = service_token, id, email}) )
+		end
+
+
+		# Stores the registered services library
+		SERVICES = {}
+
+		# This method registers a social login service that conforms to the OAuth2 model.
+		#
+		# Accepts the following required parameters:
+		# service_name:: a Symbol naming the service. i.e. :facebook or :google .
+		# options:: a Hash of options, some of which are required.
+		#
+		# The options are:
+		# app_id:: the aplication's unique ID registered with the service. i.e. ENV[FB_APP_ID] (storing these in environment variables is safer then hardcoding them)
+		# app_secret:: the aplication's unique secret registered with the service.
+		# auth_url:: the authentication URL. This is the url to which the user is redirected. i.e.: "https://www.facebook.com/dialog/oauth"
+		# token_url:: the token request URL. This is the url used to switch the single-use code into a persistant authentication token. i.e.: "https://www.googleapis.com/oauth2/v3/token"
+		# profile_url:: the URL used to ask the service for the user's profile (the service's API url). i.e.: "https://graph.facebook.com/v2.3/me"
+		# scope:: a String representing the scope requested. i.e. 'email profile'.
+		#
+		# There will be an attempt to aitomatically register Facebook and Google login services under these conditions:
+		#
+		# * For Facebook: Both ENV['FB_APP_ID'] && ENV['FB_APP_SECRET'] have been defined.
+		# * For Google: Both ENV['GOOGLE_APP_ID'] && ENV['GOOGLE_APP_SECRET'] have been defined.
+		#
+		#
+		# Just for reference, at the time of this writing:
+		#
+		# * facebook auth_url: "https://www.facebook.com/dialog/oauth"
+		# * facebook token_url: "https://graph.facebook.com/v2.3/oauth/access_token"
+		# * facebook profile_url: "https://graph.facebook.com/v2.3/me"
+		# * google auth_url: "https://accounts.google.com/o/oauth2/auth"
+		# * google token_url: "https://www.googleapis.com/oauth2/v3/token"
+		# * google profile_url: "https://www.googleapis.com/plus/v1/people/me"
+		#
+		def self.register_service service_name, options
+			raise "Cannot register service, missing required information." unless service_name && options[:auth_url] && options[:token_url] && options[:profile_url] && options[:app_id] && options[:app_secret]
+			# for google, scope is space delimited. for facebook it's comma delimited
+			options[:scope] ||= 'profile, email'
+			SERVICES[service_name] = options
+		end
+
+		# Called to manually run through the authentication logic for the requested service,
+		# without performing any redirections.
+		#
+		# Use this method to attempt and re-login a user using an existing login token:
+		#
+		#             token = 'google_token_could_be_recieved_also_from_javascript_sdk'
+		#             OAuth2Ctrl.auth :google, token, self
+		#
+		# The method will return false if re-login fails and it will otherwise return the callback's return value.
+		#
+		# Call this method from within a controller, passing the controller (self) to the method, like so:
+		#
+		#             OAuth2Ctrl.auth :facebook, token, self
+		#
+		# This is especially effective if `auth_callback` returns the user object, as it would allow to chain
+		# different login methods, i.e.:
+		#
+		#             @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
+			# 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)
+			auth_res = {}
+			uri = URI.parse("#{service[:profile_url]}?access_token=#{service_token}")
+			Net::HTTP.start(uri.host, uri.port, use_ssl: (uri.scheme == "https"), verify_mode: OpenSSL::SSL::VERIFY_NONE) do |http|
+				req =  Net::HTTP::Get.new(uri)
+				res = http.request(req).body
+				auth_res = (JSON.parse res) rescue ({})
+			end if service_token
+			auth_res['id'] ? controller.instance_exec( service_name, service_token, auth_res['id'], auth_res['email'], auth_res, &auth_callback) : ( controller.instance_exec( service_name, nil, nil, nil, auth_res, &auth_callback) && false)
+		end
+
+		def update
+			service_name = params[:id].to_s.to_sym
+			service = SERVICES[service_name]
+			retrun false unless service
+			if params[:error]
+				instance_exec( service_name, nil, nil, nil, {}, &self.class.auth_callback)
+				return redirect_to(flash[:redirect_after])
+			end
+			unless params[:code]
+				flash[:redirect_after] = params[:redirect_after] || '/'
+				return redirect_to _auth_url_for(service_name)
+			end
+			uri = URI.parse service[:token_url]
+			service_token = nil
+			Net::HTTP.start(uri.host, uri.port, use_ssl: (uri.scheme == "https"), verify_mode: OpenSSL::SSL::VERIFY_NONE) do |http|
+				req =  Net::HTTP::Post.new(uri)
+				req.form_data = {"client_id" => service[:app_id],
+								"client_secret" => service[:app_secret], "code" => params[:code] ,
+								"grant_type" => "authorization_code","redirect_uri" => "#{request.base_url}/auth/#{service_name.to_s}"}
+				res = http.request(req).body
+				service_token = ((JSON.parse res)['access_token'] rescue nil)
+			end
+
+			self.class.auth service_name, service_token, self
+			redirect_to(flash[:redirect_after])
+		end
+		alias :show :update
+
+		protected
+
+		# returns a url for the requested service's social login.
+		#
+		# this is used internally. Normal behavior would be to set a link to '/auth/{service_name}', where correct redirection will be automatic.
+		#
+		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
+			return "#{service[:auth_url]}?client_id=#{service[:app_id]}&redirect_uri=#{redirect_uri}&scope=#{service[:scope]}&response_type=code"
+		end
+
+		register_service(:facebook, app_id: ENV['FB_APP_ID'],
+									app_secret: ENV['FB_APP_SECRET'],
+									auth_url: "https://www.facebook.com/dialog/oauth",
+									token_url: "https://graph.facebook.com/v2.3/oauth/access_token",
+									profile_url: "https://graph.facebook.com/v2.3/me",
+									scope: "public_profile,email") if ENV['FB_APP_ID'] && ENV['FB_APP_SECRET']
+		register_service(:google, app_id: ENV['GOOGLE_APP_ID'],
+									app_secret: ENV['GOOGLE_APP_SECRET'],
+									auth_url: "https://accounts.google.com/o/oauth2/auth",
+									token_url: "https://www.googleapis.com/oauth2/v3/token",
+									profile_url: "https://www.googleapis.com/oauth2/v1/userinfo",
+									scope: "profile email") if ENV['GOOGLE_APP_ID'] && ENV['GOOGLE_APP_SECRET']
+
+	end
+end
+
+# This method creates the OAuth2Ctrl route.
+# This is actually a short-cut for:
+#
+#       shared_route "auth/(:id)/(:code)" , Plezi::OAuth2Ctrl
+#       Plezi::OAuth2Ctrl.auth_callback = Proc.new {|service, user_id, user_email, service_response| ... }
+#
+# the `:id` parameter is used to identify the service (facebook, google. etc').
+#
+# The method accepts a block that will be used to set the authentication callback. See the Plezi::OAuth2Ctrl documentation for details.
+#
+# The method can be called only once and will self-destruct.
+def create_auth_shared_route options = {}, &block
+	shared_route "auth/(:id)/(:code)" , Plezi::OAuth2Ctrl
+	undef create_auth_shared_route
+	Plezi::OAuth2Ctrl.auth_callback = block if block
+	Plezi::OAuth2Ctrl
+end

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.8.3"
+    VERSION = "0.8.4"
 end

data/resources/oauth_config.rb

@@ -0,0 +1,24 @@
+###############
+# # OAuth2 Config File
+# # ==================
+# # 
+# # Here you can sets the OAuth2 variables and require the OAuth2 Plezi controller.
+# # (if the variables aren't set BEFORE the inclution, automatic setup will NOT take place)
+# #
+# # First set the variables:
+# #
+# ENV["FB_APP_ID"] ||= "app id"
+# ENV["FB_APP_SECRET"] ||= "secret"
+# ENV['GOOGLE_APP_ID'] = "app id"
+# ENV['GOOGLE_APP_SECRET'] = "secret"
+# #
+# # Then, require the actual OAuth2 controller class (Plezi::OAuth2Ctrl).
+# #
+# require 'plezi/oauth'
+# #
+# # Last, but not least, remember to add the authentication route in the correct placement using:
+# create_auth_shared_route do |service_name, remote_user_id, remote_user_email, remote_response|
+#         # ...callback for authentication.
+#         # This callback should return the app user object or false
+#         # This callback hass access to the magic controller methods (request, cookies, etc')
+# end

data/resources/redis_config.rb

@@ -5,8 +5,7 @@ if defined? Redis
 	# ## Plezi Redis Automation
 	# ## ====
 	# ##
-	# ## sets up Plezi to use Radis broadcast.
-	# ## this is less recommended then writing your own tailored solution
+	# ## Sets up Plezi to use Radis broadcast.
 	# ##
 	# ## If Plezi Redis Automation is enabled:
 	# ## Plezi creates is own listening thread for each Controller class that broadcasts using Redis.
@@ -15,17 +14,17 @@ if defined? Redis
 	# ## this overrides the default Controller#broadcast method which is very powerful but
 	# ## is limited to one process.
 	# ##
-	# ENV['PL_REDIS_URL'] = ENV['REDISCLOUD_URL'] ||= ENV["REDISTOGO_URL"] ||= "redis://username:password@my.host:6389"
+	# ENV['PL_REDIS_URL'] ||= ENV['REDIS_URL'] || ENV['REDISCLOUD_URL'] || ENV['REDISTOGO_URL'] || "redis://username:password@my.host:6389"
 
 
-	# ## Custom Redis Automation
+	# ## OR, write your own custom Redis Automation here
 	# ## ====
 	# ##
 	# ## 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_URI = URI.parse(ENV['REDISCLOUD_URL'] || "redis://username:password@my.host:6389")
+	# RADIS_URI = URI.parse(ENV['REDIS_URL'] || 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|

data/test/plezi_tests.rb

@@ -0,0 +1,235 @@
+# I started writing tests... but I haven't finished quite yet.
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'open-uri'
+require 'plezi'
+
+class TestCtrl
+
+	# this will be called before every request.
+	def before
+	end
+
+	# this will be called after every request.
+	def after
+	end
+
+	# shouldn't be available (return 404).
+	def _hidden
+		"do you see me?"
+	end
+	def index
+		"test"
+	end
+
+	# should return a 500 internal server error message.
+	def fail
+		raise "Hell!"
+	end
+
+	# called when request is GET and params\[:id] == "new".
+	def new
+		"new"
+	end
+	# called when request is GET and params\[:id] exists (unless params\[:id] == "new").
+	def show
+		"show #{params[:id]}"
+	end
+	# called when request is POST / PUT and params\[:id] exists and isn't 'new'
+	def update
+		"update #{params[:id]}"
+	end
+	def delete
+		"delete #{params[:id]}"
+	end
+	# called when request is POST / PUT and params\[:id] is 'new'
+	def save
+		params[:data].to_s
+	end
+	def sleeper
+		sleep 1
+		"slept"
+	end
+	# should return a 404 error.
+	def get404
+		false
+	end
+	# path to test for chuncked encoding and response streaming.
+	def streamer
+		response.start_http_streaming
+		PL.callback(self, :_stream_out) { PL.callback(response, :finish) }
+		true
+	end
+	def _stream_out
+		response.send "streamed"
+		true
+	end
+	def file_test
+		if params[:file]
+			send_data params[:file][:data], type: params[:file][:type], inline: true, filename: params[:file][:filename]
+			return true
+		end
+		false
+	end
+
+
+	############
+	## WebSockets
+
+	# called once the websocket was connected
+	def on_connect
+		response << "connected"
+	end
+
+	# called when new Websocket data is recieved
+	#
+	# data is a string that contains binary or UTF8 (message dependent) data.
+	def on_message data
+		broadcast :_push, data
+		_push data
+	end
+
+	# called when a disconnect packet has been recieved or the connection has been cut
+	# (ISN'T called after a disconnect message has been sent).
+	def on_disconnect
+	end
+
+	# a demo event method that recieves a broadcast from instance siblings.
+	def _push data
+		response << data.to_s
+	end
+end
+
+module PleziTestTasks
+	module_function
+
+	RESULTS = {true => "passed", false => 'FAILED!'}
+
+	def run_tests
+		(public_methods(false)).each {|m| method(m).call if m.to_s.match /^test_/}
+		true
+	end
+	def test_sleep
+		Plezi.run_async do
+			begin
+				puts "Sleeper test: #{RESULTS[URI.parse("http://localhost:3000/sleeper").read == 'slept']}"
+				puts "ASync tasks test: #{RESULTS[true]}"
+			rescue => e
+				puts "Sleeper test FAILED TO RUN!!!"
+				puts e
+			end
+		end
+	end
+
+	def test_index
+		begin
+			puts "index test: #{RESULTS[URI.parse("http://localhost:3000/").read == 'test']}"
+		rescue => e
+			puts "Index test FAILED TO RUN!!!"
+			puts e
+		end
+	end
+	def test_ssl
+		puts "Connection to non-ssl and unique route test: #{RESULTS[URI.parse("http://localhost:3000/ssl").read == 'false']}"
+		uri = URI.parse("https://localhost:3030/ssl")
+		Net::HTTP.start(uri.host, uri.port, use_ssl: (uri.scheme == "https"), verify_mode: OpenSSL::SSL::VERIFY_NONE) do |http|
+			puts "Connection to ssl and unique ssl route test: #{RESULTS[ http.request(Net::HTTP::Get.new(uri)).body == 'true' ]}"
+		end
+		rescue => e
+		puts "SSL Tests FAILED to complete!!!"
+		puts e
+	end
+	def test_new
+		puts "New RESTful path test: #{RESULTS[URI.parse("http://localhost:3000/new").read == 'new']}"
+
+		rescue => e
+		puts "New RESTful path test FAILED TO RUN!!!"
+		puts e
+	end
+	def test_show
+		puts "Show RESTful path test: #{RESULTS[URI.parse("http://localhost:3000/3").read == 'show 3']}"
+
+		rescue => e
+		puts "Show RESTful path test FAILED TO RUN!!!"
+		puts e
+	end
+	def test_update
+		puts "Update RESTful path test: #{RESULTS[Net::HTTP.post_form( URI.parse("http://localhost:3000/"), id: 3).body == 'update 3']}"
+
+		rescue => e
+		puts "Update RESTful path test FAILED TO RUN!!!"
+		puts e
+	end
+	def test_delete
+		puts "Delete RESTful path test: #{RESULTS[Net::HTTP.post_form( URI.parse("http://localhost:3000/"), id: 3, _method: :delete).body == 'delete 3']}"
+
+		rescue => e
+		puts "Delete RESTful path test FAILED TO RUN!!!"
+		puts e
+	end
+	def test_save
+		puts "Save RESTful path test: #{RESULTS[Net::HTTP.post_form( URI.parse("http://localhost:3000/new"), data: "passed").body == 'passed']}"
+
+		rescue => e
+		puts "Save RESTful path test FAILED TO RUN!!!"
+		puts e
+	end
+	def test_streamed
+		begin
+			puts "Streaming test: #{RESULTS[URI.parse("http://localhost:3000/streamer").read == 'streamed']}"
+		rescue => e
+			puts "Streaming test FAILED TO RUN!!!"
+			puts e
+		end
+	end
+	def test_404
+		puts "404 not found and router continuity tests: #{RESULTS[ Net::HTTP.get_response(URI.parse "http://localhost:3000/get404" ).code == '404' ]}"
+
+		rescue => e
+		puts "404 not found test FAILED TO RUN!!!"
+		puts e
+	end
+	def test_500
+		workers = Plezi::EventMachine.count_living_workers
+		puts "500 internal error test: #{RESULTS[ Net::HTTP.get_response(URI.parse "http://localhost:3000/fail" ).code == '500' ]}"
+		# cause 10 more exceptions to be raised... testing thread survival.
+		10.times { Net::HTTP.get_response(URI.parse "http://localhost:3000/fail" ).code }
+		workers_after_test = Plezi::EventMachine.count_living_workers
+		puts "Worker survival test: #{RESULTS[workers_after_test == workers]} (#{workers_after_test} out of #{workers})"
+
+		rescue => e
+		puts "404 not found test FAILED TO RUN!!!"
+		puts e		
+	end
+end
+
+NO_PLEZI_AUTO_START = true
+
+PL.create_logger '/dev/null'
+
+listen port: 3000
+
+route("/ssl") {|req, res| res << "false" }
+listen port: 3030, ssl: true
+route("/ssl") {|req, res| res << "true" }
+
+shared_route '/', TestCtrl
+
+
+Plezi::EventMachine.start Plezi.max_threads
+
+shoutdown_test = false
+Plezi.on_shutdown { shoutdown_test = true }
+
+PleziTestTasks.run_tests
+
+Plezi::EventMachine.clear_timers
+
+Plezi::DSL.stop_services
+
+Plezi::EventMachine.shutdown
+
+
+puts "Shutdown test: #{ PleziTestTasks::RESULTS[shoutdown_test] }"
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.4
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-30 00:00:00.000000000 Z
+date: 2015-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -74,6 +74,8 @@ files:
 - lib/plezi/handlers/magic_helpers.rb
 - lib/plezi/handlers/route.rb
 - lib/plezi/handlers/stubs.rb
+- lib/plezi/oauth.rb
+- lib/plezi/oauth/auth_controller.rb
 - lib/plezi/server/http.rb
 - lib/plezi/server/http_protocol.rb
 - lib/plezi/server/http_request.rb
@@ -102,12 +104,14 @@ files:
 - resources/environment.rb
 - resources/haml_config.rb
 - resources/i18n_config.rb
+- resources/oauth_config.rb
 - resources/plezi_gray.png
 - resources/plezi_websockets.html
 - resources/rakefile
 - resources/redis_config.rb
 - resources/routes.rb
 - resources/welcome_page.html
+- test/plezi_tests.rb
 - websocket chatroom.md
 homepage: http://boazsegev.github.io/plezi/
 licenses:
@@ -135,4 +139,5 @@ signing_key:
 specification_version: 4
 summary: Plezi is the native Ruby Framework for real time web-apps, with Websockets,
   RESTful routing and HTTP streaming support.
-test_files: []
+test_files:
+- test/plezi_tests.rb