nitro 0.9.5 → 0.10.0

data/lib/nitro/ui/pager.rb

@@ -1,6 +1,6 @@
 # * George Moschovitis  <gm@navel.gr>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: pager.rb 223 2005-01-26 17:07:40Z gmosx $
+# $Id: pager.rb 254 2005-02-10 12:44:05Z gmosx $
 
 require 'nitro/uri'
 
@@ -12,13 +12,9 @@ module N; module UI
 #
 # The new version is carefully designed for scaleability. It stores 
 # only the items for one page. The name parameter is needed, multiple 
-# pagers can coexist in a single page. Unlike the v1/v2 pagers this 
+# pagers can coexist in a single page. Unlike older pagers this 
 # pager leverages the SQL LIMIT option to optimize database interaction.
 #
-# The pager does not extend Array (it includes an Array instead) to
-# avoid a concat() in the initialization step. 
-#
-#
 # === Example
 #
 #	@pager = N::UI::Pager.new('entries', @request, 5)

data/lib/nitro/uri.rb

@@ -1,8 +1,6 @@
-# code: 
 # * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: uri.rb 202 2005-01-17 10:44:13Z gmosx $
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: uri.rb 254 2005-02-10 12:44:05Z gmosx $
 
 require "uri"
 require "cgi"
@@ -11,8 +9,6 @@ require "glue/string"
 
 module N
 
-# = UriUtils
-#
 # URI utilities collection
 #
 # === Design:
@@ -23,7 +19,7 @@ module N
 # which isn't possible if you use self.
 #
 # The uris passed as parameters are typically strings.
-#
+
 module UriUtils
 
 	# Decode the uri components.
@@ -64,7 +60,7 @@ module UriUtils
 	# hash of parameters, contains arrays for multivalued parameters
 	# (multiselect, checkboxes , etc)
 	# If no query string is provided (nil or "") returns an empty hash.
-	#
+	
 	def self.query_string_to_hash(query_string)
 		return {} unless query_string
 
@@ -156,7 +152,7 @@ module UriUtils
 	#
 	# === TODO:
 	# optimize this a litle bit.
