plezi 0.8.4 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e19a46b1de10e66f183bb5e62328d68762725cd
-  data.tar.gz: 9e7169464ae76ac2fc86387d30d7203a093244c5
+  metadata.gz: 7f6b05d42e0915681853564afa40dde6362c11a5
+  data.tar.gz: 4acd945c253d4eb550f4c3d102494703c5aac507
 SHA512:
-  metadata.gz: 1591203078e67b70960fb20695962f3c2c7e01f5097a6272c1f7dac1d053641e943cbe808c31061c906910b42554333ed2d3f7342614172bb6036bd6031f7103
-  data.tar.gz: 0e5fdf7ca6e8fa261a827cec565ffaf3a1c44d526d346f84c664a9a2ee9a76ee2f473cf07274383509a91d0535a0daea6f6d7be1fac73e7802283e5bb49d98f8
+  metadata.gz: c8e251f2f1e9b358612406cc13df2d59a3f601703000999a3424072c712ff2e6ebd0a3a2555dadaf5d8a11b26cc06ca75fea117b046b1b11967be99d27cd3e75
+  data.tar.gz: 5637b576b93d7672f83b3f5e7943e993aeeee2f6fdceb3125fe4e28df67c2830ca12959158c6043e0a5be5a608f0c26a341285fcaa7d53914dac5746acaf0095

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ***
 
+Change log v.0.8.5
+
+**feature**: Plezi now includes a very simple Websocket Client (no support for cookies). It's used for testing the integrity of the Plezi Framework and could be used to test the Plezi apps.
+
+**feature**: the Controller can now create easy urls for it's own paths, using the #url_for method. Works wonderfuly for simple routes (routes such as: '/path/to/restful/controller/(:id)/(:other)/(:simple)/(:options)').
+
+**update**: better ActiveRecord support now adds AC rake tasks.
+
+***
+
 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.

data/README.md

@@ -4,7 +4,7 @@
 
 > 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.")_
