viking-sequel 3.10.0

data/lib/sequel/model/default_inflections.rb

@@ -0,0 +1,45 @@
+module Sequel
+  # Proc that is instance evaled to create the default inflections for both the
+  # model inflector and the inflector extension.
+  DEFAULT_INFLECTIONS_PROC = proc do
+    plural(/$/, 's')
+    plural(/s$/i, 's')
+    plural(/(alias|(?:stat|octop|vir|b)us)$/i, '\1es')
+    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')
+
+    singular(/s$/i, '')
+    singular(/([ti])a$/i, '\1um')
+    singular(/(analy|ba|cri|diagno|parenthe|progno|synop|the)ses$/i, '\1sis')
+    singular(/([^f])ves$/i, '\1fe')
+    singular(/([h|t]ive)s$/i, '\1')
+    singular(/([lr])ves$/i, '\1f')
+    singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    singular(/(m)ovies$/i, '\1ovie')
+    singular(/(x|ch|ss|sh)es$/i, '\1')
+    singular(/([m|l])ice$/i, '\1ouse')
+    singular(/buses$/i, 'bus')
+    singular(/oes$/i, 'o')
+    singular(/shoes$/i, 'shoe')
+    singular(/(alias|(?:stat|octop|vir|b)us)es$/i, '\1')
+    singular(/(vert|ind)ices$/i, '\1ex')
+    singular(/matrices$/i, 'matrix')
+
+    irregular('person', 'people')
+    irregular('man', 'men')
+    irregular('child', 'children')
+    irregular('sex', 'sexes')
+    irregular('move', 'moves')
+    irregular('quiz', 'quizzes')
+    irregular('testis', 'testes')
+
+    uncountable(%w(equipment information rice money species series fish sheep news))
+  end
+end

data/lib/sequel/model/errors.rb

@@ -0,0 +1,39 @@
+module Sequel
+  class Model
+    # Errors represents validation errors, a simple hash subclass
+    # with a few convenience methods.
+    class Errors < ::Hash
+      ATTRIBUTE_JOINER = ' and '.freeze
+
+      # Assign an array of messages for each attribute on access
+      def [](k)
+        has_key?(k) ? super : (self[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
+        values.inject(0){|m, v| m + v.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(ATTRIBUTE_JOINER)} #{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 has_key?(att)
+      end
+    end
+  end
+end

data/lib/sequel/model/exceptions.rb

@@ -0,0 +1,21 @@
+module Sequel
+  # Exception class raised when raise_on_save_failure is set and a before hook returns false
+  class BeforeHookFailed < Error; end
+  
+  # Exception class raised when require_modification is set and an UPDATE or DELETE statement to modify the dataset doesn't
+  # modify a single row.
+  class NoExistingObject < Error; end
+  
+  # Exception class raised when raise_on_save_failure is set and validation fails
+  class ValidationFailed < Error
+    def initialize(errors)
+      if errors.respond_to?(:full_messages)
+        @errors = errors
+        super(errors.full_messages.join(', '))
+      else
+        super
+      end
+    end
+    attr_reader :errors
+  end
+end

data/lib/sequel/model/inflections.rb

@@ -0,0 +1,162 @@
+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 Sequel.inflections,
+  # which is used to override or specify additional inflection rules
+  # for Sequel. Examples:
+  #
+  #   Sequel.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
+    CAMELIZE_CONVERT_REGEXP = /(^|_)(.)/.freeze
+    CAMELIZE_MODULE_REGEXP = /\/(.?)/.freeze
+    DASH = '-'.freeze
+    DEMODULIZE_CONVERT_REGEXP = /^.*::/.freeze
+    EMPTY_STRING= ''.freeze
+    SLASH = '/'.freeze
+    VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
+    UNDERSCORE = '_'.freeze
+    UNDERSCORE_CONVERT_REGEXP1 = /([A-Z]+)([A-Z][a-z])/.freeze
+    UNDERSCORE_CONVERT_REGEXP2 = /([a-z\d])([A-Z])/.freeze
+    UNDERSCORE_CONVERT_REPLACE = '\1_\2'.freeze
+    UNDERSCORE_MODULE_REGEXP = /::/.freeze
+
+    @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
+
+    instance_eval(&DEFAULT_INFLECTIONS_PROC)
+
+    private
+
+    # Convert the given string to CamelCase.  Will also convert '/' to '::' which is useful for converting paths to namespaces.
+    def camelize(s)
+      s = s.to_s
+      return s.camelize if s.respond_to?(:camelize)
+      s = s.gsub(CAMELIZE_MODULE_REGEXP){|x| "::#{x[-1..-1].upcase unless x == SLASH}"}.gsub(CAMELIZE_CONVERT_REGEXP){|x| x[-1..-1].upcase}
+      s
+    end
+  
+    # 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.
+    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 = VALID_CONSTANT_NAME_REGEXP.match(s.to_s)
+      Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+    end
+  
+    # Removes the module part from the expression in the string
+    def demodulize(s)
+      s = s.to_s
+      return s.demodulize if s.respond_to?(:demodulize)
+      s.gsub(DEMODULIZE_CONVERT_REGEXP, EMPTY_STRING)
+    end
+  
+    # Returns the plural form of the word in the string.
+    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.
+    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.
+    def underscore(s)
+      s = s.to_s
+      return s.underscore if s.respond_to?(:underscore)
+      s.gsub(UNDERSCORE_MODULE_REGEXP, SLASH).gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE).
+        gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE).tr(DASH, UNDERSCORE).downcase
+    end
+  end
+end