-	#
+	
 	def self.update_query_string(uri, parameters)
 		query_string = self.get_query_string(uri)
 		rest = uri.dup.gsub(/\?#{query_string}/, "")
@@ -176,7 +172,7 @@ module UriUtils
 	# Gets the request uri, injects extra parameters in the query string
 	# and returns a new uri. The request object is not modified.
 	# There is always a qs string so an extra test is skipped.
-	#
+	
 	def self.update_request_uri(request, parameters)
 		hash = request.parameters.dup()
 		hash.update(parameters)
@@ -191,4 +187,4 @@ module UriUtils
 
 end
 
-end # module
+end

data/lib/og.rb

@@ -1,7 +1,8 @@
 # * George Moschovitis  <gm@navel.gr>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: og.rb 248 2005-01-31 13:38:34Z gmosx $
+# $Id: og.rb 259 2005-02-15 08:54:54Z gmosx $
 
+require 'glue'
 require 'glue/logger'
 require 'glue/attribute'
 require 'glue/property'
@@ -9,6 +10,7 @@ require 'glue/array'
 require 'glue/hash'
 require 'glue/time'
 require 'glue/pool'
+require 'glue/validation'
 
 # Og (ObjectGraph) is an efficient, yet simple Object-Relational 
 # mapping library. 
@@ -19,10 +21,10 @@ require 'glue/pool'
 #
 # + Object-Relational mapping.
 # + Absolutely no configuration files.
-# + Multiple backends (PostgreSQL, MySQL).
+# + Multiple backends (PostgreSQL, MySQL, SQLite).
 # + ActiveRecord-style meta language and db aware methods.
-# + Deserialize to Ruby Objects or ResultSets.
-# + Deserialize sql join queries to Ruby Objects.
+# + Deserialize to Ruby Objects.
+# + Deserialize sql join queries to Ruby Objects (temporarily dissabled).
 # + Serialize arbitrary ruby object graphs through YAML.
 # + Connection pooling.
 # + Thread safety.
@@ -89,6 +91,18 @@ require 'glue/pool'
 
 class Og
 
+	# The name.
+
+	Name = 'ObjectGraph'
+
+	# The version.
+
+	Version = '0.10.0'
+
+	# Library path.
+
+	LibPath = File.dirname(__FILE__)
+
 	# If true, only allow reading from the database. Usefull
 	# for maintainance.
 	
@@ -131,267 +145,19 @@ class Og
 		@@db.get_connection
 	end
 
-end
-
-# gmosx: leave this here.
-require 'og/enchant'
-require 'og/meta'
-
-class Og
-	
-# Marker module. If included this in a class, the Og automanager
-# ignores this class.
+	# The adapter of the active database.
 
-module Unmanageable; end
-
-# Encapsulates an Og Database.
-
-class Database
-	include Og::Enchant
-
-	# 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
+	def self.adapter
+		@@db.adapter
 	end
 
-	# hash of configuration options.
+	# Marker module. If included this in a class, the Og automanager
+	# ignores this class.
 
-	attr_accessor :config
+	module Unmanageable; end
 
-	# 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 "og/backends/#{backend}"
-		eval %{	@config[:backend] = #{backend.capitalize}Backend }
-		
-		@connection_pool = N::Pool.new
-		@managed_classes = N::SafeHash.new
-		
-		Logger.info "Connecting to database '#{@config[:database]}' using backend '#{backend}'."
-		
-		@config[:connection_count].times do
-			@connection_pool << Og::Connection.new(self)
-		end
-	
-		# gmosx, FIXME: this automanage code is not elegant and slow
-		# should probably recode this, along with glue/property.rb
-		
-		if Og.auto_manage_classes
-			# automatically manage classes with properties and metadata.
-			# gmosx: Any idea how to optimize this?
-			classes_to_manage = []
-			ObjectSpace.each_object(Class) do |c|
-				if c.respond_to?(:__props) and c.__props
-					classes_to_manage << c
-				end
-			end
-			Logger.info "Og auto manages the following classes:"
-			Logger.info "#{classes_to_manage.inspect}"
-			manage_classes(*classes_to_manage)
-		end
-
-		# use the newly created database.
-		Og.use(self)
-	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
-		thread = Thread.current
-		
-		unless conn = thread[:og_conn]
-			conn = @connection_pool.pop()
-			thread[:og_conn] = conn
-		end
-		
-		return conn
-	end
-	alias_method :connection, :get_connection
-	
-	# Restore an unused connection to the pool.
-	
-	def put_connection
-		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) or klass.ancestors.include?(Og::Unmanageable)
-		
-		@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)
-		# Grab backend class
-		backend = @config[:backend]
-
-		# gmosx: this check is needed to allow the developer to customize
-		# the sql generated for oid
-		backend.eval_og_oid(klass) unless klass.instance_methods.include?(:oid)
-		
-		klass.class_eval %{
-			DBTABLE = "#{backend.table(klass)}"
-			DBSEQ = "#{backend.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.
-		backend.eval_og_insert(klass)
-		backend.eval_og_update(klass)
-		backend.eval_og_deserialize(klass, self)
-	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 :count, "sql, klass = nil"
-	wrap_method :delete, "obj_or_oid, klass = nil"	
-	wrap_method :query, "sql"
-	wrap_method :exec, "sql"
-
-	class << self
-		def create_db!(config)
-			get_connection().db.create_db(config[:database], config[:user], 
-					config[:password])
-		end
-		alias_method :create!, :create_db!
-
-		def drop_db!(config)
-			backend = config[:backend] || "psql"
-			require "og/backends/#{backend}"
-			eval %{
-				#{backend.capitalize}Backend.drop_db(config[:database], config[:user], 
-						config[:password])
-			}
-		end
-		alias_method :drop!, :drop_db!
-	end
 end
 
-end
+# gmosx: leave this here.
+
+require 'og/database'

data/lib/og/adapter.rb

