sequel 2.11.0 → 2.12.0

data/lib/sequel/deprecated_migration.rb

@@ -0,0 +1,91 @@
+module Sequel
+  class Migration
+    def initialize(db)
+      Deprecation.deprecate('Sequel::Migration', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      @db = db
+    end
+    
+    def self.apply(db, direction)
+      Deprecation.deprecate('Sequel::Migration', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      apply(db, direction)
+    end
+
+    def self.descendants
+      Deprecation.deprecate('Sequel::Migration', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      @descendants ||= []
+    end
+    
+    def self.inherited(base)
+      Deprecation.deprecate('Sequel::Migration', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      descendants << base
+    end
+    
+    def down
+      Deprecation.deprecate('Sequel::Migration', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+    end
+    
+    def method_missing(method_sym, *args, &block)
+      Deprecation.deprecate('Sequel::Migration', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      @db.send(method_sym, *args, &block)
+    end
+
+    def up
+      Deprecation.deprecate('Sequel::Migration', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+    end
+  end
+
+  module Migrator
+    def self.apply(db, directory, target = nil, current = nil)
+      Deprecation.deprecate('Sequel::Migrator', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      apply(db, directory, target, current)
+    end
+
+    def self.get_current_migration_version(db)
+      Deprecation.deprecate('Sequel::Migrator', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      r = schema_info_dataset(db).first
+      r ? r[:version] : 0
+    end
+
+    def self.latest_migration_version(directory)
+      Deprecation.deprecate('Sequel::Migrator', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      l = migration_files(directory).last
+      l ? File.basename(l).to_i : nil
+    end
+
+    def self.migration_classes(directory, target, current, direction)
+      Deprecation.deprecate('Sequel::Migrator', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      migration_classes(directory, target, current, direction)
+    end
+    
+    def self.migration_files(directory, range = nil)
+      Deprecation.deprecate('Sequel::Migrator', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      migration_files(directory, range)
+    end
+    
+    def self.schema_info_dataset(db)
+      Deprecation.deprecate('Sequel::Migrator', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      db.create_table(:schema_info) {integer :version} unless db.table_exists?(:schema_info)
+      db[:schema_info]
+    end
+    
+    def self.set_current_migration_version(db, version)
+      Deprecation.deprecate('Sequel::Migrator', "require 'sequel/extensions/migration' first")
+      require 'sequel/extensions/migration'
+      dataset = schema_info_dataset(db)
+      dataset.send(dataset.first ? :update : :<<, :version => version)
+    end
+  end
+end

data/lib/sequel/exceptions.rb

@@ -0,0 +1,48 @@
+module Sequel
+  # The default exception class for exceptions raised by Sequel.
+  # All exception classes defined by Sequel are descendants of this class.
+  class Error < ::StandardError
+  end  
+    
+  # Raised when the adapter requested doesn't exist or can't be loaded.
+  class AdapterNotFound < Error ; end
+
+  # Generic error raised by the database adapters, indicating a
+  # problem originating from the database server.  Usually raised
+  # because incorrect SQL syntax is used.
+  class DatabaseError < Error; end
+  
+  # Error raised when the Sequel is unable to connect to the database with the
+  # connection parameters it was given.
+  class DatabaseConnectionError < DatabaseError; end
+
+  # Error that should be raised by adapters when they determine that the connection
+  # to the database has been lost.  Instructs the connection pool code to 
+  # remove that connection from the pool so that other connections can be acquired
+  # automatically.
+  class DatabaseDisconnectError < DatabaseError; end
+
+  # Raised on an invalid operation, such as trying to update or delete
+  # a joined or grouped dataset.
+  class InvalidOperation < Error; end
+                                     
+  # Raised when attempting an invalid type conversion.
+  class InvalidValue < Error ; end
+                                     
+  # Raised when the connection pool cannot acquire a database connection
+  # before the timeout.
+  class PoolTimeout < Error ; end
+                                     
+  # Exception that you should raise to signal a rollback of the current transaction.
+  # The transaction block will catch this exception, rollback the current transaction,
+  # and won't reraise it.
+  class Rollback < Error ; end
+
+  class Error
+    AdapterNotFound = Sequel::AdapterNotFound
+    InvalidOperation = Sequel::InvalidOperation
+    InvalidValue = Sequel::InvalidValue
+    PoolTimeoutError = Sequel::PoolTimeout
+    Rollback = Sequel::Rollback
+  end  
+end

data/lib/sequel/extensions/blank.rb

@@ -0,0 +1,42 @@
+class FalseClass
+  # false is always blank
+  def blank?
+    true
+  end
+end
+
+# Helpers from Metaid and a bit more
+class Object
+  # Objects are blank if they respond true to empty?
+  def blank?
+    respond_to?(:empty?) && empty?
+  end
+end
+
+class NilClass
+  # nil is always blank
+  def blank?
+    true
+  end
+end
+
+class Numeric
+  # Numerics are never blank (not even 0)
+  def blank?
+    false
+  end
+end
+
+class String
+  # Strings are blank if they are empty or include only whitespace
+  def blank?
+    strip.empty?
+  end
+end
+
+class TrueClass
+  # true is never blank
+  def blank?
+    false
+  end
+end

data/lib/{sequel_model → sequel/extensions}/inflector.rb

@@ -21,7 +21,9 @@ class String
   module Inflections
     @plurals, @singulars, @uncountables = [], [], []
 
-    metaattr_reader :plurals, :singulars, :uncountables
+    class << self
+      attr_reader :plurals, :singulars, :uncountables
+    end
 
     # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,
     # the options are: :plurals, :singulars, :uncountables
@@ -30,6 +32,7 @@ class String
     #   clear :all
     #   clear :plurals
     def self.clear(scope = :all)
+      Sequel::Inflections.clear(scope)
       case scope
       when :all
         @plurals, @singulars, @uncountables = [], [], []
@@ -45,6 +48,7 @@ class String
     #   irregular 'octopus', 'octopi'
     #   irregular 'person', 'people'
     def self.irregular(singular, plural)
+      Sequel::Inflections.irregular(singular, plural)
       plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
       singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
     end
@@ -55,6 +59,7 @@ class String
     # Example:
     #   plural(/(x|ch|ss|sh)$/i, '\1es')
     def self.plural(rule, replacement)
+      Sequel::Inflections.plural(rule, replacement)
       @plurals.insert(0, [rule, replacement])
     end
 
@@ -64,6 +69,7 @@ class String
     # Example:
     #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
     def self.singular(rule, replacement)
+      Sequel::Inflections.singular(rule, replacement)
       @singulars.insert(0, [rule, replacement])
     end
 
@@ -74,6 +80,7 @@ class String
     #   uncountable "money", "information"
     #   uncountable %w( money information rice )
     def self.uncountable(*words)
+      Sequel::Inflections.uncountable(*words)
       (@uncountables << words).flatten!
     end
 

data/lib/{sequel_core → sequel/extensions}/migration.rb

@@ -35,7 +35,7 @@ module Sequel
   # 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')
+  #   DB = Sequel.connect('sqlite://mydb')
   #   CreateSessions.apply(DB, :up)
   #
   # See Sequel::Schema::Generator for the syntax to use for creating tables,

data/lib/{sequel_core → sequel/extensions}/pretty_table.rb

@@ -1,4 +1,11 @@
 module Sequel
+  class Dataset
+    # Pretty prints the records in the dataset as plain-text table.
+    def print(*cols)
+      Sequel::PrettyTable.print(naked.all, cols.empty? ? columns : cols)
+    end
+  end
+
   module PrettyTable
     # Prints nice-looking plain-text tables via puts
     # 

data/lib/{sequel_core/dataset → sequel/extensions}/query.rb

@@ -1,4 +1,11 @@
 module Sequel
+  class Database
+    # Return a dataset modified by the query block
+    def query(&block)
+      dataset.query(&block)
+    end
+  end
+
   class Dataset
     # Translates a query block into a dataset. Query blocks can be useful
     # when expressing complex SELECT statements, e.g.:

data/lib/sequel/extensions/string_date_time.rb

@@ -0,0 +1,47 @@
+# This file contains the previous extensions to String for date/time
+# conversions.  These are provided mainly for backward compatibility,
+# Sequel now uses a module level method instead of extending string
+# to handle the internal conversions.
+
+class String
+  # Converts a string into a Date object.
+  def to_date
+    begin
+      Date.parse(self, Sequel.convert_two_digit_years)
+    rescue => e
+      raise Sequel::InvalidValue, "Invalid Date value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts a string into a DateTime object.
+  def to_datetime
+    begin
+      DateTime.parse(self, Sequel.convert_two_digit_years)
+    rescue => e
+      raise Sequel::InvalidValue, "Invalid DateTime value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts a string into a Time or DateTime object, depending on the
+  # value of Sequel.datetime_class
+  def to_sequel_time
+    begin
+      if Sequel.datetime_class == DateTime
+        DateTime.parse(self, Sequel.convert_two_digit_years)
+      else
+        Sequel.datetime_class.parse(self)
+      end
+    rescue => e
+      raise Sequel::InvalidValue, "Invalid #{Sequel.datetime_class} value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts a string into a Time object.
+  def to_time
+    begin
+      Time.parse(self)
+    rescue => e
+      raise Sequel::InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
+    end
+  end
+end

data/lib/sequel/metaprogramming.rb

@@ -0,0 +1,43 @@
+module Sequel
+  # Contains methods that ease metaprogramming, used by some of Sequel's classes.
+  module Metaprogramming
+    # Add methods to the object's metaclass
+    def meta_def(name, &block)
+      meta_eval{define_method(name, &block)}
+    end 
+  
+    private
+  
+    # Make a singleton/class attribute accessor method(s).
+    # Replaces the construct:
+    #
+    #   class << self
+    #     attr_accessor *meths
+    #   end
+    def metaattr_accessor(*meths)
+      meta_eval{attr_accessor(*meths)}
+    end
+  
+    # Make a singleton/class attribute reader method(s).
+    # Replaces the construct:
+    #
+    #   class << self
+    #     attr_reader *meths
+    #   end
+    def metaattr_reader(*meths)
+      meta_eval{attr_reader(*meths)}
+    end
+  
+    # Evaluate the block in the context of the object's metaclass
+    def meta_eval(&block)
+      metaclass.instance_eval(&block)
+    end 
+  
+    # The hidden singleton lurks behind everyone
+    def metaclass
+      class << self
+        self
+      end 
+    end 
+  end
+end

data/lib/sequel/model.rb

@@ -0,0 +1,110 @@
+require 'sequel/core'
+
+module Sequel
+  # Lets you create a Model subclass with its dataset already set.
+  # source can be an existing dataset or a symbol (in which case
+  # it will create a dataset using the default database with 
+  # the given symbol as the table name).
+  #
+  # The purpose of this method is to set the dataset automatically
+  # for a model class, if the table name doesn't match the implicit
+  # name.  This is neater than using set_dataset inside the class,
+  # doesn't require a bogus query for the schema, and allows
+  # it to work correctly in a system that uses code reloading.
+  #
+  # Example:
+  #   class Comment < Sequel::Model(:something)
+  #     table_name # => :something
+  #   end
+  def self.Model(source)
+    Model::ANONYMOUS_MODEL_CLASSES[source] ||= Class.new(Model).set_dataset(source)
+  end
+
+  # Sequel::Model is an object relational mapper built on top of Sequel core.  Each
+  # model class is backed by a dataset instance, and many dataset methods can be
+  # called directly on the class.  Model datasets return rows as model instances,
+  # which have fairly standard ORM instance behavior.
+  #
+  # Sequel::Model is built completely out of plugins, the only method not part of a
+  # plugin is the plugin method itself.  Plugins can override any class, instance, or
+  # dataset method defined by a previous plugin and call super to get the default
+  # behavior.
+  #
+  # You can set the SEQUEL_NO_ASSOCIATIONS constant or environment variable to
+  # make Sequel not load the associations plugin by default.
+  class Model
+    # Map that stores model classes created with Sequel::Model(), to allow the reopening
+    # of classes when dealing with code reloading.
+    ANONYMOUS_MODEL_CLASSES = {}
+
+    # Class methods added to model that call the method of the same name on the dataset
+    DATASET_METHODS = %w'<< all avg count delete distinct eager eager_graph
+       each each_page empty? except exclude filter first from from_self
+       full_outer_join get graph group group_and_count group_by having import
+       inner_join insert insert_multiple intersect interval join join_table
+       last left_outer_join limit map multi_insert naked order order_by
+       order_more paginate print query range reverse_order right_outer_join
+       select select_all select_more server set set_graph_aliases 
+       single_value to_csv to_hash transform union unfiltered unordered 
+       update where with_sql'.map{|x| x.to_sym}
+  
+    # Class instance variables to set to nil when a subclass is created, for -w compliance
+    EMPTY_INSTANCE_VARIABLES = [:@overridable_methods_module, :@db]
+
+    # Empty instance methods to create that the user can override to get hook/callback behavior.
+    # Just like any other method defined by Sequel, if you override one of these, you should
+    # call super to get the default behavior (while empty by default, they can also be defined
+    # by plugins).  
+    HOOKS = [:after_initialize, :before_create, :after_create, :before_update,
+      :after_update, :before_save, :after_save, :before_destroy, :after_destroy,
+      :before_validation, :after_validation]
+
+    # Class instance variables that are inherited in subclasses.  If the value is :dup, dup is called
+    # on the superclass's instance variable when creating the instance variable in the subclass.
+    # If the value is nil, the superclass's instance variable is used directly in the subclass.
+    INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup, :@dataset_methods=>:dup, 
+      :@dataset_method_modules=>:dup, :@primary_key=>nil, :@use_transactions=>nil,
+      :@raise_on_save_failure=>nil, :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
+      :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil,
+      :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
+      :@raise_on_typecast_failure=>nil}
+
+    # Regexp that determines if a method name is normal in the sense that
+    # it could be called directly in ruby code without using send.  Used to
+    # avoid problems when using eval with a string to define methods.
+    NORMAL_METHOD_NAME_REGEXP = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+
+    # The setter methods (methods ending with =) that are never allowed
+    # to be called automatically via set/update/new/etc..
+    RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_empty_string_to_nil= typecast_on_assignment= strict_param_setting= raise_on_save_failure= raise_on_typecast_failure="
+
+    # Regular expression that determines if the method is a valid setter name
+    # (i.e. it ends with =).
+    SETTER_METHOD_REGEXP = /=\z/
+
+    @allowed_columns = nil
+    @db = nil
+    @db_schema = nil
+    @dataset_method_modules = []
+    @dataset_methods = {}
+    @overridable_methods_module = nil
+    @primary_key = :id
+    @raise_on_save_failure = true
+    @raise_on_typecast_failure = true
+    @restrict_primary_key = true
+    @restricted_columns = nil
+    @simple_pk = nil
+    @simple_table = nil
+    @strict_param_setting = true
+    @typecast_empty_string_to_nil = true
+    @typecast_on_assignment = true
+    @use_transactions = true
+  end
+
+  require %w"inflections plugins base exceptions errors", "model"
+  if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
+    require 'associations', 'model'
+    Model.plugin Model::Associations
+  end
+  require 'deprecated', 'model'
+end