picombo 0.1.0

data/lib/bootstrap.rb

@@ -0,0 +1,17 @@
+require 'thin'
+require 'erb'
+require 'yaml'
+require 'dm-core'
+require 'singleton'
+require 'core/core'
+require 'classes/config'
+
+def run_system()
+	app = Rack::Builder.new do
+		use Rack::ShowExceptions
+		#use Rack::Reloader
+		use Rack::Static, :urls => ['/css', '/images']
+		use Rack::Session::Cookie
+		run Picombo::Core.new
+	end
+end

data/lib/classes/bench.rb

@@ -0,0 +1,57 @@
+module Picombo
+	# == Benchmarking Class
+	#
+	# The benchmark class allows you to run simple named benchmarks.
+	#
+	# === Usage
+	#
+	# To start a benchmark, use the Picombo::Bench.instance.start(name) method. Name should be unique to the benchmark being ran.
+	# 	# Start a simple benchmark
+	# 	Picombo::Bench.instance.start(:myapp_simple_mark)
+	#
+	# To stop a benchmark, use the Picombo::Bench.instance.stop(name) method.
+	# 	# Stop the previous benchmark
+	# 	Picombo::Bench.instance.stop(:myapp_simple_mark)
+	#
+	# You can retrieve the benchmark results anytime after you stop the benchmark with Picombo::Bench.instance.get(name)
+	# 	# Retrieve the previously ran benchmark
+	# 	time = Picombo::Bench.instance.get(:myapp_simple_mark)
+	#
+	# You can alter the precision of the returned benchmark time with the second parameter, it defaults to four decimal places
+	# 	# Only go to two decimal places
+	# 	time = Picombo::Bench.instance.get(:myapp_simple_mark, 2)
+	#
+	# get() will return nil if the named benchmark doesn't exist
+	class Bench
+		include Singleton
+
+		# Internal hash of benchmarks
+		@@marks = {}
+
+		# Starts a benchmark defined by name
+		def start(name)
+			@@marks[name] = {'start' => Time.new,
+			                'stop'  => nil}
+		end
+
+		# Stops a benchmark defined by name
+		def stop(name)
+			# only stop if the benchmark exists
+			if (@@marks.has_key?(name))
+				@@marks[name]['stop'] = Time.new
+			end
+		end
+
+		# Gets a benchmark result defined by name
+		def get(name, precision = 4)
+			if ( ! @@marks.has_key?(name))
+				return nil
+			else
+				start = @@marks[name]['start'].to_f
+				stop = @@marks[name]['stop'].to_f
+				rounded_number = (Float((stop-start)) * (10 ** precision)).round.to_f / 10 ** precision
+				return rounded_number.to_s
+			end
+		end
+	end
+end

data/lib/classes/cache.rb

@@ -0,0 +1,89 @@
+module Picombo
+	# == Cache Class
+	#
+	# The cache class allows you to serialize ruby objects,
+	# store them in a backend system, and retreive them later.
+	# 
+	# Caching can be useful for methods that take a long time to run,
+	# or complex database queries that cannot be made quicker.
+	#
+	# === Usage
+	#
+	# To set a cache item, use the set method:
+	# 	Picombo::Cache.new.set(:test, '<h1>It Works!</h1><p>This is a test.</p>')
+	# You can also pass a hash into the first parameter to set multiple items
+	#
+	# To retreive a cache item, use the get method:
+	# 	html = Picombo::Cache.new.get(:test)
+	# 	# html will contain '<h1>It Works!</h1><p>This is a test.</p>'
+	#
+	# To delete an existing cache item, use the delete method
+	# 	Picombo::Cache.new.delete(:test)
+	#
+	# === Drivers
+	#
+	# The cache class supports drivers, which will allow you to use different backend
+	# systems to store your cache items. Right now only a file driver is available.
+	# You can write your own cache drivers to behave how you want as well.
+	#
+	# By default the cache driver will use the "default" group in your config file: cache.yaml
+	# You can specify multiple groups as well.
+	#
+	# ==== Usage
+	#
+	# To call the cache driver with an alternate group, just pass that group name into the new method
+	# 	Picombo::Cache.new('my_other_group')
+	#
+	# To do this, you need to define the 'my_other_group' in your config file
+	#
+	# === Lifetimes
+	#
+	# The cache class supports lifetimes, which will automatically expire cache items after the
+	# specified time period. These are specifies in seconds from the current time. When you use the
+	# set method, you can set a specific lifetime with the third parameter.
+	# The default is located in the config file group
+	class Cache
+
+		@@driver = nil
+		@@config = nil
+		@@group = nil
+
+		# Set up the driver
+		def initialize(group = nil)
+			group = 'default' if group == nil
+			@@group = group
+			@@config = Picombo::Config.get('cache.'+group)
+			driver_name = 'Cache_'+@@config['driver'].capitalize!
+			@@driver = Picombo::const_get(driver_name).new(@@config)
+		end
+
+		# Sets a cache item
+		def set(key, value = nil, lifetime = nil)
+			lifetime = Picombo::Config.get('cache.'+@@group+'.lifetime').to_i if lifetime == nil
+			unless key.is_a? Hash
+				key = {key => value}
+			end
+
+			@@driver.set(key, lifetime)
+		end
+
+		# Retreives a cache item
+		def get(key)
+			@@driver.get(key.to_s, (key.is_a? Array) ? true : false)
+		end
+
+		# Deletes a cache item
+		def delete(keys)
+			unless key.is_a? Array
+				key = [key]
+			end
+
+			@@driver.delete(keys)
+		end
+
+		# Deletes all the cache items
+		def delete_all
+			@@driver.delete_all
+		end
+	end
+end

