sequel 3.21.0 → 3.41.0

data/lib/sequel/plugins/subclasses.rb

@@ -15,20 +15,34 @@ module Sequel
     #   sc2.subclasses  # []
     #   ssc1.subclasses # []
     #   c.descendents   # [sc1, ssc1, sc2]
+    #
+    # You can provide a block when loading the plugin, and it will be called
+    # with each subclass created:
+    #
+    #   a = []
+    #   Sequel::Model.plugin(:subclasses){|sc| a << sc}
+    #   class A < Sequel::Model; end
+    #   class B < Sequel::Model; end
+    #   a # => [A, B]
     module Subclasses
       # Initialize the subclasses instance variable for the model.
-      def self.apply(model)
+      def self.apply(model, &block)
         model.instance_variable_set(:@subclasses, [])
+        model.instance_variable_set(:@on_subclass, block)
       end
 
       module ClassMethods
+        # Callable object that should be called with every descendent
+        # class created.
+        attr_reader :on_subclass
+
         # All subclasses for the current model.  Does not
         # include the model itself.
         attr_reader :subclasses
 
         # All descendent classes of this model.
         def descendents
-          subclasses.map{|x| [x] + x.descendents}.flatten
+          Sequel.synchronize{_descendents}
         end
 
         # Add the subclass to this model's current subclasses,
@@ -36,8 +50,20 @@ module Sequel
         # in the subclass.
         def inherited(subclass)
           super
-          subclasses << subclass
+          Sequel.synchronize{subclasses << subclass}
           subclass.instance_variable_set(:@subclasses, [])
+          if on_subclass
+            subclass.instance_variable_set(:@on_subclass, on_subclass)
+            on_subclass.call(subclass)
+          end
+        end
+
+        private
+
+        # Recursive, non-thread safe version of descendents, since
+        # the mutex Sequel uses isn't reentrant.
+        def _descendents
+          subclasses.map{|x| [x] + x.send(:_descendents)}.flatten
         end
       end
     end

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -28,19 +28,18 @@ module Sequel
     module TacticalEagerLoading
       module InstanceMethods
         # The dataset that retrieved this object, set if the object was
-        # reteived via Dataset#all with an active identity map.
+        # reteived via Dataset#all.
         attr_accessor :retrieved_by
 
         # All model objects retrieved with this object, set if the object was
-        # reteived via Dataset#all with an active identity map.
+        # reteived via Dataset#all.
         attr_accessor :retrieved_with
 
         private
 
-        # If there is an active identity map and the association is not in the
-        # associations cache and the object was reteived via Dataset#all,
-        # eagerly load the association for all model objects retrieved with the
-        # current object.
+        # If there the association is not in the associations cache and the object
+        # was reteived via Dataset#all, eagerly load the association for all model
+        # objects retrieved with the current object.
         def load_associated_objects(opts, reload=false)
           name = opts[:name]
           if !associations.include?(name) && retrieved_by
@@ -51,6 +50,7 @@ module Sequel
               # is only defined in a subclass.  This particular instance can use the
               # association, but it can't be eagerly loaded as the parent class doesn't
               # have access to the association, and that's the class doing the eager loading.
+              nil
             end
           end
           super
@@ -60,7 +60,7 @@ module Sequel
       module DatasetMethods
         private
 
-        # If there is an active identity map, set the reteived_with attribute for the object
+        # Set the reteived_with and retrieved_by attributes for the object
         # with the current dataset and array of all objects.
         def post_load(objects)
           super

data/lib/sequel/plugins/timestamps.rb

@@ -19,7 +19,7 @@ module Sequel
     #   # timestamp, and setting the update timestamp when creating
     #   Album.plugin :timestamps, :force=>true, :update_on_create=>true
     module Timestamps
-      # Configure the plugin by setting the avialable options.  Note that
+      # Configure the plugin by setting the available options.  Note that
       # if this method is run more than once, previous settings are ignored,
       # and it will just use the settings given or the default settings.  Options:
       # * :create - The field to hold the create timestamp (default: :created_at)

data/lib/sequel/plugins/touch.rb

@@ -52,7 +52,7 @@ module Sequel
         attr_accessor :touch_column
 
         # A hash specifying the associations to touch when instances are
-        # updated or destroyed. Keys are association dataset method name symbols and values
+        # updated or destroyed. Keys are association name symbols and values
         # are column name symbols.
         attr_reader :touched_associations
 
@@ -71,8 +71,8 @@ module Sequel
           associations.flatten.each do |a|
             a = {a=>touch_column} if a.is_a?(Symbol)
             a.each do |k,v|
-              raise(Error, "invalid association: #{k}") unless r = association_reflection(k)
-              touched_associations[r.dataset_method] = v
+              raise(Error, "invalid association: #{k}") unless association_reflection(k)
+              touched_associations[k] = v
             end
           end
         end
@@ -113,10 +113,22 @@ module Sequel
           Sequel::CURRENT_TIMESTAMP
         end
 
-        # Directly update the database using the association dataset for each association.
+        # Update the updated at field for all associated objects that should be touched.
         def touch_associations
