plezi 0.12.22 → 0.14.0

data/lib/plezi/handlers/placebo.rb

@@ -1,112 +0,0 @@
-module Plezi
-
-	# This API wil allows you to listen to Websocket Broadcasts sent to any object and to accept unicasts
-	# even when NOT connected to a websocket.
-	#
-	# Simpley create a class to handle any events and call `Plezi::Placebo.new ClassName` or use the {Plezi.start_placebo} shortcut:
-	#
-	#        # Important: set up a unique - but shared - main redis channel for BOTH Apps (The Plezi and the Placebo).
-	#        Plezi::Settings.redis_channel_name = 'unique_channel_name_for_app_b24270e2'
-	#        # Important: set Plezi's auo-Redis pub/sub server.
-	#        ENV['PL_REDIS_URL'] ||=  "redis://redis:password@redis.server.com:9999"
-	#
-	#        # create the Placebo bridge handler
-	#        class PleziBridge
-	#        	def on_open
-	#        		multicast :print, "Hello from Placebo!"
-	#        	end
-	#        	def print data
-	#        		Iodine.info "Placebo message: #{data}"
-	#        		puts "Placebo message: #{data}"
-	#        	end
-	#        end
-	#
-	#        # initiate Placebo mode using the bridge class. it's possible to create multiple
-	#        # it's possible to create multiple bridge classes this way.
-	#        Plezi.start_placebo(PleziBridge)
-	#
-	# A new instance will be created and that instance will answer any broadcasts, for ALL possible
-	# Plezi controllers, as long as it had a method defined that is capable to handle the broadcast.
-	#
-	# The new instance will also accept unicasts sent to it's unique UUID.
-	#
-	# Returns an instance that is a member of the class passed, after that class was inherited by Plezi and
-	# more methods were injected into it's subclass.
-	module Placebo
-
-		# the base module exposes some of the core functionality, but shouldn't be relied upon as far as it's API goes.
-		module Base
-			#the methods here will be injected to the Placebo controller.
-			module Core
-				def self.included base
-					base.send :include, Plezi::Base::WSObject
-					base.send :include, InstanceMethods
-					base.extend ClassMethods
-					base.superclass.instance_eval {extend SuperClassMethods}
-				end
-
-				#the methods here will be injected to the Placebo controller as Instance methods.
-				module InstanceMethods
-					public
-					attr_accessor :io
-					def initialize io_in, io_out, request
-						@io_in = io_in
-						@io_out = io_out
-						@request = request
-						super()
-					end
-					# Cleanup on disconnection
-					def on_close
-						@io_out.close unless @io_out.closed?
-						return super() if defined? super
-						Iodine.warn "Placebo #{self.class.superclass.name} disconnected. Ignore if this message appears during shutdown."
-					end
-					def placebo?
-						true
-					end
-				end
-				#the methods here will be injected to the Placebo controller as class methods.
-				module ClassMethods
-				end
-				module SuperClassMethods
-					def placebo?
-						true
-					end
-				end
-			end
-			class PlaceboIO < ::Iodine::Http::Websockets
-				# emulate Iodine::Protocol#timeout?
-				def timeout? time
-					false
-				end
-				# emulate Iodine::Protocol#call
-				def call
-					read
-					Iodine.warn "Placebo IO recieved IO signal - this is unexpected..."
-				end
-				# override "go_away"
-				def go_away
-					close
-				end
-			end
-		end
-		module_function
-		def new placebo_class, create = true
-			new_class_name = "PlaceboPlezi__#{placebo_class.name.gsub( /[\:\-\#\<\>\{\}\(\)\s]/ , '_')}"
-			new_class = nil
-			new_class =  Module.const_get new_class_name if Module.const_defined? new_class_name
-			unless new_class
-				new_class = Class.new(placebo_class) do
-					include Placebo::Base::Core
-				end
-				Object.const_set(new_class_name, new_class)
-			end
-			return new_class unless create
-			i, o = IO.pipe
-			req = {}
-			handler = new_class.new(i, o, req)
-			Placebo::Base::PlaceboIO.new i, handler: handler, request: req
-			handler
-		end
-	end
-end

data/lib/plezi/handlers/route.rb

