sequel 3.21.0 → 3.39.0

data/lib/sequel/model/errors.rb

@@ -40,7 +40,7 @@ module Sequel
       def full_messages
         inject([]) do |m, kv| 
           att, errors = *kv
-          errors.each {|e| m << "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}"}
+          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}")}
           m
         end
       end

data/lib/sequel/model/exceptions.rb

@@ -1,6 +1,18 @@
 module Sequel
   # Exception class raised when +raise_on_save_failure+ is set and a before hook returns false
-  class BeforeHookFailed < Error; end
+  # or an around hook doesn't call super or yield.
+  class HookFailed < Error
+    # The Sequel::Model instance related to this error.
+    attr_reader :model
+
+    def initialize(message, model=nil)
+      @model = model
+      super(message)
+    end
+  end
+
+  # Deprecated alias for HookFailed, kept for backwards compatibility
+  BeforeHookFailed = HookFailed
   
   # Exception class raised when +require_modification+ is set and an UPDATE or DELETE statement to modify the dataset doesn't
   # modify a single row.
@@ -11,7 +23,18 @@ module Sequel
   
   # Exception class raised when +raise_on_save_failure+ is set and validation fails
   class ValidationFailed < Error
+    # The Sequel::Model object related to this exception.
+    attr_reader :model
+
+    # The Sequel::Model::Errors object related to this exception.
+    attr_reader :errors
+
     def initialize(errors)
+      if errors.is_a?(Sequel::Model)
+        @model = errors
+        errors = @model.errors
+      end
+
       if errors.respond_to?(:full_messages)
         @errors = errors
         super(errors.full_messages.join(', '))
@@ -19,6 +42,5 @@ module Sequel
         super
       end
     end
-    attr_reader :errors
   end
 end

data/lib/sequel/model/inflections.rb

@@ -121,7 +121,7 @@ module Sequel
     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)
+      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s)
       Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
     end
   

data/lib/sequel/model.rb

@@ -11,9 +11,9 @@ module Sequel
   #             with the +Database+ in +source+ to create the
   #             dataset to use) 
   # Dataset :: Sets the dataset for this model to +source+. 
-  # Symbol :: Sets the table name for this model to +source+. The
-  #           class will use the default database for model
-  #           classes in order to create the dataset.
+  # other :: Sets the table name for this model to +source+. The
+  #          class will use the default database for model
+  #          classes in order to create the dataset.
   #
   # The purpose of this method is to set the dataset/database automatically
   # for a model class, if the table name doesn't match the implicit
@@ -35,13 +35,18 @@ module Sequel
   #     dataset # => DB1[:comments]
   #   end
   def self.Model(source)
-    Model::ANONYMOUS_MODEL_CLASSES[source] ||= if source.is_a?(Database)
+    if Sequel::Model.cache_anonymous_models && (klass = Sequel.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source]})
+      return klass
+    end
+    klass = if source.is_a?(Database)
       c = Class.new(Model)
       c.db = source
       c
     else
       Class.new(Model).set_dataset(source)
     end
+    Sequel.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source] = klass} if Sequel::Model.cache_anonymous_models
+    klass
   end
 
   # <tt>Sequel::Model</tt> is an object relational mapper built on top of Sequel core.  Each
@@ -49,14 +54,18 @@ module Sequel
   # called directly on the class.  Model datasets return rows as model instances,
   # which have fairly standard ORM instance behavior.
   #
-  # <tt>Sequel::Model</tt> is built completely out of plugins, the only method not part of a
-  # plugin is the plugin method itself.  Plugins can override any class, instance, or
-  # dataset method defined by a previous plugin and call super to get the default
-  # behavior.
+  # <tt>Sequel::Model</tt> is built completely out of plugins.  Plugins can override any class,
+  # instance, or dataset method defined by a previous plugin and call super to get the default
+  # behavior.  By default, <tt>Sequel::Model</tt> loads two plugins, <tt>Sequel::Model</tt>
+  # (which is itself a plugin) for the base support, and <tt>Sequel::Model::Associations</tt>
+  # for the associations support.
   #
   # You can set the +SEQUEL_NO_ASSOCIATIONS+ constant or environment variable to
   # make Sequel not load the associations plugin by default.
   class Model
+    # Cache anonymous models created by Sequel::Model()
+    @cache_anonymous_models = true
+
     # Map that stores model classes created with <tt>Sequel::Model()</tt>, to allow the reopening
     # of classes when dealing with code reloading.
     ANONYMOUS_MODEL_CLASSES = {}
