sequel 0.1.9.2 → 0.1.9.3

data/CHANGELOG

@@ -1,3 +1,15 @@
+=== SVN
+
+* Added Sequel.dbi convenience method for using DBI connection strings to open DBI databases.
+
+=== 0.1.9.3 (2007-08-10)
+
+* Added support for specifying field size in schema definitions (thanks Florian Aßmann.)
+
+* Added migration code based on work by Florian Aßmann.
+
+* Reintroduced metaid dependency. No need to keep a local copy of it.
+
 === 0.1.9.2 (2007-07-24)
 
 * Removed metaid dependency. Refactored requires in lib/sequel.rb.

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.1.9.2"
+VERS = "0.1.9.3"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",
@@ -43,7 +43,9 @@ spec = Gem::Specification.new do |s|
   s.homepage = 'http://sequel.rubyforge.org'
   s.executables = ['sequel']
 
-  s.required_ruby_version = '>= 1.8.2'
+  s.add_dependency('metaid')
+  
+  s.required_ruby_version = '>= 1.8.4'
 
   s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*")
       

data/lib/sequel.rb

@@ -1,6 +1,8 @@
+require 'metaid'
+
 files = %w[
-  metaid core_ext error database connection_pool
-  schema pretty_table expressions dataset model
+  core_ext error database connection_pool
+  schema pretty_table expressions dataset migration model
 ]
 dir = File.join(File.dirname(__FILE__), 'sequel')
 files.each {|f| require(File.join(dir, f))}

data/lib/sequel/dbi.rb

@@ -5,14 +5,19 @@ end
 require 'dbi'
 
 module Sequel
+  def self.dbi(conn_string, opts = nil)
+    opts ||= {}
+    opts.merge!(:database => conn_string)
+    Sequel::DBI::Database.new(opts)
+  end
+  
   module DBI
-
     class Database < Sequel::Database
       set_adapter_scheme :dbi
     
       def connect
-        dbname = @opts[:database] =~ /^DBI:/ ? \
-          @opts[:database] : @opts[:database] = 'DBI:' + @opts[:database]
+        dbname = @opts[:database]
+        dbname = 'DBI:' + dbname unless dbname =~ /^DBI:/
         ::DBI.connect(dbname, @opts[:user], @opts[:password])
       end
     

data/lib/sequel/migration.rb

