nitro 0.2.0 → 0.3.0

data/examples/ndb/README

@@ -1,5 +0,0 @@
-= NDB Example
-
-A simple example that demonstrates various NDB features. Before
-runing this example, create a database named test.
-

data/examples/ndb/run.rb

@@ -1,271 +0,0 @@
-# = NDB Example 
-#
-# A simple example to demonstrate the NDB library.
-# Ignore the errors marked as surpressed.
-#
-# code: 
-# * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: run.rb 106 2004-10-25 11:31:11Z gmosx $
-
-$:.unshift "../../lib"
-
-require "n/std"
-require "n/logger"
-require "n/db"
-
-# = A parent class
-#
-class Article
-	manage {
-		# include some Mixins to 'synthesize' the class.
-		include N::Entity
-		include N::CreateTime
-		
-		prop_accessor String, :title
-		prop_accessor String, :body
-		# override the default O->R mapping
-		prop_accessor Fixnum, "smallint DEFAULT 1", :level
-		# store a Ruby Hash in the Database. Marshal
-		# is used for serializing the attribute.
-		prop_accessor Hash, :options
-	}
-	# this attribute is NOT stored in the db.
-	attr_accessor :other_options
-	
-	# Managed object constructors with no args, take *args 
-	# as parameter to allow for Mixin chaining.
-	#
-	def initialize(title = nil, body = nil)
-		# call the constructors of the mixins
-		super
-		@title, @body = title, body
-		options = {}
-		other_options = {}
-	end
-	
-	def to_s
-		return "#@title: #@body"
-	end
-end
-
-# = Another Parent class
-#
-class User
-	manage {
-		include N::Entity
-		include N::Named
-	}
-
-	def initialize(name = nil)
-		@name = name
-		# can be called afterwards if you want.
-		super
-	end
-	
-	def to_s
-		return @name
-	end
-end
-
-# = A child class
-#
-class Comment
-	manage {
-		# include some Mixins to 'synthesize' the class.
-		# This way we get OO sql table definitions.
-		include N::Entity
-		include N::Child
-		# by including this mixin the object can be attached
-		# to different parents.
-		include N::ParentClass
-		include N::CreateTime
-		
-		prop_accessor String, :body
-	}
-	
-	def initialize(body = nil)
-		super
-		@body = body
-	end
-	
-	def to_s
-		return @body
-	end
-end
-
-# = Another child class
-#
-class DummyChild
-	manage {
-		include N::Entity
-		include N::Child
-		
-		prop_accessor String, :body
-	}
-	
-	def initialize(body = nil)
-		super
-		@body = body
-	end
-	
-	def to_s
-		return @body
-	end
-end
-
-# Initialize a logger.
-
-$log = Logger.new(STDERR); 
-
-# Intialize NDB
-
-begin
-	$db = N::Db.new(
-		:address => "localhost",
-		:database => "test",
-		:user => "postgres",
-		:password => "navelrulez",
-		:connection_count => 5
-	)
-rescue => ex
-	puts "Database 'test' does not exist"
-	puts "Create a new database with the following command: "
-	puts "$ createdb test -U postgres"	
-end
-
-# Cleanup the database for earlier executions
-
-$db.drop_table(Article)
-$db.drop_table(Comment)
-
-# Create some articles
-
-a1 = Article.new("Title1", "Body1")
-# by adding the managed object to the $db virtual array you denote
-# that this object should be managed.
-$db << a1
-
-a2 = Article.new("Title2", "Body2")
-$db << a2
-
-puts "\n\n"
-puts "Ignore the errors, NDB automatically initialized the schema"
-
-# Until now we use $db as a helper. From now on we 'll explicitly
-# require a connection to the db. The standard block idiom is used.
-# You can also use the $db.xxx helpers if you just want to execute
-# one command.
-
-$db.open { |db|
-	
-	puts "\n\n"
-	puts "* Get and print all articles:"
-	articles = db.get_all(Article)
-	articles.each { |a| puts a }
-
-	puts "\n\n"
-	puts "* Print all children of the root (oid = -1) of class Aritcle:"
-	articles = db.children(-1, Article)
-	articles.each { |a| puts a }
-	
-	# Create some comments
-	
-	c1 = Comment.new("Comment 1")
-	c1.set_parent(a1)
-	$db << c1
-
-	c2 = Comment.new("Comment 2")
-	# alternative way to set the parent.
-	c2.pid = a1.oid
-	$db << c2
-
-	c3 = Comment.new("Comment 3")
-	# alternative way to set the parent.
-	c3.pid = a1.oid
-	$db << c3
-	
-	puts "\n\n"
-	puts "* Print all all comments for article 1:"
-	comments = db.children(a1, Comment)
-	comments.each { |c| puts c }
-
-	# Most NDB commands allow you to fine-tune the low level
-	# SQL code by passing extra_sql parameters, here is an
-	# example
-	puts "\n\n"
-	puts "* comments with sql finetunings:"
-	# use a standard SQL limit clause
-	comments = db.children(a1, Comment, "LIMIT 2")
-	comments.each { |c| puts c }
-	
-
-	# Change a managed object
-	a1.title = "Changed Title"
-	# NDB knows that this is a managed object and executes
-	# an SQL UPDATE instead of an SQL INSERT
-	$db << a1
-	
-	puts "\n\n"
-	db.get_all(Article).each { |a| puts a }
-	
-	# The previous command updates the whole object. It is used
-	# when there are many updates or you dont care about speed. 
-	# To update only specific fields use pupdate or properties_update
-	db.pupdate("title='A specific title'", a2)
-
-	puts "\n\n"
-	db.get_all(Article).each { |a| puts a }
-
-	# delete an object
-	db.delete(c3)
-	
-	puts "\n\n"
-	db.get_all(Comment).each { |a| puts a }
-
-
-	# Serialize a hash
-	a1.options = { "k1" => "val1", "k2" => "val2" }
-	db << a1
-
-	# lookup an object
-	article = db.get(a1.oid, Article)
-
-	puts "\n\n"
-	puts article.options.inspect
-	
-	# attach another class of child objects to Article:
-	
-	d1 = DummyChild.new("hello")
-	d1.set_parent(a1)
-	db << d1
-
-	d1 = DummyChild.new("world")
-	d1.set_parent(a1)
-	db << d1
-	
-	# Show the dummy children and not the comments.
-	
-	dummies = db.children(a1, DummyChild)
-	dummies.each { |d| puts d }
-	
-	# And now something cool: We attach the Comment objects to different
-	# parents
-	
-	u = User.new("gmosx")
-	db << u
-
-	c4 = Comment.new("Comment 4")
-	c4.set_parent(u)
-	$db << c4
-
-	c5 = Comment.new("Comment 5")
-	c5.set_parent(u)
-	$db << c5
-	
-	comments = db.children(u, Comment)
-	comments.each { |c| puts c }
-}
-
-