@@ -69,7 +78,8 @@ module Sequel
     EMPTY_INSTANCE_VARIABLES = [:@overridable_methods_module, :@db]
 
     # Boolean settings that can be modified at the global, class, or instance level.
-    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_transactions]
+    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, \
+      :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_after_commit_rollback, :use_transactions]
 
     # Hooks that are called before an action.  Can return false to not do the action.  When
     # overriding these, it is recommended to call +super+ as the last line of your method,
@@ -78,7 +88,13 @@ module Sequel
 
     # Hooks that are called after an action.  When overriding these, it is recommended to call
     # +super+ on the first line of your method, so later hooks are called after earlier hooks.
-    AFTER_HOOKS = [:after_initialize, :after_create, :after_update, :after_save, :after_destroy, :after_validation]
+    AFTER_HOOKS = [:after_initialize, :after_create, :after_update, :after_save, :after_destroy,
+      :after_validation, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]
+
+    # Hooks that are called around an action.  If overridden, these methods must call super
+    # exactly once if the behavior they wrap is desired.  The can be used to rescue exceptions
+    # raised by the code they wrap or ensure that some behavior is executed no matter what.
+    AROUND_HOOKS = [:around_create, :around_update, :around_save, :around_destroy, :around_validation]
 
     # Empty instance methods to create that the user can override to get hook/callback behavior.
     # Just like any other method defined by Sequel, if you override one of these, you should
@@ -96,7 +112,9 @@ module Sequel
       :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
       :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil,
       :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
-      :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil}
+      :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil,
+      :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil,
+      :@fast_instance_delete_sql=>nil}
 
     # Regular expression that determines if a method name is normal in the sense that
     # it could be used literally in ruby code without using send.  Used to
@@ -126,6 +144,7 @@ module Sequel
     @strict_param_setting = true
     @typecast_empty_string_to_nil = true
     @typecast_on_assignment = true
+    @use_after_commit_rollback = true
     @use_transactions = true
 
     Sequel.require %w"default_inflections inflections plugins base exceptions errors", "model"

data/lib/sequel/no_core_ext.rb

@@ -0,0 +1,2 @@
+::SEQUEL_NO_CORE_EXTENSIONS = true unless defined?(::SEQUEL_NO_CORE_EXTENSIONS)
+require 'sequel'

data/lib/sequel/plugins/active_model.rb

@@ -16,7 +16,14 @@ module Sequel
     #   # Make the Album class active_model compliant
     #   Album.plugin :active_model
     module ActiveModel
-      ClassMethods = ::ActiveModel::Naming
+      module ClassMethods
+        include ::ActiveModel::Naming
+        
+        # Class level cache for to_partial_path.
+        def _to_partial_path
+          @_to_partial_path ||= "#{underscore(pluralize(to_s))}/#{underscore(demodulize(to_s))}".freeze
+        end
+      end
 
       module InstanceMethods
         # The default string to join composite primary keys with in to_param.
@@ -56,6 +63,11 @@ module Sequel
             k.join(to_param_joiner)
           end
         end
+
+        # Returns a string identifying the path associated with the object.
+        def to_partial_path
+          model._to_partial_path
+        end
         
         private
         

data/lib/sequel/plugins/association_pks.rb

@@ -14,7 +14,7 @@ module Sequel
     #
     # Note that it uses the singular form of the association name. Also note
     # that the setter both associates to new primary keys not in the assocation
-    # and disassociated from primary keys not provided to the method.
+    # and disassociates from primary keys not provided to the method.
     #
     # This plugin makes modifications directly to the underlying tables,
     # it does not create or return any model objects, and therefore does
@@ -56,6 +56,7 @@ module Sequel
             _join_table_dataset(opts).filter(opts[:left_key]=>send(opts[:left_primary_key])).select_map(opts[:right_key])
           end
           def_association_pks_setter(opts) do |pks|
+            pks = convert_pk_array(opts, pks)
             checked_transaction do
               ds = _join_table_dataset(opts).filter(opts[:left_key]=>send(opts[:left_primary_key]))
               ds.exclude(opts[:right_key]=>pks).delete
@@ -71,17 +72,34 @@ module Sequel
           super
           return if opts[:type] == :one_to_one
           def_association_pks_getter(opts) do
-            send(opts.dataset_method).select_map(opts[:primary_key])
+            send(opts.dataset_method).select_map(opts.associated_class.primary_key)
           end
           def_association_pks_setter(opts) do |pks|
+            pks = convert_pk_array(opts, pks)
             checked_transaction do
               ds = send(opts.dataset_method)