@@ -0,0 +1,180 @@
+# The migration code is based on work by Florian Aßmann:
+#   http://code.google.com/p/ruby-sequel/issues/detail?id=23
+
+module Sequel
+  # The Migration class describes a database migration that can be reversed.
+  # The migration looks very similar to ActiveRecord (Rails) migrations, e.g.:
+  #
+  #   class CreateSessions < Sequel::Migration
+  #     def up
+  #       create_table :sessions do
+  #         primary_key :id
+  #         varchar   :session_id, :length => 32, :unique => true
+  #         timestamp :created_at
+  #         text      :data
+  #       end
+  #     end
+  # 
+  #     def down
+  #       execute 'DROP TABLE sessions'
+  #     end
+  #   end
+  #
+  # To apply a migration to a database, you can invoke the #apply with
+  # the target database instance and the direction :up or :down, e.g.:
+  #
+  #   DB = Sequel.open ('sqlite:///mydb')
+  #   CreateSessions.apply(DB, :up)
+  #
+  class Migration
+    # Creates a new instance of the migration and sets the @db attribute.
+    def initialize(db)
+      @db = db
+    end
+    
+    # Adds the new migration class to the list of Migration descendants.
+    def self.inherited(base)
+      descendants << base
+    end
+    
+    # Returns the list of Migration descendants.
+    def self.descendants
+      @descendants ||= []
+    end
+    
+    def up; end #:nodoc:
+    def down; end #:nodoc:
+    
+    # Applies the migration to the supplied database in the specified
+    # direction.
+    def self.apply(db, direction)
+      obj = new(db)
+      case direction
+      when :up: obj.up
+      when :down: obj.down
+      else
+        raise SequelError, "Invalid migration direction (#{direction})"
+      end
+    end
+
+    # Intercepts method calls intended for the database and sends them along.
+    def method_missing(method_sym, *args, &block)
+      @db.send method_sym, *args, &block
+    end
+  end
+
+  # The Migrator module performs migrations based on migration files in a 
+  # specified directory. The migration files should be named using the
+  # following pattern (in similar fashion to ActiveRecord migrations):
+  # 
+  #   <version>_<title>.rb
+  #
+  # For example, the following files are considered migration files:
+  #   
+  #   001_create_sessions.rb
+  #   002_add_data_column.rb
+  #   ...
+  #
+  # The migration files should contain one or more migration classes based
+  # on Sequel::Migration.
+  #
+  # To apply a migration, the #apply method must be invoked with the database
+  # instance, the directory of migration files and the target version. If
+  # no current version is supplied, it is read from the database. The migrator
+  # automatically creates a schema_info table in the database to keep track
+  # of the current migration version. If no migration version is stored in the
+  # database, the version is considered to be 0. If no target version is 
+  # specified, the database is migrated to the latest version available in the
+  # migration directory.
+  #
+  # For example, to migrate the database to the latest version:
+  #
+  #   Sequel::Migrator.apply(DB, '.')
+  #
+  # To migrate the database from version 1 to version 5:
+  #
+  #   Sequel::Migrator.apply(DB, '.', 5, 1)
+  #
+  module Migrator
+    # Migrates the supplied database in the specified directory from the
+    # current version to the target version. If no current version is
+    # supplied, it is extracted from a schema_info table. The schema_info
+    # table is automatically created and maintained by the apply function.
+    def self.apply(db, directory, target = nil, current = nil)
+      # determine current and target version and direction
+      current ||= get_current_migration_version(db)
+      target ||= latest_migration_version(directory)
+      raise SequelError, "No current version available" if current.nil?
+      raise SequelError, "No target version available" if target.nil?
+      direction = current < target ? :up : :down
+      
+      classes = migration_classes(directory, target, current, direction)
+      
+      db.transaction do
+        classes.each {|c| c.apply(db, direction)}
+        set_current_migration_version(db, target)
+      end
+    end
+
+    # Returns a list of migration classes filter for the migration range and
+    # ordered according to the migration direction.
+    def self.migration_classes(directory, target, current, direction)
+      range = direction == :up ?
+        (current + 1)..target : (target + 1)..current
+        
+      # load migration files
+      Migration.descendants.clear # remove any defined migration classes
+      migration_files(directory, range).each {|fn| load(fn)}
+      
+      # get migration classes
+      classes = Migration.descendants
+      classes.reverse! if direction == :down
+      classes
+    end
+    
+    MIGRATION_FILE_PATTERN = '[0-9][0-9][0-9]_*.rb'.freeze
+
+    # Returns any found migration files in the supplied directory.
+    def self.migration_files(directory, range = nil)
+      pattern = File.join(directory, MIGRATION_FILE_PATTERN)
+      files = Dir[pattern].inject([]) do |m, path|
+        m[File.basename(path).to_i] = path
+        m
+      end
+      filtered = range ? files[range] : files
+      filtered ? filtered.compact : []
+    end
+    
+    def self.latest_migration_version(directory)
+      l = migration_files(directory).last
+      l ? File.basename(l).to_i : nil
+    end
+
+    # Gets the current migration version stored in the database. If no version
+    # number is stored, 0 is returned.
+    def self.get_current_migration_version(db)
+      r = schema_info_dataset(db).first
+      r ? r[:version] : 0
+    end
+    
+    # Sets the current migration  version stored in the database.
+    def self.set_current_migration_version(db, version)
+      dataset = schema_info_dataset(db)
+      if dataset.first
+        dataset.update(:version => version)
+      else
+        dataset << {:version => version}
+      end
+    end
+    
+    # Returns the dataset for the schema_info table. If no such table
+    # exists, it is automatically created.
+    def self.schema_info_dataset(db)
+      unless db.table_exists?(:schema_info)
+        db.create_table(:schema_info) {integer :version}
+      end
+
+      db[:schema_info]
+    end
+  end
+end

data/lib/sequel/schema.rb

@@ -2,6 +2,7 @@ module Sequel
   class Schema
     COMMA_SEPARATOR = ', '.freeze
     COLUMN_DEF = '%s %s'.freeze
+    SIZE_DEF = '(%d)'.freeze
     UNIQUE = ' UNIQUE'.freeze
     NOT_NULL = ' NOT NULL'.freeze
     DEFAULT = ' DEFAULT %s'.freeze
@@ -31,6 +32,8 @@ module Sequel
     
     def self.column_definition(column)
       c = COLUMN_DEF % [column[:name], TYPES[column[:type]]]
+      column[:size] ||= 255 if column[:type] == :varchar
+      c << SIZE_DEF % column[:size] if column[:size]
       c << UNIQUE if column[:unique]
       c << NOT_NULL if column[:null] == false
       c << DEFAULT % PGconn.quote(column[:default]) if column.include?(:default)

data/spec/migration_spec.rb