data/lib/sequel/model/plugins.rb

@@ -0,0 +1,70 @@
+module Sequel
+  # Empty namespace that plugins should use to store themselves,
+  # so they can be loaded via Model.plugin.
+  #
+  # Plugins should be modules with one of the following conditions:
+  # * A singleton method named apply, which takes a model, 
+  #   additional arguments, and an optional block.  This is called
+  #   the first time the plugin is loaded for this model (unless it was
+  #   already loaded by an ancestor class), with the arguments
+  #   and block provided to the call to Model.plugin.
+  # * A module inside the plugin module named InstanceMethods,
+  #   which will be included in the model class.
+  # * A module inside the plugin module named ClassMethods,
+  #   which will extend the model class.
+  # * A module inside the plugin module named DatasetMethods,
+  #   which will extend the model's dataset.
+  # * A singleton method named configure, which takes a model, 
+  #   additional arguments, and an optional block.  This is called
+  #   every time the Model.plugin method is called.
+  module Plugins
+  end
+  
+  class Model
+    # Loads a plugin for use with the model class, passing optional arguments
+    # to the plugin.  If the plugin is a module, load it directly.  Otherwise,
+    # require the plugin from either sequel/plugins/#{plugin} or
+    # sequel_#{plugin}, and then attempt to load the module using a
+    # the camelized plugin name under Sequel::Plugins.
+    def self.plugin(plugin, *args, &blk)
+      arg = args.first
+      m = plugin.is_a?(Module) ? plugin : plugin_module(plugin)
+      unless @plugins.include?(m)
+        @plugins << m
+        m.apply(self, *args, &blk) if m.respond_to?(:apply)
+        include(m::InstanceMethods) if m.const_defined?("InstanceMethods")
+        extend(m::ClassMethods)if m.const_defined?("ClassMethods")
+        if m.const_defined?("DatasetMethods")
+          dataset.extend(m::DatasetMethods) if @dataset
+          dataset_method_modules << m::DatasetMethods
+          meths = m::DatasetMethods.public_instance_methods.reject{|x| NORMAL_METHOD_NAME_REGEXP !~ x.to_s}
+          def_dataset_method(*meths) unless meths.empty?
+        end
+      end
+      m.configure(self, *args, &blk) if m.respond_to?(:configure)
+    end
+    
+    module ClassMethods
+      # Array of plugins loaded by this class
+      attr_reader :plugins
+      
+      private
+  
+      # Returns the module for the specified plugin. If the module is not 
+      # defined, the corresponding plugin gem is automatically loaded.
+      def plugin_module(plugin)
+        module_name = plugin.to_s.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+        if !Sequel::Plugins.const_defined?(module_name) ||
+           (Sequel.const_defined?(module_name) &&
+            Sequel::Plugins.const_get(module_name) == Sequel.const_get(module_name))
+          begin
+            Sequel.tsk_require "sequel/plugins/#{plugin}"
+          rescue LoadError
+            Sequel.tsk_require "sequel_#{plugin}"
+          end
+        end
+        Sequel::Plugins.const_get(module_name)
+      end
+    end
+  end
+end

data/lib/sequel/plugins/active_model.rb

@@ -0,0 +1,59 @@
+require 'active_model'
+module Sequel
+  module Plugins
+    # The ActiveModel plugin makes Sequel::Model objects the
+    # pass the ActiveModel::Lint tests, which should
+    # hopefully mean full ActiveModel compliance.  This should
+    # allow the full support of Sequel::Model objects in Rails 3.
+    # This plugin requires active_model in order to use
+    # ActiveModel::Naming.
+    module ActiveModel
+      ClassMethods = ::ActiveModel::Naming
+
+      module InstanceMethods
+        # The default string to join composite primary keys with in to_param.
+        DEFAULT_TO_PARAM_JOINER = '-'.freeze
+      
+        # Record that an object was destroyed, for later use by
+        # destroyed?
+        def after_destroy
+          super
+          @destroyed = true
+        end
+        
+        # False if the object is new? or has been destroyed, true otherwise.
+        def persisted?
+          !new? && @destroyed != true
+        end
+        
+        # An array of primary key values, or nil if the object is not persisted.
+        def to_key
+          if persisted?
+            primary_key.is_a?(Symbol) ? [pk] : pk
+          end
+        end
+
+        # With the ActiveModel plugin, Sequel model objects are already
+        # compliant, so this returns self.
+        def to_model
+          self
+        end
+        
+        # An string representing the object's primary key.  For composite
+        # primary keys, joins them with to_param_joiner.
+        def to_param
+          if k = to_key
+            k.join(to_param_joiner)
+          end
+        end
+        
+        private
+        
+        # The string to use to join composite primary key param strings.
+        def to_param_joiner
+          DEFAULT_TO_PARAM_JOINER
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/association_dependencies.rb

