nitro 0.2.0 → 0.3.0

data/examples/tiny/conf/config.rb

@@ -8,7 +8,7 @@
 # * George Moschovitis  <gm@navel.gr>
 #
 # (c) 2004 Navel, all rights reserved.
-# $Id: config.rb 106 2004-10-25 11:31:11Z gmosx $
+# $Id: config.rb 112 2004-10-27 10:59:55Z gmosx $
 
 require "n/logger"
 require "n/config"
@@ -27,13 +27,13 @@ require "tiny/conf/requires"
 
 $srv_extension_map = {
 	"sx" => ["text/html",
-		N::App::PageHandler.new
+		N::PageHandler.new
 	],
 	"si" => ["text/html",
-		N::App::PageHandler.new
+		N::PageHandler.new
 	],
 	"rx" => ["text/html",
-		N::App::CodeHandler.new
+		N::CodeHandler.new
 	]
 }
 

data/examples/tiny/conf/requires.rb

@@ -8,12 +8,11 @@
 # * George Moschovitis  <gm@navel.gr>
 #
 # (c) 2004 Navel, all rights reserved.
-# $Id: requires.rb 101 2004-10-22 12:35:39Z gmosx $
+# $Id: requires.rb 124 2004-11-01 12:34:17Z gmosx $
 
 require "n/std"
 require "n/properties"
 
-require "n/db"
 require "n/l10n"
 require "n/logger"
 require "n/parts"
@@ -29,6 +28,6 @@ require "n/utils/html"
 require "n/utils/hash"
 require "n/utils/array"
 
-require "n/app/handlers/page-handler"
-require "n/app/handlers/code-handler"
+require "n/server/handlers/page-handler"
+require "n/server/handlers/code-handler"
 

data/lib/n/config.rb

@@ -6,13 +6,13 @@
 # * George Moschovitis  <gm@navel.gr>
 #
 # (c) 2004 Navel, all rights reserved.
-# $Id: config.rb 106 2004-10-25 11:31:11Z gmosx $
+# $Id: config.rb 116 2004-10-29 16:26:32Z gmosx $
 
 # the name of the server
 $srv_name = "Nitro"
 
 # the version of the server
-$srv_version = "0.2.0"
+$srv_version = "0.3.0"
 
 # monitor scripts for changes
 #--
@@ -39,4 +39,51 @@ $drb_state = false
 $error_page_url = nil
 
 # default encoding for the app.
-$conf_encoding = "iso-8859-1"
+$encoding = "iso-8859-1"
+
+if $DBG
+	
+	puts "\nRunning DEBUG configuration.\n\n"
+	
+	# Logger (redirect to STDERR)
+
+	$log = Logger.new(STDERR); 
+	$log.level = Logger::DEBUG
+
+	# If set to true disables xsl caching. Usefull when debugging xsls.
+
+	$reload_xsl = true
+
+	# If set to true disables script compilation. Usefull when debugging
+	# statically included scripts.
+
+	$reload_scripts = true
+
+	# Standard server setup for debugging.
+
+	$srv_address = $appsrv_address = "127.0.0.1"
+	$srv_port = 8080
+	$appsrv_port = 9090
+	$srv_url = "http://#$srv_address:#$srv_port"
+	
+else
+
+	puts "\nRunning LIVE configuration.\n\n"
+
+	# If set to true disables xsl caching. Usefull when debugging xsls.
+
+	$reload_xsl = false 
+
+	# If set to true disables script compilation. Usefull when debugging
+	# statically included scripts.
+
+	$reload_scripts = false
+
+	# Standard server setup for live server. You probably 
+	# want to override this.
+
+	$srv_address = $appsrv_address = "127.0.0.1"
+	$srv_port = 8080
+	$appsrv_port = 9090
+	$srv_url = "http://#$srv_address:#$srv_port"
+end

data/lib/n/logger.rb