@@ -0,0 +1,241 @@
+require File.join(File.dirname(__FILE__), '../lib/sequel')
+
+context "Migration classes" do
+  setup do
+    Sequel::Migration.descendants.clear
+  end
+
+  specify "should be registred in Migration.descendants" do
+    @class = Class.new(Sequel::Migration)
+    
+    Sequel::Migration.descendants.should == [@class]
+  end
+  
+  specify "should be registered in the right order" do
+    @c1 = Class.new(Sequel::Migration)
+    @c2 = Class.new(Sequel::Migration)
+    @c3 = Class.new(Sequel::Migration)
+    
+    Sequel::Migration.descendants.should == [@c1, @c2, @c3]
+  end
+end
+
+context "Migration#apply" do
+  setup do
+    @c = Class.new do
+      define_method(:one) {|x| [1111, x]}
+      define_method(:two) {|x| [2222, x]}
+    end
+    @db = @c.new
+    
+    @migration = Class.new(Sequel::Migration) do
+      define_method(:up) {one(3333)}
+      define_method(:down) {two(4444)}
+    end
+  end
+  
+  specify "should raise for an invalid direction" do
+    proc {@migration.apply(@db, :hahaha)}.should raise_error(SequelError)
+  end
+  
+  specify "should apply the up direction correctly" do
+    @migration.apply(@db, :up).should == [1111, 3333]
+  end
+
+  specify "should apply the down direction correctly" do
+    @migration.apply(@db, :down).should == [2222, 4444]
+  end
+end
+
+class DummyMigrationDataset
+  attr_reader :from
+  
+  def initialize(x); @from = x; end
+  
+  @@version = nil
+  
+  def version; @@version; end
+  def version=(x); @@version = x; end
+  def first; @@version ? {:version => @@version} : nil; end
+  def update(h); @@version = h[:version]; end
+  def <<(h); @@version = h[:version]; end
+end
+
+class DummyMigrationDB
+  attr_reader :creates, :drops, :table_created
+  
+  def initialize
+    @creates = []
+    @drops = []
+  end
+  
+  def create(x); @creates << x; end
+  def drop(x); @drops << x; end
+  
+  def [](x); DummyMigrationDataset.new(x); end
+  
+  def create_table(x); raise if @table_created == x; @table_created = x; end
+  def table_exists?(x); @table_created == x; end
+  
+  def transaction; yield; end
+end
+
+MIGRATION_001 = %[
+  class CreateSessions < Sequel::Migration
+    def up
+      create(1111)
+    end
+    
+    def drop
+      drop(1111)
+    end
+  end
+]
+
+MIGRATION_002 = %[
+  class CreateNodes < Sequel::Migration
+    def up
+      create(2222)
+    end
+    
+    def down
+      drop(2222)
+    end
+  end
+]
+
+MIGRATION_003 = %[
+  class CreateUsers < Sequel::Migration
+    def up
+      create(3333)
+    end
+    
+    def down
+      drop(3333)
+    end
+  end
+]
+
+MIGRATION_005 = %[
+  class CreateAttributes < Sequel::Migration
+    def up
+      create(5555)
+    end
+    
+    def down
+      drop(5555)
+    end
+  end
+]
+
+context "Sequel::Migrator" do
+  setup do
+    @db = DummyMigrationDB.new
+    
+    File.open('001_create_sessions.rb', 'w') {|f| f << MIGRATION_001}
+    File.open('002_create_nodes.rb', 'w') {|f| f << MIGRATION_002}
+    File.open('003_create_users.rb', 'w') {|f| f << MIGRATION_003}
+    File.open('005_create_attributes.rb', 'w') {|f| f << MIGRATION_005}
+    
+    @db[:schema_info].version = nil
+  end
+  
+  teardown do
+    Object.send(:remove_const, "CreateSessions") if Object.const_defined?("CreateSessions")
+    Object.send(:remove_const, "CreateNodes") if Object.const_defined?("CreateNodes")
+    Object.send(:remove_const, "CreateUsers") if Object.const_defined?("CreateUsers")
+    Object.send(:remove_const, "CreateAttributes") if Object.const_defined?("CreateAttributes")
+
+    FileUtils.rm('001_create_sessions.rb')
+    FileUtils.rm('002_create_nodes.rb')
+    FileUtils.rm('003_create_users.rb')
+    FileUtils.rm('005_create_attributes.rb')
+  end
+  
+  specify "should return the list of files for a specified version range" do
+    Sequel::Migrator.migration_files('.', 1..1).should == \
+      ['./001_create_sessions.rb']
+
+    Sequel::Migrator.migration_files('.', 1..3).should == \
+      ['./001_create_sessions.rb', './002_create_nodes.rb', './003_create_users.rb']
+
+    Sequel::Migrator.migration_files('.', 3..5).should == \
+      ['./003_create_users.rb', './005_create_attributes.rb']
+      
+    Sequel::Migrator.migration_files('.', 7..8).should == []
+  end
+  
+  specify "should return the latest version available" do
+    Sequel::Migrator.latest_migration_version('.').should == 5
+  end
+  
+  specify "should load the migration classes for the specified range" do
+    Sequel::Migrator.migration_classes('.', 3, 0, :up).should == \
+      [CreateSessions, CreateNodes, CreateUsers]
+  end
+  
+  specify "should start from current + 1 for the up direction" do
+    Sequel::Migrator.migration_classes('.', 3, 1, :up).should == \
+      [CreateNodes, CreateUsers]
+  end
+  
+  specify "should end on current + 1 for the down direction" do
+    Sequel::Migrator.migration_classes('.', 2, 5, :down).should == \
+      [CreateAttributes, CreateUsers]
+  end
+  
+  specify "should automatically create the schema_info table" do
+    @db.table_exists?(:schema_info).should be_false
+    Sequel::Migrator.schema_info_dataset(@db)
+    @db.table_exists?(:schema_info).should be_true
+    
+    # should not raise if table already exists
+    proc {Sequel::Migrator.schema_info_dataset(@db)}.should_not raise_error
+  end
+  
+  specify "should return a dataset for the schema_info table" do
+    d = Sequel::Migrator.schema_info_dataset(@db)
+    d.from.should == :schema_info
+  end
+  
+  specify "should get the migration version stored in the database" do
+    # default is 0
+    Sequel::Migrator.get_current_migration_version(@db).should == 0
+    
+    Sequel::Migrator.schema_info_dataset(@db) << {:version => 4321}
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 4321
+  end
+  
+  specify "should set the migration versison stored in the datbase" do
+    Sequel::Migrator.get_current_migration_version(@db).should == 0
+    Sequel::Migrator.set_current_migration_version(@db, 6666)
+    Sequel::Migrator.get_current_migration_version(@db).should == 6666
+  end
+  
+  specify "should apply migrations correctly in the up direction" do
+    Sequel::Migrator.apply(@db, '.', 3, 2)
+    @db.creates.should == [3333]
+    
+    Sequel::Migrator.get_current_migration_version(@db).should == 3
+
+    Sequel::Migrator.apply(@db, '.', 5)
+    @db.creates.should == [3333, 5555]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 5
+  end
+
+  specify "should apply migrations correctly in the down direction" do
+    Sequel::Migrator.apply(@db, '.', 1, 5)
+    @db.drops.should == [5555, 3333, 2222]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 1
+  end
+
+  specify "should apply migrations up to the latest version if no target is given" do
+    Sequel::Migrator.apply(@db, '.')
+    @db.creates.should == [1111, 2222, 3333, 5555]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 5
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.1.9.2
-date: 2007-07-24 00:00:00 +03:00
+  version: 0.1.9.3
+date: 2007-08-10 00:00:00 +03:00
 summary: Concise ORM for Ruby.
 require_paths: 
 - lib
