plezi 0.9.2 → 0.10.1

data/lib/plezi/handlers/http_router.rb

@@ -1,69 +1,148 @@
 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
+	module Base
 
-		# 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
+		#####
+		# handles the HTTP Routing
+		class HTTPRouter
 
-		# 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
+			class Host
+				attr_reader :params
+				attr_reader :routes
+				def initialize params
+					@params = params
+					@routes = []
+				end
 			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.'] ]
+
+			# 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
+				@sass_cache = Sass::CacheStores::Memory.new if defined?(::Sass)
+			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)
+				@active_host = get_host(host_name) || ( @hosts[host_name] = Host.new(params) )
+				add_alias host_name, *params[:alias] if params[:alias]
+				@active_host
+			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
+				host = get_host host_name
+				return false unless host
+				aliases.each {|a| @hosts[a.to_s.downcase] = host}
+				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.routes << Route.new(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.routes << Route.new(path, controller, &block) }
+			end
+
+			# handles requests send by the HTTP Protocol (HTTPRequest objects)
+			def call request, response
+				begin
+					host = get_host(request[:host_name].to_s.downcase) || @hosts[:default]
+					return false unless host
+					request.io[:params] = host.params
+					# render any assets?
+					return true if render_assets request, response, host.params
+					# send static file, if exists and root is set.
+					return true if Base::HTTPSender.send_static_file request, response
+					# return if a route answered the request
+					host.routes.each {|r| a = r.on_request(request, response); return a if a}
+					#return error code or 404 not found
+					Base::HTTPSender.send_by_code request, response, 404
+				rescue => e				
+					# return 500 internal server error.
+					GReactor.error e
+					Base::HTTPSender.send_by_code request, response, 500
+				end
+			end
+
+			protected
+
+			def get_host host_name
+				@hosts.each {|k, v| return v if k === host_name}
+				nil
 			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, response, params
+				# 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, response)
+
+				# 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 ? Base::HTTPSender.send_raw_data(request, response, 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 Base::HTTPSender.send_file request, response, 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 Base::HTTPSender.send_file request, response, 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
-
 end

data/lib/plezi/handlers/route.rb

@@ -13,18 +13,16 @@ module Plezi
 		attr_reader :params
 
 		# lets the route answer the request. returns false if no response has been sent.
-		def on_request request
+		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| HTTP.add_param_to_hash k, v, request.params }
+			fill_parameters.each {|k,v| GRHttp::HTTP.add_param_to_hash k, v, request.params }
 			ret = false
-			response = HTTPResponse.new request
 			if controller
-				ret = controller.new(request, response, params)._route_path_to_methods_and_set_the_response_
+				ret = controller.new(request, response)._route_path_to_methods_and_set_the_response_
 			elsif proc
 				ret = proc.call(request, response)
-				# response << ret if ret.is_a?(String)
 			elsif controller == false
 				request.path = path.match(request.path).to_a.last.to_s
 				return false
@@ -33,28 +31,9 @@ module Plezi
 				request.params.replace old_params unless fill_parameters.empty?
 				return false
 			end
-			response.try_finish
 			return ret
 		end
 
-		# handles Rack requests (dresses up as Rack).
-		def call request
-			fill_parameters = match request.path_info
-			return false unless fill_parameters
-			fill_parameters.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
@@ -122,7 +101,7 @@ module Plezi
 				# 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
+			dest.default_proc = Plezi::Base::Helpers::HASH_SYM_PROC
 
 			url = '/'
 
@@ -133,7 +112,7 @@ module Plezi
 				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 << GRHttp::HTTP.encode(dest.delete(param_name).to_s, :url)
 					url << '/' 
 				elsif !param_name
 					url << sec
@@ -146,7 +125,7 @@ module Plezi
 			end
 			unless dest.empty?
 				add = '?'
-				dest.each {|k, v| url << "#{add}#{HTTP.encode(k.to_s, :url)}=#{HTTP.encode(v.to_s, :url)}"; add = '&'}
+				dest.each {|k, v| url << "#{add}#{GRHttp::HTTP.encode(k.to_s, :url)}=#{GRHttp::HTTP.encode(v.to_s, :url)}"; add = '&'}
 			end
 			url
 
@@ -250,7 +229,7 @@ module Plezi
 			# m = nil
 			# unless @fill_parameters.values.include?("format")
 			# 	if (m = path.match /([^\.]*)\.([^\.\/]+)$/)