data/lib/n/app/webrick.rb

@@ -1,73 +0,0 @@
-# code:
-# * George Moschovitis  <gm@navel.gr>
-# * Elias Athanasopoulos  <elathan@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: webrick.rb 106 2004-10-25 11:31:11Z gmosx $
-
-require "drb"
-require "cgi"
-require "webrick"
-
-require "n/logger"
-require "n/application"
-require "n/app/server"
-require "n/app/webrick-servlet"
-
-module N; module App
-
-# = Webrick AppServer
-#
-# The Application Server. Handles dynamic requests in a web application.
-# Dont keepalive (or use a VERY SMALL keepalive). Typically this server
-# is used along with a standard http server that handles other resources.
-#
-# Used temporarily unitl we build our own app server.
-#
-class Webrick < N::App::Server
-	include WEBrick
-
-	# the integrated webrock server.
-	attr_accessor :webrick
-	
-	def initialize(name = "WebrickServer")
-		super
-	end
-
-	# Start the application server.
-	#
-	def start
-		accesslog = WEBrick::BasicLog::new("/dev/null") 
-		referer = WEBrick::BasicLog::new("/dev/null")	
-		
-		@webrick = HTTPServer.new(
-			:BindAddress => $appsrv_address, 
-			:Port => $appsrv_port, 
-			:DocumentRoot => $root_dir,
-			# gmosx, FIXME: this shit still logs!!
-			:Logger => Log.new(nil, WEBrick::Log::WARN),
-			# elathan: amateur...
-			:AccessLog => [
-          [accesslog, AccessLog::COMMON_LOG_FORMAT],
-          [referer, AccessLog::REFERER_LOG_FORMAT]
-        ]
-		)
-		
-		@webrick.mount("/", N::App::WebrickServlet)
-		
-		trap("INT") {
-		 @webrick.shutdown() 
-		}
-		
-		@webrick.start()
-	end
-	
-	# Stop the application server.
-	#
-	def stop
-		@webrick.stop
-	end
-	
-end
-
-end; end # module

data/lib/n/db.rb

