viking-sequel 3.10.0

data/lib/sequel/exceptions.rb

@@ -0,0 +1,51 @@
+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
+    # If this exception wraps an underlying exception, the underlying
+    # exception is held here.
+    attr_accessor :wrapped_exception
+  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,43 @@
+# The blank extension adds the blank? method to all objects (e.g. Object#blank?).
+
+class FalseClass
+  # false is always blank
+  def blank?
+    true
+  end
+end
+
+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/extensions/inflector.rb

@@ -0,0 +1,242 @@
+# The inflector extension adds inflection instance methods to String, which allows the easy transformation of
+# words from singular to plural, class names to table names, modularized class
+# names to ones without, and class names to foreign keys.  It exists for 
+# backwards compatibility to legacy Sequel code.
+
+class String
+  # This module acts as a singleton returned/yielded by String.inflections,
+  # which is used to override or specify additional inflection rules. Examples:
+  #
+  #   String.inflections do |inflect|
+  #     inflect.plural /^(ox)$/i, '\1\2en'
+  #     inflect.singular /^(ox)en/i, '\1'
+  #
+  #     inflect.irregular 'octopus', 'octopi'
+  #
+  #     inflect.uncountable "equipment"
+  #   end
+  #
+  # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+  # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+  # already have been loaded.
+  module Inflections
+    @plurals, @singulars, @uncountables = [], [], []
+
+    class << self
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for plurization.
+      attr_reader :plurals
+
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for singularization.
+      attr_reader :singulars
+
+      # Array of strings for words were the singular form is the same as the plural form
+      attr_reader :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
+    #
+    # Examples:
+    #   clear :all
+    #   clear :plurals
+    def self.clear(scope = :all)
+      case scope
+      when :all
+        @plurals, @singulars, @uncountables = [], [], []
+      else
+        instance_variable_set("@#{scope}", [])
+      end
+    end
+
+    # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+    # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+    #
+    # Examples:
+    #   irregular 'octopus', 'octopi'
+    #   irregular 'person', 'people'
+    def self.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
+
+    # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   plural(/(x|ch|ss|sh)$/i, '\1es')
+    def self.plural(rule, replacement)
+      @plurals.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
+    def self.singular(rule, replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Add uncountable words that shouldn't be attempted inflected.
+    #
+    # Examples:
+    #   uncountable "money"
+    #   uncountable "money", "information"
+    #   uncountable %w( money information rice )
+    def self.uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+
+    Sequel.require('default_inflections', 'model')
+    instance_eval(&Sequel::DEFAULT_INFLECTIONS_PROC)
+  end
+
+  # Yield the Inflections module if a block is given, and return
+  # the Inflections module.
+  def self.inflections
+    yield Inflections if block_given?
+    Inflections
+  end
+
+  # By default, camelize converts the string to UpperCamelCase. If the argument to camelize
+  # is set to :lower then camelize produces lowerCamelCase.
+  #
+  # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+  #
+  # Examples
+  #   "active_record".camelize #=> "ActiveRecord"
+  #   "active_record".camelize(:lower) #=> "activeRecord"
+  #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
+  def camelize(first_letter_in_uppercase = :upper)
+    s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+    s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
+    s
+  end
+  alias_method :camelcase, :camelize
+
+  # Singularizes and camelizes the string.  Also strips out all characters preceding
+  # and including a period (".").
+  #
+  # Examples
+  #   "egg_and_hams".classify #=> "EggAndHam"
+  #   "post".classify #=> "Post"
+  #   "schema.post".classify #=> "Post"
+  def classify
+    sub(/.*\./, '').singularize.camelize
+  end
+
+  # Constantize tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize #=> Module
+  #   "Class".constantize #=> Class
+  def constantize
+    raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
+    Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  # Example
+  #   "puni_puni".dasherize #=> "puni-puni"
+  def dasherize
+    gsub(/_/, '-')
+  end
+
+  # Removes the module part from the expression in the string
+  #
+  # Examples
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+  #   "Inflections".demodulize #=> "Inflections"
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+
+  # Creates a foreign key name from a class name.
+  # +use_underscore+ sets whether the method should put '_' between the name and 'id'.
+  #
+  # Examples
+  #   "Message".foreign_key #=> "message_id"
+  #   "Message".foreign_key(false) #=> "messageid"
+  #   "Admin::Post".foreign_key #=> "post_id"
+  def foreign_key(use_underscore = true)
+    "#{demodulize.underscore}#{'_' if use_underscore}id"
+  end
+
+  # Capitalizes the first word and turns underscores into spaces and strips _id.
+  # Like titleize, this is meant for creating pretty output.
+  #
+  # Examples
+  #   "employee_salary" #=> "Employee salary"
+  #   "author_id" #=> "Author"
+  def humanize
+    gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  end
+
+  # Returns the plural form of the word in the string.
+  #
+  # Examples
+  #   "post".pluralize #=> "posts"
+  #   "octopus".pluralize #=> "octopi"
+  #   "sheep".pluralize #=> "sheep"
+  #   "words".pluralize #=> "words"
+  #   "the blue mailman".pluralize #=> "the blue mailmen"
+  #   "CamelOctopus".pluralize #=> "CamelOctopi"
+  def pluralize
+    result = dup
+    Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # The reverse of pluralize, returns the singular form of a word in a string.
+  #
+  # Examples
+  #   "posts".singularize #=> "post"
+  #   "octopi".singularize #=> "octopus"
+  #   "sheep".singluarize #=> "sheep"
+  #   "word".singluarize #=> "word"
+  #   "the blue mailmen".singularize #=> "the blue mailman"
+  #   "CamelOctopi".singularize #=> "CamelOctopus"
+  def singularize
+    result = dup
+    Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # Underscores and pluralizes the string.
+  #
+  # Examples
+  #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
+  #   "egg_and_ham".tableize #=> "egg_and_hams"
+  #   "fancyCategory".tableize #=> "fancy_categories"
+  def tableize
+    underscore.pluralize
+  end
+
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. Titleize is meant for creating pretty output.
+  #
+  # titleize is also aliased as as titlecase
+  #
+  # Examples
+  #   "man from the boondocks".titleize #=> "Man From The Boondocks"
+  #   "x-men: the last stand".titleize #=> "X Men: The Last Stand"
+  def titleize
+    underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
+  end
+  alias_method :titlecase, :titleize
+
+  # The reverse of camelize. Makes an underscored form from the expression in the string.
+  # Also changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "ActiveRecord".underscore #=> "active_record"
+  #   "ActiveRecord::Errors".underscore #=> active_record/errors
+  def underscore
+    gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+end

data/lib/sequel/extensions/looser_typecasting.rb

@@ -0,0 +1,21 @@
+# The LooserTypecasting extension changes the float and integer typecasting to
+# use the looser .to_f and .to_i instead of the more strict Kernel.Float and
+# Kernel.Integer.  To use it, you should extend the database with the
+# Sequel::LooserTypecasting module after loading the extension:
+#
+#   Sequel.extension :looser_typecasting
+#   DB.extend(Sequel::LooserTypecasting)
+
+module Sequel
+  module LooserTypecasting
+    # Typecast the value to a Float using to_f instead of Kernel.Float
+    def typecast_value_float(value)
+      value.to_f
+    end
+
+    # Typecast the value to an Integer using to_i instead of Kernel.Integer
+    def typecast_value_integer(value)
+      value.to_i
+    end
+  end
+end

data/lib/sequel/extensions/migration.rb

@@ -0,0 +1,239 @@
+# Adds the Sequel::Migration and Sequel::Migrator classes, which allow
+# the user to easily group schema changes and migrate the database
+# to a newer version or revert to a previous version.
+
+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
+  #         String :session_id, :size => 32, :unique => true
+  #         DateTime :created_at
+  #         text :data
+  #       end
+  #     end
+  # 
+  #     def down
+  #       # You can use raw SQL if you need to
+  #       self << 'DROP TABLE sessions'
+  #     end
+  #   end
+  #
+  #   class AlterItems < Sequel::Migration
+  #     def up
+  #       alter_table :items do
+  #         add_column :category, String, :default => 'ruby'
+  #       end
+  #     end
+  # 
+  #     def down
+  #       alter_table :items do
+  #         drop_column :category
+  #       end  
+  #     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.connect('sqlite://mydb')
+  #   CreateSessions.apply(DB, :up)
+  #
+  # See Sequel::Schema::Generator for the syntax to use for creating tables,
+  # and Sequel::Schema::AlterTableGenerator for the syntax to use when
+  # altering existing tables.  Migrations act as a proxy for the database
+  # given in #apply, so inside #down and #up, you can act as though self
+  # refers to the database.  So you can use any of the Sequel::Database
+  # instance methods directly.
+  class Migration
+    # Creates a new instance of the migration and sets the @db attribute.
+    def initialize(db)
+      @db = db
+    end
+    
+    # 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 ArgumentError, "Invalid migration direction specified (#{direction.inspect})"
+      end
+    end
+
+    # Returns the list of Migration descendants.
+    def self.descendants
+      @descendants ||= []
+    end
+    
+    # Adds the new migration class to the list of Migration descendants.
+    def self.inherited(base)
+      descendants << base
+    end
+    
+    # The default down action does nothing
+    def down
+    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
+
+    # The default up action does nothing
+    def up
+    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.
+  #
+  # Migrations are generally run via the sequel command line tool,
+  # using the -m and -M switches.  The -m switch specifies the migration
+  # directory, and the -M switch specifies the version to which to migrate.
+  # 
+  # You can apply migrations using the Migrator API, as well (this is necessary
+  # if you want to specify the version from which to migrate in addition to the version
+  # to which to migrate).
+  # 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
+    DEFAULT_SCHEMA_COLUMN = :version
+    DEFAULT_SCHEMA_TABLE = :schema_info
+    MIGRATION_FILE_PATTERN = /\A\d+_.+\.rb\z/.freeze
+    MIGRATION_SPLITTER = '_'.freeze
+
+    # Wrapper for run, maintaining backwards API compatibility
+    def self.apply(db, directory, target = nil, current = nil)
+      run(db, directory, :target => target, :current => current)
+    end
+
+    # Migrates the supplied database using the migration files in the the specified directory. Options:
+    # * :column - The column in the :table argument storing the migration version (default: :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 table containing the schema version (default: :schema_info).
+    # * :target - The target version to which to migrate.  If not given, migrates to the maximum version.
+    #
+    # Examples: 
+    #   Sequel::Migrator.run(DB, "migrations")
+    #   Sequel::Migrator.run(DB, "migrations", :target=>15, :current=>10)
+    #   Sequel::Migrator.run(DB, "app1/migrations", :column=> :app2_version)
+    #   Sequel::Migrator.run(DB, "app2/migrations", :column => :app2_version, :table=>:schema_info2)
+    def self.run(db, directory, opts={})
+      raise(Error, "Must supply a valid migration path") unless directory and File.directory?(directory)
+      raise(Error, "No current version available") unless current = opts[:current] || get_current_migration_version(db, opts)
+      raise(Error, "No target version available") unless target  = opts[:target]  || latest_migration_version(directory)
+
+      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, opts)
+      end
+      
+      target
+    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, opts={})
+      (schema_info_dataset(db, opts).first || {})[opts[:column] || DEFAULT_SCHEMA_COLUMN] || 0
+    end
+
+    # Returns the latest version available in the specified directory.
+    def self.latest_migration_version(directory)
+      l = migration_files(directory).last
+      l ? migration_version_from_file(File.basename(l)) : nil
+    end
+
+    # Returns a list of migration classes filtered 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
+
+      # Remove class definitions
+      Migration.descendants.each do |c|
+        Object.send(:remove_const, c.to_s) rescue nil
+      end
+      Migration.descendants.clear # remove any defined migration classes
+
+      # load migration files
+      migration_files(directory, range).each {|fn| load(fn)}
+      
+      # get migration classes
+      classes = Migration.descendants
+      classes.reverse! if direction == :down
+      classes
+    end
+    
+    # Returns any found migration files in the supplied directory.
+    def self.migration_files(directory, range = nil)
+      files = []
+      Dir.new(directory).each do |file|
+        files[migration_version_from_file(file)] = File.join(directory, file) if MIGRATION_FILE_PATTERN.match(file)
+      end
+      filtered = range ? files[range] : files
+      filtered ? filtered.compact : []
+    end
+    
+    # Returns the dataset for the schema_info table. If no such table
+    # exists, it is automatically created.
+    def self.schema_info_dataset(db, opts={})
+      column = opts[:column] || DEFAULT_SCHEMA_COLUMN
+      table  = opts[:table]  || DEFAULT_SCHEMA_TABLE
+      db.create_table?(table){Integer column}
+      db.alter_table(table){add_column column, Integer} unless db.from(table).columns.include?(column)
+      db.from(table)
+    end
+    
+    # Sets the current migration  version stored in the database.
+    def self.set_current_migration_version(db, version, opts={})
+      column = opts[:column] || DEFAULT_SCHEMA_COLUMN
+      dataset = schema_info_dataset(db, opts)
+      dataset.send(dataset.first ? :update : :insert, column => version)
+    end
+
+    # Return the integer migration version based on the filename.
+    def self.migration_version_from_file(filename) # :nodoc:
+      filename.split(MIGRATION_SPLITTER, 2).first.to_i
+    end
+    private_class_method :migration_version_from_file
+  end
+end