-              ds.unfiltered.filter(opts[:primary_key]=>pks).update(opts[:key]=>pk)
-              ds.exclude(opts[:primary_key]=>pks).update(opts[:key]=>nil)
+              primary_key = opts.associated_class.primary_key
+              key = opts[:key]
+              ds.unfiltered.filter(primary_key=>pks).update(key=>pk)
+              ds.exclude(primary_key=>pks).update(key=>nil)
             end
           end
         end
       end
+
+      module InstanceMethods
+        private
+
+        # If the associated class's primary key column type is integer,
+        # typecast all provided values to integer before using them.
+        def convert_pk_array(opts, pks)
+          if klass = opts.associated_class and sch = klass.db_schema and col = sch[klass.primary_key] and col[:type] == :integer
+            pks.map{|pk| model.db.typecast_value(:integer, pk)}
+          else
+            pks
+          end
+        end
+      end
     end
   end
 end

data/lib/sequel/plugins/caching.rb

@@ -53,9 +53,21 @@ module Sequel
         # The time to live for the cache store, in seconds.
         attr_reader :cache_ttl
 
-        # Set the time to live for the cache store, in seconds (default is 3600, # so 1 hour).
-        def set_cache_ttl(ttl)
-          @cache_ttl = ttl
+        # Delete the cached object with the given primary key.
+        def cache_delete_pk(pk)
+          cache_delete(cache_key(pk))
+        end
+
+        # Return the cached object with the given primary key,
+        # or nil if no such object is in the cache.
+        def cache_get_pk(pk)
+          cache_get(cache_key(pk))
+        end
+
+        # Return a key string for the given primary key.
+        def cache_key(pk)
+          raise(Error, 'no primary key for this record') unless pk.is_a?(Array) ? pk.all? : pk
+          "#{self}:#{Array(pk).join(',')}"
         end
         
         # Copy the necessary class instance variables to the subclass.
@@ -69,8 +81,13 @@ module Sequel
             @cache_ttl = ttl
             @cache_ignore_exceptions = cache_ignore_exceptions
           end
-        end
+        end 
 
+        # Set the time to live for the cache store, in seconds (default is 3600, # so 1 hour).
+        def set_cache_ttl(ttl)
+          @cache_ttl = ttl
+        end
+        
         private
     
         # Delete the entry with the matching key from the cache
@@ -79,6 +96,8 @@ module Sequel
           nil
         end
         
+        # Returned the cached object, or nil if the object was not
+        # in the cached
         def cache_get(ck)
           if @cache_ignore_exceptions
             @cache_store.get(ck) rescue nil
@@ -87,11 +106,6 @@ module Sequel
           end
         end
     
-        # Return a key string for the pk
-        def cache_key(pk)
-          "#{self}:#{Array(pk).join(',')}"
-        end
-        
         # Set the object in the cache_store with the given key for cache_ttl seconds.
         def cache_set(ck, obj)
           @cache_store.set(ck, obj, @cache_ttl)
@@ -120,14 +134,7 @@ module Sequel
         # primary key value(s) for the object.  If the model does not have a primary
         # key, raise an Error.
         def cache_key
-          raise(Error, "No primary key is associated with this model") unless key = primary_key
-          pk = case key
-          when Array
-            key.collect{|k| @values[k]}
-          else
-            @values[key] || (raise Error, 'no primary key for this record')
-          end
-          model.send(:cache_key, pk)
+          model.cache_key(pk)
         end
     
         # Remove the object from the cache when deleting
@@ -140,7 +147,7 @@ module Sequel
     
         # Delete this object from the cache
         def cache_delete
-          model.send(:cache_delete, cache_key)
+          model.cache_delete_pk(pk)
         end
       end
     end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -90,9 +90,9 @@ module Sequel
           @cti_columns = {table_name=>columns}
           @cti_table_map = opts[:table_map] || {}
           dataset.row_proc = if key
-            lambda{|r| (m.call(r[key]) rescue model).load(r)}
+            lambda{|r| (m.call(r[key]) rescue model).call(r)}
           else
-            lambda{|r| model.load(r)}
+            model
           end
         end
       end
@@ -152,9 +152,9 @@ module Sequel
           subclass.instance_eval do
             m = method(:constantize)
             dataset.row_proc = if cti_key
-              lambda{|r| (m.call(r[ck]) rescue subclass).load(r)}
+              lambda{|r| (m.call(r[ck]) rescue subclass).call(r)}
             else