@@ -0,0 +1,352 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: adapter.rb 255 2005-02-10 12:45:32Z gmosx $
+
+require 'yaml'
+require 'singleton'
+
+require 'og/connection'
+
+class Og
+
+# An adapter communicates with the backend datastore. 
+# The adapters for all supported datastores extend this 
+# class. Typically, an RDBMS is used to implement a
+# datastore.
+
+class Adapter 
+	include Singleton
+
+	# A mapping between Ruby and backend Datastore types.
+
+	attr_accessor :typemap
+	
+	# Lookup the adapter instance from the adapter name.
+
+	def self.for_name(name)
+		require "og/adapters/#{name}"
+		eval %{	return  #{name.capitalize}Adapter.instance }
+	end
+
+	def initialize
+		@typemap = {
+			Integer => 'integer',
+			Fixnum => 'integer',
+			Float => 'float',
+			String => 'text',
+			Time => 'timestamp',
+			Date => 'date',
+			TrueClass => 'boolean',
+			Object => 'text',
+			Array => 'text',
+			Hash => 'text'
+		}
+	end
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: Utilities
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# Escape an SQL string
+	
+	def self.escape(str)
+		return nil unless str
+		return str.gsub( /'/, "''" )
+	end
+
+	# Convert a ruby time to an sql timestamp.
+	# TODO: Optimize this
+	 
+	def self.timestamp(time = Time.now)
+		return nil unless time
+		return time.strftime("%Y-%m-%d %H:%M:%S")
+	end
+	
+	# Output YYY-mm-dd
+	# TODO: Optimize this
+	
+	def self.date(date)
+		return nil unless date
+		return "#{date.year}-#{date.month}-#{date.mday}" 
+	end
+	
+	# Parse sql datetime
+	# TODO: Optimize this
+	
+	def self.parse_timestamp(str)
+		return Time.parse(str)		
+	end
+	
+	# Input YYYY-mm-dd
+	# TODO: Optimize this
+	
+	def self.parse_date(str)
+		return nil unless str
+		return Date.strptime(str)
+	end
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: Database methods 
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# Create the database.
+	
+	def create_db(database, user = nil, password = nil)
+		Logger.info "Creating database '#{database}'."
+	end
+	
+	# Drop the database.
+	
+	def drop_db(database, user = nil, password = nil)
+		Logger.info "Dropping database '#{database}'."
+	end
+
+	# Create a new connection to the backend.
+
+	def new_connection(db)
+		return Og::Connection.new(db)
+	end
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: OR mapping methods and utilities. 
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# Encode the name of the klass as an sql safe string.
+	# The Module separators are replaced with _ and NOT stripped 
+	# out so that we can convert back to the original notation if 
+	# needed. The leading module if available is removed.
+	
+	def self.encode(klass)
+		"#{klass.name.gsub(/^.*::/, "")}".gsub(/::/, "_").downcase
+	end
+
+	# The name of the SQL table where objects of this class 
+	# are stored.
+	
+	def self.table(klass)
+		"_#{Og.table_prefix}#{encode(klass)}"
+	end
+
+	# The name of the join table for the two given classes.
+	
+	def self.join_table(klass1, klass2)
+		"_#{Og.table_prefix}j_#{encode(klass1)}_#{encode(klass2)}"
+	end
+	
+	# Return an sql string evaluator for the property.
+	# No need to optimize this, used only to precalculate code.
+	# YAML is used to store general Ruby objects to be more 
+	# portable.
+	#
+	# FIXME: add extra handling for float.
+	
+	def write_prop(p)
+		if p.klass.ancestors.include?(Integer)
+			return "#\{@#{p.symbol} || 'NULL'\}"
+		elsif p.klass.ancestors.include?(Float)
+			return "#\{@#{p.symbol} || 'NULL'\}"		
+		elsif p.klass.ancestors.include?(String)
+			return "'#\{#{self.class}.escape(@#{p.symbol})\}'"
+		elsif p.klass.ancestors.include?(Time)
+			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
+		elsif p.klass.ancestors.include?(Date)
+			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : 'NULL'\}|
+		elsif p.klass.ancestors.include?(TrueClass)
+			return "#\{@#{p.symbol} ? \"'t'\" : 'NULL' \}"
+		else 
+			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
+		end
+	end		
+
+	# Return an evaluator for reading the property.
+	# No need to optimize this, used only to precalculate code.
+	
+	def read_prop(p, idx)
+		if p.klass.ancestors.include?(Integer)
+			return "res[#{idx}].to_i"
+		elsif p.klass.ancestors.include?(Float)
+			return "res[#{idx}].to_f"
+		elsif p.klass.ancestors.include?(String)
+			return "res[#{idx}]"
+		elsif p.klass.ancestors.include?(Time)
+			return "#{self.class}.parse_timestamp(res[#{idx}])"
+		elsif p.klass.ancestors.include?(Date)
+			return "#{self.class}.parse_date(res[#{idx}])"
+		elsif p.klass.ancestors.include?(TrueClass)
+			return "('0' != res[#{idx}])"
+		else 
+			return "YAML::load(res[#{idx}])"
+		end				
+	end
+
+	# Create the fields that correpsond to the klass properties.
+	# The generated fields array is used in create_table.
+	# If the property has an :sql metadata this overrides the 
+	# default mapping. If the property has an :extra_sql metadata 
+	# the extra sql is appended after the default mapping.
+	
+	def create_fields(klass)
+		fields = []
+		
+		klass.__props.each do |p|
+			klass.sql_index(p.symbol) if p.meta[:sql_index]
+				
+			field = "#{p.symbol}"
+			
+			if p.meta and p.meta[:sql]
+				field << " #{p.meta[:sql]}"
+			else
+				field << " #{@typemap[p.klass]}"
+				# attach extra sql
+				if p.meta and extra_sql = p.meta[:extra_sql]
+					field << " #{extra_sql}"
+				end
+			end
+			
+			fields << field 
+		end
+
+		return fields
+	end
+
+	# Create the managed object table. The properties of the
+	# object are mapped to the table columns. Additional sql relations
+	# and constrains are created (indicices, sequences, etc).
+	
+	def create_table(klass)
+		raise 'Not implemented!'	
+	end
+
+	# Returns the props that will be included in the insert query.
+	# For some backends the oid should be stripped.
+	
+	def props_for_insert(klass)
+		klass.__props
+	end
+
+	# Returns the code that actually inserts the object into the
+	# database. Returns the code as String.
+	
+	def insert_code(klass, sql, pre_cb, post_cb)
+		raise 'Not implemented!'
+	end
+	
+	# Generate the mapping of the database fields to the
+	# object properties.
+	
+	def calc_field_index(klass, og)
+		raise 'Not implemented!'
+	end
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: Managed object enchant methods 
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# Generate the property for oid.
+
+	def eval_og_oid(klass)
+		klass.class_eval %{
+			prop_accessor :oid, Fixnum, :sql => "integer PRIMARY KEY"
+		}
+	end
+
+	# Precompile the insert code for the given class.
+	# The generated code sets the oid when inserting!
+	
+	def eval_og_insert(klass, db)
+		if klass.instance_methods.include?('og_pre_insert')
+			pre_cb = 'og_pre_insert(conn);'
+		else
+			pre_cb = ''
+		end
+
+		if klass.instance_methods.include?('og_post_insert')
+			post_cb = 'og_post_insert(conn);'
+		else
+			post_cb = ''
+		end
+
+		if klass.instance_methods.include?('og_pre_insert_update')
+			pre_cb << 'og_pre_insert_update(conn);'
+		end
+
+		if klass.instance_methods.include?('og_post_insert_update')
+			post_cb << 'og_post_insert_update(conn);'
+		end
+		
+		klass.class_eval %{
+			def og_insert(conn)
+				#{insert_code(klass, db, pre_cb, post_cb)}
+			end
+		}
+	end
+
+	# Precompile the update code for the given class.
+	# Ignore the oid when updating!
+	
+	def eval_og_update(klass, db)
+		props = klass.__props.reject { |p| :oid == p.symbol }
+		
+		updates = props.collect { |p|
+			"#{p.name}=#{write_prop(p)}"
+		}
+
+		sql = "UPDATE #{klass::DBTABLE} SET #{updates.join(', ')} WHERE oid=#\{@oid\}"
+
+		if klass.instance_methods.include?('og_pre_update')
+			pre_cb = 'og_pre_update(conn);'
+		else
+			pre_cb = ''
+		end
+
+		if klass.instance_methods.include?('og_post_update')
+			post_cb = 'og_post_update(conn);'
+		else
+			post_cb = ''
+		end
+
+		if klass.instance_methods.include?('og_pre_insert_update')
+			pre_cb << 'og_pre_insert_update(conn);'
+		end
+
+		if klass.instance_methods.include?('og_post_insert_update')
+			post_cb << 'og_post_insert_update(conn);'
+		end
+		
+		klass.class_eval %{
+			def og_update(conn)
+				#{pre_cb}
+				conn.exec "#{sql}"
+				#{post_cb}
+			end
+		}
+	end
+
+	# Precompile the code to read (deserialize) objects of the 
+	# given class from the backend. In order to allow for changing 
+	# field/attribute orders we have to use a field mapping hash.
+	
+	def eval_og_read(klass, db)
+		calc_field_index(klass, db)
+		
+		props = klass.__props 
+		code = []
+
+		props.each do |p|
+			if idx = db.managed_classes[klass].field_index[p.name]
+				# more fault tolerant if a new field is added and it 
+				# doesnt exist in the database.
+				code << "@#{p.name} = #{read_prop(p, idx)}"
+			end
+		end
+		
+		klass.class_eval %{
+	 		def og_read(res, tuple = nil)
+				#{code.join('; ')}
+			end
+		}
+	end				
+
+end
+
+end