+Find more info on [Plezi's framework, web server and websocket documentation](http://www.rubydoc.info/gems/plezi/)
 
 ## About the Plezi framework \ server
 
@@ -319,6 +319,53 @@ Plezi is ment to be very flexible. please take a look at the Plezi Module for se
 
 Feel free to fork or contribute. right now I am one person, but together we can make something exciting that will help us enjoy Ruby in this brave new world and (hopefully) set an example that will induce progress in the popular mainstream frameworks such as Rails and Sinatra.
 
+## OAuth2 and other Helpers
+
+Plezi has a few helpers that help with common tasks.
+
+For instance, Plezi has a built in controller that allows you to add social authentication using Google, Facebook
+and and other OAuth2 authentication service. For example:
+
+    require 'plezi'
+
+    class Controller
+        def index
+            flash[:login] ? "You are logged in as #{flash[:login]}" : "You aren't logged in. Please visit one of the following:\n\n* #{request.base_url}#{Plezi::OAuth2Ctrl.url_for :google}\n\n* #{request.base_url}#{Plezi::OAuth2Ctrl.url_for :facebook}"
+        end
+    end
+
+    # set up the common social authentication variables for automatic Plezi::OAuth2Ctrl service recognition.
+    ENV["FB_APP_ID"] ||= "facebook_app_id / facebook_client_id"
+    ENV["FB_APP_SECRET"] ||= "facebook_app_secret / facebook_client_secret"
+    ENV['GOOGLE_APP_ID'] = "google_app_id / google_client_id"
+    ENV['GOOGLE_APP_SECRET'] = "google_app_secret / google_client_secret"
+
+    require 'plezi/oauth'
+
+    # manually setup any OAuth2 service (we'll re-setup facebook as an example):
+    Plezi::OAuth2Ctrl.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']
+
+
+    listen
+
+    create_auth_shared_route do |service_name, token, remote_user_id, remote_user_email, remote_response|
+        # we will create a temporary cookie storing a login message. replace this code with your app's logic
+        flash[:login] = "#{remote_response['name']} (#{remote_user_email}) from #{service_name}"
+    end
+
+    route "/" , Controller
+
+    exit
+
+Plezi has a some more goodies under the hood.
+
+Whether such goodies are part of the Plezi-App Template (such as rake tasks for ActiveRecord without Rails) or part of the Plezi Framework core (such as descried in the Plezi::ControllerMagic documentation: #flash, #url_for, #render, #send_data, etc'), these goodies are fun to work with and make completion of common tasks a breeze.
+
 ## Contributing
 
 1. Fork it ( https://github.com/boazsegev/plezi/fork )

data/Rakefile

@@ -1,7 +1,13 @@
 require "bundler/gem_tasks"
 
 # create a default task
-desc "Not yet implemented: Tests most of the basic features for the Plezi framework."
+desc "Tests most of the basic features for the Plezi framework."
 task :test do
 	load "./test/plezi_tests.rb"
 end
+desc "Leaves the testing server open for 1 minute after most of the tests are complete, delaying shutdown testing."
+task :slowtest do
+	PLEZI_TEST_TIME = 60
+	load "./test/plezi_tests.rb"
+end
+

data/bin/plezi

@@ -5,6 +5,7 @@ $0="Plezi Builder"
 require 'irb'
 require 'securerandom'
 
+
 ##########
 # this is the template writer
 #
@@ -72,6 +73,8 @@ class AppTemplate
 		#set up database stub folders
 		app_tree["db"] ||= {}
 		app_tree["db"]["migrate"] ||= {}
+		app_tree["db"]["fixtures"] ||= {}
+		app_tree["db"]["config.yml"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"database.yml"),  __FILE__))
 
 		#set up the extras folder, to be filled with future goodies.
 		app_tree["extras"] ||= {}
@@ -205,6 +208,10 @@ end
 ######################################################################
 ######################################################################
 
+# update with http://ruby-doc.org/stdlib-2.2.0/libdoc/optparse/rdoc/OptionParser.html
+
+# require 'optparser'
+
 if ARGV[0] == 'new' || ARGV[0] == 'n' || ARGV[0] == "force"
 	#########
 	## set up building environment

data/lib/plezi.rb

@@ -56,6 +56,8 @@ require 'plezi/server/http_response.rb'
 require 'plezi/server/websocket.rb'
 require 'plezi/server/ws_response.rb'
 
+### websocket client
+require 'plezi/server/websocket_client.rb'
 ### Handlers / Framework
 
 require "plezi/handlers/http_echo"

data/lib/plezi/eventmachine/ssl_connection.rb

@@ -12,7 +12,13 @@ module Plezi
 			attr_reader :ssl_socket
 
 			def initialize socket, params
-				if params[:ssl] || params[:ssl_key] || params[:ssl_cert]
+				if params[:ssl_client]
+					context = OpenSSL::SSL::SSLContext.new
+					context.set_params verify_mode: OpenSSL::SSL::VERIFY_NONE # OpenSSL::SSL::VERIFY_PEER #OpenSSL::SSL::VERIFY_NONE
+					@ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, context)
+					@ssl_socket.sync_close = true
+					@ssl_socket.connect
+				elsif params[:ssl] || params[:ssl_key] || params[:ssl_cert]
 					params[:ssl_cert], params[:ssl_key] = SSLConnection.self_cert unless params[:ssl_key] && params[:ssl_cert]
 					context = OpenSSL::SSL::SSLContext.new
 					context.set_params verify_mode: OpenSSL::SSL::VERIFY_NONE # OpenSSL::SSL::VERIFY_PEER #OpenSSL::SSL::VERIFY_NONE
@@ -24,7 +30,7 @@ module Plezi
 					@ssl_socket.sync_close = true
 					@ssl_socket.accept
 				end
-				raise "Not an SSL connection or SSL Socket creation failed" unless ssl_socket
+				raise "Not an SSL connection or SSL Socket creation failed" unless @ssl_socket
 				super
 			end
 
@@ -68,7 +74,7 @@ module Plezi
 			def read size = 1048576
 				data = ''
 				begin
