sequel 2.11.0 → 2.12.0

data/lib/sequel/model/deprecated.rb

@@ -0,0 +1,204 @@
+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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,335 @@
+# 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