@@ -1,216 +0,0 @@
-module Plezi
-	module Base
-		class Route
-			# the Regexp that will be used to match the request.
-			attr_reader :path
-			# the controller that answers the request on this path (if exists).
-			attr_reader :controller
-			# the proc that answers the request on this path (if exists).
-			attr_reader :proc
-			# the parameters for the router and service that were used to create the service, router and host.
-			attr_reader :params
-			# an array containing the parts of the original url, if any. `false` for Regexp or non relevant routes.
-			attr_reader :url_array
-
-			# lets the route answer the request. returns false if no response has been sent.
-			def on_request request, response
-				fill_parameters = match request.path
-				return false unless fill_parameters
-				old_params = request.params.dup
-				fill_parameters.each {|k,v| Plezi::Base::Helpers.add_param_to_hash k, ::Plezi::Base::Helpers.form_decode(v), request.params }
-				ret = false
-				if controller
-					ret = controller.new(request, response)._route_path_to_methods_and_set_the_response_
-				elsif proc
-					# proc.init(request, response)
-					# ret = proc.instance_exec(request, response, &proc)
-					ret = proc.call(request, response)
-				elsif controller == false
-					request.path = path.match(request.path).to_a.last.to_s
-					return false
-				end
-				unless ret
-					request.params.replace old_params unless fill_parameters.empty?
-					return false
-				end
-				return ret
-			end
-
-			# the initialize method accepts a Regexp or a String and creates the path object.
-			#
-			# Regexp paths will be left unchanged
-			#
-			# 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
-				@original_path, @url_array, @params = path, false, params
-				initialize_path( (controller == false) ? "#{path.chomp('/')}/*" : path )
-				initialize_controller controller, block
-			end
-
-			# initializes the controller,
-			# by inheriting the class into an Plezi controller subclass (with the Plezi::ControllerMagic injected).
-			#
-			# Proc objects are currently passed through without any change - as Proc routes are assumed to handle themselves correctly.
-			def initialize_controller controller, block
-				@controller, @proc = controller, block
-				if controller.is_a?(Class)
-					# add controller magic
-					@controller = self.class.make_controller_magic controller, self
-				end
-				if @proc.is_a?(Proc)
-					# # proc's methods aren't executed since it's binding isn't `self`
-					# @proc.instance_exec do
-					# 	extend ::Plezi::ControllerMagic::InstanceMethods
-					# 	undef :url_for
-					# 	undef :full_url_for
-					# 	undef :requested_method
-					# 	def run request, response
-					# 		@request = request
-					# 		@params = request.params
-					# 		@flash = response.flash
-					# 		@host_params = request[:host_settings]
-					# 		@response = response
-					# 		@cookies = request.cookies
-					# 	end
-					# end
-				end
-			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
-				@fill_parameters = {}
-				if path.is_a? Regexp
-					@path = path
-				elsif path.is_a? String
-					# prep used prameters
-					param_num = 0
-
-					section_search = "([\\/][^\\/]*)"
-					optional_section_search = "([\\/][^\\/]*)?"
-
-					@path = '^'
-					@url_array = []
-
-					# prep path string and split it where the '/' charected is unescaped.
-					@url_array = path.gsub(/(^\/)|(\/$)/, ''.freeze).gsub(/([^\\])\//, '\1 - /').split ' - /'
-					@url_array.each.with_index do |section, section_index|
-						if section == '*'.freeze
-							# create catch all
-							section_index == 0 ? (@path << "(.*)") : (@path << "(\\/.*)?")
-							# finish
-							@path = /#{@path}$/
-							return
-
-						# check for routes formatted: /:paramater - required parameters
-						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]
-
-						# check for routes formatted: /(:paramater) - optional parameters
-						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]
-
-						# check for routes formatted: /(:paramater){regexp} - optional parameters
-						elsif section.match REGEXP_FORMATTED_OPTIONAL_PARAMS
-							#create a optional section catcher
-						 	@path << (  "(\/(" +  section.match(REGEXP_FORMATTED_OPTIONAL_PARAMS)[2] + "))?"  )
-						 	# add paramater recognition value
-						 	@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
-							#create a simple section catcher
-						 	@path << (  "(\/(" +  section.match(REGEXP_FORMATTED_REQUIRED_PARAMS)[2] + "))"  )
-						 	# add paramater recognition value
-						 	@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
-							#create a simple section catcher
-						 	@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
-						end
-					end
-					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."
-				end	
-				return
-			end
-
-			# this performs the match and assigns the parameters, if required.
-			def match path
-				hash = {}
-				# m = nil
-				# unless @fill_parameters.values.include?("format")
-				# 	if (m = path.match /([^\.]*)\.([^\.\/]+)$/)
-				# 		Plezi::Base::Helpers.add_param_to_hash 'format', m[2], hash
-				# 		path = m[1]
-				# 	end
-				# end
-				m = @path.match path
-				return false unless m
-				@fill_parameters.each { |k, v| hash[v] = m[k][1..-1] if m[k] && m[k] != '/'.freeze }
-				hash
-			end
-
-			###########
-			## class magic methods
-
-			protected
-
-			# injects some magic to the controller
-			#
-			# adds the `redirect_to` and `send_data` methods to the controller class, as well as the properties:
-			# env:: the env recieved by the Rack server.
-			# params:: the request's parameters.
-			# 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, container)
-				new_class_name = "Plezi__#{controller.name.gsub(/[\:\-\#\<\>\{\}\(\)\s]/ , '_'.freeze)}"
-				return Module.const_get new_class_name if Module.const_defined? new_class_name
-				# controller.include Plezi::ControllerMagic
-				controller.instance_exec(container) {|r| include Plezi::ControllerMagic; }
-				ret = Class.new(controller) do
-					include Plezi::Base::ControllerCore
-				end
-				Object.const_set(new_class_name, ret)
-				Module.const_get(new_class_name).reset_routing_cache
-				ret
-			end
-
-		end
-	end
-
-end