-					loop { data << @ssl_socket.read_nonblock(size).to_s }
+					 (data << @ssl_socket.read_nonblock(size).to_s) until data.bytesize >= size
 				rescue => e
 					
 				end

data/lib/plezi/handlers/controller_magic.rb

@@ -93,6 +93,28 @@ module Plezi
 				true
 			end
 
+			# Returns the RELATIVE url for methods in THIS controller (i.e.: "/path_to_controller/restful/params?non=restful&params=foo")
+			#
+			# accepts one parameter:
+			# dest:: a destination object, either a Hash, a Symbol, a Numerical or a String.
+			#
+			# If :dest is a Numerical, a Symbol or a String, it should signify the id of an object or the name of the method this controller should respond to.
+			#
+			# If :dest is a Hash, it should contain all the relevant parameters the url should set (i.e. `url_for id: :new, name: "Jhon Doe"`)
+			#
+			# If :dest is false (or nil), the String returned will be the url to the index.
+			#
+			# * If you use the same controller in different routes, the first route will dictate the returned url's structure (cause by route priority).
+			#
+			# * Not all controllers support this method. Regexp controller paths and multi-path options will throw an exception.
+			def url_for dest = nil
+				self.class.url_for dest
+			end
+			# same as #url_for, but returns the full URL (protocol:port:://host/path?params=foo)
+			def full_url_for dest
+				request.base_url + url_for(dest)
+			end
+
 			# this method adds data to be sent.
 			#
 			# this is usful for sending 'attachments' (data to be downloaded) rather then
@@ -234,7 +256,6 @@ module Plezi
 				self.class.__inner_redis_broadcast(uuid, method_name, args, &block) || self.class.__inner_process_broadcast(uuid, method_name.to_sym, args, &block)
 			end
 
-
 			# WebSockets.
 			#
 			# Use this to collect data from all 'sibling' websockets (websockets that have been created using the same Controller class).
@@ -274,8 +295,29 @@ module Plezi
 		end
 
 		module ClassMethods
+			protected
+
+			# Sets the HTTP route that is the owner of this controller.
+			#
+			# This is used by the Plezi framework internally and is supplied only for advanced purposes. It is better to avoid using this method. 
+			def set_pl_route route
+				@pl_http_route = route
+			end
+
+			# Gets the HTTP route that is the owner of this controller.
+			#
+			# This is used to utilize the `url_for` method.
+			def get_pl_route
+				@pl_http_route
+			end
+
 			public
 
+			# This class method behaves the same way as the instance method #url_for. See the instance method's documentation for more details.
+			def url_for dest
+				get_pl_route.url_for dest				
+			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

data/lib/plezi/handlers/magic_helpers.rb

@@ -14,12 +14,19 @@ module Plezi
 		def []= key, val
 			if key.is_a?(Symbol) && self.has_key?( key.to_s)
 				key = key.to_s
-			elsif key.is_a?(String) && self.has_key?( key.to_sym)
-				key = key.to_sym
+			elsif self.has_key?( key.to_s.to_sym)
+				key = key.to_s.to_sym
 			end
 			@controller.response.set_cookie key, (val ? val.to_s.dup : nil) if @controller
 			super
 		end
 	end
 
+	module Helpers
+		# a proc that allows Hashes to search for key-value pairs while also converting keys from objects to symbols and from symbols to strings.
+		#
+		# (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) }
+	end
+
 end

data/lib/plezi/handlers/route.rb

@@ -62,7 +62,7 @@ module Plezi
 		# a string can be either a simple string `"/users"` or a string with parameters:
 		# `"/static/:required/(:optional)/(:optional_with_format){[\d]*}/:optional_2"`
 		def initialize path, controller, params={}, &block
-			@path_sections , @params = false, params
+			@original_path, @url_array, @params = path, false, params
 			initialize_path path
 			initialize_controller controller, block
 		end
@@ -75,10 +75,95 @@ module Plezi
 			@controller, @proc = controller, block
 			if controller.is_a?(Class)
 				# add controller magic
-				@controller = self.class.make_controller_magic controller
+				@controller = self.class.make_controller_magic controller, self
 			end
 		end
 
