plezi 0.12.22 → 0.14.0

data/lib/plezi/common/defer.rb

@@ -1,21 +0,0 @@
-
-module Plezi
-
-	module_function
-
-	# Defers any missing methods to the Iodine Library.
-	def method_missing name, *args, &block
-		return super unless REACTOR_METHODS.include? name
-		::Iodine.__send__ name, *args, &block
-	end
-	# Defers any missing methods to the Iodine Library.
-	def respond_to_missing?(name, include_private = false)
-		REACTOR_METHODS.include?(name) || super
-	end
-
-	protected
-
-	REACTOR_METHODS = ::Iodine.public_methods(false)
-
-end
-

data/lib/plezi/common/dsl.rb

@@ -1,94 +0,0 @@
-unless defined? PLEZI_NON_DSL
-
-	# shortcut for Plezi.listen. Deprecated.
-	#
-	def listen(params = {})
-		Plezi.listen params
-	end
-
-	# adds a virtul host or switches to an existing host, for routes setup or parameters update.
-	#
-	# accepts:
-	# host_name: a String with the full host name (i.e. "www.google.com" / "mail.google.com")
-	# params:: any of the parameters accepted by the {Plezi.host} command.
-	#
-	# If no host is specified or host name is `false`, the default host would be set as the active host and returned.
-	def host(host_name = false, params = {})
-		Plezi.host host_name, params
-	end
-
-	# adds a route to the last (or default) host
-	#
-	# path:: the path for the route
-	# controller:: The controller class which will accept the route.
-	#
-	# `path` parameters has a few options:
-	#
-	# * `path` can be a Regexp object, forcing the all the logic into controller (typically using the before method).
-	#
-	# * simple String paths are assumed to be basic RESTful paths:
-	#
-	#     route "/users", Controller => route "/users/(:id)", Controller
-	#
-	# * routes can define their own parameters, for their own logic:
-	#
-	#     route "/path/:required_paramater/:required_paramater{with_format}/(:optional_paramater)/(:optional){with_format}"
-	#
-	# * routes can define optional or required routes with regular expressions in them:
-	#
-	#     route "(:locale){en|ru}/path"
-	#
-	# * routes which use the special '/' charecter within a parameter's format, must escape this charecter using the '\' charecter. **Notice the single quotes** in the following example:
-	#
-	#     route '(:math){[\d\+\-\*\^\%\.\/]}'
-	#
-	#   * or, with double quotes:
-	#
-	#     route "(:math){[\\d\\+\\-\\*\\^\\%\\.\\/]}"
-	#
-	# magic routes make for difficult debugging - the smarter the routes, the more difficult the debugging.
-	# use with care and avoid complex routes when possible. RESTful routes are recommended when possible.
-	# JSON serving apps are advised to use required parameters and empty sections indicating missing required parameters (i.e. /path///foo/bar///).
-	#
-	def route(path, controller = nil, &block)
-		Plezi.route(path, controller, &block)
-	end
-
-	# adds a route to the all the existing servers and hosts.
-	#
-	# accepts same options as route.
-	def shared_route(path, controller = nil, &block)
-		Plezi.shared_route(path, controller, &block)
-	end
-
-	# defines a method with a special name, such as "humens.txt".
-	#
-	# this could be used in controller classes, to define special routes which might defy
-	# normal Ruby naming conventions, such as "/welcome-home", "/play!", etc'
-	#
-	# could also be used to define methods with special formatting, such as "humans.txt",
-	# until a more refined way to deal with formatting will be implemented.
-	def def_special_method name, obj=self, &block
-		obj.instance_exec { define_method name.to_s.to_sym, &block }
-	end
-
-
-	# sets information to be used when restarting
-	$PL_SCRIPT = $0
-	$PL_ARGV = $*.dup
-
-	# restarts the Plezi app with the same arguments as when it was started.
-	#
-	# EXPERIMENTAL
-	def restart_plezi_app
-		exec "/usr/bin/env ruby #{$PL_SCRIPT} #{$PL_ARGV.join ' '}"
-	end
-
-	# sets to start the services once dsl script is finished loading.
-	at_exit do
-		undef listen
-		undef host
-		undef route
-		undef shared_route
-	end
-end

