tripper 0.0.3d

data/lib/tripper/ORMDB/orm_db_classes.rb

@@ -0,0 +1,423 @@
+require 'active_record'
+require 'logger'
+require 'yaml'
+
+module Tripper
+	module ORMDB
+		ORMDBCONFIG = YAML::load(File.open(File.dirname(__FILE__)+'/config/database.yml'))['development']
+		ActiveRecord::Base.logger = Logger.new(STDERR)
+
+		module ObjectType
+			def contains_identifying_constraint?
+				! identifying_constraint_objects.empty?
+			end
+
+			# Will return a list of lists. Each of these list represent an external uniqueness constraint.
+			# e.g. [[NoLot1, NoLot2, NoLot3], [NoLot 8, NoLot9]]
+			def exernal_uniqueness_constraint_object_types
+				uniqueness_constraints_from_predicates.inject(OrmArray.new) do |res, constraint|
+					if constraint.object_roles.size > 1
+						pred_objects = constraint.object_roles.inject(OrmArray.new) do |res_con, objr|
+							res_con << objr.orm_object #unless  objr.orm_object == self
+							res_con
+						end
+						#when self is in the array, we are part of someone else's external uniqueness.
+						res	<< pred_objects unless pred_objects.empty? || pred_objects.include?(self)
+					end
+					res
+				end
+			end
+
+			def object_types_identified_by_me
+				# uniqueness_constraints_from_predicates.inject(OrmArray.new) do |res, constraint|
+				# 	if constraint.object_roles.size == 1 && constraint.object_roles.first.orm_object != self
+				# 		res << constraint.object_roles.first.orm_object
+				# 	end
+				# 	res
+				# end
+				object_role_constraints.where('object_role_constraints.constraint_type' => 'Tripper::ORMDB::UniquenessConstraint').inject(OrmArray.new) do |res, obj_role_const|
+					if obj_role_const.constraint.object_roles.count == 1
+						obj_role_const.object_role.predicate.object_roles.each do |objr|
+							unless objr.orm_object == self
+								res << objr.orm_object unless objr.orm_object.name < self.name
+							end
+						end
+					end
+					res
+				end
+			end
+
+			def has_many_object_types
+				object_role_ids= object_role_constraints.select('object_role_id').where('object_role_constraints.constraint_type' => 'Tripper::ORMDB::UniquenessConstraint').map(&:object_role_id)
+				result = []
+				ors = object_role_ids.empty? ? object_roles : object_roles.where("id NOT IN (?)", object_role_ids) #sqlite does not support NOT EXISTS
+				ors.each do |objrole|
+					predicate = objrole.predicate
+					other_or = predicate.object_roles - [objrole]
+					result.concat other_or.map(&:orm_object)
+				end
+				result
+			end
+
+			def identifying_constraint_objects
+				object_role_constraints.where('object_role_constraints.constraint_type' => 'Tripper::ORMDB::UniquenessConstraint').inject(OrmArray.new) do |res, obj_role_const|
+					if obj_role_const.constraint.object_roles.count == 1
+						obj_role_const.object_role.predicate.object_roles.each do |objr|
+							unless objr.orm_object == self
+								res << objr.orm_object if objr.orm_object.name < self.name
+							end
+						end
+					end
+					res
+				end
+			end
+
+			def mandatory_constraint_objects
+				object_role_constraints.where('object_role_constraints.constraint_type' => 'Tripper::ORMDB::MandatoryConstraint').inject(OrmArray.new) do |res, obj_role_const|
+					if obj_role_const.constraint.object_roles.count == 1
+						obj_role_const.object_role.predicate.object_roles.each do |objr|
+							res << objr.orm_object unless  objr.orm_object == self
+						end
+					end
+					res
+				end
+			end
+
+			def has_many
+				unique_obj_role_ids = object_role_constraints.where('object_role_constraints.constraint_type' => 'Tripper::ORMDB::UniquenessConstraint').map(&:object_role_id)
+				many_object_roles = unique_obj_role_ids.empty? ? object_roles : object_roles.where("id not in (?)",unique_obj_role_ids)
+				result = many_object_roles.inject([]) do |res, obj_role|
+				#result = object_roles.inject([]) do |res, obj_role|
+					obj_role.predicate.object_roles.where("id != ?", obj_role.id).each do |op_role|
+						#check if the other role of the predicate has a uniqueness constraint
+						res << op_role unless op_role.uniqueness_constraints.empty?
+					end
+					res
+				end
+				result.map(&:orm_object)
+			end
+
+			def has_many_many
+				unique_obj_role_ids = object_role_constraints.where('object_role_constraints.constraint_type' => 'Tripper::ORMDB::UniquenessConstraint').map(&:object_role_id)
+				many_object_roles = unique_obj_role_ids.empty? ? object_roles : object_roles.where("id not in (?)",unique_obj_role_ids)
+				result = many_object_roles.inject([]) do |res, obj_role|
+					# res.concat(obj_role.predicate.object_roles.where("id != ?", obj_role.id))
+					obj_role.predicate.object_roles.where("id != ?", obj_role.id).each do |op_role|
+						#check if the other role of the predicate has a uniqueness constraint
+						res << op_role if op_role.uniqueness_constraints.empty?
+					end
+					res
+				end
+				result.map(&:orm_object)
+			end
+
+			# private
+
+			def uniqueness_constraints_from_predicates
+				#UniquenessConstraint.joins(:object_roles).where('object_roles.predicate_id' => predicates).group('object_roles.predicate_id').uniq
+				UniquenessConstraint.joins(:object_roles).where('object_roles.predicate_id' => predicates).uniq
+			end
+		end
+
+		class OrmArray < Array
+			def no_lots
+				self.select do |obj|
+					obj.is_a? Tripper::ORMDB::NoLot
+				end
+			end
+			def lots
+				self.select do |obj|
+					obj.is_a? Tripper::ORMDB::Lot
+				end
+			end
+		end
+
+		class OrmSchema < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			attr_accessible :title, :creator, :version, :description, :origin, :last_visit
+			#has_many :orm_objects
+			has_many :no_lots, dependent: :destroy
+			has_many :lots, dependent: :destroy
+			has_many :subtypes, dependent: :destroy
+			has_many :no_lot_constraints, dependent: :destroy
+			has_many :references, dependent: :destroy
+			has_many :predicates, dependent: :destroy
+			has_many :object_roles, dependent: :destroy
+			has_many :object_role_constraints, dependent: :destroy
+			has_many :constraints, dependent: :destroy
+			has_many :mandatory_constraints, dependent: :destroy
+			has_many :uniqueness_constraints, dependent: :destroy
+			has_many :ring_constraints, dependent: :destroy
+			has_many :subset_constraints, dependent: :destroy
+			has_many :equality_constraints, dependent: :destroy
+			has_many :exclusion_constraints, dependent: :destroy
+			has_many :total_constraints, dependent: :destroy
+			has_many :exclusive_constraints, dependent: :destroy
+			has_many :frequency_constraints, dependent: :destroy
+			has_many :value_constraints, dependent: :destroy
+			has_many :value_constraint_values, dependent: :destroy
+			has_many :values, dependent: :destroy
+			has_many :value_ranges, dependent: :destroy
+
+			def object_types_by_name name
+				no_lots.where(:name => name) + lots.where(:name => name)
+			end
+
+			attr_protected
+		end
+
+		#class OrmObject < ActiveRecord::Base
+		#	self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+		#  attr_accessible :id, :name, :orm_schema_id
+		#	has_one :reference
+		#	has_many :object_roles
+		#	belongs_to :orm_schema
+		#end
+
+		class Lot < ActiveRecord::Base
+			include ObjectType
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+		  attr_accessible :id, :name, :numeric, :application_name
+			has_one :value_constraint, dependent: :destroy
+
+			attr_protected
+		end
+
+		class NoLot < ActiveRecord::Base
+			include ObjectType
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+		  attr_accessible :id, :name, :independant, :application_name
+			has_one :reference
+			has_many :object_roles, :as => :orm_object, dependent: :destroy
+			has_many :predicates, :through => :object_roles
+			belongs_to :orm_schema
+
+			has_many :object_role_constraints, :through => :object_roles
+
+			has_many :children, :through => :subtypes_by_parent_id
+			has_many :subtypes_by_parent_id, :class_name => "Subtype", :foreign_key => :parent_id
+
+			has_many :parents, :through => :subtypes_by_child_id
+			has_many :subtypes_by_child_id, :class_name => "Subtype", :foreign_key => :child_id
+
+			has_many :no_lot_constraints, dependent: :destroy
+			# these are helper methods to ensure that the role will be automatically set.
+			has_many :no_lot_constraints_role_supertype, :class_name => "Tripper::ORMDB::NoLotConstraint", :conditions => {:role => "supertype"}
+			has_many :no_lot_constraints_role_subtype, :class_name => "Tripper::ORMDB::NoLotConstraint", :conditions => {:role => "subtype"}
+
+			has_many :total_constraints_as_supertype, :through => :no_lot_constraints_role_supertype, :source => :constraint, :source_type => "Tripper::ORMDB::TotalConstraint"
+			has_many :total_constraints_as_subtype, :through => :no_lot_constraints_role_subtype, :source => :constraint, :source_type => "Tripper::ORMDB::TotalConstraint"
+			has_many :exclusive_constraints_as_supertype, :through => :no_lot_constraints_role_supertype, :source => :constraint, :source_type => "Tripper::ORMDB::ExclusiveConstraint"
+			has_many :exclusive_constraints_as_subtype, :through => :no_lot_constraints_role_subtype, :source => :constraint, :source_type => "Tripper::ORMDB::ExclusiveConstraint"
+
+			attr_protected
+		end
+
+		class Subtype < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			belongs_to :parent, :class_name => "NoLot", :foreign_key => :parent_id
+			belongs_to :child, :class_name => "NoLot", :foreign_key => :child_id
+			belongs_to :orm_schema
+			attr_protected
+		end
+
+		class NoLotConstraint < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			attr_accessible :role, :no_lot_id, :orm_schema_id
+			belongs_to :no_lot
+			belongs_to :constraint, :polymorphic => true, :dependent => :destroy
+			belongs_to :orm_schema
+			attr_protected
+		end
+
+		class Reference < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			attr_accessible :id, :name, :numeric, :orm_schema_id
+			belongs_to :orm_object, :polymorphic => true
+			belongs_to :orm_schema
+			attr_protected
+		end
+
+		class Predicate < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			attr_accessible :derived, :derived_stored, :predicate_object, :predicate_name, :orm_schema_id, :identifier
+			has_many :object_roles, dependent: :destroy
+			has_many :object_role_constraints, :through => :object_roles
+			belongs_to :orm_schema
+			has_many :orm_objects, :through => :object_roles
+			has_many :nolots_obj_roles, as: :orm_object, class_name: "Tripper::ORMDB::ObjectRole", conditions: {orm_object_type: 'Tripper::ORMDB::NoLot'}
+			has_many :nolots, through: :object_roles, source: :orm_object, source_type: "Tripper::ORMDB::NoLot", class_name: "Tripper::ORMDB::NoLot"
+			has_many :lots, through: :object_roles, source: :orm_object, source_type: "Tripper::ORMDB::Lot", class_name: "Tripper::ORMDB::Lot"
+			#validates_uniqueness_of :identifier, :scope => :orm_schema_id
+			attr_protected
+
+			def self.verbalized_lexons
+				res = []
+				all.each do |pred|
+					verbelization = ""
+					pred.object_roles.each do |obj_role|
+						verbelization += obj_role.orm_object.name
+						#verbelization += obj_role.role
+					end
+					res << verbelization
+				end
+				return res
+			end
+		end
+
+		class ObjectRole < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			attr_accessible :role, :identifier, :orm_object_id, :orm_object_type, :orm_schema_id
+			belongs_to :predicate
+			belongs_to :orm_object, :polymorphic => true
+			belongs_to :orm_schema
+			has_many :object_role_constraints, dependent: :destroy
+			# these are helper methods to ensure that the role will be automatically set.
+			has_many :object_role_constraints_role_parent, :class_name => "Tripper::ORMDB::ObjectRoleConstraint", :conditions => {:role => "parent"}
+			has_many :object_role_constraints_role_child, :class_name => "Tripper::ORMDB::ObjectRoleConstraint", :conditions => {:role => "child"}
+			has_many :object_role_constraints_role_first, :class_name => "Tripper::ORMDB::ObjectRoleConstraint", :conditions => {:role => "first"}
+			has_many :object_role_constraints_role_second, :class_name => "Tripper::ORMDB::ObjectRoleConstraint", :conditions => {:role => "second"}
+
+			has_many :mandatory_constraints, :through => :object_role_constraints, :source => :constraint, :source_type => "Tripper::ORMDB::MandatoryConstraint"
+			has_many :uniqueness_constraints, :through => :object_role_constraints, :source => :constraint, :source_type => "Tripper::ORMDB::UniquenessConstraint"
+			has_many :subset_constraints_as_parent, :through => :object_role_constraints_role_parent, :source => :constraint, :source_type => "Tripper::ORMDB::SubsetConstraint"
+			has_many :subset_constraints_as_child, :through => :object_role_constraints_role_child, :source => :constraint, :source_type => "Tripper::ORMDB::SubsetConstraint"
+			has_many :equality_constraints_as_first, :through => :object_role_constraints_role_first, :source => :constraint, :source_type => "Tripper::ORMDB::EqualityConstraint"
+			has_many :equality_constraints_as_second, :through => :object_role_constraints_role_second, :source => :constraint, :source_type => "Tripper::ORMDB::EqualityConstraint"
+			has_many :exclusion_constraints_as_first, :through => :object_role_constraints_role_first, :source => :constraint, :source_type => "Tripper::ORMDB::ExclusionConstraint"
+			has_many :exclusion_constraints_as_second, :through => :object_role_constraints_role_second, :source => :constraint, :source_type => "Tripper::ORMDB::ExclusionConstraint"
+			has_one :frequency_constraint
+
+			has_one :ring_constraint, :through => :object_role_constraint_single, :source => :constraint, :source_type => "Tripper::ORMDB::RingConstraint"
+			has_one :object_role_constraint_single, :class_name => "Tripper::ORMDB::ObjectRoleConstraint"
+			attr_protected
+		end
+
+		class ObjectRoleConstraint < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			attr_accessible :constraint_id, :constraint_type, :orm_schema_id, :role #to denotate things such as: parent, child, first etc..
+			belongs_to :object_role
+			belongs_to :constraint, :polymorphic => true
+			belongs_to :orm_schema
+			attr_protected
+		end
+
+		class Constraint < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			belongs_to :orm_schema
+			attr_protected
+		end
+
+		class MandatoryConstraint < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			attr_accessible :type, :orm_schema_id, :identifier
+			has_many :object_roles, :through => :object_role_constraints
+			has_many :object_role_constraints, :as => :constraint
+			attr_protected
+		end
+
+		class UniquenessConstraint < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			has_many :object_roles, :through => :object_role_constraints
+			has_many :object_role_constraints, :as => :constraint
+			attr_protected
+		end
+
+		class RingConstraint < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			attr_accessible :kind, :orm_schema_id
+			belongs_to :orm_schema
+			validates :kind, :inclusion => { :in => %w(antisymmetric asymmetric acyclic irreflexive intransitive symmetric acyclic+intransitive asymmetric+intransitive intransitive+symmetric irreflexive+symmetric),
+				:message => "%{value} is not a valid ring contraint type"}
+			has_many :object_roles, :through => :object_role_constraints
+			has_many :object_role_constraints, :as => :constraint, :conditions => {:constraint_type => "Tripper::ORMDB::RingConstraint"}
+			attr_protected
+		end
+
+		class SubsetConstraint < Constraint
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			has_many :parents, :through => :object_role_constraints_role_parent, :source => :object_role
+			has_many :children, :through => :object_role_constraints_role_child, :source => :object_role
+			has_many :object_role_constraints_role_parent, :class_name => "Tripper::ORMDB::ObjectRoleConstraint", :as => :constraint , :conditions => {:role => "parent", :constraint_type => "Tripper::ORMDB::SubsetConstraint"}
+			has_many :object_role_constraints_role_child, :class_name => "Tripper::ORMDB::ObjectRoleConstraint", :as => :constraint , :conditions => {:role => "child", :constraint_type => "Tripper::ORMDB::SubsetConstraint"}
+			attr_protected
+		end
+
+		class EqualityConstraint < Constraint
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			has_many :first, :through => :object_role_constraints_role_first, :source => :object_role
+			has_many :second, :through => :object_role_constraints_role_second, :source => :object_role
+			has_many :object_role_constraints_role_first, :class_name => "Tripper::ORMDB::ObjectRoleConstraint", :as => :constraint, :conditions => {:role => "first", :constraint_type => "Tripper::ORMDB::EqualityConstraint"}
+			has_many :object_role_constraints_role_second, :class_name => "Tripper::ORMDB::ObjectRoleConstraint", :as => :constraint, :conditions => {:role => "second", :constraint_type => "Tripper::ORMDB::EqualityConstraint"}
+			attr_protected
+		end
+
+		class ExclusionConstraint < Constraint
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			has_many :first, :through => :object_role_constraints_role_first, :source => :object_role
+			has_many :second, :through => :object_role_constraints_role_second, :source => :object_role
+			has_many :object_role_constraints_role_first, :class_name => "Tripper::ORMDB::ObjectRoleConstraint", :as => :constraint, :conditions => {:role => "first", :constraint_type => "Tripper::ORMDB::ExclusionConstraint"}
+			has_many :object_role_constraints_role_second, :class_name => "Tripper::ORMDB::ObjectRoleConstraint", :as => :constraint, :conditions => {:role => "second", :constraint_type => "Tripper::ORMDB::ExclusionConstraint"}
+			attr_protected
+		end
+
+		class TotalConstraint < Constraint
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			has_one :supertype, :through => :no_lot_constraints_role_supertype, :source => :no_lot
+			has_many :subtypes, :through => :no_lot_constraints_role_subtype, :source => :no_lot
+			has_one :no_lot_constraints_role_supertype, :class_name => "Tripper::ORMDB::NoLotConstraint", :as => :constraint, :conditions => {:role => "supertype", :constraint_type => "Tripper::ORMDB::TotalConstraint"}
+			has_many :no_lot_constraints_role_subtype, :class_name => "Tripper::ORMDB::NoLotConstraint", :as => :constraint, :conditions => {:role => "subtype", :constraint_type => "Tripper::ORMDB::TotalConstraint"}
+			attr_protected
+		end
+
+		class ExclusiveConstraint < Constraint
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			has_one :supertype, :through => :no_lot_constraints_role_supertype, :source => :no_lot
+			has_many :subtypes, :through => :no_lot_constraints_role_subtype, :source => :no_lot
+			has_one :no_lot_constraints_role_supertype, :class_name => "Tripper::ORMDB::NoLotConstraint", :as => :constraint, :conditions => {:role => "supertype", :constraint_type => "Tripper::ORMDB::ExclusiveConstraint"}
+			has_many :no_lot_constraints_role_subtype, :class_name => "Tripper::ORMDB::NoLotConstraint", :as => :constraint, :conditions => {:role => "subtype", :constraint_type => "Tripper::ORMDB::ExclusiveConstraint"}
+			attr_protected
+		end
+
+		class FrequencyConstraint < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			belongs_to :orm_schema
+			attr_accessible :minimum, :maximum
+			belongs_to :object_role
+			attr_protected
+		end
+
+		class ValueConstraint < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			belongs_to :orm_schema
+			belongs_to :lot
+			has_many :values, :through => :value_constraint_values,:source => :valueish, :source_type => "Value"
+			has_many :value_ranges, :through => :value_constraint_values, :source => :valueish, :source_type => "ValueRange"
+			has_many :value_constraint_values
+			attr_protected
+		end
+
+		class ValueConstraintValue < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			belongs_to :orm_schema
+			belongs_to :value_constraint
+			belongs_to :valueish, :polymorphic => true, :dependent => :destroy
+			attr_protected
+		end
+
+		class Value < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			belongs_to :orm_schema
+			attr_accessible :data_type, :value
+			attr_protected
+		end
+
+		class ValueRange < ActiveRecord::Base
+			self.establish_connection(Tripper::ORMDB::ORMDBCONFIG)
+			belongs_to :orm_schema
+			belongs_to :start_value, :class_name => "Value"
+			belongs_to :end_value, :class_name => "Value"
+			attr_protected
+		end
+	end
+end