data/lib/classes/cache_file.rb

@@ -0,0 +1,80 @@
+module Picombo
+	class Cache_File
+		@@config = nil
+
+		def initialize(config)
+			@@config = config
+			raise "Cache directory does not exist: "+APPPATH+'cache' unless File.directory?(APPPATH+'cache/')
+			raise "Cache directory not writable: "+APPPATH+'cache' unless File.writable?(APPPATH+'cache/')
+		end
+
+		def exists(keys)
+			return Dir.glob(APPPATH+'cache/*~*') if keys == true
+
+			paths = []
+			[*keys].each do |key|
+				Dir.glob(APPPATH+'cache/'+key.to_s+'~*').each do |path|
+					paths.push(path)
+				end
+			end
+
+			paths.uniq
+		end
+
+		def set(items, lifetime)
+			lifetime+=Time.now.to_i
+
+			success = true
+
+			items.each do |key, value|
+				delete(key)
+
+				File.open(APPPATH+'cache/'+key.to_s+'~'+lifetime.to_s, 'w') {|f| f.write(Marshal.dump(value)) }
+			end
+
+			return true
+		end
+
+		def get(keys, single = false)
+			items = []
+
+			exists(keys).each do |file|
+				if expired(file)
+					next
+				end
+
+				contents = ''
+				File.open(file, "r") do |infile|
+					while (line = infile.gets)
+						contents+=line+"\n"
+					end
+				end
+				items.push(Marshal.load(contents))
+			end
+			items.uniq!
+
+			if single
+				return items.length > 0 ? items.shift : nil
+			else
+				return items
+			end
+		end
+
+		def delete(keys)
+			exists(keys).each do |file|
+				File.unlink(file)
+			end
+		end
+
+		def delete_all
+			exists(true).each do |file|
+				File.unlink(file)
+			end
+		end
+
+		def expired(file)
+			expires = file[file.index('~') + 1, file.length]
+			return (expires != 0 and expires.to_i <= Time.now.to_i);
+		end
+	end
+end

data/lib/classes/config.rb

@@ -0,0 +1,81 @@
+module Picombo
+	class Config
+		include Enumerable
+
+		# Internal cache.
+		@@cache = {}
+
+		# Loads configuration files by name
+		def self.load(name)
+			# Look for this config item in the cache
+			if @@cache.has_key?(name)
+				return @@cache[name]
+			end
+
+			configuration, files = {}, Picombo::Core.find_file('config', name, false, 'yaml')
+
+			files.each do |file|
+				configuration.merge! YAML::load_file(file)
+			end
+
+			# Set the internal cache
+			@@cache[name] = configuration
+
+			configuration
+			rescue Errno::ENOENT => e
+			# A config file couldn't be loaded...
+		end
+
+		# Used for dynamic config setting. Not implimented yet
+		def self.set(key, value)
+		end
+
+		# Retrieves a config item in dot notation
+		def self.get(key, required = true)
+			# get the group name from the key
+			key = key.split('.')
+			group = key.shift
+
+			value = key_string(load(group), key.join('.'))
+
+			raise "Config key '"+key.join('.')+"' not found!!" if required && value.nil?
+
+			value
+		end
+
+		# Clears the internal cache for a config file(s)
+		def self.clear(group)
+			@@cache.delete(group)
+		end
+
+		# Allows searching an hash by dot seperated strings
+		def self.key_string(hash, keys)
+			return false if ! hash.is_a? Hash
+
+			keys = keys.split('.')
+
+			until keys.length == 0
+				key = keys.shift
+
+				if hash.has_key? key
+					if hash[key].is_a? Hash and ! keys.empty?
+						hash = hash[key]
+					else
+						return hash[key]
+					end
+				else
+					break
+				end
+			end
+
+			nil
+		end
+
+		#
+		# Define an each method, required for Enumerable.
+		#
+		def self.each(file)
+
+		end
+	end
+end