data/lib/plezi/common/redis.rb

@@ -1,65 +0,0 @@
-
-module Plezi
-
-	module Base
-		module AutoRedis
-			@redis_locker ||= Mutex.new
-			@redis = @redis_sub_thread = nil
-			module_function
-			def inner_init_redis
-				return false unless ENV['PL_REDIS_URL'] && defined?(::Redis)
-				@redis_locker.synchronize do
-					return @redis if (@redis_sub_thread && @redis_sub_thread.alive?) && @redis # repeat the test once syncing is done.
-					@redis.quit if @redis
-					@redis = ::Redis.new(url: ENV['PL_REDIS_URL'])
-					raise "Redis connction failed for: #{ENV['PL_REDIS_URL']}" unless @redis
-					@redis_sub_thread = Thread.new do
-						begin
-							::Redis.new(url: ENV['PL_REDIS_URL']).subscribe(Plezi::Settings.redis_channel_name, Plezi::Settings.uuid) do |on|
-								on.message do |channel, msg|
-									::Plezi::Base::WSObject.forward_message ::Plezi::Base::WSObject.translate_message(msg)
-								end
-							end
-						rescue => e
-							Iodine.error e
-							retry
-						end
-					end
-					@redis
-				end
-			end
-			def get_redis
-				return @redis if (@redis_sub_thread && @redis_sub_thread.alive?) && @redis
-				inner_init_redis
-			end
-			def away? server
-				return true unless get_redis
-				@redis.pubsub('CHANNELS', server).empty?				
-			end
-		end
-	end
-
-	module_function
-
-	# Reviews the Redis connection, sets it up if it's missing and returns the Redis connection.
-	#
-	# A Redis connection will be automatically created if the `ENV['PL_REDIS_URL']` is set.
-	# for example:
-	#      ENV['PL_REDIS_URL'] = ENV['REDISCLOUD_URL']`
-	# or
-	#      ENV['PL_REDIS_URL'] = "redis://:password@my.host:6379/0"
-	#
-	# Accepts an optional block that will receive the Redis connection object. i.e.
-	#
-	#      Plezi.redis {|r| r.connected? }
-	#
-	# Returns the Redis object or the block's returned value (if a block is provided).
-	def redis
-		if r = Plezi::Base::AutoRedis.get_redis
-			return (block_given? ? yield(r) : r)
-		end
-		false
-	end
-	alias :redis_connection :redis
-end
-

data/lib/plezi/common/renderer.rb