@@ -1,233 +0,0 @@
-# code:
-# * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: db.rb 106 2004-10-25 11:31:11Z gmosx $
-
-module N; 
-
-require "n/properties"
-require "n/utils/array"
-require "n/utils/time"
-require "n/utils/pool"
-
-require "n/db/utils"
-require "n/db/managed"
-require "n/db/connection"
-require "n/db/mixins"
-
-# Configuration
-
-# if true, enables the read only mode
-$db_read_only_mode = false
-
-# = Db
-#
-# An efficient, yet simple Object-Relational Mapper. 
-#
-# == Features
-#
-# The library provides the following features:
-#
-# + Object-Relational mapping
-# + Deserialize to Ruby Objects or ResultSets
-# + Deserialize sql join queries to Ruby Objects
-# + Serialize arbitrary ruby object graphs through Marshal
-# + Connection pooling
-# + Thread safety
-# + SQL transactions
-# + Callbacks
-# + Simple support for cascading deletes
-# + Hierarchical structures (preorder traversal, materialized paths)
-# + Works safely as part of distributed application.
-# + Simple implementation < 10k lines of code.
-#
-# === Design
-#
-# Keep this class backend agnostic. Put backend specific code in
-# the Connection / Managed class.
-#
-# Try to make the methods work with oids. We do keep 
-# a unified id space. Include the N::Sequenced Marker to 
-# denote custom id space.
-# 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!!)
-#
-# Db 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 Marshal.dump of the object.
-# Arbitrary object graphs are supported too.
-# 
-# === Future 
-# 
-# * Support multiple DataBase backends (Postgres, MySQL, ...)
-# * Support prepared statements (pgsql)
-# * Support stored procedures (pgsql)
-# * Support caching
-# * Deserialize to OpenStruct
-# * Better documentation
-# * Code cleanup, refactoring
-# * Release as Gem, RPAbase
-# * Foreign keys (cascading delete)
-#
-# === Design:
-#
-# - This is NOT a singleton, an application may access multiple
-#   databases.
-#
-class Db
-	# hash of configuration options.
-	attr_accessor :config
-
-	# Pool of connections to the backend.
-	attr_accessor :pool
-	
-	# Entities cache.
-	attr_accessor :cache
-
-	# Managed classes fields. A hash of hashes.
-	attr_accessor :fields
-	
-	# Initialize the database interface.
-	#
-	def initialize(config)
-		@config = config
-		
-		if backend = config[:backend]
-			require "n/db/#{backend}"
-		else
-			require "n/db/psql"
-		end
-
-		$log.info "Connecting to database '#{config[:database]}'."
-		
-		@pool = N::Pool.new
-		@fields = N::SafeHash.new
-		
-		for i in (0...config[:connection_count])
-			@pool << DbConnection.new(config)
-		end
-	end
-	
-	# Shutdown the database interface.
-	#
-	def shutdown
-		for con in @pool
-			con.close()
-		end
-	end
-	alias_method :close, :shutdown
-
-	# Get a connection from the pool to access the database.
-	#
-	def get_connection
-		return @pool.pop()
-	end
-	
-	# Restore an unused connection to the pool.
-	#
-	def put_connection(connection)
-		return @pool.push(connection)
-	end	
-	
-	# Utility method, automatically restores a connection to the pool.
-	#
-	def connect(deserialize = nil, &block)
-		result = nil
-		
-		begin
-			db = @pool.pop()
-			db.deserialize = deserialize unless deserialize.nil?
-			
-			result = yield(db)
-			
-			db.deserialize = true
-		ensure
-			@pool.push(db)
-		end
-
-		return result
-	end
-	alias_method :open, :connect
-
-	# Utility method, gets connection and encloses in transaction.
-	#
-	def transaction(deserialize = nil, &block) 
-		result = nil
-		
-		begin
-			db = @pool.pop()
-			db.deserialize = deserialize if deserialize
-			
-			db.start()
-			result = yield(db)
-			db.commit()
-			
-			db.deserialize = true
-		ensure
-			@pool.push(db)
-		end
-
-		return result
-	end
-
-	# Utility method, creates an entity from a row
-	#
-	def entity_from_row(row, klass)
-		entity = klass.new()
-		entity.__db_read_row__(row)
-		return entity
-	end
-
-	private
-	
-	# Automatically wrap connection methods.
-	#
-	def self.wrap_method(method, args)
-		args = args.split(/,/)
-		class_eval %{
-			def #{method}(#{args.join(", ")})
-				begin
-					db = @pool.pop()
-					res = db.#{method}(#{args.collect {|a| a.split(/=/)[0]}.join(", ")})
-				ensure
-					@pool.push(db)
-				end
-				return res
-			end
-		}
-	end
-
-	wrap_method :put, "entity"
-	alias_method :<<, :put
-	wrap_method :insert, "obj"
-	wrap_method :update, "obj"
-	wrap_method :update_properties, "update_sql, ent_or_oid, klass = nil"
-	wrap_method :pupdate, "update_sql, ent_or_oid, klass = nil"	
-	wrap_method :get, "oid, klass"	
-	wrap_method :get_by_oid, "oid, klass"
-	wrap_method :get_by_name, "name, klass"
-	wrap_method :get_all, "klass, extrasql = nil"
-	wrap_method :select, "sql, klass, join_fields = nil"
-	wrap_method :select_one, "sql, klass, join_fields = nil"
-	wrap_method :child, "entity, klass, extrasql = nil"
-	wrap_method :children, "entity, klass, extrasql = nil"
-	wrap_method :count_children, "entity, klass, extrasql = nil"
-	wrap_method :delete, "entity, klass = nil, cascade = true"
-	wrap_method :query, "sql"
-	wrap_method :query_one, "sql"
-	wrap_method :count, "sql"
-	wrap_method :match, "sql"
-	wrap_method :exec, "sql"
-	wrap_method :exec_and_clear, "sql"
-	wrap_method :exec_clear, "sql"
-	wrap_method :drop_table, "klass"	
-end
-
-end # module
-