data/lib/classes/cookie.rb

@@ -0,0 +1,27 @@
+module Picombo
+	class Cookie
+		include Singleton
+
+		# Initializes the request for cookies
+		def init(req)
+			@@req = req
+		end
+
+		# Retrieves a cookie item defined by key
+		def self.get(key, default = nil)
+			return @@req.cookies[key] if @@req.cookies.has_key?(key)
+
+			default
+		end
+
+		# Sets a cookie item defined by key to val
+		def self.set(key, val)
+			Picombo::Core.raw_response.set_cookie(key, val)
+		end
+
+		# Deletes a cookie item defined by key
+		def self.delete(key)
+			Picombo::Core.raw_response.delete_cookie(key)
+		end
+	end
+end

data/lib/classes/e404.rb

@@ -0,0 +1,5 @@
+module Picombo
+	class E404 < Exception
+		
+	end
+end

data/lib/classes/event.rb

@@ -0,0 +1,136 @@
+module Picombo
+	# == Event Class
+	#
+	# Process queuing/execution class. Allows an unlimited number of callbacks
+	# to be added to 'events'. Events can be run multiple times, and can also
+	# process event-specific data. By default, Picombo has several system events.
+	#
+	# The event class is a powerful system where you can add, modify or remove Picombo functionality, and you can also create your own events to leverage easy plugablity features in your applicetion.
+	#
+	# === Examples
+	# It's very easy to use events to alter system behavior. This event addition will merge some parameters to every controller call:
+	# 	Picombo::Event.add('system.post_router') do |data|
+	# 		data.merge!({:params => ['test', 'test', 'test']})
+	# 	end
+	# This event will be called on the system.post_router event, after the router has parsed the URI
+	#
+	# Because the system.post_router is called as Picombo::Event.run('system.post_router', uri) it passes the routed uri variable as data in the method above.
+	#
+	# You can also add class methods to events:
+	# 	Picombo::Event.add('system.shutdown', 'Picombo::Foobar.new.write_access_log')
+	# This might process some data and then write it to an event log on the system.shutdown event right before the output is sent to the browser
+
+	class Event
+		private
+		# Events that have ran.
+		@@ran = []
+
+		# Event-specific data.
+		@@data = nil
+
+		# Callbacks.
+		@@events = {}
+
+		public
+		# Data reader.
+		def self.data()
+			@@data
+		end
+
+		# Data writer.
+		def self.data=(data)
+			@@data = data
+		end
+
+		#
+		# Add a callback to an event queue.
+		#
+		def self.add(name, callback = nil, &block)
+			# Create the event queue if it doesn't exist yet.
+			unless @@events.include?(name) and ! @@events.empty?
+				@@events[name] = []
+			end
+
+			# Make sure there isn't a callback and a block, two callbacks at the same time doesn't make sense.
+			raise ArgumentError.new('You cannot add a callback to an event queue and specify a block, at the same time.') if ! callback.nil? and block_given?
+
+			if block_given?
+				@@events[name].push(block)
+			else
+				# If the callback is a string/array, make sure it doesn't already exist.
+				if ! callback.respond_to?(:call)
+					return false if @@events[name].include?(callback)
+				end
+
+				@@events[name].push(callback)
+			end
+		end
+
+		#
+		# Return all of the callbacks attached to an event, or an empty array if there are none.
+		#
+		def self.get(name)
+			( ! @@events.include?(name) or @@events[name].empty?) ? [] : @@events[name]
+		end
+
+		#
+		# Remove one or all of the callbacks from a given event.
+		#
+		def self.clear!(name, callback = nil)
+			return false unless @@events.include?(name)
+
+			if callback.nil?
+				@@events[name] = []
+			else
+				@@events[name].delete(callback)
+			end
+		end
+
+		#
+		# Execute all of the callbacks attached to a given event.
+		#
+		def self.run(name, data = nil)
+			# Make sure the event queue exists and has at least one attached callback.
+			return false unless @@events.include?(name) and ! @@events[name].empty?
+
+			@@data = data
+
+			@@events[name].each do |callback|
+				if callback.is_a?(Array)
+					if callback[0].is_a?(String)
+						const_get(callback[0]).send(callback[1])
+					else
+						callback[0].send(callback[1])
+					end
+				elsif callback.is_a?(String)
+					eval(callback)
+					#callback = callback.split('.')
+
+					#if callback.length > 1
+					#	namespace = Object
+					#	callback[0].split("::").each do |const|
+					#		namespace = namespace.const_get(const)
+					#	end
+
+					#	Picombo::Log.write('info', 'trying to run '+namespace.inspect+'.'+callback[1])
+					#	namespace.send(callback[1])
+					#else
+					#	Kernel.send(callback[0])
+					#end
+				elsif callback.is_a?(Proc)
+					callback.call(data)
+				end
+			end
+
+			@@ran.push(name)
+			@@data = nil
+		end
+
+		#
+		# Determine whether or not an event has ran yet.
+		#
+		def self.ran?(name)
+			@@ran.include?(name)
+		end
+	end
+end