@@ -1,141 +0,0 @@
-module Plezi
-	module Base
-
-		class ExtentionManager
-			def initialize
-				@render_library = {}
-				@locker = Mutex.new
-			end
-			# Registers a rendering extention.
-			#
-			# Slim, Haml and ERB are registered by default.
-			#
-			# extention:: a Symbol or String representing the extention of the file to be rendered. i.e. 'slim', 'md', 'erb', etc'
-			# handler :: a Proc or other object that answers to call(filename, context, &block) and returnes the rendered string. The block accepted by the handler is for chaining rendered actions (allowing for `yield` within templates) and the context is the object within which the rendering should be performed (if `binding` handling is supported by the engine).
-			#
-			# If a block is passed to the `register_hook` method with no handler defined, it will act as the handler.
-			def register extention, handler = nil, &block
-				handler ||= block
-				raise "Handler or block required." unless handler
-				@locker.synchronize { @render_library[extention.to_s] = handler }
-				handler
-			end
-			def review extention
-				@locker.synchronize { @render_library[extention.to_s] }
-			end
-			# Removes a registered render extention
-			def remove extention
-				@locker.synchronize { @render_library.delete extention.to_s }
-			end
-			def each &block
-				block_given? ? @render_library.each(&block) :  @render_library.each
-			end
-
-
-			def render base_filename, context = ( Object.new.instance_eval { binding } ), &block
-				@render_library.each {|ext, handler| f = "#{base_filename}.#{ext}".freeze ; return handler.call(f, context, &block) if File.exist?(f) }
-				false
-			end
-
-		end
-
-		module SASSExt
-			module_function
-			SASS_OPTIONS = { style: (ENV['SASS_STYLE'] || ((ENV['ENV'] || ENV['RACK_ENV']) == 'production' ? :compressed : :nested )) }
-
-			def call filename, context, &block
-				return false unless defined? ::Sass
-				SASS_OPTIONS[:cache_store] ||= Sass::CacheStores::Memory.new
-				# review mtime and render sass if necessary
-				if refresh_sass?(filename)
-					eng = Sass::Engine.for_file(filename, SASS_OPTIONS)
-					Plezi.cache_data filename, eng.dependencies
-					css, map = eng.render_with_sourcemap("#{File.basename(filename, '.*'.freeze)}.map".freeze)
-					Plezi.cache_data filename.sub(/\.s[ac]ss$/, '.map'.freeze), map.to_json( css_uri: File.basename(filename, '.*'.freeze) )
-					Plezi.cache_data "#{filename}.css", css
-					return css
-				end
-				Plezi.get_cached("#{filename}.css")
-			end
-
-			def refresh_sass? sass
-				return true if Plezi.cache_needs_update?(sass)
-				# return false unless Plezi.allow_cache_update? # no meaningful performance boost.
-				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
-
-	# asset rendering extentions.
-	module AssetManager
-		@render_library = {}
-		@locker = Mutex.new
-
-		module_function
-		# Registers a rendering extention for a specific asset type (js, css, etc').
-		#
-		# type:: the type of
-		# extention:: a Symbol or String representing the extention of the file to be rendered. i.e. 'scss', 'sass', 'coffee', etc'
-		# handler :: a Proc or other object that answers to call(filename, context, &block) and returnes the rendered string. The block accepted by the handler is for chaining rendered actions (allowing for `yield` within templates) and the context is a Binding object which is offered to the rendering (if `binding` handling is supported by the engine).
-		#
-		# handlers are expected to manage caching for their data. The {Plezi::Cache} module is available for this task,
-		# but it should be noted that Plezi might cache data in that same system and conflicts might occure if the final filename isn't used for the caching (including the handler-type extention, i.e. 'coffee', slim' or 'erb').
-		#
-		# If a block is passed to the `register_hook` method with no handler defined, it will act as the handler.
-		def register type, extention, handler = nil, &block
-			raise "Type required." unless type
-			handler ||= block
-			raise "Handler or block required." unless handler
-			@locker.synchronize { (@render_library[type.to_s] ||= ::Plezi::Base::ExtentionManager.new).register extention, handler }
-			handler
-		end
-		# Removes a registered render extention
-		def remove type, extention
-			@locker.synchronize { (@render_library[type.to_s] ||= ::Plezi::Base::ExtentionManager.new).remove extention.to_s }
-		end
-		# returns an array with all the registered extentions
-		def all_extentions
-			out = []
-			@render_library.each {|t, l| l.each {|e, h| out << e } }
-			out.uniq!
-			out
-		end
-
-
-		def render base_filename, context = ( Object.new.instance_eval { binding } ), &block
-			handlers = @render_library[File.extname(base_filename)[1..-1]]
-			handlers.each {|ext, handler| f = "#{base_filename}.#{ext}".freeze ; return handler.call(f, context, &block) if File.exists?(f) } if handlers
-			false
-		end
-	end
-
-	# Render Managment
-	Renderer = ::Plezi::Base::ExtentionManager.new
-
-	Renderer.register :erb do |filename, context, &block|
-		next unless defined? ::ERB
-		( Plezi.cache_needs_update?(filename) ? Plezi.cache_data( filename, ( ERB.new( Plezi::Base::Helpers.try_utf8! IO.binread(filename) ) ) )  : (Plezi.get_cached filename) ).result((context) , &block)
-	end
-	Renderer.register :slim do |filename, context, &block|
-		next unless defined? ::Slim
-		( Plezi.cache_needs_update?(filename) ? Plezi.cache_data( filename, ( Slim::Template.new() { Plezi::Base::Helpers.try_utf8! IO.binread(filename) } ) )  : (Plezi.get_cached filename) ).render(context.receiver, &block)
-	end
-	Renderer.register :haml do |filename, context, &block|
-		next unless defined? ::Haml
-		( Plezi.cache_needs_update?(filename) ? Plezi.cache_data( filename, ( Haml::Engine.new( Plezi::Base::Helpers.try_utf8! IO.binread(filename) ) ) )  : (Plezi.get_cached filename) ).render(context.receiver, &block)
-	end
-
-	# JavaScript asset rendering
-	AssetManager.register :js, :erb, Renderer.review(:erb)
-	AssetManager.register :js, :coffee do |filename, context, &block|
-		next unless defined? ::CoffeeScript
-		( Plezi.cache_needs_update?(filename) ? Plezi.cache_data( filename, CoffeeScript.compile(Plezi::Base::Helpers.try_utf8!(IO.binread(filename))) )  : (Plezi.get_cached filename) )
-	end
-
-	# CSS asset rendering
-	AssetManager.register :css, :erb, Renderer.review(:erb)
-	AssetManager.register :css, :scss, ::Plezi::Base::SASSExt
-	AssetManager.register :css, :sass, ::Plezi::Base::SASSExt
-end

