epugh-sequel 0.0.0

data/lib/sequel/model/deprecated_validations.rb

@@ -0,0 +1,384 @@
+module Sequel
+  module Plugins
+    module DeprecatedValidationClassMethods
+      module ClassMethods
+        # The Generator class is used to generate validation definitions using 
+        # the validates {} idiom.
+        class Generator
+          # Initializes a new generator.
+          def initialize(receiver ,&block)
+            @receiver = receiver
+            instance_eval(&block)
+          end
+      
+          # Delegates method calls to the receiver by calling receiver.validates_xxx.
+          def method_missing(m, *args, &block)
+            @receiver.send(:"validates_#{m}", *args, &block)
+          end
+        end
+    
+        # Returns true if validations are defined.
+        def has_validations?
+          !validations.empty?
+        end
+    
+        # Instructs the model to skip validations defined in superclasses
+        def skip_superclass_validations
+          @skip_superclass_validations = true
+        end
+        
+        # Defines validations by converting a longhand block into a series of 
+        # shorthand definitions. For example:
+        #
+        #   class MyClass < Sequel::Model
+        #     validates do
+        #       length_of :name, :minimum => 6
+        #       length_of :password, :minimum => 8
+        #     end
+        #   end
+        #
+        # is equivalent to:
+        #   class MyClass < Sequel::Model
+        #     validates_length_of :name, :minimum => 6
+        #     validates_length_of :password, :minimum => 8
+        #   end
+        def validates(&block)
+          Deprecation.deprecate('Sequel::Model.validates', 'Use Model.plugin(:validation_class_methods) first')
+          Generator.new(self, &block)
+        end
+    
+        # Validates the given instance.
+        def validate(o)
+          if superclass.respond_to?(:validate) && !@skip_superclass_validations
+            superclass.validate(o)
+          end
+          validations.each do |att, procs|
+            v = case att
+            when Array
+              att.collect{|a| o.send(a)}
+            else
+              o.send(att)
+            end
+            procs.each {|tag, p| p.call(o, att, v)}
+          end
+        end
+        
+        # Validates acceptance of an attribute.  Just checks that the value
+        # is equal to the :accept option. This method is unique in that
+        # :allow_nil is assumed to be true instead of false.
+        #
+        # Possible Options:
+        # * :accept - The value required for the object to be valid (default: '1')
+        # * :message - The message to use (default: 'is not accepted')
+        def validates_acceptance_of(*atts)
+          Deprecation.deprecate('Sequel::Model.validates_acceptance_of', 'Use Model.plugin(:validation_class_methods) first')
+          opts = {
+            :message => 'is not accepted',
+            :allow_nil => true,
+            :accept => '1',
+            :tag => :acceptance,
+          }.merge!(extract_options!(atts))
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            o.errors[a] << opts[:message] unless v == opts[:accept]
+          end
+        end
+    
+        # Validates confirmation of an attribute. Checks that the object has
+        # a _confirmation value matching the current value.  For example:
+        #
+        #   validates_confirmation_of :blah
+        #
+        # Just makes sure that object.blah = object.blah_confirmation.  Often used for passwords
+        # or email addresses on web forms.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is not confirmed')
+        def validates_confirmation_of(*atts)
+          Deprecation.deprecate('Sequel::Model.validates_confirmation_of', 'Use Model.plugin(:validation_class_methods) first')
+          opts = {
+            :message => 'is not confirmed',
+            :tag => :confirmation,
+          }.merge!(extract_options!(atts))
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            o.errors[a] << opts[:message] unless v == o.send(:"#{a}_confirmation")
+          end
+        end
+    
+        # Adds a validation for each of the given attributes using the supplied
+        # block. The block must accept three arguments: instance, attribute and 
+        # value, e.g.:
+        #
+        #   validates_each :name, :password do |object, attribute, value|
+        #     object.errors[attribute] << 'is not nice' unless value.nice?
+        #   end
+        #
+        # Possible Options:
+        # * :allow_blank - Whether to skip the validation if the value is blank. 
+        # * :allow_missing - Whether to skip the validation if the attribute isn't a key in the
+        #   values hash.  This is different from allow_nil, because Sequel only sends the attributes
+        #   in the values when doing an insert or update.  If the attribute is not present, Sequel
+        #   doesn't specify it, so the database will use the table's default value.  This is different
+        #   from having an attribute in values with a value of nil, which Sequel will send as NULL.
+        #   If your database table has a non NULL default, this may be a good option to use.  You
+        #   don't want to use allow_nil, because if the attribute is in values but has a value nil,
+        #   Sequel will attempt to insert a NULL value into the database, instead of using the
+        #   database's default.
+        # * :allow_nil - Whether to skip the validation if the value is nil.
+        # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
+        #   skipping this validation if it returns nil or false.
+        # * :tag - The tag to use for this validation.
+        def validates_each(*atts, &block)
+          Deprecation.deprecate('Sequel::Model.validates_each', 'Use Model.plugin(:validation_class_methods) first')
+          opts = extract_options!(atts)
+          blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
+            proc do |o,a,v|
+              next if i && !validation_if_proc(o, i)
+              next if an && Array(v).all?{|x| x.nil?}
+              next if ab && Array(v).all?{|x| x.blank?}
+              next if am && Array(a).all?{|x| !o.values.has_key?(x)}
+              block.call(o,a,v)
+            end
+          else
+            block
+          end
+          tag = opts[:tag]
+          atts.each do |a| 
+            a_vals = validations[a]
+            if tag && (old = a_vals.find{|x| x[0] == tag})
+              old[1] = blk
+            else
+              a_vals << [tag, blk]
+            end
+          end
+        end
+    
+        # Validates the format of an attribute, checking the string representation of the
+        # value against the regular expression provided by the :with option.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is invalid')
+        # * :with - The regular expression to validate the value with (required).
+        def validates_format_of(*atts)
+          Deprecation.deprecate('Sequel::Model.validates_format_of', 'Use Model.plugin(:validation_class_methods) first')
+          opts = {
+            :message => 'is invalid',
+            :tag => :format,
+          }.merge!(extract_options!(atts))
+          
+          unless opts[:with].is_a?(Regexp)
+            raise ArgumentError, "A regular expression must be supplied as the :with option of the options hash"
+          end
+          
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            o.errors[a] << opts[:message] unless v.to_s =~ opts[:with]
+          end
+        end
+    
+        # Validates the length of an attribute.
+        #
+        # Possible Options:
+        # * :is - The exact size required for the value to be valid (no default)
+        # * :maximum - The maximum size allowed for the value (no default)
+        # * :message - The message to use (no default, overrides :too_long, :too_short, and :wrong_length
+        #   options if present)
+        # * :minimum - The minimum size allowed for the value (no default)
+        # * :too_long - The message to use use if it the value is too long (default: 'is too long')
+        # * :too_short - The message to use use if it the value is too short (default: 'is too short')
+        # * :within - The array/range that must include the size of the value for it to be valid (no default)
+        # * :wrong_length - The message to use use if it the value is not valid (default: 'is the wrong length')
+        def validates_length_of(*atts)
+          Deprecation.deprecate('Sequel::Model.validates_length_of', 'Use Model.plugin(:validation_class_methods) first')
+          opts = {
+            :too_long     => 'is too long',
+            :too_short    => 'is too short',
+            :wrong_length => 'is the wrong length'
+          }.merge!(extract_options!(atts))
+          
+          opts[:tag] ||= ([:length] + [:maximum, :minimum, :is, :within].reject{|x| !opts.include?(x)}).join('-').to_sym
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            if m = opts[:maximum]
+              o.errors[a] << (opts[:message] || opts[:too_long]) unless v && v.size <= m
+            end
+            if m = opts[:minimum]
+              o.errors[a] << (opts[:message] || opts[:too_short]) unless v && v.size >= m
+            end
+            if i = opts[:is]
+              o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && v.size == i
+            end
+            if w = opts[:within]
+              o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && w.include?(v.size)
+            end
+          end
+        end
+    
+        # Validates whether an attribute is not a string.  This is generally useful
+        # in conjunction with raise_on_typecast_failure = false, where you are
+        # passing in string values for non-string attributes (such as numbers and dates).
+        # If typecasting fails (invalid number or date), the value of the attribute will
+        # be a string in an invalid format, and if typecasting succeeds, the value will
+        # not be a string.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is a string' or 'is not a valid (integer|datetime|etc.)' if the type is known)
+        def validates_not_string(*atts)
+          Deprecation.deprecate('Sequel::Model.validates_not_string', 'Use Model.plugin(:validation_class_methods) first')
+          opts = {
+            :tag => :not_string,
+          }.merge!(extract_options!(atts))
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            if v.is_a?(String)
+              unless message = opts[:message]
+                message = if sch = o.db_schema[a] and typ = sch[:type]
+                  "is not a valid #{typ}"
+                else
+                  "is a string"
+                end
+              end
+              o.errors[a] << message
+            end
+          end
+        end
+    
+        # Validates whether an attribute is a number.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is not a number')
+        # * :only_integer - Whether only integers are valid values (default: false)
+        def validates_numericality_of(*atts)
+          Deprecation.deprecate('Sequel::Model.validates_numericality_of', 'Use Model.plugin(:validation_class_methods) first')
+          opts = {
+            :message => 'is not a number',
+            :tag => :numericality,
+          }.merge!(extract_options!(atts))
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            begin
+              if opts[:only_integer]
+                Kernel.Integer(v.to_s)
+              else
+                Kernel.Float(v.to_s)
+              end
+            rescue
+              o.errors[a] << opts[:message]
+            end
+          end
+        end
+    
+        # Validates the presence of an attribute.  Requires the value not be blank,
+        # with false considered present instead of absent.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is not present')
+        def validates_presence_of(*atts)
+          Deprecation.deprecate('Sequel::Model.validates_presence_of', 'Use Model.plugin(:validation_class_methods) first')
+          opts = {
+            :message => 'is not present',
+            :tag => :presence,
+          }.merge!(extract_options!(atts))
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            o.errors[a] << opts[:message] if v.blank? && v != false
+          end
+        end
+        
+        # Validates that an attribute is within a specified range or set of values.
+        #
+        # Possible Options:
+        # * :in - An array or range of values to check for validity (required)
+        # * :message - The message to use (default: 'is not in range or set: <specified range>')
+        def validates_inclusion_of(*atts)
+          Deprecation.deprecate('Sequel::Model.validates_inclusion_of', 'Use Model.plugin(:validation_class_methods) first')
+          opts = extract_options!(atts)
+          unless opts[:in] && opts[:in].respond_to?(:include?) 
+            raise ArgumentError, "The :in parameter is required, and respond to include?"
+          end
+          opts[:message] ||= "is not in range or set: #{opts[:in].inspect}"
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            o.errors[a] << opts[:message] unless opts[:in].include?(v)
+          end
+        end
+    
+        # Validates only if the fields in the model (specified by atts) are
+        # unique in the database.  Pass an array of fields instead of multiple
+        # fields to specify that the combination of fields must be unique,
+        # instead of that each field should have a unique value.
+        #
+        # This means that the code:
+        #   validates_uniqueness_of([:column1, :column2])
+        # validates the grouping of column1 and column2 while
+        #   validates_uniqueness_of(:column1, :column2)
+        # validates them separately.
+        #
+        # You should also add a unique index in the
+        # database, as this suffers from a fairly obvious race condition.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is already taken')
+        def validates_uniqueness_of(*atts)
+          Deprecation.deprecate('Sequel::Model.validates_uniqueness_of', 'Use Model.plugin(:validation_class_methods) first')
+          opts = {
+            :message => 'is already taken',
+            :tag => :uniqueness,
+          }.merge!(extract_options!(atts))
+    
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            error_field = a
+            a = Array(a)
+            v = Array(v)
+            ds = o.class.filter(a.zip(v))
+            num_dups = ds.count
+            allow = if num_dups == 0
+              # No unique value in the database
+              true
+            elsif num_dups > 1
+              # Multiple "unique" values in the database!!
+              # Someone didn't add a unique index
+              false
+            elsif o.new?
+              # New record, but unique value already exists in the database
+              false
+            elsif ds.first === o
+              # Unique value exists in database, but for the same record, so the update won't cause a duplicate record
+              true
+            else
+              false
+            end
+            o.errors[error_field] << opts[:message] unless allow
+          end
+        end
+    
+        # Returns the validations hash for the class.
+        def validations
+          @validations ||= Hash.new {|h, k| h[k] = []}
+        end
+        
+        private
+    
+        def validation_if_proc(o, i)
+          case i
+          when Symbol then o.send(i)
+          when Proc then o.instance_eval(&i)
+          when nil then true
+          else raise(::Sequel::Error, "invalid value for :if validation option")
+          end
+        end
+      end
+    
+      module InstanceMethods
+        # Validates the object.
+        def validate
+          model.validate(self)
+        end
+      end
+    end
+  end
+
+  Model.plugin :deprecated_validation_class_methods
+end