-			# 		HTTP.add_param_to_hash 'format', m[2], hash
+			# 		GRHttp::HTTP.add_param_to_hash 'format', m[2], hash
 			# 		path = m[1]
 			# 	end
 			# end
@@ -277,157 +256,9 @@ module Plezi
 			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_exec(container) {|r| include Plezi::ControllerMagic; set_pl_route r;}
+			controller.instance_exec(container) {|r| include Plezi::ControllerMagic; }
 			ret = Class.new(controller) do
-
-				def name
-					new_class_name
-				end
-
-				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
-
-				# 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.params).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
-
-				# Inner Routing
-				#
-				#
-				def _route_path_to_methods_and_set_the_response_
-					#run :before filter
-					return false if self.class.available_routing_methods.include?(:before) && self.before == false 
-					#check request is valid and call requested method
-					ret = requested_method
-					return false unless self.class.available_routing_methods.include?(ret)
-					return false unless (ret = self.method(ret).call)
-					#run :after filter
-					return false if self.class.available_routing_methods.include?(:after) && self.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
-				# a callback that resets the class router whenever a method (a potential route) is added
-				def self.method_added(id)
-					reset_routing_cache
-				end
-				# a callback that resets the class router whenever a method (a potential route) is removed
-				def self.method_removed(id)
-					reset_routing_cache
-				end
-				# a callback that resets the class router whenever a method (a potential route) is undefined (using #undef_method).
-				def self.method_undefined(id)
-					reset_routing_cache
-				end
-
-				# # lists the available methods that will be exposed to HTTP requests
-				# def self.available_public_methods
-				# 	# set class global to improve performance while checking for supported methods
-				# 	@@___available_public_methods___ ||= available_routing_methods - [:before, :after, :save, :show, :update, :delete, :initialize, :on_message, :pre_connect, :on_connect, :on_disconnect]
-				# end
-
-				# # lists the available methods that will be exposed to the HTTP router
-				# def self.available_routing_methods
-				# 	# set class global to improve performance while checking for supported methods
-				# 	@@___available_routing_methods___ ||= (((public_instance_methods - Object.public_instance_methods) - Plezi::ControllerMagic::InstanceMethods.instance_methods).delete_if {|m| m.to_s[0] == '_'})
-				# end
-
-				# # resets this controller's router, to allow for dynamic changes
-				# def self.reset_routing_cache
-				# 	@@___available_routing_methods___ = @@___available_public_methods___ = nil
-				# 	available_routing_methods
-				# 	available_public_methods
-				# end
-
-				
-				# # reviews the Redis connection, sets it up if it's missing and returns the Redis connection.
-				# #
-				# # todo: review thread status? (incase an exception killed it)
-				# def self.redis_connection
-				# 	return false unless defined?(Redis) && ENV['PL_REDIS_URL']
-				# 	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
-				# 		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|
-				# 					args = JSON.parse(msg)
-				# 					params = args.shift
-				# 					__inner_process_broadcast params['_pl_ignore_object'], params['_pl_method_broadcasted'].to_sym, args
-				# 				end
-				# 			end						
-				# 		rescue Exception => e
-				# 			Plezi.error e
-				# 			retry
-				# 		end
-				# 	end
-				# 	raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless @@redis
-				# 	@@redis
-				# end
-
-				# # returns a Redis channel name for this controller.
-				# def self.redis_channel_name
-				# 	self.name.to_s
-				# end
-
-				# # broadcasts messages (methods) for this process
-				# def self.__inner_process_broadcast ignore, method_name, args, &block
-				# 	ObjectSpace.each_object(self) { |controller| Plezi.callback controller, method_name, *args, &block if controller.accepts_broadcast? && (!ignore || controller.uuid != ignore) }
-				# end
-
-				# # broadcasts messages (methods) between all processes (using Redis).
-				# def self.__inner_redis_broadcast ignore, method_name, args, &block
-				# 	return false unless redis_connection
-				# 	raise "Radis broadcasts cannot accept blocks (no inter-process callbacks of memory sharing)!" if block
-				# 	# raise "Radis broadcasts accept only one paramater, which is an optional Hash (no inter-process memory sharing)" if args.length > 1 || (args[0] && !args[0].is_a?(Hash))
-				# 	args.unshift ({_pl_method_broadcasted: method_name, _pl_ignore_object: ignore})
-				# 	redis_connection.publish(redis_channel_name, args.to_json )
-				# 	true
-				# end
-
+				include Plezi::Base::ControllerCore
 			end
 			Object.const_set(new_class_name, ret)
 			Module.const_get(new_class_name).reset_routing_cache