@@ -0,0 +1,103 @@
+module Sequel
+  module Plugins
+    # The AssociationDependencies plugin allows you do easily set up before and/or after destroy hooks
+    # for destroying, deleting, or nullifying associated model objects.  The following
+    # association types support the following dependency actions:
+    # 
+    # * :many_to_many - :nullify (removes all related entries in join table)
+    # * :many_to_one - :delete, :destroy
+    # * :one_to_many, one_to_one - :delete, :destroy, :nullify (sets foreign key to NULL for all associated objects)
+    #
+    # This plugin works directly with the association datasets and does not use any cached association values.
+    # The :delete action will delete all associated objects from the database in a single SQL call.
+    # The :destroy action will load each associated object from the database and call the destroy method on it.
+    #
+    # To set up an association dependency, you must provide a hash with association name symbols
+    # and dependency action values.  You can provide the hash to the plugin call itself or
+    # to the add_association_dependencies method:
+    #
+    #   Business.plugin :association_dependencies, :address=>:delete
+    #   # or:
+    #   Artist.plugin :association_dependencies
+    #   Artist.add_association_dependencies :albums=>:destroy, :reviews=>:delete, :tags=>:nullify
+    module AssociationDependencies
+      # Mapping of association types to when the dependency calls should be made (either
+      # :before for in before_destroy or :after for in after_destroy)
+      ASSOCIATION_MAPPING = {:one_to_many=>:before, :many_to_one=>:after, :many_to_many=>:before, :one_to_one=>:before}
+
+      # The valid dependence actions
+      DEPENDENCE_ACTIONS = [:delete, :destroy, :nullify]
+
+      # Initialize the association_dependencies hash for this model.
+      def self.apply(model, hash={})
+        model.instance_eval{@association_dependencies = {:before_delete=>[], :before_destroy=>[], :before_nullify=>[], :after_delete=>[], :after_destroy=>[]}}
+      end
+
+      # Call add_association_dependencies with any dependencies given in the plugin call.
+      def self.configure(model, hash={})
+        model.add_association_dependencies(hash) unless hash.empty?
+      end
+
+      module ClassMethods
+        # A hash specifying the association dependencies for each model.  The keys
+        # are symbols indicating the type of action and when it should be executed
+        # (e.g. :before_delete).  Values are an array of method symbols.
+        # For before_nullify, the symbols are remove_all_association methods.  For other
+        # types, the symbols are association_dataset methods, on which delete or
+        # destroy is called.
+        attr_reader :association_dependencies
+
+        # Add association dependencies to this model.  The hash should have association name
+        # symbol keys and dependency action symbol values (e.g. :albums=>:destroy).
+        def add_association_dependencies(hash)
+          hash.each do |association, action|
+            raise(Error, "Nonexistent association: #{association}") unless r = association_reflection(association)
+            type = r[:type]
+            raise(Error, "Invalid dependence action type: association: #{association}, dependence action: #{action}") unless DEPENDENCE_ACTIONS.include?(action)
+            raise(Error, "Invalid association type: association: #{association}, type: #{type}") unless time = ASSOCIATION_MAPPING[type]
+            association_dependencies[:"#{time}_#{action}"] << if action == :nullify
+              case type
+              when :one_to_many , :many_to_many
+                proc{send(r.remove_all_method)}
+              when :one_to_one
+                proc{send(r.setter_method, nil)}
+              else
+                raise(Error, "Can't nullify many_to_one associated objects: association: #{association}")
+              end
+            else
+              raise(Error, "Can only nullify many_to_many associations: association: #{association}") if type == :many_to_many
+              r.dataset_method
+            end
+          end
+        end
+
+        # Copy the current model object's association_dependencies into the subclass.
+        def inherited(subclass)
+          super
+          ad = association_dependencies.dup
+          ad.keys.each{|k| ad[k] = ad[k].dup}
+          subclass.instance_variable_set(:@association_dependencies, ad)
+        end
+      end
+
+      module InstanceMethods
+        # Run the delete and destroy association dependency actions for
+        # many_to_one associations.
+        def after_destroy
+          super
+          model.association_dependencies[:after_delete].each{|m| send(m).delete}
+          model.association_dependencies[:after_destroy].each{|m| send(m).destroy}
+        end
+
+        # Run the delete, destroy, and nullify association dependency actions for
+        # *_to_many associations.
+        def before_destroy
+          model.association_dependencies[:before_delete].each{|m| send(m).delete}
+          model.association_dependencies[:before_destroy].each{|m| send(m).destroy}
+          model.association_dependencies[:before_nullify].each{|p| instance_eval(&p)}
+          super
+        end
+      end
+    end
+  end
+end