data/lib/plezi/common/settings.rb

@@ -1,52 +0,0 @@
-
-module Plezi
-
-	# This module allows you to set some of the Plezi framework's settings.
-	module Settings
-
-		module_function
-
-		# Sets the Redis Channel Name.
-		def redis_channel_name=val
-			return false unless defined? Redis
-			raise "Can't change channel name after Redis subscription had been initiated." if @redis
-			@redis_channel_name = val
-		end
-		# Returns the Redis Channel Name used by this app.
-		# @return [String]
-		def redis_channel_name
-			@redis_channel_name ||= "#{File.basename($0, '.*')}_redis_channel"
-		end
-
-		# Sets the message byte size limit for a Websocket message. Defaults to 0 (no limit)
-		#
-		# Although memory will be allocated for the latest TCP/IP frame,
-		# this allows the websocket to disconnect if the incoming expected message size exceeds the allowed maximum size.
-		#
-		# If the sessage size limit is exceeded, the disconnection will be immidiate as an attack will be assumed. The protocol's normal disconnect sequesnce will be discarded.
-		def ws_message_size_limit=val
-			Iodine::Http::Websockets.message_size_limit = val
-		end
-		# Gets the message byte size limit for a Websocket message. Defaults to 0 (no limit)
-		def ws_message_size_limit
-			Iodine::Http::Websockets.message_size_limit
-		end
-
-		# This Server's UUID, for Redis and unicasting identification.
-		def uuid
-			@uuid ||= SecureRandom.uuid
-		end
-
-
-		# # # The following was discarded because benchmarks show the difference is negligible
-		# # Get the cache refresh directive for the {#cache_needs_update?} implementation. Defaults to ENV['ENV'] != 'production'
-		# def allow_cache_update?
-		# 	Plezi.allow_cache_update?
-		# end
-		# # Set the cache refresh directive for the {#cache_needs_update?} implementation. Defaults to ENV['ENV'] != 'production'
-		# def allow_cache_update= val
-		# 	Plezi.allow_cache_update = val
-		# end
-		# # **Update**: up until now, Plezi would allow refresh any cached assets ot templated when they are edited. This file review is usually a waste of resources after deployment, since the files never get updated in production environments. Plezi now supports a two new settings options: `Plezi.allow_cache_update?` and `Plezi.allow_cache_update=` which will dictate if file review should be performed after caching. The default is now set to AVOID file reviews for production environments (`ENV['ENV'] || ENV['RACK_ENV'] != 'production'`).
-	end
-end