-          model.touched_associations.each do |meth, column|
-            send(meth).update(column=>touch_association_value)
+          model.touched_associations.each do |assoc, column|
+            r = model.association_reflection(assoc)
+            next unless r.can_have_associated_objects?(self)
+            ds = send(r.dataset_method)
+
+            if ds.send(:joined_dataset?)
+              # Can't update all values at once, so update each instance individually.
+              # Instead if doing a simple save, update via the instance's dataset,
+              # to avoid going into an infinite loop in some cases.
+              send(r[:name]).each{|x| x.this.update(column=>touch_association_value)}
+            else
+              # Update all values at once for performance reasons.
+              ds.update(column=>touch_association_value)
+            end
           end
         end
 

data/lib/sequel/plugins/tree.rb

@@ -4,7 +4,7 @@ module Sequel
     # treat a Model as a tree.  
     #
     # A column for holding the parent key is required and is :parent_id by default.  
-    # This may be overridden by passing column name via :key
+    # This may be overridden by passing column name via :key.
     #
     # Optionally, a column to control order of nodes returned can be specified
     # by passing column name via :order.
@@ -98,7 +98,7 @@ module Sequel
           nodes 
         end
 
-        # Returns the root node of the tree that this node descends from
+        # Returns the root node of the tree that this node descends from.
         # This node is returned if it is a root node itself.
         def root
           ancestors.last || self
@@ -124,7 +124,7 @@ module Sequel
         end
       end
 
-      # Plugin included when :single_root option is passed
+      # Plugin included when :single_root option is passed.
       module SingleRoot
         module ClassMethods
           # Returns the single root node.

data/lib/sequel/plugins/typecast_on_load.rb

@@ -5,7 +5,7 @@ module Sequel
     # typecast correctly (with correct being defined as how the model object
     # would typecast the same column values).
     #
-    # This plugin modifies Model.load to call the setter methods (which typecast
+    # This plugin modifies Model#set_values to call the setter methods (which typecast
     # by default) for all columns given.  You can either specify the columns to
     # typecast on load in the plugin call itself, or afterwards using 
     # add_typecast_on_load_columns:
@@ -41,16 +41,11 @@ module Sequel
           super
           subclass.instance_variable_set(:@typecast_on_load_columns, typecast_on_load_columns.dup)
         end
-
-        # Call the setter method for each of the typecast on load columns,
-        # ensuring the model object will have the correct typecasting even
-        # if the database doesn't typecast the columns correctly.
-        def load(values)
-          super.load_typecast
-        end
       end
 
       module InstanceMethods
+        # Call the setter method for each of the model's typecast_on_load_columns
+        # with the current value, so it can be typecasted correctly.
         def load_typecast
           model.typecast_on_load_columns.each do |c|
             if v = values[c]
@@ -61,10 +56,12 @@ module Sequel
           self
         end
 
-        private
-
-        def _refresh(dataset)
-          super.load_typecast
+        # Typecast values using #load_typecast when the values are retrieved from
+        # the database.
+        def set_values(values)
+          ret = super
+          load_typecast
+          ret
         end
       end
     end

data/lib/sequel/plugins/update_primary_key.rb

@@ -1,6 +1,6 @@
 module Sequel
   module Plugins
-    # The update_primary_key plugin allows you to modify an objects
+    # The update_primary_key plugin allows you to modify an object's
     # primary key and then save the record.  Sequel does not work
     # correctly with primary key modifications by default.  Sequel
     # is designed to work with surrogate primary keys that never need to be
@@ -22,7 +22,7 @@ module Sequel
     module UpdatePrimaryKey
       module ClassMethods
         # Cache the pk_hash when loading records
-        def load(h)
+        def call(h)
           r = super(h)
           r.pk_hash
           r

data/lib/sequel/plugins/validation_class_methods.rb

@@ -60,7 +60,6 @@ module Sequel
 
         # Setup the validations and validation_reflections hash in the subclass.
         def inherited(subclass)
-          super
           vr = @validation_reflections
           subclass.class_eval do
             @validation_mutex = Mutex.new
@@ -69,6 +68,7 @@ module Sequel
             vr.each{|k,v| h[k] = v.dup}
             @validation_reflections = h
           end
+          super
         end
     
         # Instructs the model to skip validations defined in superclasses
@@ -385,6 +385,7 @@ module Sequel
             error_field = a
             a = Array(a)
             v = Array(v)
+            next if v.empty? || !v.all?
             ds = o.class.filter(a.zip(v))
             num_dups = ds.count
             allow = if num_dups == 0

data/lib/sequel/plugins/validation_helpers.rb

@@ -40,6 +40,37 @@ module Sequel
     # changing the values of the Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS hash.  You
     # change change the default options on a per model basis
     # by overriding a private instance method default_validation_helpers_options.
