sequel-inline_schema 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6037f75d98e75ad634497e1000fdf8cac67cd388a366dc01d73e7a4f00897f15
+  data.tar.gz: 8c6d0fe5f0146d296e85a3e074cf28394e803104c93253e1f200c04274da3ba5
+SHA512:
+  metadata.gz: d5bf204ce162b8dae4e8780202f5031c2c7a48bf2f3f3eaa18552e2a346c9096a6c046a2e6c5232eb3f3f175314e332fa95d51c11a29711f848135d7f7701dd9
+  data.tar.gz: 2eed48961ec313876ecc72aa512d53f7cdca5ab0792fe93309c01d359d8dbe72489f02ce91e5250769580b1f00a8cae25f449219b77a5b8d8c207332605fc551

checksums.yaml.gz.sig

@@ -0,0 +1 @@
+����&��ƒ��sȻc�9�&�gDX��n��%���i��,�,����.|���>E�Cs��*���&36h'���J����S5��|4j

data.tar.gz.sig

@@ -0,0 +1,3 @@
+���Q.���e��Đ�xzEm��E�aQ��M'�5"�-`���࿝��;w���C��?�[b��R�Z���m��v��`�2 �2�.�I��4�ң�~h�B:��;EL�C�=�P�:j�������T��j}�ɵuz�{�`p�dO��?�����Y�X�&!YQ
+����v�a
��Lk��y:\D�e�'�	O���لR
+�n99*�ԃ�ĽU�k�q�m��]5���W�u���ZzT.�g�S�t��J=���Y��?��a�{��Н(���O�M6�-{�;).�=�"�'ϳ�/c+�L����T�z�Ȋ�٘
���U?��K��	ݶ����q+�K7�VX,7C���?HM��a`K&Wv�D�

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+README.md
+ChangeLog.md
+
+LICENSE.txt

data/.editorconfig

@@ -0,0 +1,14 @@
+# http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+# Tab indentation
+[**.*]
+indent_style = tab
+

data/.rdoc_options

@@ -0,0 +1,16 @@
+--- !ruby/object:RDoc::Options
+encoding: UTF-8
+static_path: []
+rdoc_include:
+  - .
+charset: UTF-8
+exclude: 
+hyperlink_all: false
+line_numbers: false
+main_page: README.md
+markup: markdown
+show_hash: false
+tab_width: 8
+title: sequel-plugins-inline_schema Documentation
+visibility: :protected
+webcvs:

data/.simplecov

@@ -0,0 +1,9 @@
+# Simplecov config
+
+SimpleCov.start do
+	add_filter 'spec'
+	add_filter 'integration'
+	add_group "Needing tests" do |file|
+		file.covered_percent < 90
+	end
+end

data/ChangeLog

@@ -0,0 +1,48 @@
+2018-07-10  Michael Granger  <ged@FaerieMUD.org>
+
+	* .hgtags:
+	Added tag v0.0.1 for changeset 5f6554f4bd40
+	[8fe6f86ec7c7] [tip]
+
+	* .hgsigs:
+	Added signature for changeset f94a7b19d4de
+	[5f6554f4bd40] [v0.0.1]
+
+	* .hgignore, History.md, README.md, Rakefile, sequel-
+	inline_schema.gemspec:
+	Prep for first release.
+	[f94a7b19d4de]
+
+2017-09-28  Michael Granger  <ged@FaerieMUD.org>
+
+	* lib/sequel/plugins/inline_migrations.rb,
+	lib/sequel/plugins/inline_schema.rb:
+	Fix documentation formatting, add some more details about migrations
+	[f7de01d27012] [github/master]
+
+2017-09-27  Michael Granger  <ged@FaerieMUD.org>
+
+	* README.md:
+	Fix README links.
+	[81085384e8eb]
+
+	* lib/sequel/plugins/inline_schema.rb,
+	spec/sequel/plugins/inline_schema_spec.rb:
+	More documentation updates, add drop_table hooks.
+	[dc2231fc945a]
+
+	* .hgignore, README.md, lib/sequel/plugins/inline_migrations.rb,
+	lib/sequel/plugins/inline_schema.rb:
+	Documentation fixes/additions.
+	[4783fffe2ab9]
+
+	* .document, .editorconfig, .gems, .hgignore, .pryrc, .rdoc_options,
+	.ruby-gemset, .ruby-version, .simplecov, Gemfile, History.md,
+	LICENSE.txt, Manifest.txt, README.md, Rakefile, certs/ged.pem,
+	lib/sequel/inline_schema.rb,
+	lib/sequel/plugins/inline_migrations.rb,
+	lib/sequel/plugins/inline_schema.rb, sequel-inline_schema.gemspec,
+	spec/sequel/plugins/inline_migrations_spec.rb,
+	spec/sequel/plugins/inline_schema_spec.rb, spec/spec_helper.rb:
+	Initial implementation
+	[fe2f291518ce]

data/History.md

@@ -0,0 +1,4 @@
+## v0.0.1 [2018-07-19] Michael Granger <ged@FaerieMUD.org>
+
+Initial release.
+

data/LICENSE.txt

@@ -0,0 +1,26 @@
+This plugin uses code from the Sequel project under the MIT License:
+
+Copyright (c) 2007-2008 Sharon Rosner
+Copyright (c) 2008-2017 Jeremy Evans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+The rest is licensed under the same terms, but:
+
+Copyright (c) 2017, Michael Granger
+

data/Manifest.txt

@@ -0,0 +1,16 @@
+.document
+.editorconfig
+.rdoc_options
+.simplecov
+ChangeLog
+History.md
+LICENSE.txt
+Manifest.txt
+README.md
+Rakefile
+lib/sequel/inline_schema.rb
+lib/sequel/plugins/inline_migrations.rb
+lib/sequel/plugins/inline_schema.rb
+spec/sequel/plugins/inline_migrations_spec.rb
+spec/sequel/plugins/inline_schema_spec.rb
+spec/spec_helper.rb

data/README.md

@@ -0,0 +1,85 @@
+# sequel-inline_schema
+
+home
+: http://bitbucket.org/ged/sequel-inlineschema
+
+github
+: https://github.com/ged/sequel-inlineschema
+
+docs
+: http://deveiate.org/code/sequel-inline_schema
+
+
+## Description
+
+This is a set of plugins for Sequel for declaring a model's table schema and
+any migrations in the class itself (similar to the legacy `schema` plugin).
+
+It has only really been tested with PostgreSQL, but patches that make it more generic are welcomed.
+
+The two plugins are:
+
+* Sequel::Plugins::InlineSchema
+* Sequel::Plugins::InlineMigrations
+
+Examples and usage documentation are included there.
+
+
+## Prerequisites
+
+* Ruby >= 2.4
+* Sequel >= 5.0
+
+
+## Installation
+
+    $ gem install sequel-inline_schema
+
+
+## Contributing
+
+You can check out the current development source with Mercurial via its
+[project page][bitbucket]. Or if you prefer Git, via [its Github
+mirror][github].
+
+After checking out the source, run:
+
+    $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the API documentation.
+
+
+## License
+
+This plugin uses code from the Sequel project under the MIT License:
+
+Copyright (c) 2007-2008 Sharon Rosner
+Copyright (c) 2008-2017 Jeremy Evans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+The rest is licensed under the same terms, but:
+
+Copyright (c) 2017-2018, Michael Granger
+
+
+
+[bitbucket]: http://bitbucket.org/ged/sequel-inlineschema
+[github]: https://github.com/ged/sequel-inlineschema
+

data/Rakefile

@@ -0,0 +1,99 @@
+#!/usr/bin/env rake
+
+begin
+	require 'hoe'
+rescue LoadError
+	abort "This Rakefile requires hoe (gem install hoe)"
+end
+
+GEMSPEC = 'sequel-inline_schema.gemspec'
+
+
+Hoe.plugin :mercurial
+Hoe.plugin :signing
+Hoe.plugin :deveiate
+
+Hoe.plugins.delete :rubyforge
+
+hoespec = Hoe.spec 'sequel-inline_schema' do |spec|
+
+	spec.readme_file = 'README.md'
+	spec.history_file = 'History.md'
+	spec.urls = {
+		home:   'http://bitbucket.org/ged/sequel-inline_schema',
+		code:   'http://bitbucket.org/ged/sequel-inline_schema',
+		docs:   'http://deveiate.org/code/sequel-inline_schema',
+		github: 'http://github.com/ged/sequel-inline_schema',
+	}
+
+	spec.extra_rdoc_files = FileList[ '*.rdoc', '*.md' ]
+	spec.license 'BSD-3-Clause'
+
+	spec.developer 'Michael Granger', 'ged@FaerieMUD.org'
+
+	spec.dependency 'sequel', '~> 5.0'
+
+	spec.dependency 'hoe-deveiate',            '~> 0.9', :developer
+	spec.dependency 'simplecov',               '~> 0.13', :developer
+	spec.dependency 'rdoc-generator-fivefish', '~> 0.3', :developer
+
+	spec.require_ruby_version( '>=2.4.0' )
+	spec.hg_sign_tags = true if spec.respond_to?( :hg_sign_tags= )
+	spec.check_history_on_release = true if spec.respond_to?( :check_history_on_release= )
+
+	spec.rdoc_locations << "deveiate:/usr/local/www/public/code/#{remote_rdoc_dir}"
+end
+
+
+ENV['VERSION'] ||= hoespec.spec.version.to_s
+
+# Run the tests before checking in
+task 'hg:precheckin' => [ :check_history, :check_manifest, :gemspec, :spec ]
+
+task :test => :spec
+
+# Rebuild the ChangeLog immediately before release
+task :prerelease => 'ChangeLog'
+CLOBBER.include( 'ChangeLog' )
+
+desc "Build a coverage report"
+task :coverage do
+	ENV["COVERAGE"] = 'yes'
+	Rake::Task[:spec].invoke
+end
+CLOBBER.include( 'coverage' )
+
+
+# Use the fivefish formatter for docs generated from development checkout
+if File.directory?( '.hg' )
+	require 'rdoc/task'
+
+	Rake::Task[ 'docs' ].clear
+	RDoc::Task.new( 'docs' ) do |rdoc|
+
+		rdoc.markup = 'markdown'
+		rdoc.main = "README.md"
+		rdoc.rdoc_files.include( "*.md", "ChangeLog", "lib/**/*.rb" )
+
+		rdoc.generator = :fivefish
+		rdoc.title = 'sequel-inline_schema'
+		rdoc.rdoc_dir = 'doc'
+	end
+end
+
+task :gemspec => GEMSPEC
+file GEMSPEC => [ __FILE__, 'Manifest.txt' ]
+task GEMSPEC do |task|
+	spec = $hoespec.spec
+	spec.files.delete( '.gemtest' )
+	spec.signing_key = nil
+	spec.cert_chain = ['certs/ged.pem']
+	spec.version = "#{spec.version.bump}.0.pre#{Time.now.strftime("%Y%m%d%H%M%S")}"
+	File.open( task.name, 'w' ) do |fh|
+		fh.write( spec.to_ruby )
+	end
+end
+CLOBBER.include( GEMSPEC.to_s )
+
+task :default => :gemspec
+

data/lib/sequel/inline_schema.rb

@@ -0,0 +1,16 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'sequel'
+require 'sequel/plugins/inline_schema'
+
+module Sequel::InlineSchema
+
+	# Package version
+	VERSION = '0.0.1'
+
+	# Version control revision
+	REVISION = %q$Revision: fe2f291518ce $
+
+end # Sequel::InlineSchema
+

data/lib/sequel/plugins/inline_migrations.rb

@@ -0,0 +1,475 @@
+#!/usr/bin/env ruby
+
+require 'sequel'
+require 'sequel/model'
+
+Sequel.extension( :migration )
+
+
+# A plugin for Sequel::Model that allows migrations for the model to be defined
+# directly in the class declaration. It uses the `inline_schema` plugin
+# internally, and will add it for you if necessary.
+#
+# ## Example
+#
+# Define a base (abstract) model class:
+#
+# ```
+# # lib/acme/model.rb
+# module Acme
+#     Model = Class.new( Sequel::Model )
+#     Model.def_Model( Acme )
+#
+#     class Model
+#         plugin :inline_schema
+#         plugin :inline_migrations
+#     end
+# end
+# ```
+#
+# Defining a model class with two migrations:
+#
+# ```
+# # lib/acme/vendor.rb
+# require 'acme/model'
+#
+# class Acme::Vendor < Acme::Model( :vendor )
+#
+#     # The schema should always be kept up-to-date. I.e., it should be
+#     # modified along with each migration to reflect the state of the table
+#     # after the migration is applied.
+#     set_schema do
+#         primary_key :id
+#         String :name
+#         String :contact
+#         timestamp :created_at, :null => false
+#         timestamp :updated_at
+#
+#         add_index :name
+#     end
+#
+#     # Similar to Sequel's TimeStampMigrator, inline migrations have a symbolic
+#     # name, which is how they're tracked in the migrations table, and how
+#     # they're ordered when they're applied. The second argument is a human-readable
+#     # description that can be used for automated change control descriptions or
+#     # other tooling.
+#     migration( '20110228_1115_add_timestamps', "Add timestamp fields" ) do
+#         change do
+#             alter_table do
+#                 add_column :created_at, :timestamp, :null => false
+#                 add_column :updated_at, :timestamp
+#             end
+#             update( :created_at => :now[] )
+#         end
+#     end
+#
+#     migration( '20110303_1751_index_name', "Add an index to the name field" ) do
+#         change do
+#             alter_table do
+#                 add_index :name
+#             end
+#         end
+#     end
+#
+# end
+# ```
+#
+# Apply pending migrations.
+#
+# ```
+# # bin/migrate
+#
+# require 'acme/model'
+# require 'acme/vendor'
+# # ...
+#
+# puts "Creating new tables, applying any pending migrations..."
+# Acme::Model.migrate
+# ```
+#
+# ## Notable Model Methods
+#
+# See Sequel::Plugins::InlineSchema::ClassMethods for documentation for the methods the
+# plugin adds to your model class/es.
+#
+# * `migration` -- define a migration
+# * `migrate` -- create any missing tables for the receiving model and any subclasses,
+#   then run any unapplied migrations.
+#
+# Inline migrations also have model hook methods:
+#
+# * `before_migration`
+# * `after_migration`
+#
+# There's also a method that will return a configured Sequel::Plugins::InlineMigrations::Migrator
+# in case you want to inspect what will happen when you call #migrate:
+#
+# * `migrator`
+#
+module Sequel::Plugins::InlineMigrations
+
+	### Sequel plugin API -- Called the first time the plugin is loaded for
+	### this model (unless it was already loaded by an ancestor class),
+	### before including/extending any modules, with the arguments and block
+	### provided to the call to Model.plugin.
+	def self::apply( model, *args ) # :nodoc:
+		@plugins ||= []
+		model.plugin( :subclasses ) # track subclasses
+		model.plugin( :inline_schema )
+		model.instance_variable_set( :@migrations, {} )
+	end
+
+
+	### A mixin that gets applied to inline migrations to add introspection attributes
+	### and accessors.
+	module MigrationIntrospection
+
+		### Extension callback -- adds 'name', 'model_class', and 'description' instance
+		### variables.
+		def self::extend_object( obj )
+			super
+			obj.instance_variable_set( :@description, nil )
+			obj.instance_variable_set( :@model_class, nil )
+			obj.instance_variable_set( :@name, nil )
+		end
+
+		attr_accessor :name, :model_class, :description
+
+	end # module MigrationIntrospection
+
+
+	# Methods to extend Model classes with.
+	#
+	# :markup: RDoc
+	module ClassMethods
+
+		# A Regexp for matching valid migration names
+		MIGRATION_NAME_PATTERN = /\A\d{8}_\d{4}_\w+\z/
+
+
+		# The Hash of Sequel::SimpleMigration objects for this model, keyed by name
+		attr_reader :migrations
+
+
+		### Add a migration with the specified +name+ and optional +description+. See the
+		### docs for Sequel::Migration for usage, and Sequel::MigrationDSL for the allowed
+		### syntax in the +block+. The name of the migration should be in the form:
+		###   <year><month><day>_<hour><minute>_<underbarred_desc>
+		def migration( name, description=nil, &block )
+			raise ScriptError, "invalid migration name %p" % [ name ] unless
+				MIGRATION_NAME_PATTERN.match( name )
+
+			@migrations ||= {}
+			migration_obj = Sequel::MigrationDSL.create( &block )
+			migration_obj.extend( MigrationIntrospection )
+			migration_obj.name = name
+			migration_obj.model_class = self
+			migration_obj.description = description
+
+			@migrations[ name ] = migration_obj
+		end
+
+
+		### Table-migration hook; called once before missing tables are installed and pending
+		### migrations are run.
+		def before_migration
+			return true
+		end
+
+
+		### Table-migration hook; called once after missing tables are installed and
+		### pending migrations are run.
+		def after_migration
+			return true
+		end
+
+
+		### After table creation hook to register any existing migrations as being
+		### already applied, as the schema declared by set_schema should be the *latest*
+		### schema, and already incorporate the changes described by the migrations.
+		def after_create_table
+			super
+			self.register_existing_migrations
+		end
+
+
+		### Register any migrations on the receiver as having already been run (as when creating
+		### the table initially).
+		def register_existing_migrations
+			# Register existing migrations as already being applied
+			if self.migrations && !self.migrations.empty?
+				migrator = self.migrator
+
+				self.migrations.each_value do |migration|
+					migration_data = {
+						name: migration.name,
+						model_class: migration.model_class.name
+					}
+					next unless migrator.dataset.filter( migration_data ).empty?
+					self.db.log_info "  fast-forwarding migration #{migration.name}..."
+					migrator.dataset.insert( migration_data )
+				end
+			end
+		end
+
+		### Create any new tables and run any pending migrations. If the optional +target+ is
+		### supplied, the migrations up to (and including) that one will be applied. If
+		### it has already been applied, any from the currently-applied one to it
+		### (inclusive) will be reversed. A target of +nil+ is equivalent to the last one
+		def migrate( target=nil )
+			migrator = self.migrator( target )
+			classes_to_install = self.uninstalled_tables
+			self.db.log_info "Classes with tables that need to be installed: %p" % [ classes_to_install ]
+
+			self.db.transaction do
+				self.before_migration
+				self.db.log_info "Creating tables that don't yet exist..."
+				classes_to_install.each( &:create_table )
+
+				self.db.log_info "Running any pending migrations..."
+				migrator.run
+				self.after_migration
+			end
+		end
+
+
+		### Return a configured inline migrator set with the given +target+ migration.
+		def migrator( target=nil )
+			self.db.log_info "Creating the migrator..."
+			Sequel::Plugins::InlineMigrations::Migrator.new( self, nil, target: target )
+		end
+
+
+	end # module ClassMethods
+
+
+	# Subclass of Sequel::Migrator that provides the logic for extracting and running
+	# migrations from the model classes themselves.
+	class Migrator < Sequel::Migrator
+
+		# Default options for .run and #initialize.
+		DEFAULT_OPTS = {
+			:table  => :schema_migrations,
+			:column => :name,
+		}
+
+
+		### Migrates the supplied +db+ (a Sequel::Database) using the migrations declared in the
+		### given +baseclass+. The +baseclass+ is the class to gather migrations from; it and all
+		### of its concrete descendents will be considered.
+		###
+		### The +options+ this method understands:
+		###
+		### column
+		### : The column in the table that stores the migration version. Defaults to
+		### `:version`.
+		###
+		### current
+		### : The current version of the database.  If not given, it is retrieved from the
+		### database using the `:table` and `:column` options.
+		###
+		### table
+		### : The name of the migrations table. Defaults to `:schema_migrations`.
+		###
+		### target
+		### : The target version to migrate to.  If not given, migrates to the
+		### maximum version.
+		###
+		### Examples
+		###
+		### ```
+		### # Assuming Acme::Model is a Sequel::Model subclass, and Acme::Vendor is a subclass
+		### # of that...
+		### Sequel::InlineMigrations::Migrator.run( Acme::Model )
+		### Sequel::InlineMigrations::Migrator.run( Acme::Model, :target => 15, :current => 10 )
+		### Sequel::InlineMigrations::Migrator.run( Acme::Vendor, :column => :app2_version)
+		### Sequel::InlineMigrations::Migrator.run( Acme::Vendor, :column => :app2_version,
+		###                                         :table => :schema_info2 )
+		### ```
+		def self::run( baseclass, db=nil, opts={} )
+			if db.is_a?( Hash )
+				opts = db
+				db = nil
+			end
+
+			new( baseclass, db, opts ).run
+		end
+
+
+		### Create a new Migrator that will organize migrations defined for
+		### +baseclass+ or any of its subclasses for the specified +db+.
+		### See Sequel::Plugins::InlineMigrations::Migrator.run for argument details.
+		def initialize( baseclass, db=nil, opts={} )
+			if db.is_a?( Hash )
+				opts = db
+				db = nil
+			end
+
+			db ||= baseclass.db
+
+			opts = DEFAULT_OPTS.merge( opts )
+			schema, table = db.send( :schema_and_table, opts[:table] )
+
+			@db        = db
+			@baseclass = baseclass
+			@table     = opts[ :table ]
+			@column    = opts[ :column ]
+			@target    = opts[ :target ]
+			@dataset   = make_schema_dataset( @db, @table, @column )
+		end
+
+
+		######
+		public
+		######
+
+		# The database to which the migrator will apply its migrations; a Sequel::Database.
+		attr_reader :db
+
+		# The Class at the top of the hierarchy from which migrations will be fetched
+		attr_reader :baseclass
+
+		# The name of the migration table as a Sequel::SQL::QualifiedIdentifier.
+		attr_reader :table
+
+		# The name of the column which will contain the names of applied migrations as a Symbol.
+		attr_reader :column
+
+		# The migration table dataset (a Sequel::Dataset).
+		attr_reader :dataset
+
+		# The name of the target migration to play up or down to as a String.
+		attr_reader :target
+
+
+		### Apply all migrations to the database
+		def run
+			applied, pending = self.get_partitioned_migrations
+
+			# If no target was specified, and there are no pending
+			# migrations, return early.
+			return if pending.empty? && self.target.nil?
+
+			# If no target was specified, the last one is the target
+			target     = self.target || pending.last.name
+			migrations = nil
+			direction  = nil
+
+			if target == '0'
+				direction = :down
+				migrations = applied.reverse
+
+			elsif tgtidx = pending.find_index {|m| m.name == target }
+				migrations = pending[ 0..tgtidx ]
+				direction = :up
+
+			elsif tgtidx = applied.find_index {|m| m.name == target }
+				migrations = applied[ tgtidx..-1 ].reverse
+				direction = :down
+
+			else
+				raise Sequel::Error, "couldn't find migration %p"
+			end
+
+			# Run the selected migrations
+			self.db.log_info "Migrating %d steps %s..." % [ migrations.length, direction ]
+			migrations.each do |migration|
+				start = Time.now
+				self.db.log_info "Begin: %s, direction: %s" %
+					[ migration.description, direction ]
+
+				self.db.transaction do
+					migration.apply( self.db, direction )
+
+					mclass = migration.model_class.name
+					if direction == :up
+						self.dataset.insert( self.column => migration.name, :model_class => mclass )
+					else
+						self.dataset.filter( self.column => migration.name, :model_class => mclass ).delete
+					end
+				end
+
+				self.db.log_info "  finished: %s, direction: %s (%0.6fs)" %
+					[ migration.description, direction, Time.now - start ]
+			end
+		end
+
+
+		### Fetch an Array of all model classes which are descended from the migrating subclass,
+		### inclusive.
+		def all_migrating_model_classes
+			return [ self.baseclass ] + self.baseclass.descendents
+		end
+
+
+		### Returns any migration objects found in the migrating subclass or any of its
+		### descendents as an Array of Sequel::SimpleMigration objects, sorted by the migration
+		### name and the name of its migrating class.
+		def all_migrations
+			migrations = self.all_migrating_model_classes.
+				collect( &:migrations ).
+				compact.
+				inject {|all, hash| all.merge(hash) }
+
+			return migrations.values.sort_by {|m| [m.name, m.model_class.name] }
+		end
+
+
+		### Returns two Arrays of migrations, the first one containing those which have already
+		### been applied, and the second containing migrations which are pending. Migrations that
+		### have been marked as applied but are (no longer) defined by a model class will be
+		### ignored.
+		def get_partitioned_migrations
+
+			# Get the list of applied migrations for the subclass and its descendents.
+			migrating_class_names = self.all_migrating_model_classes.map( &:name ).compact
+			applied_map = self.dataset.
+				filter( :model_class => migrating_class_names ).
+				select_hash( column, :model_class )
+
+			# Split up the migrations by whether or not it exists in the map of applied migrations.
+			# Each one is removed from the map, so it can be checked for consistency
+			part_migrations = self.all_migrations.partition do |migration|
+				applied_map.delete( migration.name )
+			end
+
+			# If there are any "applied" migrations left, it's likely been deleted since it was
+			# applied, so just ignore it.
+			unless applied_map.empty?
+				applied_map.each do |migration, classname|
+					db.log_info "No %s migration defined in %s; ignoring it." %
+						[ migration, classname ]
+				end
+			end
+
+			return part_migrations
+		end
+
+
+		#######
+		private
+		#######
+
+		### Returns the dataset for the schema_migrations table. If no such table
+		### exists, it is automatically created.
+		def make_schema_dataset( db, table, column )
+			ds = db.from( table )
+			db.log_info "Schema dataset is: %p" % [ ds ]
+
+			if !db.table_exists?( table ) || ds.columns.empty?
+				db.log_info "No migrations table: Installing one."
+				db.create_table( table ) do
+					String column, :primary_key => true
+					String :model_class, :null => false
+				end
+			elsif !ds.columns.include?( column )
+				raise Sequel::Error, "Migrator table %p does not contain column %p (%p)" %
+					[ table, column, ds.columns ]
+			end
+
+			return ds
+		end
+
+	end # class Migrator
+
+end # Sequel::Plugins::InlineMigrations