data/lib/sequel/model/errors.rb

@@ -0,0 +1,37 @@
+module Sequel
+  class Model
+    # Errors represents validation errors, a simple hash subclass
+    # with a few convenience methods.
+    class Errors < ::Hash
+      # Assign an array of messages for each attribute on access
+      def initialize
+        super{|h,k| h[k] = []}
+      end
+
+      # Adds an error for the given attribute.
+      def add(att, msg)
+        self[att] << msg
+      end
+
+      # Return the total number of error messages.
+      def count
+        full_messages.length
+      end
+      
+      # Returns an array of fully-formatted error messages.
+      def full_messages
+        inject([]) do |m, kv| 
+          att, errors = *kv
+          errors.each {|e| m << "#{Array(att).join(' and ')} #{e}"}
+          m
+        end
+      end
+      
+      # Returns the array of errors for the given attribute, or nil
+      # if there are no errors for the attribute.
+      def on(att)
+        self[att] if include?(att)
+      end
+    end
+  end
+end

data/lib/sequel/model/exceptions.rb

@@ -0,0 +1,7 @@
+module Sequel
+  # This exception will be raised when raise_on_save_failure is set and a validation fails
+  class ValidationFailed < Error;end
+
+  # This exception will be raised when raise_on_save_failure is set and a before hook fails
+  class BeforeHookFailed < Error;end
+end