data/lib/plezi/handlers/session.rb

@@ -1,109 +0,0 @@
-module Plezi
-	module Base
-		module SessionStorage
-			module_function
-			# returns a session object
-			def fetch id
-				return Plezi::Session.new(id) if Plezi.redis # avoid a local cache if Redis is used.
-				Iodine::Http::SessionManager::FileSessionStorage.fetch id # use the tmp-file-session logic if Redis isn't present
-			end
-		end
-	end
-	# A hash like interface for storing request session data.
-	# The store must implement: store(key, value) (aliased as []=);
-	# fetch(key, default = nil) (aliased as []);
-	# delete(key); clear;
-	class Session
-
-		# The session's lifetime in seconds = 24 hours. This is only true when using the built in support for the Redis persistent storage.
-		SESSION_LIFETIME = 60*60*24
-		# called by the Plezi framework to initiate a session with the id requested
-		def initialize id
-			@id = id
-			if id && Plezi.redis
-				return self
-			end
-			failed
-		end
-		# returns the session id (the session cookie value).
-		def id
-			@id
-		end
-		# Get a key from the session data store. If a Redis server is supplied, it will be used to synchronize session data.
-		#
-		# Due to scaling considirations, all keys will be converted to strings, so that `"name" == :name` and `1234 == "1234"`.
-		# If you store two keys that evaluate as the same string, they WILL override each other.
-		def [] key
-			key = key.to_s
-			if conn=Plezi.redis
-				conn.expire @id, SESSION_LIFETIME
-				return conn.hget @id, key
-			end
-			failed
-		end
-		alias :fetch :[]
-
-		# Stores a key in the session's data store. If a Redis server is supplied, it will be used to synchronize session data.
-		#
-		# Due to scaling considirations, all keys will be converted to strings, so that `"name" == :name` and `1234 == "1234"`.
-		# If you store two keys that evaluate as the same string, they WILL override each other.
-		def []= key, value
-			return delete key if value.nil?
-			key = key.to_s
-			if (conn=Plezi.redis)
-				conn.hset @id, key, value
-				conn.expire @id, SESSION_LIFETIME
-				return value
-			end
-			failed
-		end
-		alias :store :[]=
-
-		# @return [Hash] returns a shallow copy of the current session data as a Hash.
-		def to_h
-			if (conn=Plezi.redis) 
-				conn.expire @id, SESSION_LIFETIME
-				return conn.hgetall(@id)
-			end
-			failed
-		end
-		alias :refresh :to_h
-
-		# @return [String] returns the Session data in YAML format.
-		def to_s
-			if (conn=Plezi.redis) 
-				conn.expire @id, SESSION_LIFETIME
-				return conn.hgetall(@id).to_yaml
-			end
-			failed
-		end
-
-		# Removes a key from the session's data store.
-		def delete key
-			key = key.to_s
-			if (conn=Plezi.redis)
-				conn.expire @id, SESSION_LIFETIME
-				ret = conn.hget @id, key
-				conn.hdel @id, key
-				return ret
-			end				
-			failed
-		end
-
-		# Clears the session's data.
-		def clear
-			if (conn=Plezi.redis)
-				return conn.del @id
-			end
-			failed
-		end
-
-		protected
-
-		def failed
-			raise 'Redis connection failed while using Redis Session Storage.'
-			
-		end
-	end
-	Iodine::Http::SessionManager.storage = Plezi::Base::SessionStorage
-end

data/lib/plezi/handlers/stubs.rb

