audrey 0.2

data/lib/audrey.rb

@@ -0,0 +1,2503 @@
+require 'securerandom'
+require 'forwardable'
+require 'fileutils'
+require 'xeme'
+
+
+#===============================================================================
+# Audrey
+#
+class Audrey
+	attr_reader :engine
+	attr_accessor :autopurge
+	attr_reader :partition
+	attr_reader :closers
+	@@current_db = nil
+	
+	# version
+	VERSION = '0.2'
+	
+	#---------------------------------------------------------------------------
+	# delegate
+	#
+	extend Forwardable
+	
+	# root object
+	delegate(%w(
+		[] []= each length keys values delete clear
+		== <= >= ===
+		has_key? any?
+		) => :@root);
+	
+	# engine
+	delegate %w(commit rollback in_transaction?) => :@engine
+	
+	#
+	# delegate
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(*params)
+		@org_opts = self.class.params_to_opts(*params)
+		
+		# mode
+		# KLUDGE: For now, just always using the mode that was sent with the
+		# "new" command. Eventually we'll need to recognize that different
+		# partitions will have different modes
+		@mode = Audrey::Mode.new(@org_opts['mode'])
+		
+		# finalizer
+		ObjectSpace.define_finalizer(self, proc { self.class.finalize(self.object_id) })
+		
+		# engine opts
+		@engine_opts = {}
+		
+		# immediate_commit
+		if @org_opts.has_key?('immediate_commit')
+			@engine_opts['immediate_commit'] = @org_opts['immediate_commit']
+		end
+		
+		# default autopurge
+		@autopurge = true
+		
+		# connect engine
+		connect_engine()
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# connect_engine
+	#
+	def connect_engine
+		# objects that should be closed before the database is closed
+		@closers = {}
+		
+		# sqlite3
+		if @org_opts['engine'] == 'sqlite3'
+			require 'audrey/engine/sqlite3'
+			@engine = Audrey::Engine::SQLite3.new(@org_opts['connect'], @mode, @engine_opts)
+		else
+			# @engine = self.class.initialize_engine(opts)
+			raise 'not-yet-implemented-non-sqlite-engine'
+		end
+		
+		# default partition to m
+		self.partition = 'm'
+	end
+	#
+	# connect_engine
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# reset
+	#
+	def reset
+		close()
+		connect_engine()
+	end
+	#
+	# reset
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# partition=
+	#
+	def partition=(val)
+		# $tm.hrm
+		
+		# set partition
+		@partition = val
+		@engine.partition = val
+		
+		# set root
+		@root = Audrey::Node::Hash.new(self, 'pk'=>@engine.root_pk)
+	end
+	#
+	# partition=
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# connect
+	#
+	def self.connect(*opts)
+		if block_given?
+			begin
+				db = self.new(*opts)
+				
+				db.current do
+					yield db
+				end
+			
+			# implement db.exit by catching Audrey::Exception::DatabaseExit
+			rescue Audrey::Exception::DatabaseExit => e
+				# NOTE: for whatever reason, e.db == db doesn't return true,
+				# even though they're the same object. Using object_id to
+				# bypass that problem.
+				unless e.db.object_id == db.object_id
+					raise e
+				end
+				
+				# return out of this method
+				return nil
+			
+			# ensure database is closed
+			ensure
+				db and db.close
+			end
+		else
+			return self.new(*opts)
+		end
+	end
+	#
+	# connect
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# exit
+	#
+	def exit()
+		e = Audrey::Exception::DatabaseExit.new(self)
+		raise e
+	end
+	#
+	# exit
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# current
+	#
+	def current
+		hold_current = Audrey.current_db
+		Audrey.current_db = self
+		yield
+	ensure
+		Audrey.current_db = hold_current
+	end
+	
+	def self.current_db(opts={})
+		return @@current_db
+	end
+	
+	def self.explicit_or_current_db(accessor)
+		# $tm.hrm
+		
+		# explicit accessor was sent
+		if accessor
+			return accessor
+		
+		# else return current database
+		else
+			return @@current_db
+		end
+	end
+	
+	def self.current_db=(db)
+		@@current_db = db
+	end
+	#
+	# current
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# session_pk
+	#
+	def session_pk
+		if not instance_variable_defined?(:@session_pk)
+			@session_pk = Audrey::Util.uuid
+		end
+		
+		return @session_pk
+	end
+	#
+	# session_pk
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# finalize
+	#
+	def self.finalize(id)
+		# $tm.hrm
+		obj = ObjectSpace._id2ref(id)
+		obj.close()
+	end
+	#
+	# finalize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# close
+	#
+	def close
+		# closers
+		@closers.keys.each do |k|
+			@closers[k].close
+			@closers.delete(k)
+		end
+		
+		# purge
+		if @engine
+			@engine.close 'purge'=>@autopurge
+		end
+	end
+	#
+	# close
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# build_array
+	#
+	def build_array(row)
+		node = Audrey::Node::Array.new(self, 'pk'=>row['pk'])
+		rv = []
+		node.attach_to rv
+		return rv
+	end
+	#
+	# build_array
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# purge
+	#
+	def purge
+		# $tm.hrm
+		@engine.purge
+	end
+	#
+	# purge
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# read_check, write_check
+	#
+	def read_check
+		# $tm.hrm
+		@mode.read or raise Audrey::Exception::Permission::Read.new()
+	end
+	
+	def write_check
+		@mode.write or raise Audrey::Exception::Permission::Write.new()
+	end
+	#
+	# read_check, write_check
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# ensure_object_record
+	#
+	def ensure_object_record(object)
+		# $tm.hrm
+		write_check()
+		
+		# early exit: object already has a audrey object
+		if object.respond_to?('audrey')
+			return object.audrey.pk
+		end
+		
+		# scalar
+		if dfn = Audrey::RUBY_OBJECT_TO_AUDREY[object.class]
+			if dfn['nclass']
+				pk = @engine.insert_object(object)
+				node = dfn['nclass'].new(self, 'pk'=>pk)
+				node.attach_to object
+				return pk
+			else
+				return @engine.insert_object(object)
+			end
+		end
+	end
+	#
+	# ensure_object_record
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# object_from_row
+	#
+	def object_from_row(row)
+		# $tm.hrm
+		
+		# scalar
+		if dfn = Audrey::AUDREY_SCALAR_TO_RUBY[row['fclass']]
+			return dfn.call(row['scalar'])
+		end
+		
+		# collection
+		if dfn = Audrey::AUDREY_COLLECTION_TO_RUBY[row['fclass']]
+			return dfn['nclass'].create_object(self, 'row'=>row)
+		end
+		
+		# custom class
+		if Module.const_defined?(row['fclass'])
+			clss = Module.const_get(row['fclass'])
+			nclass = Audrey::AUDREY_COLLECTION_TO_RUBY[clss.bclass.to_s]['nclass']
+			node = nclass.new(self, 'row'=>row)
+			rv = clss.new('db'=>self, 'node'=>node)
+			return rv
+		end
+		
+		# if we get this far then we don't know how to turn the row into a
+		# Audrey object
+		raise 'unknown-fclass: ' + row['fclass'].to_s
+	end
+	#
+	# object_from_row
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# insert_object
+	#
+	def insert_object(object)
+		write_check()
+		checks_outside_transaction object.class
+		return @engine.insert_object(object)
+	end
+	#
+	# insert_object
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# object_from_pk
+	#
+	def object_from_pk(pk)
+		row = @engine.row_by_pk(pk)
+		
+		if row
+			return object_from_row(row)
+		else
+			return nil
+		end
+	end
+	#
+	# object_from_pk
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# q0
+	#
+	def q0
+		require 'audrey/query/q0'
+		return Audrey::Query::Q0.new(self)
+	end
+	#
+	# q0
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# import_csv
+	#
+	def import_csv(fclass, path, opts={})
+		# $tm.hrm
+		return @engine.import_csv(fclass, path, opts)
+	end
+	#
+	# import_csv
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# checks_outside_transaction
+	#
+	def checks_outside_transaction(fclass)
+		if fclass.respond_to?('has_checks?')
+			if (not in_transaction?) and fclass.has_checks?
+				raise 'cannot-create-or-modify-object-that-has-checks-when-not-in-a-transaction'
+			end
+		end
+	end
+	#
+	# checks_outside_transaction
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# transaction
+	#
+	def transaction(opts={})
+		# $tm.hrm
+		
+		# yield to block and return nil
+		if block_given?
+			@engine.transaction(opts) do |tr|
+				# yield
+				yield tr
+				
+				# run checks
+				# xeme = run_checks()
+				
+				# autocommit
+				if opts['autocommit']
+					tr.commit
+				end
+			end
+		
+		# else just return transaction
+		else
+			raise 'not-yet-implemented-non-block-transaction'
+		end
+	end
+	#
+	# transaction
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# autocommit
+	#
+	def autocommit(opts={}, &block)
+		# $tm.hrm
+		opts = {'autocommit'=>true}.merge(opts)
+		transaction opts, &block
+	end
+	#
+	# autocommit
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# run_checks
+	#
+	def run_checks()
+		# $tm.hrm
+		xeme = Xeme.new()
+		
+		# loop through records that have been changed
+		changed_objects() do |obj|
+			if obj.class.has_checks?
+				obj.class.fields.each do |fieldname, dfn|
+					val = obj.audrey[fieldname]
+					
+					# require
+					if dfn.required and val.nil?
+						xeme.error('required') do |msg|
+							msg['field'] = fieldname
+						end
+					
+					# wrong class
+					elsif dfn.fclass and (not val.is_a?(dfn.fclass))
+						xeme.error('wrong-fclass') do |msg|
+							msg['field'] = fieldname
+							msg['fclass'] = dfn.fclass.to_s
+						end
+					
+					# run checks
+					else
+						dfn.base_checks xeme, fieldname, val
+					end
+				end
+			else
+				obj.audrey.changed = false
+			end
+		end
+		
+		# return
+		return xeme
+	end
+	#
+	# run_checks
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# changed_objects
+	#
+	def changed_objects()
+		@engine.changed_objects do |row|
+			yield self.object_from_row(row)
+		end
+	end
+	#
+	# changed_objects
+	#---------------------------------------------------------------------------
+	
+	
+	# private
+	private
+	
+	
+	#---------------------------------------------------------------------------
+	# initialize_engine
+	#
+	def self.initialize_engine(opts)
+		# $tm.hrm
+		engine = opts['engine']
+		
+		# if already an engine, return it
+		if engine.is_a?(Audrey::Engine)
+			return engine
+		end
+		
+		# if class, return that
+		if engine.is_a?(Class) and (engine < Audrey::Engine)
+			return engine.new(opts)
+		end
+	end
+	#
+	# initialize_engine
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# params_to_opts
+	#
+	def self.params_to_opts(*params)
+		# $tm.hrm
+		# $tm.show params
+		
+		# if single value and it's a hash, return that
+		if (params.length == 1) and params[0].is_a?(Hash)
+			return params[0]
+		end
+		
+		# default engine
+		default = {'engine'=>'sqlite3'}
+		
+		# if three, and third is a hash, use that as the options
+		if (params.length == 3) and params[2].is_a?(Hash)
+			default = default.merge(params.pop)
+		end
+		
+		# if two params, then they are the connection string and the mode
+		if (params.length == 2)
+			rv = {'connect'=>params[0], 'mode'=>params[1]}
+			rv = default.merge(rv)
+			return rv
+		end
+		
+		# else invalid input
+		raise 'invalid-params-for-initialize'
+	end
+	#
+	# params_to_opts
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Transaction
+#
+class Audrey::Transaction
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(db, opts={})
+		# $tm.hrm
+		@db = db
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Transaction
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Engine
+#
+class Audrey::Engine
+end
+#
+# Audrey::Engine
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Mode
+#
+class Audrey::Mode
+	attr_reader :read
+	attr_reader :write
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(p_mode)
+		# $tm.hrm
+		
+		# mode cannot be tainted
+		if p_mode.tainted?
+			raise 'cannot-use-tainted-read-write-mode'
+		end
+		
+		# set read and write
+		if (p_mode == 'rw') or (p_mode == 'wr')
+			@read = true
+			@write = true
+		elsif p_mode == 'r'
+			@read = true
+			@write = false
+		elsif p_mode == 'w'
+			@read = false
+			@write = true
+		else
+			raise 'unknown-mode: ' + p_mode.to_s
+		end
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Mode
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Node
+# This class defines an object that connects to the database for a single
+# object record.
+#
+class Audrey::Node
+	attr_reader :pk
+	attr_reader :db
+	extend Forwardable
+	
+	# delegate read and write checks to database
+	delegate(%w(read_check write_check) => :@db);
+	
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(p_db, opts={})
+		# param check
+		if not p_db.is_a?(Audrey)
+			raise 'db-param-not-audrey: ' + p_db.class.to_s
+		end
+		
+		# db and engine
+		@db = p_db
+		@engine = @db.engine
+		
+		# hold on to flcass if one was sent
+		@fclass = opts['fclass']
+		
+		# if a row was sent, cache it and set pk
+		if opts['row']
+			@row_cache = opts['row']
+			@pk = @row_cache['pk']
+		else
+			@pk = opts['pk'] || Audrey::Util.uuid
+			@row_cache = nil
+		end
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# row
+	#
+	def row()
+		# $tm.hrm
+		read_check()
+		
+		if not @row_cache
+			@row_cache = @engine.row_by_pk(@pk)
+		end
+		
+		return @row_cache
+	end
+	#
+	# row
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# fco, isolate
+	#
+	def fco
+		# $tm.hrm
+		return Audrey::Util.fclass_fco(row['fclass'])
+	end
+	
+	def isolate
+		# $tm.hrm
+		return Audrey::Util.fclass_isolate(row['fclass'])
+	end
+	#
+	# fco, isolate
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# ancestors
+	#
+	def ancestors
+		read_check()
+		
+		@engine.ancestors(@pk) do |row|
+			yield @db.object_from_row(row)
+		end
+	end
+	#
+	# ancestors
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# alive?
+	#
+	def alive?
+		# $tm.hrm
+		return @engine.object_exists?(@pk)
+	end
+	#
+	# alive?
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# delete_object
+	#
+	def delete_object
+		write_check()
+		return @engine.delete_object(@pk)
+	end
+	#
+	# delete_object
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Node
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Node::Collection
+#
+class Audrey::Node::Collection < Audrey::Node
+	#---------------------------------------------------------------------------
+	# create_object
+	#
+	def self.create_object(p_db, opts={})
+		# $tm.hrm
+		obj = new_object()
+		node = self.new(p_db, opts)
+		node.attach_to obj
+		return obj
+	end
+	#
+	# create_object
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# clear
+	#
+	def clear
+		write_check()
+		return @engine.clear_collection(@pk)
+	end
+	#
+	# clear
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# length
+	#
+	def length
+		read_check()
+		return @engine.collection_length(@pk)
+	end
+	#
+	# length
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# any?
+	#
+	def any?
+		read_check()
+		return @engine.collection_length(@pk) > 0
+	end
+	#
+	# any?
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# child_pks
+	#
+	def child_pks
+		# $tm.hrm
+		return @engine.collection_child_pks(@pk)
+	end
+	#
+	# child_pks
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# changed
+	#
+	def changed
+		# $tm.hrm
+		return @engine.changed_get(@pk)
+	end
+	
+	def changed=(bool)
+		# $tm.hrm
+		return @engine.changed_set(@pk, bool)
+	end
+	#
+	# changed
+	#---------------------------------------------------------------------------
+	
+	
+	# private
+	private
+	
+	
+	#---------------------------------------------------------------------------
+	# save_child
+	#
+	def save_child(child, opts={})
+		write_check()
+		child_pk = @db.ensure_object_record(child)
+		@engine.add_relationship(@pk, child_pk, 'hkey'=>opts['key'])
+	end
+	#
+	# save_child
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Node::Collection
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Node::Hash
+#
+class Audrey::Node::Hash < Audrey::Node::Collection
+	#---------------------------------------------------------------------------
+	# new_object
+	#
+	def self.new_object
+		return({})
+	end
+	#
+	# new_object
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# []
+	#
+	def [](key)
+		# $tm.hrm
+		# puts "@pk: #{@pk}"
+		# puts "key: #{key}"
+		
+		read_check()
+		hsh = @engine.row_hash_by_key(@pk, key)
+		
+		# if we got a hash
+		if hsh
+			return @db.object_from_row(hsh)
+			
+		# else return nil
+		else
+			return nil
+		end
+	end
+	#
+	# []
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# []=
+	#
+	def []=(key, child)
+		write_check()
+		
+		# test for checks outside of a transaction
+		@db.checks_outside_transaction @fclass
+		
+		@engine.hash_element_delete @pk, key
+		save_child child, 'key'=>key.to_s
+		return child
+	end
+	#
+	# []=
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# keys
+	#
+	def keys
+		read_check()
+		return @engine.hash_keys(@pk)
+	end
+	#
+	# keys
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# values
+	#
+	def values
+		read_check()
+		rv = []
+		
+		# loop through records
+		@engine.hash_each(@pk) do |key, row|
+			rv.push @db.object_from_row(row)
+		end
+		
+		# return
+		return rv
+	end
+	#
+	# values
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# each
+	#
+	def each
+		read_check()
+		rv = nil
+		
+		# loop through records
+		@engine.hash_each(@pk) do |key, row|
+			object = @db.object_from_row(row)
+			
+			if block_given?
+				yield key, object
+			else
+				rv ||= []
+				rv.push [key, object]
+			end
+		end
+		
+		# return
+		return rv
+	end
+	#
+	# each
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# delete
+	#
+	def delete(key)
+		write_check()
+		record = @engine.hash_element_delete(@pk, key)
+		
+		# if record, return node, else return nil
+		if record
+			return @db.object_from_row(record)
+		else
+			return nil
+		end
+	end
+	#
+	# delete
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# has_key?
+	#
+	def has_key?(key)
+		read_check()
+		return @engine.hash_has_key?(@pk, key)
+	end
+	#
+	# has_key?
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# attach_to
+	#
+	def attach_to(hsh)
+		# hold on to original values
+		orgs = hsh.clone
+		
+		# audrey()
+		def hsh.audrey(p_node = nil)
+			if p_node
+				@audrey_node = p_node
+			end
+			
+			# return
+			return @audrey_node
+		end
+		
+		# []
+		def hsh.[](key)
+			return @audrey_node[key]
+		end
+		
+		# []=
+		def hsh.[]=(key, child)
+			return @audrey_node[key] = child
+		end
+		
+		# each
+		def hsh.each()
+			if block_given?
+				@audrey_node.each do |k, v|
+					yield k, v
+				end
+			else
+				return @audrey_node.each
+			end
+		end
+		
+		# length
+		def hsh.length()
+			return @audrey_node.length
+		end
+		
+		# keys
+		def hsh.keys()
+			return @audrey_node.keys
+		end
+		
+		# values
+		def hsh.values()
+			return @audrey_node.values
+		end
+		
+		# delete
+		def hsh.delete(*opts)
+			return @audrey_node.delete(*opts)
+		end
+		
+		# clear
+		def hsh.clear()
+			return @audrey_node.clear()
+		end
+		
+		# has_key?
+		def hsh.has_key?(key)
+			return @audrey_node.has_key?(key)
+		end
+		
+		# any?
+		def hsh.any?()
+			return @audrey_node.any?
+		end
+		
+		# ==
+		def hsh.==(*opts)
+			return @audrey_node.==(*opts)
+		end
+		
+		# <=
+		def hsh.<=(*opts)
+			return @audrey_node.<=(*opts)
+		end
+		
+		# >=
+		def hsh.>=(*opts)
+			return @audrey_node.>=(*opts)
+		end
+		
+		# ===
+		def hsh.===(*opts)
+			return @audrey_node.===(*opts)
+		end
+		
+		# initial call to audrey object
+		hsh.audrey self
+		
+		# save child elements
+		orgs.each do |k, v|
+			hsh[k] = v
+		end
+	end
+	#
+	# attach_to
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Node::Hash
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Node::Array
+#
+class Audrey::Node::Array < Audrey::Node::Collection
+	#---------------------------------------------------------------------------
+	# new_object
+	#
+	def self.new_object
+		return([])
+	end
+	#
+	# new_object
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# []
+	#
+	def [](idx)
+		read_check()
+		row = @engine.row_by_array_index(@pk, idx)
+		
+		# if we got a hash
+		if row
+			return @db.object_from_row(row)
+			
+		# else return nil
+		else
+			return nil
+		end
+	end
+	#
+	# []
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# []=
+	#
+	def []=(key, child)
+	end
+	#
+	# []=
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# push
+	#
+	def push(child)
+		write_check()
+		save_child child
+		return child
+	end
+	#
+	# push
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# each
+	#
+	def each
+		# $tm.hrm
+		read_check()
+		rv = nil
+		
+		# loop through rows
+		@engine.array_each(@pk) do |row|
+			obj = @db.object_from_row(row)
+			
+			if block_given?
+				yield obj
+			else
+				rv ||= []
+				rv.push obj
+			end
+		end
+		
+		# return
+		return rv
+	end
+	
+	def each_with_index
+		idx = 0
+		
+		each do |el|
+			yield el, idx
+			idx += 1
+		end
+	end
+	#
+	# each
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# to_array
+	#
+	def to_array
+		rv = []
+		
+		each do |el|
+			rv.push el
+		end
+		
+		return rv
+	end
+	#
+	# to_array
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# include?
+	# NOTE: This routine could probably be better implemented by the database
+	# engine. For now just doing it the brute force way.
+	#
+	def include?(val)
+		# $tm.hrm
+		
+		# if val has a audrey object
+		if val.respond_to?('audrey')
+			each do |object|
+				if object.respond_to?('audrey')
+					if val.audrey.pk == object.audrey.pk
+						return true
+					end
+				end
+			end
+		else
+			each do |object|
+				if val === object
+					return true
+				end
+			end
+		end
+		
+		# didn't find it
+		return false
+	end
+	#
+	# include?
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# attach_to
+	#
+	def attach_to(arr)
+		# hold on to original values
+		orgs = arr.clone
+		
+		# audrey()
+		def arr.audrey(p_node = nil)
+			if p_node
+				@audrey_node = p_node
+			end
+			
+			# return
+			return @audrey_node
+		end
+		
+		# NOTE: There must be a simpler way to delegate all these hash methods
+		# to @audrey_node
+		
+		# []
+		def arr.[](idx)
+			return @audrey_node[idx]
+		end
+		
+		# push
+		def arr.push(val)
+			return @audrey_node.push(val)
+		end
+		
+		# each
+		def arr.each()
+			if block_given?
+				@audrey_node.each do |k, v|
+					yield k, v
+				end
+			else
+				return @audrey_node.each
+			end
+		end
+		
+		# each_with_index
+		def arr.each_with_index()
+			@audrey_node.each_with_index do |el, idx|
+				yield el, idx
+			end
+		end
+		
+		# length
+		def arr.length()
+			return @audrey_node.length
+		end
+		
+		# any?
+		def arr.any?()
+			return @audrey_node.any?
+		end
+		
+		# clear
+		def arr.clear()
+			return @audrey_node.clear()
+		end
+		
+		# join
+		def arr.join(sep)
+			rv = []
+			
+			@audrey_node.each do |el|
+				rv.push el
+			end
+			
+			return rv.join(sep)
+		end
+		
+		# include?
+		def arr.include?(val)
+			return @audrey_node.include?(val)
+		end
+		
+		# initial call to audrey object
+		arr.audrey self
+		
+		# save child elements
+		orgs.each do |v|
+			arr.push v
+		end
+	end
+	#
+	# attach_to
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Node::Array
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Util
+#
+module Audrey::Util
+	#---------------------------------------------------------------------------
+	# uuid
+	#
+	def self.uuid
+		return SecureRandom.uuid
+	end
+	#
+	# uuid
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# randstr
+	# Always returns a string consisting of just alphabetic characters. String
+	# is untainted.
+	#
+	def self.randstr(len=5)
+		return (0...len).map { ('a'..'z').to_a[rand(26)] }.join.untaint
+	end
+	#
+	# uuid
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# rclass_from_fclass
+	#
+	RCLASS_FROM_FCLASS_CACHE = {}
+	
+	def self.rclass_from_fclass(fclass)
+		if early = RCLASS_FROM_FCLASS_CACHE[fclass]
+			return early
+		end
+		
+		if Module.const_defined?(fclass)
+			rclass = Module.const_get(fclass)
+			
+			if rclass < Audrey::Object
+				RCLASS_FROM_FCLASS_CACHE[fclass] = rclass
+				return rclass
+			else
+				raise 'not-custom-class: ' + fclass.to_s
+			end
+		else
+			raise 'unknown-fclass: ' + fclass.to_s
+		end
+	end
+	#
+	# rclass_from_fclass
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# fclass_fco, fclass_isolate
+	#
+	def self.fclass_fco(fclass)
+		return self.rclass_from_fclass(fclass).fco
+	end
+	
+	def self.fclass_isolate(fclass)
+		return self.rclass_from_fclass(fclass).isolate
+	end
+	#
+	# fclass_fco, fclass_isolate
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# graph_field?
+	#
+	def self.graph_field?(fclass, hkey)
+		# $tm.hrm
+		
+		if fclass and Module.const_defined?(fclass)
+			clss = Module.const_get(fclass)
+			
+			if clss.respond_to?('fields')
+				if dfn = clss.fields[hkey]
+					return dfn.graph
+				end
+			end
+		end
+		
+		# if we get this far then it's not a graph field
+		return false
+	end
+	#
+	# graph_field?
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# custom_class?
+	#
+	@@CUSTOM_CLASSES = {}
+	
+	def self.custom_class?(fclass)
+		# $tm.hrm
+		
+		# cache
+		if not @@CUSTOM_CLASSES.has_key?(fclass)
+			# puts fclass
+			@@CUSTOM_CLASSES[fclass] = rclass_from_fclass(fclass) < Audrey::Object::Custom
+		end
+		
+		# return
+		return @@CUSTOM_CLASSES[fclass]
+	end
+	#
+	# custom_class?
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Util
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Object
+#
+class Audrey::Object
+	#---------------------------------------------------------------------------
+	# inherited, descendants, fclasses
+	#
+	def self.inherited(desc)
+		if not instance_variable_defined?(:@children)
+			@children = []
+		end
+		
+		@children.push desc
+	end
+	
+	def self.descendants
+		rv = []
+		
+		if instance_variable_defined?(:@children)
+			@children.each do |child|
+				rv.push child
+				rv += child.descendants
+			end
+		end
+		
+		return rv
+	end
+	
+	def self.fclasses
+		rv = [self.to_s]
+		
+		descendants.each do |desc|
+			rv.push desc.to_s
+		end
+		
+		return rv
+	end
+	#
+	# inherited, descendants, fclasses
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# fco, isolate
+	#
+	def self.fco()
+		if not instance_variable_defined?(:@fco)
+			@fco = superclass.fco
+			
+			if @fco.nil?
+				raise 'must-override-fco: class=' + self.to_s
+			end
+		end
+		
+		return @fco
+	end
+	
+	def self.isolate()
+		if not instance_variable_defined?(:@isolate)
+			@isolate = superclass.isolate
+		end
+		
+		return @isolate
+	end
+	#
+	# fco, isolate
+	#---------------------------------------------------------------------------
+	
+	
+	# private
+	private
+	
+	
+	#---------------------------------------------------------------------------
+	# isolate=, fco=
+	#
+	def self.isolate=(val)
+		@isolate = val
+	end
+	
+	def self.fco=(val)
+		@fco = val
+	end
+	
+	self.fco = false
+	self.isolate = false
+	#
+	# isolate=, fco=
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Object
+#===============================================================================
+
+
+#===============================================================================
+# scalar types
+#
+class Audrey::Object::Scalar < Audrey::Object
+	def self.bclass
+		return self
+	end
+end
+
+class Audrey::Object::Scalar::String < Audrey::Object::Scalar
+	def self.field_definition
+		return Audrey::Object::Scalar::String::Field
+	end
+end
+
+class Audrey::Object::Scalar::Number < Audrey::Object::Scalar
+end
+
+class Audrey::Object::Scalar::Boolean < Audrey::Object::Scalar
+end
+
+class Audrey::Object::Scalar::Null < Audrey::Object::Scalar
+end
+#
+# scalar types
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Object::Collection
+#
+class Audrey::Object::Collection < Audrey::Object
+end
+#
+# Audrey::Object::Collection
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Object::Array
+#
+class Audrey::Object::Array < Audrey::Object::Collection
+	def self.bclass
+		return self
+	end
+	
+	def self.node_class
+		return Audrey::Node::Hash
+	end
+end
+#
+# Audrey::Object::Array
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Object::Hash
+#
+class Audrey::Object::Hash < Audrey::Object::Collection
+	def self.bclass
+		return Audrey::Object::Hash
+	end
+	
+	def self.node_class
+		return Audrey::Node::Hash
+	end
+end
+#
+# Audrey::Object::Hash
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Object::Root
+#
+class Audrey::Object::Root < Audrey::Object::Hash
+	def self.bclass
+		return Audrey::Object::Hash
+	end
+	
+	def self.node_class
+		return Audrey::Node::Hash
+	end
+	
+	# fco
+	self.fco = true
+end
+#
+# Audrey::Object::Root
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Object::Searchable
+#
+module Audrey::Object::Searchable
+	#---------------------------------------------------------------------------
+	# each
+	#
+	def each(opts={})
+		prepare_query(opts).each do |object|
+			yield object
+		end
+	end
+	#
+	# each
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# count
+	#
+	def count(opts={})
+		return prepare_query(opts).count
+	end
+	#
+	# count
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# first
+	#
+	def first(opts={})
+		prepare_query(opts).each do |object|
+			return object
+		end
+	end
+	#
+	# each
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# sample, samples
+	#
+	def sample(opts={})
+		query = prepare_query(opts)
+		return query.sample
+	end
+	
+	def samples(c, opts={})
+		query = prepare_query(opts)
+		return query.samples(c)
+	end
+	#
+	# sample, samples
+	#---------------------------------------------------------------------------
+	
+	
+	# private
+	private
+	
+	
+	#---------------------------------------------------------------------------
+	# prepare_query
+	#
+	def prepare_query(opts)
+		db = Audrey.explicit_or_current_db(opts['accessor'])
+		query = db.q0
+		query.fclass = self
+		return query
+	end
+	#
+	# prepare_query
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Object::Searchable
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Object::Custom
+#
+class Audrey::Object::Custom < Audrey::Object::Hash
+	extend Audrey::Object::Searchable
+	
+	# default fco to nil, which means fco must be explicitly overridden in
+	# subclasses
+	self.fco = nil
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(opts={})
+		# If a node is passed as an option, use that node and don't create a
+		# new object.
+		if @node = opts['node']
+			if block_given?
+				@node.db.transaction() do |tr|
+					yield self
+					tr.commit
+				end
+			end
+		
+		# If no node is passed, create a new object. If a block is given, run
+		# that block within a transaction.
+		else
+			db = Audrey.explicit_or_current_db(opts['accessor'])
+			
+			# if within block
+			if block_given?
+				db.transaction() do |tr|
+					within_initialize db, opts
+					yield self
+					tr.commit
+				end
+			else
+				within_initialize db, opts
+			end
+		end
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# audrey
+	#
+	def audrey
+		return @node
+	end
+	#
+	# audrey
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# own_fields
+	#
+	def self.own_fields
+		# $tm.hrm
+		
+		# ensure @own_fields exists
+		if not instance_variable_defined?(:@own_fields)
+			@own_fields = {}
+		end
+		
+		# return
+		return @own_fields
+	end
+	#
+	# own_fields
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# fields
+	#
+	def self.fields
+		# $tm.hrm
+		
+		# get superclass fields
+		if self.superclass.respond_to?('fields')
+			rv = self.superclass.fields()
+		else
+			rv = {}
+		end
+		
+		# get own fields
+		rv = rv.merge(own_fields())
+		
+		# return
+		return rv
+	end
+	#
+	# fields
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# descendant?
+	#
+	def self.descendant?(object)
+		if object.is_a?(Class)
+			return object < Audrey::Object::Custom
+		else
+			return object.class < Audrey::Object::Custom
+		end
+	end
+	#
+	# descendant?
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# new_auto_fields
+	#
+	def self.new_auto_fields(object)
+		# $tm.hrm
+		
+		# loop through fields
+		fields.each do |name, dfn|
+			dfn.auto_add object
+		end
+		
+		# rescurse to super class
+		unless self == Audrey::Object::Custom
+			self.superclass.new_auto_fields(object)
+		end
+	end
+	#
+	# new_auto_fields
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# has_checks?
+	#
+	def self.has_checks?
+		# cache return value
+		if not instance_variable_defined?(:@has_checks_cache)
+			@has_checks_cache = has_checks_search()
+		end
+		
+		# return
+		return @has_checks_cache
+	end
+	#
+	# has_checks?
+	#---------------------------------------------------------------------------
+	
+	
+	# private
+	private
+	
+	
+	#---------------------------------------------------------------------------
+	# within_initialize
+	#
+	def within_initialize(db, opts)
+		uuid = db.insert_object(self)
+		@node = Audrey::Node::Hash.new(db, 'fclass'=>self.class, 'pk'=>uuid)
+		self.class.new_auto_fields self
+	end
+	#
+	# within_initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# has_checks_search
+	#
+	def self.has_checks_search
+		fields.each do |field_name, dfn|
+			dfn.has_checks? and return true
+		end
+		
+		return false
+	end
+	#
+	# has_checks_search
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# id_field
+	#
+	def self.id_field=(val)
+		@id_field = val
+	end
+	
+	def self.id_field()
+		if instance_variable_defined?(:@id_field)
+			return @id_field
+		else
+			return self.superclass.id_field
+		end
+	end
+	
+	self.id_field = nil
+	
+	def self.[](key)
+		# $tm.hrm
+		
+		# if this class has an id field
+		if idf = self.id_field
+			db = Audrey.explicit_or_current_db(nil)
+			q0 = db.q0
+			q0.fclass = self
+			q0.fields[idf] = key
+			return q0.first
+		
+		# else exception
+		else
+			raise 'no-id-field-defined'
+		end
+	end
+	#
+	# id_field
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# field
+	#
+	def self.field(name, opts={})
+		use_dfn = Audrey::Object::Custom::Field
+		
+		# get custom field definition class
+		if fclass = opts['fclass']
+			if Audrey::RUBY_OBJECT_TO_AUDREY[fclass]
+				fclass = Audrey::RUBY_OBJECT_TO_AUDREY[fclass]['fclass']
+			end
+			
+			if fclass.respond_to?('field_definition')
+				use_dfn = fclass.field_definition
+			end
+		end
+		
+		# create definition
+		dfn = use_dfn.new(name)
+		own_fields[dfn.name] = dfn
+		
+		# field rules
+		if block_given?
+			yield dfn
+		end
+		
+		# add to class
+		dfn.add_to_class self
+	end
+	#
+	# field
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Object::Custom
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Object::Custom::Field
+#
+class Audrey::Object::Custom::Field
+	attr_accessor :name
+	attr_accessor :read
+	attr_accessor :write
+	attr_accessor :clss
+	attr_accessor :auto
+	attr_accessor :publish
+	attr_accessor :graph
+	attr_accessor :required
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(p_name)
+		@name = p_name
+		@read = true
+		@write = true
+		@clss = nil
+		@auto = false
+		@publish = false
+		@graph = false
+		
+		# normalize name
+		@name = @name.strip
+		@name = @name.gsub(/\s+/mu, ' ')
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# add_to_class
+	#
+	def add_to_class(tgt)
+		# $tm.hrm
+		
+		# Ruby doesn't like it if we use an @ variable in the method definition
+		# of another class.
+		nme = @name.dup
+		
+		# read
+		if @read
+			tgt.define_method(nme) do
+				return @node[nme]
+			end
+		end
+		
+		# write
+		if @write
+			# reference self inside the method for assigning the instance
+			# variable
+			me = self
+			
+			# definew method
+			tgt.define_method("#{nme}=") do |val|
+				val = me.normalize(val)
+				return @node[nme] = val
+			end
+		end
+	end
+	#
+	# add_to_class
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# auto_add
+	#
+	def auto_add(object)
+		# early exit
+		@auto or return
+		
+		# get audrey node
+		node = object.audrey
+		
+		# init
+		new_val = nil
+		
+		# add to node
+		if Audrey::Object::Custom.descendant?(@auto)
+			new_val = @auto.new('accessor'=>node.db)
+		elsif @auto.is_a?(Proc)
+			new_val = @auto.call(object)
+		end
+		
+		# set new value
+		node[@name] = new_val
+	end
+	#
+	# auto_add
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# normalize
+	#
+	def normalize(val)
+		return val
+	end
+	#
+	# normalize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# has_checks?
+	#
+	def has_checks?
+		return false
+	end
+	#
+	# has_checks?
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# base_checks
+	#
+	def base_checks(*opts)
+	end
+	#
+	# base_checks
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Object::Custom::Field
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Object::Custom::Graph
+#
+class Audrey::Object::Custom::Graph < Audrey::Object::Custom
+end
+#
+# Audrey::Object::Custom::Graph
+#===============================================================================
+
+
+
+#===============================================================================
+# Audrey::Object::Custom::Graph::Directed
+#
+class Audrey::Object::Custom::Graph::Directed < Audrey::Object::Custom::Graph
+end
+#
+# Audrey::Object::Custom::Graph::Directed
+#===============================================================================
+
+
+
+#===============================================================================
+# Audrey::Object::Custom::Graph::Undirected
+#
+class Audrey::Object::Custom::Graph::Undirected < Audrey::Object::Custom::Graph
+	self.fco = true
+	self.isolate = true
+	field 'a'
+	field 'b'
+	
+	#---------------------------------------------------------------------------
+	# records
+	#
+	def records(*recs)
+		# $tm.hrm
+		
+		# sort by pk
+		recs.sort! do |x, y|
+			x.audrey.pk <=> y.audrey.pk
+		end
+		
+		# store
+		self.a = recs[0]
+		self.b = recs[1]
+	end
+	#
+	# records
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Object::Custom::Graph::Undirected
+#===============================================================================
+
+
+
+#===============================================================================
+# Audrey::Transaction
+#
+class Audrey::Transaction
+	def exit()
+		e = Audrey::Exception::TransactionExit.new(self)
+		raise e
+	end
+end
+#
+# Audrey::Transaction
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Exception
+#
+class Audrey::Exception < StandardError
+end
+#
+# Audrey::Exception
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Exception::TransactionExit
+#
+class Audrey::Exception::TransactionExit < Audrey::Exception
+	attr_reader :tr
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(p_tr)
+		@tr = p_tr
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Exception::TransactionExit
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Exception::DatabaseExit
+#
+class Audrey::Exception::DatabaseExit < Audrey::Exception
+	attr_reader :db
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(p_db)
+		@db = p_db
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Exception::DatabaseExit
+#===============================================================================
+
+
+#===============================================================================
+# read/write permission
+#
+class Audrey::Exception::Permission < Audrey::Exception
+end
+
+class Audrey::Exception::Permission::Read < Audrey::Exception::Permission
+end
+
+class Audrey::Exception::Permission::Write < Audrey::Exception::Permission
+end
+#
+# read/write permission
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Query
+# abstract class
+#
+class Audrey::Query
+end
+#
+# Audrey::Query
+#===============================================================================
+
+
+#===============================================================================
+# Audrey::Object::Scalar::String::Field
+#
+class Audrey::Object::Scalar::String::Field < Audrey::Object::Custom::Field
+	attr_accessor :collapse
+	attr_accessor :downcase
+	attr_accessor :upcase
+	attr_accessor :min_length
+	attr_accessor :max_length
+	attr_accessor :hascontent
+	attr_reader :fclass
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(*opts)
+		super(*opts)
+		@fclass = String
+		
+		# normalize
+		@collapse = false
+		@downcase = false
+		@upcase = false
+		
+		# checks
+		@min_length = nil
+		@max_length = nil
+		@hascontent = false
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# normalize
+	#
+	def normalize(val)
+		# early exit
+		if not val.is_a?(String)
+			return
+		end
+		
+		# collapse
+		if @collapse
+			val.strip!
+			val.gsub!(/[^[:graph:]]+/mu, ' ')
+		end
+		
+		# downcase, upcase
+		if @downcase
+			val.downcase!
+		elsif @upcase
+			val.upcase!
+		end
+		
+		# return
+		return val
+	end
+	#
+	# normalize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# has_checks?
+	#
+	def has_checks?
+		@min_length and return true
+		@max_length and return true
+		@hascontent and return true
+	end
+	#
+	# has_checks?
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# base_checks
+	#
+	def base_checks(xeme, fieldname, val)
+		# $tm.hrm
+		
+		# min_length
+		if @min_length
+			if val.length < @min_length
+				xeme.error('min-length') do |msg|
+					msg['val'] = val
+					msg['min-length'] = @min_length
+				end
+			end
+		end
+		
+		# max_length
+		if @max_length
+			if val.length > @max_length
+				xeme.error('max-length') do |msg|
+					msg['val'] = val
+					msg['max-length'] = @max_length
+				end
+			end
+		end
+		
+		# hascontent
+		if @hascontent
+			if not val.match(/\S/mu)
+				xeme.error('hascontent') do |msg|
+					msg['val'] = val
+				end
+			end
+		end
+	end
+	#
+	# base_checks
+	#---------------------------------------------------------------------------
+end
+#
+# Audrey::Object::Scalar::String::Field
+#===============================================================================
+
+
+#===============================================================================
+# build fclasses for collections
+# This code needs to go at the bottom of this file because the classes being
+# referenced aren't defined until after the COLLECTIONS hash is used.
+#
+class Audrey
+	#---------------------------------------------------------------------------
+	# RUBY_OBJECT_TO_AUDREY
+	#
+	RUBY_OBJECT_TO_AUDREY = {}
+	RUBY_OBJECT_TO_AUDREY[String]      =  { 'fclass'=>Audrey::Object::Scalar::String}
+	RUBY_OBJECT_TO_AUDREY[Integer]     =  { 'fclass'=>Audrey::Object::Scalar::Number}
+	RUBY_OBJECT_TO_AUDREY[Float]       =  RUBY_OBJECT_TO_AUDREY[Integer]
+	RUBY_OBJECT_TO_AUDREY[TrueClass]   =  { 'fclass'=>Audrey::Object::Scalar::Number}
+	RUBY_OBJECT_TO_AUDREY[FalseClass]  =  RUBY_OBJECT_TO_AUDREY[TrueClass]
+	RUBY_OBJECT_TO_AUDREY[NilClass]    =  { 'fclass'=>Audrey::Object::Scalar::Null}
+
+	RUBY_OBJECT_TO_AUDREY[Hash]        =  {'fclass'=>Audrey::Object::Hash, 'nclass'=>Audrey::Node::Hash}
+	RUBY_OBJECT_TO_AUDREY[Array]       =  {'fclass'=>Audrey::Object::Array, 'nclass'=>Audrey::Node::Array}
+	RUBY_OBJECT_TO_AUDREY.freeze
+	#
+	# RUBY_OBJECT_TO_AUDREY
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# AUDREY_SCALAR_TO_RUBY
+	#
+	AUDREY_SCALAR_TO_RUBY = {}
+	AUDREY_SCALAR_TO_RUBY[Audrey::Object::Scalar::String.to_s]   =  proc {|obj| obj}
+	AUDREY_SCALAR_TO_RUBY[Audrey::Object::Scalar::Number.to_s]   =  proc {|obj| obj.to_f}
+	AUDREY_SCALAR_TO_RUBY[Audrey::Object::Scalar::Boolean.to_s]  =  proc {|obj| obj == 0 ? false : true}
+	AUDREY_SCALAR_TO_RUBY[Audrey::Object::Scalar::Null.to_s]     =  proc {|obj| nil}
+	AUDREY_SCALAR_TO_RUBY.freeze
+	#
+	# AUDREY_SCALAR_TO_RUBY
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# AUDREY_COLLECTION_TO_RUBY
+	#
+	AUDREY_COLLECTION_TO_RUBY = {}
+	AUDREY_COLLECTION_TO_RUBY[Audrey::Object::Hash.to_s] = {'nclass'=>Audrey::Node::Hash}
+	AUDREY_COLLECTION_TO_RUBY[Audrey::Object::Array.to_s] = {'nclass'=>Audrey::Node::Array}
+	AUDREY_COLLECTION_TO_RUBY.freeze
+	#
+	# AUDREY_COLLECTION_TO_RUBY
+	#---------------------------------------------------------------------------
+end
+#
+# build fclasses for collections
+#===============================================================================