+		# # returns the url for THIS route (i.e. `url_for :index`)
+		# #
+		# # This will be usually used by the Controller's #url_for method to get the relative part of the url.
+		# def url_for dest = :index
+		# 	raise NotImplementedError, "#url_for isn't implemented for this router - could this be a Regexp based router?" unless @url_array
+		# 	# convert dest.id and dest[:id] to their actual :id value.
+		# 	dest = (dest.id rescue false) || (raise TypeError, "Expecting a Symbol, Hash, String, Numeric or an object that answers to obj[:id] or obj.id") unless !dest || dest.is_a?(Symbol) || dest.is_a?(String) || dest.is_a?(Numeric) || dest.is_a?(Hash)
+		# 	url = '/'
+		# 	case dest
+		# 	when false, nil, '', :index
+		# 		add = true
+		# 		@url_array.each do |sec|
+		# 			add = false unless sec[0] != :path
+		# 			url << sec[1] if add
+		# 			raise NotImplementedError, '#url_for(index) cannot be implementedfor this path.' if !add && sec[0] == :path
+		# 			# todo: :multi_path
+		# 		end
+		# 	when Hash
+		# 	when Symbol, String, Numeric
+		# 	end
+		# end
+
+
+
+		# returns the url for THIS route (i.e. `url_for :index`)
+		#
+		# This will be usually used by the Controller's #url_for method to get the relative part of the url.
+		def url_for dest = :index
+			raise NotImplementedError, "#url_for isn't implemented for this router - could this be a Regexp based router?" unless @url_array
+			case dest
+			when String
+				dest = {id: dest.dup}
+			when Numeric, Symbol
+				dest = {id: dest}
+			when Hash
+				dest = dest.dup
+				dest.each {|k,v| dest[k] = v.dup if v.is_a? String }
+			when nil, false
+				dest = {}
+			else
+				# convert dest.id and dest[:id] to their actual :id value.
+				dest = {id: (dest.id rescue false) || (raise TypeError, "Expecting a Symbol, Hash, String, Numeric or an object that answers to obj[:id] or obj.id") }
+			end
+			dest.default_proc = Plezi::Helpers::HASH_SYM_PROC
+
+			url = '/'
+
+			@url_array.each do |sec|
+				raise NotImplementedError, "#url_for isn't implemented for this router - Regexp multi-path routes are still being worked on... use a named parameter instead (i.e. '/foo/(:multi_route){route1|route2}/bar')" if REGEXP_FORMATTED_PATH === sec
+
+				param_name = (REGEXP_OPTIONAL_PARAMS.match(sec) || REGEXP_FORMATTED_OPTIONAL_PARAMS.match(sec) || REGEXP_REQUIRED_PARAMS.match(sec) || REGEXP_FORMATTED_REQUIRED_PARAMS.match(sec))
+				param_name = param_name[1].to_sym if param_name
+
+				if param_name && dest[param_name]
+					url << HTTP.encode(dest.delete(param_name).to_s, :url)
+					url << '/' 
+				elsif !param_name
+					url << sec
+					url << '/' 
+				elsif REGEXP_REQUIRED_PARAMS === sec || REGEXP_OPTIONAL_PARAMS === sec
+					url << '/'
+				elsif REGEXP_FORMATTED_REQUIRED_PARAMS === sec
+					raise ArgumentError, "URL can't be formatted becuse a required parameter (#{param_name.to_s}) isn't specified and it requires a special format (#{REGEXP_FORMATTED_REQUIRED_PARAMS.match(sec)[2]})."
+				end
+			end
+			unless dest.empty?
+				add = '?'
+				dest.each {|k, v| url << "#{add}#{HTTP.encode(k.to_s, :url)}=#{HTTP.encode(v.to_s, :url)}"; add = '&'}
+			end
+			url
+
+		end
+
+
+		# Used to check for routes formatted: /:paramater - required parameters
+		REGEXP_REQUIRED_PARAMS = /^\:([^\(\)\{\}\:]*)$/
+		# Used to check for routes formatted: /(:paramater) - optional parameters
+		REGEXP_OPTIONAL_PARAMS = /^\(\:([^\(\)\{\}\:]*)\)$/
+		# Used to check for routes formatted: /(:paramater){regexp} - optional formatted parameters
+		REGEXP_FORMATTED_OPTIONAL_PARAMS = /^\(\:([^\(\)\{\}\:]*)\)\{(.*)\}$/
+		# Used to check for routes formatted: /:paramater{regexp} - required parameters
+		REGEXP_FORMATTED_REQUIRED_PARAMS = /^\:([^\(\)\{\}\:\/]*)\{(.*)\}$/
+		# Used to check for routes formatted: /{regexp} - required path
+		REGEXP_FORMATTED_PATH = /^\{(.*)\}$/
+
 		# initializes the path by converting the string into a Regexp
 		# and noting any parameters that might need to be extracted for RESTful routes.
 		def initialize_path path