-              lambda{|r| subclass.load(r)}
+              subclass
             end
             (columns - [cbm.primary_key]).each{|a| define_lazy_attribute_getter(a)}
             cti_tables.reverse.each do |table|

data/lib/sequel/plugins/composition.rb

@@ -1,20 +1,53 @@
 module Sequel
   module Plugins
-    # The composition plugin allows you to easily define getter and
-    # setter instance methods for a class where the backing data
-    # is composed of other getters and decomposed to other setters.
+    # The composition plugin allows you to easily define a virtual
+    # attribute where the backing data is composed of other columns.
     #
-    # A simple example of this is when you have a database table with
-    # separate columns for year, month, and day, but where you want
-    # to deal with Date objects in your ruby code.  This can be handled
-    # with:
+    # There are two ways to use the plugin.  One way is with the
+    # :mapping option.  A simple example of this is when you have a
+    # database table with separate columns for year, month, and day,
+    # but where you want to deal with Date objects in your ruby code.
+    # This can be handled with:
     #
     #   Album.plugin :composition
     #   Album.composition :date, :mapping=>[:year, :month, :day]
     #
-    # The :mapping option is optional, but you can define custom
-    # composition and decomposition procs via the :composer and
-    # :decomposer options.
+    # With the :mapping option, you can provide a :class option
+    # that gives the class to use, but if that is not provided, it
+    # is inferred from the name of the composition (e.g. :date -> Date).
+    # When the <tt>date</tt> method is called, it will return a
+    # Date object by calling:
+    #
+    #   Date.new(year, month, day)
+    #
+    # When saving the object, if the date composition has been used
+    # (by calling either the getter or setter method), it will
+    # populate the related columns of the object before saving:
+    #
+    #   self.year = date.year
+    #   self.month = date.month
+    #   self.day = date.day
+    #
+    # The :mapping option is just a shortcut that works in particular
+    # cases.  To handle any case, you can define a custom :composer
+    # and :decomposer procs.  The :composer proc will be instance_evaled
+    # the first time the getter is called, and the :decomposer proc
+    # will be instance_evaled before saving.  The above example could
+    # also be implemented as:
+    #
+    #   Album.composition :date,
+    #     :composer=>proc{Date.new(year, month, day) if year || month || day},
+    #     :decomposer=>(proc do
+    #       if d = compositions[:date]
+    #         self.year = d.year
+    #         self.month = d.month
+    #         self.day = d.day
+    #       else
+    #         self.year = nil
+    #         self.month = nil
+    #         self.day = nil
+    #       end
+    #     end)
     #
     # Note that when using the composition object, you should not
     # modify the underlying columns if you are also instantiating
@@ -117,9 +150,8 @@ module Sequel
       module InstanceMethods
         # Clear the cached compositions when refreshing.
         def _refresh(ds)
-          v = super
+          super
           compositions.clear
-          v
         end
 
         # For each composition, set the columns in the model class based

data/lib/sequel/plugins/constraint_validations.rb

