sequel 2.12.0 → 3.0.0

data/lib/sequel/deprecated_migration.rb

@@ -1,91 +0,0 @@
-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/model/deprecated.rb

@@ -1,204 +0,0 @@
-Sequel.require %w'deprecated_hooks deprecated_validations deprecated_inflector', 'model'
-
-module Sequel
-  class Model
-    module Validation
-      Errors = Model::Errors
-    end
-    module ClassMethods
-      {:size=>:count, :uniq=>:distinct}.each do |o, n|
-        class_eval "def #{o}(*args, &block); Deprecation.deprecate('Sequel::Model.#{o}', 'Use Sequel::Model.dataset.#{n}'); dataset.#{n}(*args, &block); end"
-      end
-  
-      def is(*args, &block)
-        Deprecation.deprecate('Sequel::Model.is', 'Use Sequel::Model.plugin')
-        plugin(*args, &block)
-      end
-  
-      def is_a(*args, &block)
-        Deprecation.deprecate('Sequel::Model.is_a', 'Use Sequel::Model.plugin')
-        plugin(*args, &block)
-      end
-  
-      def delete_all
-        Deprecation.deprecate('Sequel::Model.delete_all', 'Use Sequel::Model.delete')
-        dataset.delete
-      end
-  
-      def destroy_all
-        Deprecation.deprecate('Sequel::Model.destroy_all', 'Use Sequel::Model.destroy')
-        dataset.destroy
-      end
-  
-      def str_columns
-        Deprecation.deprecate('Sequel::Model.str_columns', 'Use model.columns.map{|x| x.to_s}')
-        @str_columns ||= columns.map{|c| c.to_s.freeze}
-      end
-  
-      def set_sti_key(key)
-        Deprecation.deprecate('Sequel::Model.set_sti_key', 'Use Model.plugin(:single_table_inheritance, key)')
-        plugin :single_table_inheritance, key
-      end
-  
-      def sti_key
-        Deprecation.deprecate('Sequel::Model.sti_key', 'Use Model.plugin(:single_table_inheritance, key) first')
-        @sti_key
-      end
-  
-      def sti_dataset
-        Deprecation.deprecate('Sequel::Model.sti_dataset', 'Use Model.plugin(:single_table_inheritance, key) first')
-        @sti_dataset
-      end
-  
-      def set_cache_ttl(ttl)
-        Deprecation.deprecate('Sequel::Model.set_cache_ttl', 'Use Model.plugin(:caching, store, opts) first')
-        @cache_ttl = ttl
-      end
-  
-      def set_cache(store, opts = {})
-        Deprecation.deprecate('Sequel::Model.set_cache', 'Use Model.plugin(:caching, store, opts)')
-        plugin :caching, store, opts
-      end
-
-      # Creates table, using the column information from set_schema.
-      def create_table
-        Deprecation.deprecate('Sequel::Model.create_table', 'Use Model.plugin(:schema) first')
-        db.create_table(table_name, :generator=>@schema)
-        @db_schema = get_db_schema(true)
-        columns
-      end
-  
-      # Drops the table if it exists and then runs create_table.  Should probably
-      # not be used except in testing.
-      def create_table!
-        Deprecation.deprecate('Sequel::Model.create_table!', 'Use Model.plugin(:schema) first')
-        drop_table rescue nil 
-        create_table
-      end
-  
-      # Drops table.
-      def drop_table
-        Deprecation.deprecate('Sequel::Model.drop_table', 'Use Model.plugin(:schema) first')
-        db.drop_table(table_name)
-      end
-  
-      # Returns table schema created with set_schema for direct descendant of Model.
-      # Does not retreive schema information from the database, see db_schema if you
-      # want that.
-      def schema
-        Deprecation.deprecate('Sequel::Model.schema', 'Use Model.plugin(:schema) first')
-        @schema || (superclass.schema unless superclass == Model)
-      end
-  
-      # Defines a table schema (see Schema::Generator for more information).
-      #
-      # This is only needed if you want to use the create_table/create_table! methods.
-      # Will also set the dataset if you provide a name, as well as setting
-      # the primary key if you defined one in the passed block.
-      #
-      # In general, it is a better idea to use migrations for production code, as
-      # migrations allow changes to existing schema.  set_schema is mostly useful for
-      # test code or simple examples.
-      def set_schema(name = nil, &block)
-        Deprecation.deprecate('Sequel::Model.set_schema', 'Use Model.plugin(:schema) first')
-        set_dataset(db[name]) if name
-        @schema = Sequel::Schema::Generator.new(db, &block)
-        set_primary_key(@schema.primary_key_name) if @schema.primary_key_name
-      end
-  
-      # Returns true if table exists, false otherwise.
-      def table_exists?
-        Deprecation.deprecate('Sequel::Model.table_exists?', 'Use Model.plugin(:schema) first')
-        db.table_exists?(table_name)
-      end
-
-      def serialize(*columns)
-        Deprecation.deprecate('Sequel::Model.serialize', 'A implementation that doesn\'t use dataset transforms can be added via plugin(:serialization, (:marshal||:yaml), column1, column2)')
-        format = extract_options!(columns)[:format] || :yaml
-        @transform = columns.inject({}) do |m, c|
-          m[c] = format
-          m
-        end
-        @dataset.transform(@transform) if @dataset
-      end
-
-      def serialized?(column)
-        @transform ? @transform.include?(column) : false
-      end
-    end
-  
-    module InstanceMethods
-      def dataset
-        Deprecation.deprecate('Sequel::Model#dataset', 'Use model_object.model.dataset')
-        model.dataset
-      end
-  
-      def save!(*args)
-        Deprecation.deprecate('Sequel::Model#save!', 'Use model_object.save(..., :validate=>false)')
-        opts = args.last.is_a?(Hash) ? args.pop : {}
-        args.push(opts.merge(:validate=>false))
-        save(*args)
-      end
-  
-      def str_columns
-        Deprecation.deprecate('Sequel::Model#str_columns', 'Use model_object.columns.map{|x| x.to_s}')
-        model.str_columns
-      end
-  
-      def set_with_params(hash)
-        Deprecation.deprecate('Sequel::Model#set_with_params', 'Use Sequel::Model#set')
-        set_restricted(hash, nil, nil)
-      end
-  
-      def update_with_params(hash)
-        Deprecation.deprecate('Sequel::Model#update_with_params', 'Use Sequel::Model#update')
-        update_restricted(hash, nil, nil)
-      end
-  
-      def set_values(values)
-        Deprecation.deprecate('Sequel::Model#set_values', 'Use Sequel::Model#set')
-        s = str_columns
-        vals = values.inject({}) do |m, kv|
-          k, v = kv
-          k = case k
-          when Symbol
-            k
-          when String
-            raise(Error, "all string keys must be a valid columns") unless s.include?(k)
-            k.to_sym
-          else
-            raise(Error, "Only symbols and strings allows as keys")
-          end
-          m[k] = v
-          m
-        end
-        vals.each {|k, v| @values[k] = v}
-        vals
-      end
-  
-      def update_values(values)
-        Deprecation.deprecate('Sequel::Model#update_values', 'Use Sequel::Model#update or model_object.this.update')
-        this.update(set_values(values))
-      end
-    end
-
-    if defined?(Associations::ClassMethods)
-      module Associations::ClassMethods
-        def belongs_to(*args, &block)
-          Deprecation.deprecate('Sequel::Model.belongs_to', 'Use Sequel::Model.many_to_one')
-          many_to_one(*args, &block)
-        end
-
-        def has_many(*args, &block)
-          Deprecation.deprecate('Sequel::Model.has_many', 'Use Sequel::Model.one_to_many')
-          one_to_many(*args, &block)
-        end
-
-        def has_and_belongs_to_many(*args, &block)
-          Deprecation.deprecate('Sequel::Model.has_and_belongs_to_many', 'Use Sequel::Model.many_to_many')
-          many_to_many(*args, &block)
-        end
-      end
-    end
-  end
-end

