plezi 0.7.0

data/lib/plezi/handlers/http_echo.rb

@@ -0,0 +1,27 @@
+module Plezi
+	#####
+	# this is a Handler stub class for an HTTP echo server.
+	module HTTPEcho
+		module_function
+
+		# handles requests by printing out the parsed data. gets the `request` parameter from the HTTP protocol.
+		def on_request request
+			response = HTTPResponse.new request, 200, {"content-type" => "text/plain"}, ["parsed as:\r\n", request.to_s]
+			response.body.last << "\n\n params:"
+			request.params.each {|k,v| response.body.last << "\n#{k}: #{v}"}
+			response.send
+			response.finish
+		end
+
+		# does nothing - a simple stub as required from handlers
+		def add_route *args
+			self
+		end
+
+		# does nothing - a simple stub as required from handlers
+		def add_host *args
+			self
+		end
+	end
+
+end

data/lib/plezi/handlers/http_host.rb

@@ -0,0 +1,215 @@
+module Plezi
+	#####
+	# this is a Handler stub class for an HTTP echo server.
+	class HTTPHost
+
+		# the parameters / settings for the Host.
+		attr_reader :params
+		# the routing array
+		attr_reader :routes
+
+		# initializes an HTTP host with the parameters for the specific host.
+		#
+		# parameters are the same (almost) as `add_service` and include `root` for file root, `assets`
+		# and other non service related options.
+		def initialize params = {}
+			@params = params
+			@routes = []
+			# params[:save_assets] = true unless params[:save_assets] == false
+			params[:index_file] ||= 'index.html'
+			params[:assets_public] ||= '/assets'
+			params[:assets_public].chomp! '/'
+
+			@sass_cache = Sass::CacheStores::Memory.new if defined?(::Sass)
+			# @sass_cache_lock = Mutex.new
+		end
+
+		# adds a route under the specific host
+		def add_route path, controller, &block
+			routes << Route.new(path, controller, params, &block)
+		end
+
+		# handles requests sent to the host. returns true if the host delt with the request.
+		#
+		# since hosts are required to handle the requests (send 404 errors if resources arrn't found),
+		# this method always returns true.
+		def on_request request
+			begin
+				# render any assets?
+				return true if render_assets request
+
+				# send static file, if exists and root is set.
+				return true if send_static_file request
+
+				# return if a route answered the request
+				routes.each {|r| return true if r.on_request(request) }
+
+				# send folder listing if root is set, directory listing is set and folder exists
+
+				#to-do
+
+				#return error code or 404 not found
+				send_by_code request, 404			
+			rescue Exception => e
+				# return 500 internal server error.
+				Plezi.error e
+				send_by_code request, 500
+			end
+			true
+		end
+
+		# Dresses up as a Rack app (If you don't like WebSockets, it's a reasonable aaproach).
+		def call request
+			request = Rack::Request.new request if defined? Rack
+			ret = nil
+			begin
+				# render any assets?
+				ret = render_assets request
+				return ret if ret
+
+				# send static file, if exists and root is set.
+				ret = send_static_file request
+				return ret if ret
+
+				# return if a route answered the request
+				routes.each {|r| ret = r.call(request); return ret if ret }
+
+				# send folder listing if root is set, directory listing is set and folder exists
+
+				#to-do
+
+				#return error code or 404 not found
+				return send_by_code request, 404			
+			rescue Exception => e
+				# return 500 internal server error.
+				Plezi.error e
+				return send_by_code request, 500
+			end
+			true
+		end
+
+		################
+		## basic responses
+		## (error codes and static files)
+
+		# sends a response for an error code, rendering the relevent file (if exists).
+		def send_by_code request, code, headers = {}
+			begin
+				if params[:root]
+					if defined?(::Slim) && Plezi.file_exists?(File.join(params[:root], "#{code}.slim"))
+						Plezi.cache_data File.join(params[:root], "#{code}.slim"), Slim::Template.new( File.join( params[:root], "#{code}.slim" ) ) unless Plezi.cached? File.join(params[:root], "#{code}.slim")
+						return send_raw_data request, Plezi.get_cached( File.join(params[:root], "#{code}.slim") ).render( self ), 'text/html', code, headers
+					elsif defined?(::Haml) && Plezi.file_exists?(File.join(params[:root], "#{code}.haml"))
+						Plezi.cache_data File.join(params[:root], "#{code}.haml"), Haml::Engine.new( IO.read( File.join( params[:root], "#{code}.haml" ) ) ) unless Plezi.cached? File.join(params[:root], "#{code}.haml")
+						return send_raw_data request, Plezi.get_cached( File.join(params[:root], "#{code}.haml") ).render( self ), 'text/html', code, headers
+					elsif defined?(::ERB) && Plezi.file_exists?(File.join(params[:root], "#{code}.erb"))
+						return send_raw_data request, ERB.new( Plezi.load_file( File.join(params[:root], "#{code}.erb") ) ).result(binding), 'text/html', code, headers
+					elsif Plezi.file_exists?(File.join(params[:root], "#{code}.html"))
+						return send_file(request, File.join(params[:root], "#{code}.html"), code, headers)
+					end
+				end
+				return true if send_raw_data(request, HTTPResponse::STATUS_CODES[code], "text/plain", code, headers)
+			rescue Exception => e
+				Plezi.error e
+			end
+			false
+		end
+
+		# attempts to send a static file by the request path (using `send_file` and `send_raw_data`).
+		#
+		# returns true if data was sent.
+		def send_static_file request
+			return false unless params[:root]
+			file_requested = request[:path].to_s.split('/')
+			unless file_requested.include? '..'
+				file_requested.shift
+				file_requested = File.join(params[:root], *file_requested)
+				return true if send_file request, file_requested
+				return send_file request, File.join(file_requested, params[:index_file])
+			end
+			false
+		end
+
+		# sends a file/cacheed data if it exists. otherwise returns false.
+		def send_file request, filename, status_code = 200, headers = {}
+			if Plezi.file_exists?(filename) && !::File.directory?(filename)
+				return send_raw_data request, Plezi.load_file(filename), MimeTypeHelper::MIME_DICTIONARY[::File.extname(filename)], status_code, headers
+			end
+			return false
+		end
+		# sends raw data through the connection. always returns true (data send).
+		def send_raw_data request, data, mime, status_code = 200, headers = {}
+			response = HTTPResponse.new request, status_code, headers
+			response['cache-control'] = 'public, max-age=86400'					
+			response << data
+			response['content-length'] = data.bytesize
+			response.finish
+			true
+		end
+
+		###############
+		## asset rendering and responses
+
+		# renders assets, if necessary, and places the rendered result in the cache and in the public folder.
+		def render_assets request
+			# contine only if assets are defined and called for
+			return false unless @params[:assets] && request.path.match(/^#{params[:assets_public]}\/.+/)
+			# review callback, if defined
+			return true if params[:assets_callback] && params[:assets_callback].call(request)
+
+			# get file requested
+			source_file = File.join(params[:assets], *(request.path.match(/^#{params[:assets_public]}\/(.+)/)[1].split('/')))
+
+			# stop if file name is reserved / has security issues
+			return false if source_file.match(/(scss|sass|coffee|\.\.\/)$/)
+
+			# set where to store the rendered asset
+			target_file = false
+			target_file = File.join( params[:root], params[:assets_public], *request.path.match(/^#{params[:assets_public]}\/(.*)/)[1].split('/') ) if params[:root]
+
+			# send the file if it exists (no render needed)
+			if File.exists?(source_file)
+				data = Plezi.cache_needs_update?(source_file) ? Plezi.save_file(target_file, Plezi.reload_file(source_file), params[:save_assets]) : Plezi.load_file(source_file)
+				return (data ? send_raw_data(request, data, MimeTypeHelper::MIME_DICTIONARY[::File.extname(source_file)]) : false)
+			end
+
+			# render supported assets
+			case source_file
+			when /\.css$/
+				sass = source_file.gsub /css$/, 'sass'
+				sass.gsub! /sass$/, 'scss' unless Plezi.file_exists?(sass)
+				return false unless Plezi.file_exists?(sass)
+				# review mtime and render sass if necessary
+				if defined?(::Sass) && refresh_sass?(sass)
+					eng = Sass::Engine.for_file(sass, cache_store: @sass_cache)
+					Plezi.cache_data sass, eng.dependencies
+					css, map = eng.render_with_sourcemap(params[:assets_public])
+					Plezi.save_file target_file, css, params[:save_assets]
+					Plezi.save_file (target_file + ".map"), map, params[:save_assets]
+				end
+				# try to send the cached css file which started the request.
+				return send_file request, target_file
+			when /\.js$/
+				coffee = source_file.gsub /js$/i, 'coffee'
+				return false unless Plezi.file_exists?(coffee)
+				# review mtime and render coffee if necessary
+				if defined?(::CoffeeScript) && Plezi.cache_needs_update?(coffee)
+					# render coffee to cache
+					Plezi.cache_data coffee, nil
+					Plezi.save_file target_file, CoffeeScript.compile(IO.read coffee), params[:save_assets]
+				end
+				# try to send the cached js file which started the request.
+				return send_file request, target_file
+			end
+			false
+		end
+		def refresh_sass? sass
+			return false unless File.exists?(sass)
+			return true if Plezi.cache_needs_update?(sass)
+			mt = Plezi.file_mtime(sass)
+			Plezi.get_cached(sass).each {|e| return true if File.exists?(e.options[:filename]) && (File.mtime(e.options[:filename]) > mt)} # fn = File.join( e.options[:load_paths][0].root, e.options[:filename]) 
+			false
+		end
+	end
+
+end

data/lib/plezi/handlers/http_router.rb

@@ -0,0 +1,69 @@
+module Plezi
+	#####
+	# this is a Handler stub class for an HTTP echo server.
+	class HTTPRouter
+
+		# the hosts dictionary router.hosts['www.foo.com'] == HTTPHost
+		attr_reader :hosts
+		# the current active host object
+		attr_reader :active_host
+
+		# initializes an HTTP router (the normal Handler for HTTP requests)
+		#
+		# the router holds the different hosts and sends them messages/requests.
+		def initialize
+			@hosts = {}
+			@active_host = nil
+		end
+
+		# adds a host to the router (or activates an existing host to add new routes). accepts a host name and any parameters not related to the service (see `Plezi.add_service`)
+		def add_host host_name, params
+			host_name = (host_name ? host_name.to_s.downcase : :default)
+			@hosts[host_name] ||= HTTPHost.new params
+			add_alias host_name, *params[:alias] if params[:alias]
+			@active_host = @hosts[host_name]
+		end
+		# adds an alias to an existing host name (normally through the :alias parameter in the `add_host` method).
+		def add_alias host_name, *aliases
+			return false unless @hosts[host_name]
+			aliases.each {|a| @hosts[a.to_s.downcase] = @hosts[host_name]}
+			true
+		end
+
+		# adds a route to the active host. The active host is the last host referenced by the `add_host`.
+		def add_route path, controller, &block
+			raise 'No Host defined.' unless @active_host
+			@active_host.add_route path, controller, &block
+		end
+
+		# adds a route to all existing hosts.
+		def add_shared_route path, controller, &block
+			raise 'No Host defined.' if @hosts.empty?
+			@hosts.each {|n, h| h.add_route path, controller, &block }
+		end
+		
+		# handles requests send by the HTTP Protocol (HTTPRequest objects)
+		def on_request request
+			request.service.timeout = 300
+			if request[:host_name] && hosts[request[:host_name].to_s.downcase]
+				hosts[request[:host_name].downcase].on_request request
+			elsif hosts[:default]
+				hosts[:default].on_request request
+			else
+				HTTPResponse.new( request, 404, {"content-type" => "text/plain", "content-length" => "15"}, ["host not found."]).finish
+			end
+			request.service.timeout = 5
+		end
+		# handles requests send by Rack - dresses up as Middleware, for Rack (if you're don't like WebSockets, go ahead...)
+		def call env
+			if env["HOST"] && hosts[env["HOST"].downcase]
+				hosts[env["HOST"].downcase].call env
+			elsif hosts[:default]
+				hosts[:default].call env
+			else
+				[404, {"content-type" => "text/plain", "content-length" => "15"}, ["host not found."] ]
+			end
+		end
+	end
+
+end

data/lib/plezi/handlers/magic_helpers.rb

@@ -0,0 +1,43 @@
+module Plezi
+
+	# set magic cookies
+	#
+	# magic cookies keep track of both incoming and outgoing cookies, setting the response's cookies as well as the combined cookie respetory (held by the request object).
+	#
+	# use only the []= for magic cookies. merge and update might not set the response cookies.
+	class Cookies < ::Hash
+		# sets the Magic Cookie's controller object (which holds the response object and it's `set_cookie` method).
+		def set_controller controller
+			@controller = controller
+		end
+		# overrides the []= method to set the cookie for the response (by encoding it and preparing it to be sent), as well as to save the cookie in the combined cookie jar (unencoded and available).
+		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
+			end
+			@controller.response.set_cookie key, (val ? val.dup : nil) if @controller
+			super
+		end
+	end
+
+	# tweeks a hash object to read both :symbols and strings (similar to Rails but without).
+	def self.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]
+			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

data/lib/plezi/handlers/route.rb

@@ -0,0 +1,272 @@
+module Plezi
+	#####
+	# this class holds the route and matching logic that will normally be used for HTTP handling
+	# it is used internally and documentation is present for development and edge users.
+	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
+
+		# lets the route answer the request. returns false if no response has been sent.
+		def on_request request
+			fill_paramaters = match request.path
+			return false unless fill_paramaters
+			fill_paramaters.each {|k,v| HTTP.add_param_to_hash k, v, request.params }
+			response = HTTPResponse.new request
+			if controller
+				ret = controller.new(request, response, params)._route_path_to_methods_and_set_the_response_
+				response.try_finish if ret
+				return ret
+			elsif proc
+				ret = proc.call(request, response)
+				# response << ret if ret.is_a?(String)
+				response.try_finish if ret
+				return ret
+			elsif controller == false
+				request.path = path.match(request.path).to_a.last
+			end
+			return false
+		end
+
+		# handles Rack requests (dresses up as Rack).
+		def call request
+			fill_paramaters = match request.path_info
+			return false unless fill_paramaters
+			fill_paramaters.each {|k,v| HTTP.add_param_to_hash k, v, request.params }
+			response = HTTPResponse.new request
+			if controller
+				ret = controller.new(request, response, params)._route_path_to_methods_and_set_the_response_
+				return response if ret
+			elsif proc
+				ret = proc.call(request, response)
+				return response if ret
+			elsif controller == false
+				request.path_info = path.match(request.path_info).to_a.last
+			end
+			return false
+		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 paramaters:
+		# `"/static/:required/(:optional)/(:optional_with_format){[\d]*}/:optional_2"`
+		def initialize path, controller, params={}, &block
+			@path_sections , @params = false, params
+			initialize_path 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
+			end
+		end
+
+		# 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_paramaters = {}
+			if path.is_a? Regexp
+				@path = path
+			elsif path.is_a? String
+				# prep used prameters
+				param_num = 0
+				section_search = "([\\/][^\\/]*)"
+				optional_section_search = "([\\/][^\\/]*)?"
+				@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
+
+				# prep path string and split it where the '/' charected is unescaped.
+				path = path.gsub(/(^\/)|(\/$)/, '').gsub(/([^\\])\//, '\1 - /').split ' - /'
+				@path_sections = path.length
+				path.each do |section|
+					if section == '*'
+						# create catch all
+						@path << "(.*)"
+						# finish
+						@path = /#{@path}$/
+						return
+
+					# check for routes formatted: /:paramater - required paramaters
+					elsif section.match /^\:([^\(\)\{\}\:]*)$/
+						#create a simple section catcher
+					 	@path << section_search
+					 	# add paramater recognition value
+					 	@fill_paramaters[param_num += 1] = section.match(/^\:([^\(\)\{\}\:]*)$/)[1]
+
+					# check for routes formatted: /:paramater{regexp} - required paramaters
+					elsif section.match /^\:([^\(\)\{\}\:\/]*)\{(.*)\}$/
+						#create a simple section catcher
+					 	@path << (  "(\/(" +  section.match(/^\:([^\(\)\{\}\:\/]*)\{(.*)\}$/)[2] + "))"  )
+					 	# add paramater recognition value
+					 	@fill_paramaters[param_num += 1] = section.match(/^\:([^\(\)\{\}\:\/]*)\{(.*)\}$/)[1]
+					 	param_num += 1 # we are using two spaces
+
+					# check for routes formatted: /(:paramater) - optional paramaters
+					elsif section.match /^\(\:([^\(\)\{\}\:]*)\)$/
+						#create a optional section catcher
+					 	@path << optional_section_search
+					 	# add paramater recognition value
+					 	@fill_paramaters[param_num += 1] = section.match(/^\(\:([^\(\)\{\}\:]*)\)$/)[1]
+
+					# check for routes formatted: /(:paramater){regexp} - optional paramaters
+					elsif section.match /^\(\:([^\(\)\{\}\:]*)\)\{(.*)\}$/
+						#create a optional section catcher
+					 	@path << (  "(\/(" +  section.match(/^\(\:([^\(\)\{\}\:]*)\)\{(.*)\}$/)[2] + "))?"  )
+					 	# add paramater recognition value
+					 	@fill_paramaters[param_num += 1] = section.match(/^\(\:([^\(\)\{\}\:]*)\)\{(.*)\}$/)[1]
+					 	param_num += 1 # we are using two spaces
+
+					else
+						@path << "\/"
+						@path << section
+					end
+				end
+				unless @fill_paramaters.values.include?("id")
+					@path << optional_section_search
+					@fill_paramaters[param_num += 1] = "id"
+				end
+				@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 paramaters, if required.
+		def match path
+			hash = {}
+			m = nil
+			# unless @fill_paramaters.values.include?("format")
+			# 	if (m = path.match /([^\.]*)\.([^\.\/]+)$/)
+			# 		HTTP.add_param_to_hash 'format', m[2], hash
+			# 		path = m[1]
+			# 	end
+			# end
+			m = @path.match path
+			return false unless m
+			@fill_paramaters.each { |k, v| hash[v] = m[k][1..-1] if m[k] && m[k] != '/' }
+			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 paramaters.
+		# 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)
+			new_class_name = "Plezi__#{controller.name.gsub /[\:\-]/, '_'}"
+			return Module.const_get new_class_name if Module.const_defined? new_class_name
+			# controller.include Plezi::ControllerMagic
+			controller.instance_eval { include Plezi::ControllerMagic }
+			ret = Class.new(controller) do
+
+				def initialize request, response, host_params
+					@request, @params, @flash, @host_params = request, request.params, response.flash, host_params
+					@response = response
+					# @response["content-type"] ||= ::Plezi.default_content_type
+
+					@_accepts_broadcast = false
+
+					# create magical cookies
+					@cookies = request.cookies
+					@cookies.set_controller self
+
+					super()
+				end
+
+				def _route_path_to_methods_and_set_the_response_
+					#run :before filter
+					return false if available_routing_methods.include?(:before) && before == false 
+					#check request is valid and call requested method
+					ret = requested_method
+					return false unless available_routing_methods.include?(ret)
+					return false unless (ret = self.method(ret).call)
+					#run :after filter
+					return false if available_routing_methods.include?(:after) && after == false
+					# review returned type for adding String to response
+					if ret.is_a?(String)
+						response << ret
+						response['content-length'] = ret.bytesize if response.body.empty? && !response.headers_sent?
+					end
+					return true
+				end
+				# WebSockets.
+				#
+				# this method handles the protocol and handler transition between the HTTP connection
+				# (with a protocol instance of HTTPProtocol and a handler instance of HTTPRouter)
+				# and the WebSockets connection
+				# (with a protocol instance of WSProtocol and an instance of the Controller class set as a handler)
+				def pre_connect
+					# make sure this is a websocket controller
+					return false unless self.class.public_instance_methods.include?(:on_message)
+					# call the controller's original method, if exists, and check connection.
+					return false if (defined?(super) && !super) 
+					# finish if the response was sent
+					return true if response.headers_sent?
+					# complete handshake
+					return false unless WSProtocol.new( request.service, request.service.parameters).http_handshake request, response, self
+					# set up controller as WebSocket handler
+					@response = WSResponse.new request
+					# create the redis connection (in case this in the first instance of this class)
+					self.class.redis_connection
+					# set broadcasts and return true
+					@_accepts_broadcast = true
+				end
+
+
+				# WebSockets.
+				#
+				# stops broadcasts from being called on closed sockets that havn't been collected by the garbage collector.
+				def on_disconnect
+					@_accepts_broadcast = false
+					super if defined? super
+				end
+			end
+			Object.const_set(new_class_name, ret)
+			ret
+		end
+
+	end
+
+end