@@ -20,7 +20,7 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: 1.8.2
+      version: 1.8.4
   version: 
 platform: ruby
 signing_key: 
@@ -40,6 +40,7 @@ files:
 - spec/database_spec.rb
 - spec/dataset_spec.rb
 - spec/expressions_spec.rb
+- spec/migration_spec.rb
 - spec/adapters/mysql_spec.rb
 - spec/adapters/sqlite_spec.rb
 - lib/sequel
@@ -52,7 +53,7 @@ files:
 - lib/sequel/dbi.rb
 - lib/sequel/error.rb
 - lib/sequel/expressions.rb
-- lib/sequel/metaid.rb
+- lib/sequel/migration.rb
 - lib/sequel/model.rb
 - lib/sequel/mysql.rb
 - lib/sequel/odbc.rb
@@ -89,5 +90,13 @@ extensions: []
 
 requirements: []
 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: metaid
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 

data/lib/sequel/metaid.rb

@@ -1,24 +0,0 @@
-# Metaid == a few simple metaclass helper
-# (See http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html.)
-class Object
-    # The hidden singleton lurks behind everyone
-    def metaclass; class << self; self; end; end
-    def meta_eval &blk; metaclass.instance_eval &blk; end
-
-    # Adds methods to a metaclass
-    def meta_def name, &blk
-        meta_eval { define_method name, &blk }
-    end
-end
-
-class Module
-    # Defines an instance method within a module
-    def module_def name, &blk
-        module_eval { define_method name, &blk }
-    end
-end
-
-class Class
-    alias class_def module_def
-end
-