@@ -4,10 +4,10 @@
 # purposes.
 #
 # code:
-# George Moschovitis  <gm@navel.gr>
+# * George Moschovitis  <gm@navel.gr>
 #
 # (c) 2004 Navel, all rights reserved.
-# $Id: logger.rb 98 2004-10-22 07:36:20Z gmosx $
+# $Id: logger.rb 109 2004-10-27 09:12:45Z gmosx $
 
 require "logger"
 
@@ -35,5 +35,17 @@ class Logger
 	def i(obj)
 		self << "Inspect #{obj.inspect()}\n"
 	end
+
+	private
+		
+		# the default Ruby logger has a hardwired silly format.
+		# we use some Ruby magic to fix it!
+		remove_const "Format"
+
+		Format = "%c: %s\n"
+
+		def format_message(severity, timestamp, msg, progname)
+			Format % [severity[0], msg]
+		end
 end
 

data/lib/n/og.rb

@@ -0,0 +1,381 @@
+# code:
+# * George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: og.rb 124 2004-11-01 12:34:17Z gmosx $
+
+require "n/properties"
+require "n/utils/array"
+require "n/utils/hash"
+require "n/utils/time"
+require "n/utils/pool"
+
+require "n/og/meta"
+
+module N
+
+# If true, only allow reading from the database. Usefull
+# for maintainance.
+#
+$og_read_only_mode = false
+
+# If true, the library automatically 'enchants' managed classes.
+# In enchant mode, special db aware methods are added to 
+# managed classes and instances.
+#
+$og_enchant_managed_classes = true
+
+# = Og
+#
+# Og (ObjectGraph) is an efficient, yet simple Object-Relational 
+# mapping library. 
+#
+# == Features
+#
+# The library provides the following features:
+#
+# + Object-Relational mapping.
+# + Absolutely no configuration files.
+# + Multiple backends (PostgreSQL, MySQL).
+# + ActiveRecord-style meta language and db aware methods.
+# + Deserialize to Ruby Objects or ResultSets.
+# + Deserialize sql join queries to Ruby Objects.
+# + Serialize arbitrary ruby object graphs through YAML.
+# + Connection pooling.
+# + Thread safety.
+# + SQL transactions.
+# + Lifecycle callbacks.
+# + Transparent support for cascading deletes for all backends.
+# + Hierarchical structures (preorder traversal, materialized paths)
+# + Works safely as part of distributed application.
+# + Simple implementation < 2k lines of code.
+#
+# === Meta language
+#
+# primary_key :pid
+# prop_accessor Fixnum, :pid, :sql => "smallint DEFAULT 1"
+# has_many Child, :children
+# many_to_many Role, :roles
+# sql_index :pid
+#
+# === Design
+#
+# Keep the main classes backend agnostic. 
+#
+# Try to make the methods work with oids. Do NOT implement descendants 
+# use a root id (rid).
+#
+# For class ids we use the name instead of a hash. Class ids are
+# typically not used in querys, they are stored for completeness.
+# If we store a hash we cannot reclaim the class thus invalidating
+# the point. Instead of .name(), to_s() is used so the methods
+# are more flexible (they accept class names too!!)
+#
+# Og allows the serialization of arbitrary Ruby objects. Just
+# mark them as Object (or Array or Hash) in the prop_accessor
+# and the engine will serialize a YAML dump of the object.
+# Arbitrary object graphs are supported too.
+#
+# This is NOT a singleton, an application may access multiple
+# databases.
+#
+# The $og.xxx methods are more flexible and allow you to use
+# multiple databases for example.
+# 
+# === Managed Objects Lifecycle Callbacks
+#
+# * og_pre_insert
+# * og_post_insert
+#	* og_pre_update
+# * og_post_update
+# * og_pre_insert_update
+# * og_post_insert_update
+# * self.og_pre_delete
+# * validate
+#
+# A class level callback is used for delete because typically you call
+# delete with an oid and not an object to avoid a deserialization.
+#
+# === Future 
+# 
+# * Support prepared statements (pgsql)
+# * Support stored procedures (pgsql)
+# * Support caching.
+# * Deserialize to OpenStruct.
+# * Better documentation.
+#
+class Og
+
+	# Managed class metadata
+	#
+	class ManagedClassMeta
+		# The managed class.
+		attr_accessor :klass
+		
+		# A mapping of the database fields to the object properties.
+		attr_accessor :field_index
+		
+		def initialize(klass = nil)
+			@klass = klass
+			@field_index = {}
+		end
+	end
+
+	# hash of configuration options.
+	attr_accessor :config
+
+	# Pool of connections to the backend.
+	attr_accessor :connection_pool
+
+	# Managed classes.
+	attr_accessor :managed_classes
+
+	# Initialize the database interface.
+	#
+	def initialize(config)
+		@config = config
+
+		# populate with default options if needed.
+		@config[:connection_count] ||= 1
+		
+		# require the backend.		
+		backend = @config[:backend] || "psql"
+		require "n/og/backends/#{backend}"
+		eval %{	@config[:backend] = #{backend.capitalize}Backend }
+		
+		@connection_pool = N::Pool.new
+		@managed_classes = N::SafeHash.new
+		
+		$log.info "Connecting to database '#{@config[:database]}' using backend '#{backend}'."
+		
+		@config[:connection_count].times do
+			@connection_pool << N::OgConnection.new(self)
+		end
+	end
+		
+	# Shutdown the database interface.
+	#
+	def shutdown
+		for con in @connection_pool
+			con.close()
+		end
+	end
+	alias_method :close, :shutdown
+
+	# Get a connection from the pool to access the database.
+	# Stores the connection in a thread-local variable.
+	#
+	def get_connection
+		$log.debug "Get Og connection" if $DBG
+		
+		thread = Thread.current
+		
+		unless conn = thread[:og_conn]
+			conn = @connection_pool.pop()
+			thread[:og_conn] = conn
+		end
+		
+		return conn
+	end
+	
+	# Restore an unused connection to the pool.
+	#
+	def put_connection
+		$log.debug "Put Og connection" if $DBG
+
+		thread = Thread.current
+		
+		if conn = thread[:og_conn]
+			thread[:og_conn] = nil
+			return @connection_pool.push(conn)
+		end
+	end	
+	
+	# Utility method, automatically restores a connection to the pool.
+	#
+	def connect(deserialize = nil, &block)
+		result = nil
+		
+		begin
+			conn = get_connection()
+			conn.deserialize = deserialize unless deserialize.nil?
+			
+			result = yield(conn)
+			
+			conn.deserialize = true
+		ensure
+			put_connection()
+		end
+
+		return result
+	end
+	alias_method :open, :connect
+	
+	
+	# Register a standard Ruby class as managed.
+	#
+	def manage(klass)
+		return if managed?(klass)
+		
+		@managed_classes[klass] = ManagedClassMeta.new(klass)
+		
+		# Add standard og methods to the class.
+		convert(klass)
+		
+		# Add helper methods to the class.
+		enchant(klass) if $og_enchant_managed_classes 
+	end
+	
+	# Helper method to set multiple managed classes.
+	#
+	def manage_classes(*klasses)
+		for klass in klasses
+			manage(klass)
+		end
+	end
+	
+	# Stop managing a Ruby class
+	#
+	def unmanage(klass)
+		@managed_classes.delete(klass)
+	end
+	
+	# Is this class managed?
+	#	
+	def managed?(klass)
+		return @managed_classes.include?(klass)
+	end
+	
+	# Add standard og functionality to the class
+	#
+	def convert(klass)
+		# gmosx: this check is needed to allow the developer to customize
+		# the sql generated for oid
+		N::OgUtils.eval_og_oid(klass) unless klass.instance_methods.include?(:oid)
+		
+		klass.class_eval %{
+			inherit_meta(superclass) if superclass
+			
+			DBTABLE = "#{N::OgUtils.table(klass)}"
+			DBSEQ = "#{N::OgUtils.table(klass)}_oids_seq" 
+			
+			def to_i()
+				@oid
+			end			
+		}
+
+		# Create the schema for this class if not available.
+		create_table(klass)				
+
+		# Precompile some code that gets executed all the time.
+		# Deletion code is not precompiled, because it is not used
+		# as frequently.
+		N::OgUtils.eval_og_insert(klass)
+		N::OgUtils.eval_og_update(klass)
+		N::OgUtils.eval_og_deserialize(klass, self)
+	end
+	
+	# Enchant a managed class. Add useful DB related methods to the 
+	# class and its instances. 
+	#
+	def enchant(klass)
+		klass.class_eval %{
+			def self.save(obj)
+				$og << obj
+			end
+			
+			def self.load(oid_or_name)
+				$og.load(oid_or_name, #{klass})
+			end
+
+			def self.[](oid_or_name)
+				$og.load(oid_or_name, #{klass})
+			end
+			
+			def self.load_all(extra_sql = nil)
+				$og.load_all(#{klass}, extra_sql)
+			end
+			
+			def self.all(extra_sql = nil)
+				$og.load_all(#{klass}, extra_sql)
+			end
+			
+			def self.select(sql)
+				$og.select(sql, #{klass})
+			end
+
+			def self.select_one(sql)
+				$og.select_one(sql, #{klass})
+			end
+			
+			def self.delete(obj_or_oid)
+				$og.delete(obj_or_oid, #{klass})
+			end
+			
+			def save
+				$og << self
+			end
+			alias_method :save!, :save
+			
+			def update_properties(updatesql)
+				$og.pupdate(updatesql, self.oid, #{klass})
+			end
+			alias_method :pupdate!, :update_properties
+			
+			def delete!
+				$og.delete(@oid, #{klass})
+			end
+		}
+	end
+	
+	# Automatically wrap connection methods.
+	#
+	def self.wrap_method(method, args)
+		args = args.split(/,/)
+		class_eval %{
+			def #{method}(#{args.join(", ")})
+				thread = Thread.current
+				
+				unless conn = thread[:og_conn]
+					conn = @connection_pool.pop()
+					thread[:og_conn] = conn
+				end
+			
+				return conn.#{method}(#{args.collect {|a| a.split(/=/)[0]}.join(", ")})
+			end
+		}
+	end
+		
+	wrap_method :create_table, "klass"
+	wrap_method :drop_table, "klass"
+	wrap_method :save, "obj";	alias_method :<<, :save; alias_method :put, :save
+	wrap_method :insert, "obj"
+	wrap_method :update, "obj"
+	wrap_method :update_properties, "update_sql, obj_or_oid, klass = nil"
+	wrap_method :pupdate, "update_sql, obj_or_oid, klass = nil"
+	wrap_method :load, "oid, klass"; alias_method :get, :load	
+	wrap_method :load_by_oid, "oid, klass"
+	wrap_method :load_by_name, "name, klass"	
+	wrap_method :load_all, "klass, extrasql = nil"
+	wrap_method :select, "sql, klass"
+	wrap_method :select_one, "sql, klass"
+	wrap_method :delete, "obj_or_oid, klass = nil"	
+	wrap_method :query, "sql"
+	wrap_method :exec, "sql"
+
+	def self.create_db!(config)
+		get_connection().db.create_db(config[:database], config[:user], 
+				config[:password])
+	end
+
+	def self.drop_db!(config)
+		backend = config[:backend] || "psql"
+		require "n/og/backends/#{backend}"
+		eval %{
+			#{backend.capitalize}Backend.drop_db(config[:database], config[:user], 
+					config[:password])
+		}
+	end
+end
+
+end # module