data/lib/tripper/ORMDB/populate.rb

@@ -0,0 +1,4 @@
+@q = Tripper::ORMDB::NoLot.find 1
+@w = Tripper::ORMDB::NoLot.find 2
+@e = Tripper::ORMDB::NoLot.find 3
+@r = Tripper::ORMDB::NoLot.find 4

data/lib/tripper/ORMDB/rakefile.rb

@@ -0,0 +1,88 @@
+require 'yaml'
+require 'logger'
+require 'active_record'
+
+namespace :db do
+  def create_database config
+    options = {:charset => 'utf8', :collation => 'utf8_unicode_ci'}
+
+    create_db = lambda do |config|
+      #ActiveRecord::Base.establish_connection config.merge('database' => nil)
+      ActiveRecord::Base.connection.create_database config['database']
+      ActiveRecord::Base.establish_connection config
+    end
+    create_db.call config
+    
+  end
+ 
+  task :environment do
+    DATABASE_ENV = ENV['DATABASE_ENV'] || 'development'
+    MIGRATIONS_DIR = ENV['MIGRATIONS_DIR'] || 'db/migrations'
+  end
+
+  task :configuration => :environment do
+    @config = YAML.load_file('config/database.yml')[DATABASE_ENV]
+    puts @config
+  end
+
+  task :configure_connection => :configuration do
+    ActiveRecord::Base.establish_connection @config
+    ActiveRecord::Base.logger = Logger.new STDOUT if @config['logger']
+  end
+
+  desc 'Create the database from config/database.yml for the current DATABASE_ENV'
+  task :create => :configure_connection do
+    create_database @config
+  end
+
+  desc 'Drops the database for the current DATABASE_ENV'
+  task :drop => :configure_connection do
+    ActiveRecord::Base.connection.drop_database @config['database']
+  end
+
+  desc 'Migrate the database (options: VERSION=x, VERBOSE=false).'
+  task :migrate => :configure_connection do
+    ActiveRecord::Migration.verbose = true
+    ActiveRecord::Migrator.migrate MIGRATIONS_DIR, ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+  end
+
+  desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n).'
+  task :rollback => :configure_connection do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    ActiveRecord::Migrator.rollback MIGRATIONS_DIR, step
+  end
+  
+  desc "drops all the tables"
+  task :drop => :configure_connection do
+    ENV['VERSION'] = "0" 
+    Rake::Task['db:migrate'].invoke
+  end
+  
+  desc "drops all the tables and creates them again"
+  task :reset => :configure_connection do
+    ENV['STEP'] = "#{ActiveRecord::Migrator.current_version}" 
+    Rake::Task['db:rollback'].invoke
+    Rake::Task['db:migrate'].invoke
+  end
+
+  desc "Retrieves the current schema version number"
+  task :version => :configure_connection do
+    puts "Current version: #{ActiveRecord::Migrator.current_version}"
+  end
+
+	namespace :schema do
+    desc "Create a db/ar_schema.rb file that can be portably used against any DB supported by AR"
+    task :dump => :configure_connection do
+      require 'active_record/schema_dumper'
+      File.open(ENV['SCHEMA'] || "db/schema.rb", "w") do |file|
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+      end
+    end
+
+    desc "Load a ar_schema.rb file into the database"
+    task :load => :configure_connection do
+      file = ENV['SCHEMA'] || "db/schema.rb"
+      load(file)
+    end
+  end
+end