@@ -0,0 +1,198 @@
+module Sequel
+  module Plugins
+    # The constraint_validations plugin is designed to be used with databases
+    # that used the constraint_validations extension when creating their
+    # tables.  The extension adds validation metadata for constraints created,
+    # and this plugin reads that metadata and automatically creates validations
+    # for all of the constraints.  For example, if you used the extension
+    # and created your albums table like this:
+    #
+    #   DB.create_table(:albums) do
+    #     primary_key :id
+    #     String :name
+    #     validate do
+    #       min_length 5, :name
+    #     end
+    #   end
+    #
+    # Then when you went to save an album that uses this plugin:
+    #
+    #   Album.create(:name=>'abc')
+    #   # raises Sequel::ValidationFailed: name is shorter than 5 characters
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses use constraint validations (called before loading subclasses)
+    #   Sequel::Model.plugin :constraint_validations
+    #
+    #   # Make the Album class use constraint validations
+    #   Album.plugin :constraint_validations
+    module ConstraintValidations
+      # The default constraint validation metadata table name.
+      DEFAULT_CONSTRAINT_VALIDATIONS_TABLE = :sequel_constraint_validations
+
+      # Automatically load the validation_helpers plugin to run the actual validations.
+      def self.apply(model, opts={})
+        model.plugin :validation_helpers
+      end
+
+      # Parse the constraint validations metadata from the database. Options:
+      # :constraint_validations_table :: Override the name of the constraint validations
+      #                                  metadata table.  Should only be used if the table
+      #                                  name was overridden when creating the constraint
+      #                                  validations.
+      def self.configure(model, opts={})
+        model.instance_variable_set(:@constraint_validations_table, opts[:constraint_validations_table] || DEFAULT_CONSTRAINT_VALIDATIONS_TABLE)
+        model.send(:parse_constraint_validations)
+      end
+
+      module DatabaseMethods
+        # A hash of validation method call metadata for all tables in the database.
+        # The hash is keyed by table name string and contains arrays of validation
+        # method call arrays.
+        attr_accessor :constraint_validations
+      end
+
+      module ClassMethods
+        # An array of validation method call arrays.  Each array is an array that
+        # is splatted to send to perform a validation via validation_helpers.
+        attr_reader :constraint_validations
+
+        # The name of the table containing the constraint validations metadata.
+        attr_reader :constraint_validations_table
+
+        # Copy the name of the constraint validations metadata table into the subclass.
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@constraint_validations_table, @constraint_validations_table)
+        end
+
+        # Parse the constraint validations from the database whenever the dataset
+        # changes.
+        def set_dataset(*)
+          r = super
+          parse_constraint_validations
+          r
+        end
+
+        private
+
+        # If the database has not already parsed constraint validation
+        # metadata, then run a query to get the metadata data and transform it
+        # into arrays of validation method calls.
+        #
+        # If this model has associated dataset, use the model's table name
+        # to get the validations for just this model.
+        def parse_constraint_validations
+          db.extend(DatabaseMethods)
+
+          unless hash = Sequel.synchronize{db.constraint_validations}
+            hash = {}
+            db.from(constraint_validations_table).each do |r|
+              (hash[r[:table]] ||= []) << constraint_validation_array(r)
+            end
+            Sequel.synchronize{db.constraint_validations = hash}
+          end
+
+          if @dataset
+            ds = @dataset.clone
+            ds.quote_identifiers = false
+            table_name = ds.literal(model.table_name)
+            @constraint_validations = Sequel.synchronize{hash[table_name]} || []
+          end
+        end
+
+        # Given a specific database constraint validation metadata row hash, transform
+        # it in an validation method call array suitable for splatting to send.
+        def constraint_validation_array(r)
+          opts = {}
+          opts[:message] = r[:message] if r[:message]
+          opts[:allow_nil] = true if db.typecast_value(:boolean, r[:allow_nil])
+          type = r[:validation_type].to_sym
+          arg = r[:argument]
+          column = r[:column]
+
+          case type
+          when :like, :ilike
+            arg = constraint_validation_like_to_regexp(arg, type == :ilike)
+            type = :format
+          when :exact_length, :min_length, :max_length
+            arg = arg.to_i
+          when :length_range
+            arg = constraint_validation_int_range(arg)
+          when :format
+            arg = Regexp.new(arg)
+          when :iformat
+            arg = Regexp.new(arg, Regexp::IGNORECASE)
+            type = :format
+          when :includes_str_array
+            arg = arg.split(',')
+            type = :includes
+          when :includes_int_array
+            arg = arg.split(',').map{|x| x.to_i}
+            type = :includes
+          when :includes_int_range
+            arg = constraint_validation_int_range(arg)
+            type = :includes
+          end
+
+          column = if type == :unique
+            column.split(',').map{|c| c.to_sym}
+          else
+            column.to_sym
+          end
+
+          a = [:"validates_#{type}"]
+          if arg
+            a << arg
+          end 
+          a << column
+          unless opts.empty?
+            a << opts
+          end
+          a
+        end
+
+        # Return a range of integers assuming the argument is in
+        # 1..2 or 1...2 format.
+        def constraint_validation_int_range(arg)
+          arg =~ /(\d+)\.\.(\.)?(\d+)/
+          Range.new($1.to_i, $3.to_i, $2 == '.')
+        end
+
+        # Transform the LIKE pattern string argument into a
+        # Regexp argument suitable for use with validates_format.
+        def constraint_validation_like_to_regexp(arg, case_insensitive)
+          arg = Regexp.escape(arg).gsub(/%%|%|_/) do |s|
+            case s
+            when '%%'
+              '%'
+            when '%'
+              '.*'
+            when '_'
+              '.'
+            end
+          end
+          arg = "\\A#{arg}\\z"
+
+          if case_insensitive
+            Regexp.new(arg, Regexp::IGNORECASE)
+          else
+            Regexp.new(arg)
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Run all of the constraint validations parsed from the database
+        # when validating the instance.
+        def validate
+          super
+          model.constraint_validations.each do |v|
+            send(*v)
+          end
+        end
+      end
+    end
+  end
+end