data/lib/sequel/model/deprecated_hooks.rb

@@ -1,103 +0,0 @@
-module Sequel
-  module Plugins
-    module DeprecatedHookClassMethods
-      def self.apply(model)
-        hooks = model.instance_variable_set(:@hooks, {})
-        Model::HOOKS.each{|h| hooks[h] = []}
-      end
-
-      module ClassMethods
-        Model::HOOKS.each{|h| class_eval("def #{h}(method = nil, &block); Deprecation.deprecate('Sequel::Model.#{h}', 'Use Model.plugin :hook_class_methods'); add_hook(:#{h}, method, &block) end", __FILE__, __LINE__)}
-
-        # This adds a new hook type. It will define both a class
-        # method that you can use to add hooks, as well as an instance method
-        # that you can use to call all hooks of that type.  The class method
-        # can be called with a symbol or a block or both.  If a block is given and
-        # and symbol is not, it adds the hook block to the hook type.  If a block
-        # and symbol are both given, it replaces the hook block associated with
-        # that symbol for a given hook type, or adds it if there is no hook block
-        # with that symbol for that hook type.  If no block is given, it assumes
-        # the symbol specifies an instance method to call and adds it to the hook
-        # type.
-        #
-        # If any hook block returns false, the instance method will return false
-        # immediately without running the rest of the hooks of that type.
-        #
-        # It is recommended that you always provide a symbol to this method,
-        # for descriptive purposes.  It's only necessary to do so when you 
-        # are using a system that reloads code.
-        # 
-        # Example of usage:
-        #
-        #  class MyModel
-        #   define_hook :before_move_to
-        #   before_move_to(:check_move_allowed){|o| o.allow_move?}
-        #   def move_to(there)
-        #     return if before_move_to == false
-        #     # move MyModel object to there
-        #   end
-        #  end
-        def add_hook_type(*hooks)
-          Deprecation.deprecate('Sequel::Model.add_hook_type', 'Use Model.plugin :hook_class_methods')
-          hooks.each do |hook|
-            @hooks[hook] = []
-            instance_eval("def #{hook}(method = nil, &block); add_hook(:#{hook}, method, &block) end", __FILE__, __LINE__)
-            class_eval("def #{hook}; run_hooks(:#{hook}); end", __FILE__, __LINE__)
-          end
-        end
-    
-        # Returns true if there are any hook blocks for the given hook.
-        def has_hooks?(hook)
-          !@hooks[hook].empty?
-        end
-    
-        # Yield every block related to the given hook.
-        def hook_blocks(hook)
-          @hooks[hook].each{|k,v| yield v}
-        end
-
-        def inherited(subclass)
-          super
-          hooks = subclass.instance_variable_set(:@hooks, {}) 
-          instance_variable_get(:@hooks).each{|k,v| hooks[k] = v.dup}
-        end
-    
-        private
-    
-        # Add a hook block to the list of hook methods.
-        # If a non-nil tag is given and it already is in the list of hooks,
-        # replace it with the new block.
-        def add_hook(hook, tag, &block)
-          unless block
-            (raise Error, 'No hook method specified') unless tag
-            block = proc {send tag}
-          end
-          h = @hooks[hook]
-          if tag && (old = h.find{|x| x[0] == tag})
-            old[1] = block
-          else
-            if hook.to_s =~ /^before/
-              h.unshift([tag,block])
-            else
-              h << [tag, block]
-            end
-          end
-        end
-      end
-
-      module InstanceMethods
-        Model::HOOKS.each{|h| class_eval("def #{h}; run_hooks(:#{h}); end", __FILE__, __LINE__)}
-
-        private
-
-        # Runs all hook blocks of given hook type on this object.
-        # Stops running hook blocks and returns false if any hook block returns false.
-        def run_hooks(hook)
-          model.hook_blocks(hook){|block| return false if instance_eval(&block) == false}
-        end
-      end
-    end
-  end
-
-  Model.plugin :deprecated_hook_class_methods
-end