data/lib/plezi/handlers/controller_core.rb

@@ -1,106 +0,0 @@
-module Plezi
-	module Base
-
-		# the methods defined in this module will be injected into the Controller's Core class (inherited from the controller).
-		module ControllerCore
-			# @!parse include Plezi::Base::WSObject
-			# @!parse include InstanceMethods
-			# @!parse extend ClassMethods
-
-			def self.included base
-				base.send :include, Plezi::Base::WSObject
-				base.send :include, InstanceMethods
-				base.extend ClassMethods
-			end
-
-			module InstanceMethods
-				public
-
-				def initialize request, response
-					@request = request
-					@params = request.params
-					@flash = response.flash
-					@host_params = request[:host_settings]
-					@response = response
-					@cookies = request.cookies
-					# # \@response["content-type"] ||= ::Plezi.default_content_type
-					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.has_super_method?(:on_message) || self.class.superclass.instance_variable_get(:@auto_dispatch)
-					# call the controller's original method, if exists, and check connection.
-					return false if (defined?(super) && !super)
-					# finish if the response was sent
-					return false if response.headers_sent?
-					# make sure that the session object is available for websocket connections
-					session
-					# make sure that rendering uses JSON for websocket messages (unless already set)
-					params[:format] ||= 'json'
-					# complete handshake
-					return self
-				end
-
-				# Websockets
-				#
-				# this method either forwards the on_message handling to the `on_message` callback, OR
-				# auto-dispatches the messages by translating the JSON into a method call using the `event` keyword.
-				def on_message data
-					unless self.class.superclass.instance_variable_get(:@auto_dispatch)
-						return super if defined? super
-						return false
-					end
-					begin
-						data = JSON.parse data
-						return close unless data.is_a?(Hash)
-					rescue
-						return close
-					end
-					Plezi::Base::Helpers.make_hash_accept_symbols data
-					ret = nil
-					begin
-						if data['_EID_'.freeze]
-							write "{\"event\":\"_ack_\",\"_EID_\":#{data['_EID_'.freeze]}}"
-						end
-						if self.class.has_auto_dispatch_method?(data['event'.freeze] = data['event'.freeze].to_s.to_sym)
-							ret = self.__send__(data['event'.freeze], data)
-						else
-							ret = (self.class.has_super_method?(:unknown) && ( unknown(data) || true)) || (self.class.has_super_method?(:unknown_event) && Iodine.warn('Auto-Dispatch API updated: use `unknown` instead of `unknown_event`') && ( unknown_event(data) || true)) || ({ event: :err, status: 404, result: "not found", request: data }.to_json)
-						end
-					rescue ArgumentError => e
-						Iodine.error "Auto-Dispatch Error for event :#{data['event'.freeze]} - #{e.message}"
-					end
-					ret = ret.to_json if ret.is_a?(Hash)
-					write(ret) if ret.is_a?(String)
-				end 
-
-				# Inner Routing
-				def _route_path_to_methods_and_set_the_response_
-					#run :before filter
-					return false if self.class.has_method?(:before) && self.before == false 
-					#check request is valid and call requested method
-					ret = requested_method
-					return false unless ret
-					ret = self.__send__(ret)
-					return false unless ret
-					#run :after filter
-					return false if self.class.has_method?(:after) && self.after == false
-					# review returned type for adding String to response
-					return ret
-				end
-
-			end
-
-			module ClassMethods
-			end
-		end
-	end
-end