data/lib/sequel/model/inflections.rb

@@ -0,0 +1,230 @@
+module Sequel
+  # Yield the Inflections module if a block is given, and return
+  # the Inflections module.
+  def self.inflections
+    yield Inflections if block_given?
+    Inflections
+  end
+
+  # 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)
+      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
+
+    # Setup the default inflections
+    # Commented out until the deprecated inflector is removed
+=begin
+    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))
+=end
+    private
+
+    # 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(s)
+      s = s.to_s
+      # return s.camelize if s.respond_to?(:camelize)
+      s = s.gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+      s
+    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(s)
+      s = s.to_s
+      # return s.constantize if s.respond_to?(:constantize)
+      raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(s.to_s)
+      Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+    end
+  
+    # Removes the module part from the expression in the string
+    #
+    # Examples
+    #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+    #   "Inflections".demodulize #=> "Inflections"
+    def demodulize(s)
+      s = s.to_s
+      # return s.demodulize if s.respond_to?(:demodulize)
+      s.gsub(/^.*::/, '')
+    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(s)
+      s = s.to_s
+      # return s.pluralize if s.respond_to?(:pluralize)
+      result = s.dup
+      Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.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(s)
+      s = s.to_s
+      # return s.singularize if s.respond_to?(:singularize)
+      result = s.dup
+      Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
+      result
+    end
+  
+    # 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(s)
+      s = s.to_s
+      # return s.underscore if s.respond_to?(:underscore)
+      s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+    end
+  end
+end