+    #
+    # By changing the default options, you can setup internationalization of the
+    # error messages.  For example, you would modify the default options:
+    #
+    #   Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS.merge!(
+    #     :exact_length=>{:message=>lambda{|exact| I18n.t("errors.exact_length", :exact => exact)}},
+    #     :integer=>{:message=>lambda{I18n.t("errors.integer")}},
+    #     ...
+    #   )
+    #
+    # and then use something like this in your yaml translation file:
+    #
+    #   en:
+    #     errors:
+    #       exact_length: "is not %{exact} characters"
+    #       integer: "is not a number"
+    #
+    # Note that if you want to support internationalization of Errors#full_messages,
+    # you need to override the method.  Here's an example:
+    #   
+    #   class Sequel::Model::Errors
+    #     ATTRIBUTE_JOINER = I18n.t('errors.joiner').freeze
+    #     def full_messages
+    #       inject([]) do |m, kv|
+    #         att, errors = *kv
+    #         att.is_a?(Array) ? Array(att).map!{|v| I18n.t("attributes.#{v}")} : att = I18n.t("attributes.#{att}")
+    #         errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}")}
+    #         m
+    #       end
+    #     end
+    #   end
     module ValidationHelpers
       # Default validation options used by Sequel.  Can be modified to change the error
       # messages for all models (e.g. for internationalization), or to set certain
@@ -162,19 +193,41 @@ module Sequel
         # since it can deal with a grouping of multiple attributes.
         #
         # Possible Options:
-        # * :message - The message to use (default: 'is already taken')
-        # * :only_if_modified - Only check the uniqueness if the object is new or
-        #   one of the columns has been modified.
+        # :message :: The message to use (default: 'is already taken')
+        # :only_if_modified :: Only check the uniqueness if the object is new or
+        #                      one of the columns has been modified.
+        # :where :: A callable object where call takes three arguments, a dataset,
+        #           the current object, and an array of columns, and should return
+        #           a modified dataset that is filtered to include only rows with
+        #           the same values as the current object for each column in the array.
+        #
+        # If you want to to a case insensitive uniqueness validation on a database that
+        # is case sensitive by default, you can use:
+        #
+        #   :where=>(proc do |ds, obj, cols|
+        #     ds.where(cols.map do |c|
+        #       v = obj.send(c)
+        #       v = v.downcase if v
+        #       [Sequel.function(:lower, c), v]
+        #     end)
+        #   end)
         def validates_unique(*atts)
           opts = default_validation_helpers_options(:unique)
           if atts.last.is_a?(Hash)
             opts = opts.merge(atts.pop)
           end
           message = validation_error_message(opts[:message])
+          where = opts[:where]
           atts.each do |a|
             arr = Array(a)
             next if opts[:only_if_modified] && !new? && !arr.any?{|x| changed_columns.include?(x)}
-            ds = model.filter(arr.map{|x| [x, send(x)]})
+            ds = if where
+              where.call(model.dataset, self, arr)
+            else
+              vals = arr.map{|x| send(x)}
+              next unless vals.all?
+              model.where(arr.zip(vals))
+            end
             ds = yield(ds) if block_given?
             ds = ds.exclude(pk_hash) unless new?
             errors.add(a, message) unless ds.count == 0

data/lib/sequel/plugins/xml_serializer.rb

@@ -79,6 +79,11 @@ module Sequel
     #
     #   Album.array_from_xml(Album.to_xml) # same as Album.all
     #
+    # If you have an existing array of model instances you want to convert to
+    # XML, you can call the class to_xml method with the :array option:
+    #
+    #   Album.to_xml(:array=>[Album[1], Album[2]])
+    #
     # Usage:
     #
     #   # Add XML output capability to all model subclass instances (called before loading subclasses)
@@ -205,9 +210,9 @@ module Sequel
                 klass.from_xml_node(node)
               end
             elsif cols.include?(k)
-              self[k.to_sym] = node[:nil] ? nil : node.children.first.to_s
+              self[k.to_sym] = node.key?('nil') ? nil : node.children.first.to_s
             elsif meths.include?("#{k}=")
-              send("#{k}=", node[:nil] ? nil : node.children.first.to_s)
+              send("#{k}=", node.key?('nil') ? nil : node.children.first.to_s)
             else
               raise Error, "Entry in XML not an association or column and no setter method exists: #{k}"
             end
@@ -266,7 +271,7 @@ module Sequel
 
           name_proc = model.xml_serialize_name_proc(opts)
           x = model.xml_builder(opts)
-          x.send(name_proc[opts.fetch(:root_name, model.send(:underscore, model.name)).to_s]) do |x1|
+          x.send(name_proc[opts.fetch(:root_name, model.send(:underscore, model.name).gsub('/', '__')).to_s]) do |x1|
             cols.each do |c|
               attrs = {}
               if types
@@ -316,8 +321,14 @@ module Sequel
           raise(Sequel::Error, "Dataset#to_xml") unless row_proc
           x = model.xml_builder(opts)
           name_proc = model.xml_serialize_name_proc(opts)
+          array = if opts[:array]
+            opts = opts.dup
+            opts.delete(:array)
+          else
+            all
+          end
           x.send(name_proc[opts.fetch(:array_root_name, model.send(:pluralize, model.send(:underscore, model.name))).to_s]) do |x1|
-            all.each do |obj|
+            array.each do |obj|
               obj.to_xml(opts.merge(:builder=>x1))
             end
           end