@@ -88,46 +173,16 @@ module Plezi
 			elsif path.is_a? String
 				# prep used prameters
 				param_num = 0
+
 				section_search = "([\\/][^\\/]*)"
 				optional_section_search = "([\\/][^\\/]*)?"
 
-				# to check for routes formatted: /:paramater - required parameters
-				regexp_required_params = /^\:([^\(\)\{\}\:]*)$/
-				# to check for routes formatted: /(:paramater) - optional parameters
-				regexp_optional_params = /^\(\:([^\(\)\{\}\:]*)\)$/
-				# to check for routes formatted: /(:paramater){regexp} - optional formatted parameters
-				regexp_formatted_optional_params = /^\(\:([^\(\)\{\}\:]*)\)\{(.*)\}$/
-				# check for routes formatted: /:paramater{regexp} - required parameters
-				regexp_formatted_required_params = /^\:([^\(\)\{\}\:\/]*)\{(.*)\}$/
-				# check for routes formatted: /{regexp} - required path
-				regexp_formatted_path = /^\{(.*)\}$/
-
 				@path = '^'
-
-				# prep path string
-				# path = path.gsub(/(^\/)|(\/$)/, '')
-
-				# scan for the '/' divider
-				# (split path string only when the '/' is not inside a {} regexp)
-				# level = 0
-				# scn = StringScanner.new(path)
-				# while scn.matched != ''
-				# 	scn.scan_until /[^\\][\/\{\}]|$/
-				# 	case scn.matched
-				# 	when '{'
-				# 		level += 1
-				# 	when '}'
-				# 		level -= 1
-				# 	when '/'
-				# 		split_pos ||= []
-				# 		split_pos << scn.pos if level == 0
-				# 	end
-				# end
+				@url_array = []
 
 				# prep path string and split it where the '/' charected is unescaped.