@@ -1,156 +0,0 @@
-module Plezi
-
-	####
-	# a skeleton for a RESTful controller class
-	#
-	# you dont have to inherit this or use this, this is stub code.
-	#
-	# it can also be used for non RESTful requests by utilizing only the
-	# index method or adding public methods that aren't RESTful reserved (and don't start with '_').
-	#
-	# if a method returns false, a 404 error (not found) is assumed. and routes continue to search.
-	#
-	# otherwise, the method's return value is added to the response body. Normally, the method will return a String object.
-	#
-	# methods should return the response's body string as their last value, unless
-	# they have correctly edited the response (in which case they should return `true`).
-	#
-	class StubRESTCtrl
-
-		# every request that routes to this controller will create a new instance
-		def initialize
-		end
-
-		# called when request is GET and params\[:id] isn't defined
-		def index
-			"Hello World!"
-		end
-
-		# called when request is GET and params\[:id] exists
-		def show
-			"nothing to show for id - #{params[:id]} - with parameters: #{params.to_s}"
-		end
-
-		# called when request is GET and params\[:id] == "new" (used for the "create new object" form).
-		def new
-			"Should we make something new?"
-		end
-
-		# called when request is POST or PUT and params\[:id] isn't defined or params\[:id] == "new" 
-		def save
-			"save called - creating a new object."
-		end
-
-		# called when request is POST or PUT and params\[:id] exists and isn't "new"
-		def update
-			"update called - updating #{params[:id]}"
-		end
-
-		# called when request is DELETE (or params[:_method] == 'delete') and request.params\[:id] exists
-		def delete
-			"delete called - deleting object #{params[:id]}"
-		end
-
-		# called before request is called
-		#
-		# if method returns false (not nil), controller exists
-		# and routes continue searching
-		def before
-			true
-		end
-		# called after request is completed
-		#
-		# if method returns false (not nil), the request body is cleared,
-		# the controller exists and routes continue searching
-		def after
-			true
-		end
-	end
-
-	####
-	# a skeleton for a WebSocket controller class which uses REST to emulate long XHR pulling
-	#
-	# you dont have to inherit this or use this, this is example/stub code.
-	#
-	# WebSockets Controllers and RESTful Controllers can be the same class
-	# (the same route can handle both a regular request and a WebSocket request).
-	#
-	# if the pre_connect method returns false, the WebSockets connection will be refused and the remaining routes will be attempted.
-	#
-	class StubWSCtrl
-
-		# every request that routes to this controller will create a new instance
-		def initialize
-		end
-
-		# called before the protocol is swithed from HTTP to WebSockets.
-		#
-		# this allows setting headers, cookies and other data (such as authentication)
-		# prior to opening a WebSocket.
-		#
-		# if the method returns false, the connection will be refused and the remaining routes will be attempted.
-		def pre_connect
-			true
-		end
-
-		# called immediately after a WebSocket connection has been established.
-		# it blocks all the connection's actions until the `on_open` initialization is finished.
-		def on_open
-			true
-		end
-
-		# called when new data is recieved
-		#
-		# 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 once, AFTER the connection was closed.
-		def on_close
-		end
-
-		# called once, during **server shutdown**, BEFORE the connection is closed.
-		# this will only be called for connections that are open while the server is shutting down.
-		def on_shutdown
-		end
-
-		# a demo event method that recieves a broadcast from instance siblings.
-		#
-		# methods that are protected and methods that start with an underscore are hidden from the router
-		# 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.to_s
-		end
-
-		# a CLASS level callback that will be called when a unicast doesn't find it's target.
-		#
-		# the lack of this callback being called does NOT imply that the unicast was processed without errors,
-		# it's only called if the target itself wasn't found.
-		def self.failed_unicast target, method, arguments_array
-		end
-
-		#####
-		## It is possible to use RESTful methods to help emulate long XHR pulling.
-		## a RESTful controller can also be a WebSockets controller (these are not exclusive qualities).
-
-		# called when request is GET and params\[:id] isn't defined
-		def index
-			"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").
-		def show
-			{message: 'read_chat', data: {id: params[:id], token: cookies['example_token'], example_data: 'we missed you.'}}.to_json
-		end
-		# called when request is POST / PUT and params\[:id] exists
-		def update
-			# assumes body is JSON - more handling could be done using the params (which hold parsed JSON data).
-			broadcast :_push, request[:body] 
-			{message: 'write_chat', data: {id: params[:id], token: cookies['example_token'], example_data: 'message sent.'}}.to_json
-		end
-
-	end
-end