data/lib/sequel/model/deprecated_inflector.rb

@@ -1,335 +0,0 @@
-# Add inflection 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.
-
-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
-      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
-    #
-    # Examples:
-    #   clear :all
-    #   clear :plurals
-    def self.clear(scope = :all)
-      Sequel::Deprecation.deprecate('String::Inflections.clear', 'require "sequel/extensions/inflector" first')
-      Sequel::Inflections.clear(scope)
-      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)
-      Sequel::Deprecation.deprecate('String::Inflections.irregular', 'require "sequel/extensions/inflector" first')
-      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
-
-    # 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)
-      Sequel::Deprecation.deprecate('String::Inflections.plural', 'require "sequel/extensions/inflector" first')
-      Sequel::Inflections.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)
-      Sequel::Deprecation.deprecate('String::Inflections.singular', 'require "sequel/extensions/inflector" first')
-      Sequel::Inflections.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)
-      Sequel::Deprecation.deprecate('String::Inflections.uncountable', 'require "sequel/extensions/inflector" first')
-      Sequel::Inflections.uncountable(*words)
-      (@uncountables << words).flatten!
-    end
-
-    output = Sequel::Deprecation.output
-    Sequel::Deprecation.output = nil
-    # Setup the default inflections
-    plural(/$/, 's')
-    plural(/s$/i, 's')
-    plural(/(ax|test)is$/i, '\1es')
-    plural(/(octop|vir)us$/i, '\1i')
-    plural(/(alias|status)$/i, '\1es')
-    plural(/(bu)s$/i, '\1ses')
-    plural(/(buffal|tomat)o$/i, '\1oes')
-    plural(/([ti])um$/i, '\1a')
-    plural(/sis$/i, 'ses')
-    plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
-    plural(/(hive)$/i, '\1s')
-    plural(/([^aeiouy]|qu)y$/i, '\1ies')
-    plural(/(x|ch|ss|sh)$/i, '\1es')
-    plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
-    plural(/([m|l])ouse$/i, '\1ice')
-    plural(/^(ox)$/i, '\1en')
-    plural(/(quiz)$/i, '\1zes')
-
-    singular(/s$/i, '')
-    singular(/(n)ews$/i, '\1ews')
-    singular(/([ti])a$/i, '\1um')
-    singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
-    singular(/(^analy)ses$/i, '\1sis')
-    singular(/([^f])ves$/i, '\1fe')
-    singular(/(hive)s$/i, '\1')
-    singular(/(tive)s$/i, '\1')
-    singular(/([lr])ves$/i, '\1f')
-    singular(/([^aeiouy]|qu)ies$/i, '\1y')
-    singular(/(s)eries$/i, '\1eries')
-    singular(/(m)ovies$/i, '\1ovie')
-    singular(/(x|ch|ss|sh)es$/i, '\1')
-    singular(/([m|l])ice$/i, '\1ouse')
-    singular(/(bus)es$/i, '\1')
-    singular(/(o)es$/i, '\1')
-    singular(/(shoe)s$/i, '\1')
-    singular(/(cris|ax|test)es$/i, '\1is')
-    singular(/(octop|vir)i$/i, '\1us')
-    singular(/(alias|status)es$/i, '\1')
-    singular(/^(ox)en/i, '\1')
-    singular(/(vert|ind)ices$/i, '\1ex')
-    singular(/(matr)ices$/i, '\1ix')
-    singular(/(quiz)zes$/i, '\1')
-
-    irregular('person', 'people')
-    irregular('man', 'men')
-    irregular('child', 'children')
-    irregular('sex', 'sexes')
-    irregular('move', 'moves')
-
-    uncountable(%w(equipment information rice money species series fish sheep))
-    Sequel::Deprecation.output = output
-  end
-
-  # Yield the Inflections module if a block is given, and return
-  # the Inflections module.
-  def self.inflections
-    Sequel::Deprecation.deprecate('String.inflections', 'require "sequel/extensions/inflector" first')
-    yield Inflections if block_given?
-    Inflections
-  end
-
-  include(Module.new do
-    unless String.method_defined?(:camelize)
-      # 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)
-        Sequel::Deprecation.deprecate('String#camelize', 'require "sequel/extensions/inflector" first')
-        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 camelcase camelize
-    end
-    
-    unless String.method_defined?(: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
-        Sequel::Deprecation.deprecate('String#classify', 'require "sequel/extensions/inflector" first')
-        sub(/.*\./, '').singularize.camelize
-      end
-    end
-    
-    unless String.method_defined?(:camelize)
-      # 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
-        Sequel::Deprecation.deprecate('String#constantize', 'require "sequel/extensions/inflector" first')
-        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
-    end
-    
-    unless String.method_defined?(:camelize)
-      # Replaces underscores with dashes in the string.
-      #
-      # Example
-      #   "puni_puni".dasherize #=> "puni-puni"
-      def dasherize
-        Sequel::Deprecation.deprecate('String#dasherize', 'require "sequel/extensions/inflector" first')
-        gsub(/_/, '-')
-      end
-    end
-    
-    unless String.method_defined?(:camelize)
-      # Removes the module part from the expression in the string
-      #
-      # Examples
-      #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
-      #   "Inflections".demodulize #=> "Inflections"
-      def demodulize
-        Sequel::Deprecation.deprecate('String#demodulize', 'require "sequel/extensions/inflector" first')
-        gsub(/^.*::/, '')
-      end
-    end
-    
-    unless String.method_defined?(:camelize)
-      # 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)
-        Sequel::Deprecation.deprecate('String#foreign_key', 'require "sequel/extensions/inflector" first')
-        "#{demodulize.underscore}#{'_' if use_underscore}id"
-      end
-    end
-    
-    unless String.method_defined?(:camelize)
-      # 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
-        Sequel::Deprecation.deprecate('String#humanize', 'require "sequel/extensions/inflector" first')
-        gsub(/_id$/, "").gsub(/_/, " ").capitalize
-      end
-    end
-    
-    unless String.method_defined?(:camelize)
-      # 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
-        Sequel::Deprecation.deprecate('String#pluralize', 'require "sequel/extensions/inflector" first')
-        result = dup
-        Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
-        result
-      end
-    end
-    
-    unless String.method_defined?(:camelize)
-      # 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
-        Sequel::Deprecation.deprecate('String#singularize', 'require "sequel/extensions/inflector" first')
-        result = dup
-        Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
-        result
-      end
-    end
-    
-    unless String.method_defined?(:camelize)
-      # Underscores and pluralizes the string.
-      #
-      # Examples
-      #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
-      #   "egg_and_ham".tableize #=> "egg_and_hams"
-      #   "fancyCategory".tableize #=> "fancy_categories"
-      def tableize
-        Sequel::Deprecation.deprecate('String#tableize', 'require "sequel/extensions/inflector" first')
-        underscore.pluralize
-      end
-    end
-    
-    unless String.method_defined?(:camelize)
-      # 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
-        Sequel::Deprecation.deprecate('String#titleize', 'require "sequel/extensions/inflector" first')
-        underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
-      end
-      alias titlecase titleize
-    end
-    
-    unless String.method_defined?(:camelize)
-      # 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
-        Sequel::Deprecation.deprecate('String#underscore', 'require "sequel/extensions/inflector" first')
-        gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-          gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
-      end
-    end
-  end)
-end