-				path = path.gsub(/(^\/)|(\/$)/, '').gsub(/([^\\])\//, '\1 - /').split ' - /'
-				@path_sections = path.length
-				path.each.with_index do |section, section_index|
+				@url_array = path.gsub(/(^\/)|(\/$)/, '').gsub(/([^\\])\//, '\1 - /').split ' - /'
+				@url_array.each.with_index do |section, section_index|
 					if section == '*'
 						# create catch all
 						section_index == 0 ? (@path << "(.*)") : (@path << "(\\/.*)?")
@@ -136,42 +191,41 @@ module Plezi
 						return
 
 					# check for routes formatted: /:paramater - required parameters
-					elsif section.match regexp_required_params
+					elsif section.match REGEXP_REQUIRED_PARAMS
 						#create a simple section catcher
 					 	@path << section_search
 					 	# add paramater recognition value
-					 	@fill_parameters[param_num += 1] = section.match(regexp_required_params)[1]
+					 	@fill_parameters[param_num += 1] = section.match(REGEXP_REQUIRED_PARAMS)[1]
 
 					# check for routes formatted: /(:paramater) - optional parameters
-					elsif section.match regexp_optional_params
+					elsif section.match REGEXP_OPTIONAL_PARAMS
 						#create a optional section catcher
 					 	@path << optional_section_search
 					 	# add paramater recognition value
-					 	@fill_parameters[param_num += 1] = section.match(regexp_optional_params)[1]
+				 		@fill_parameters[param_num += 1] = section.match(REGEXP_OPTIONAL_PARAMS)[1]
 
 					# check for routes formatted: /(:paramater){regexp} - optional parameters
-					elsif section.match regexp_formatted_optional_params
+					elsif section.match REGEXP_FORMATTED_OPTIONAL_PARAMS
 						#create a optional section catcher
-					 	@path << (  "(\/(" +  section.match(regexp_formatted_optional_params)[2] + "))?"  )
+					 	@path << (  "(\/(" +  section.match(REGEXP_FORMATTED_OPTIONAL_PARAMS)[2] + "))?"  )
 					 	# add paramater recognition value
-					 	@fill_parameters[param_num += 1] = section.match(regexp_formatted_optional_params)[1]
+					 	@fill_parameters[param_num += 1] = section.match(REGEXP_FORMATTED_OPTIONAL_PARAMS)[1]
 					 	param_num += 1 # we are using two spaces - param_num += should look for () in regex ? /[^\\](/
 
 					# check for routes formatted: /:paramater{regexp} - required parameters
-					elsif section.match regexp_formatted_required_params
+					elsif section.match REGEXP_FORMATTED_REQUIRED_PARAMS
 						#create a simple section catcher
-					 	@path << (  "(\/(" +  section.match(regexp_formatted_required_params)[2] + "))"  )
+					 	@path << (  "(\/(" +  section.match(REGEXP_FORMATTED_REQUIRED_PARAMS)[2] + "))"  )
 					 	# add paramater recognition value
-					 	@fill_parameters[param_num += 1] = section.match(regexp_formatted_required_params)[1]
+					 	@fill_parameters[param_num += 1] = section.match(REGEXP_FORMATTED_REQUIRED_PARAMS)[1]
 					 	param_num += 1 # we are using two spaces - param_num += should look for () in regex ? /[^\\](/
 
 					# check for routes formatted: /{regexp} - formated path
-					elsif section.match regexp_formatted_path
+					elsif section.match REGEXP_FORMATTED_PATH
 						#create a simple section catcher
-					 	@path << (  "\/(" +  section.match(regexp_formatted_path)[1] + ")"  )
+					 	@path << (  "\/(" +  section.match(REGEXP_FORMATTED_PATH)[1] + ")"  )
 					 	# add paramater recognition value
 					 	param_num += 1 # we are using one space - param_num += should look for () in regex ? /[^\\](/
-
 					else
 						@path << "\/"
 						@path << section
@@ -180,7 +234,9 @@ module Plezi
 				unless @fill_parameters.values.include?("id")
 					@path << optional_section_search
 					@fill_parameters[param_num += 1] = "id"
+					@url_array << '(:id)'
 				end
+				# set the Regexp and return the final result.
 				@path = /#{@path}$/
 			else
 				raise "Path cannot be initialized - path must be either a string or a regular experssion."
@@ -217,11 +273,11 @@ module Plezi
 		# cookies:: the request's cookies.
 		# flash:: an amazing Hash object that sets temporary cookies for one request only - greate for saving data between redirect calls.
 		#
-		def self.make_controller_magic(controller)
+		def self.make_controller_magic(controller, container)
 			new_class_name = "Plezi__#{controller.name.gsub /[\:\-\#\<\>\{\}\(\)\s]/, '_'}"
 			return Module.const_get new_class_name if Module.const_defined? new_class_name
 			# controller.include Plezi::ControllerMagic
-			controller.instance_eval { include Plezi::ControllerMagic }
+			controller.instance_exec(container) {|r| include Plezi::ControllerMagic; set_pl_route r;}
 			ret = Class.new(controller) do
 
 				def name
@@ -375,6 +431,7 @@ module Plezi
 			end
 			Object.const_set(new_class_name, ret)
 			Module.const_get(new_class_name).reset_routing_cache
+			ret.instance_exec(container) {|r| set_pl_route r;}
 			ret
 		end