data/lib/classes/html.rb

@@ -0,0 +1,45 @@
+module Picombo
+
+	# Helper class to generate HTML
+
+	class Html
+		include Singleton
+
+		# Returns a safe email address, by encoding each character in the email
+		def self.email(email)
+			safe = []
+
+			email.each_byte do |char|
+				safe << '&#'+char.to_s
+			end
+
+			safe.join
+		end
+
+		def self.style(css)
+			unless css.is_a? Array
+				return '<link type="text/css" href="'+Picombo::Url.base()+css+'" rel="stylesheet" />'
+			end
+
+			to_return = ''
+			css.each do |file|
+				to_return+='<link type="text/css" href="'+Picombo::Url.base()+file+'" rel="stylesheet" />'+"\n"
+			end
+
+			to_return
+		end
+
+		def self.script(js)
+			unless js.is_a? Array
+				return '<script type="text/javascript" src="'+Url.base()+js+'"></script>'
+			end
+
+			to_return = ''
+			js.each do |file|
+				to_return+='<script type="text/javascript" src="'+Url.base()+file+'"></script>'+"\n"
+			end
+
+			to_return
+		end
+	end
+end

data/lib/classes/input.rb

@@ -0,0 +1,59 @@
+module Picombo
+	# Provides access and XSS filtering to GET and POST input variables
+	#
+	# == Using Input
+	# * To fetch get variables, simple use Picombo::Input.instance().get(get_key)
+	# * To fetch post variables, simple use Picombo::Input.instance().post(post)
+	#
+	# * To return the entire input hash, omit the key
+	# * If the key is not found, the default parameter is returned, by default nil
+	#
+	# === XSS Filtering
+	#
+	# in the main config file, there is an xss_clean option. If you set this to true,
+	# all GET and POST variables will be scanned and cleaned of script data. You can manually
+	# filter strings by using:
+	# 	Picombo::Input.instance.xss_clean(str)
+	class Input
+		include Singleton
+
+		# Sets the input request
+		def set_request(req)
+			@req = req
+
+			if Picombo::Config.get('config.xss_clean')
+				@req.GET().each do |key, value|
+					Picombo::Log.write(:debug, 'Cleaning GET key: '+key)
+					@req.GET()[key] = Picombo::Security.xss_clean(value, Picombo::Config.get('config.xss_clean'))
+				end
+				@req.POST().each do |key, value|
+					Picombo::Log.write(:debug, 'Cleaning POST key: '+key)
+					@req.POST()[key] = Picombo::Security.xss_clean(value, Picombo::Config.get('config.xss_clean'))
+				end
+			end
+			Picombo::Log.write(:debug, 'Input Library initialized')
+		end
+
+		# Retrieves a GET item by key. If the key doesn't exist, return default
+		# Optionaly returns the entire GET hash if key is nil
+		def get(key = nil, default = nil)
+			return @req.GET() if key.nil?
+
+			get = @req.GET()
+			return get[key] if get.has_key?(key)
+
+			default
+		end
+
+		# Retrieves a POST item by key. If the key doesn't exist, return default
+		# Optionaly returns the entire POST hash if key is nil
+		def post(key = nil, default = nil)
+			return @req.POST() if key.nil?
+
+			post = @req.POST()
+			return post[key] if post.has_key?(key)
+
+			default
+		end
+	end
+end

data/lib/classes/log.rb

@@ -0,0 +1,31 @@
+module Picombo
+	# Provides file logging capability
+	#
+	# == Log Levels
+	# Picombo has the following log levels
+	# * 0 - Disable logging (none)
+	# * 1 - Errors and exceptions (info)
+	# * 2 - Warnings (warning)
+	# * 3 - Notices (notice)
+	# * 4 - Debugging (debug)
+	#
+	# The log level is set in config/log.yaml
+	#
+	# To write a log entry, do Picombo::Log.instance().write(:info, 'This is the message!')
+	#
+	class Log
+		include Singleton
+
+		# Writes log entry with level +type+:: with +message+::
+		def self.write(type, message)
+			types = {:none => 0, :info => 1, :warning => 2, :notice => 3, :debug => 4}
+
+			if types[type] <= Picombo::Config.get('log.log_threshold')
+				t = Time.now
+				f = File.new(APPPATH+Picombo::Config.get('log.directory')+t.year.to_s+'-'+t.month.to_s+'-'+t.day.to_s+'.log', 'a')
+				f.write(t.to_s+' --- '+type.to_s+': '+message.to_s+"\n");
+				f.close
+			end
+		end
+	end
+end