sequel 4.47.0 → 4.48.0

data/lib/sequel/plugins/defaults_setter.rb

@@ -13,6 +13,16 @@ module Sequel
     #   album = Album.new(:a=>1, :b=>3)
     #   album.a # => 1
     #   album.b # => 3
+    #
+    # You can manually set default values as well:
+    #
+    #   Album.default_values[:a] = 4
+    #   Album.new.a # => 4
+    #
+    # You can also provide procs to set default values:
+    #
+    #   Album.default_values[:a] = lambda{Date.today}
+    #   Album.new.a # => Date.today
     # 
     # Usage:
     #

data/lib/sequel/plugins/eager_each.rb

@@ -39,7 +39,7 @@ module Sequel
         end
 
         # Call #all instead of #each if eager loading,
-        # uless #each is being called by #all.
+        # unless #each is being called by #all.
         def each(&block)
           if use_eager_all?
             all(&block)

data/lib/sequel/plugins/force_encoding.rb

@@ -14,11 +14,11 @@ module Sequel
     #
     # Usage:
     #
-    #   # Force all strings to be UTF8 encoded in a all model subclasses
+    #   # Force all strings to be UTF-8 encoded in a all model subclasses
     #   # (called before loading subclasses)
     #   Sequel::Model.plugin :force_encoding, 'UTF-8'
     #
-    #   # Force the encoding for the Album model to UTF8
+    #   # Force the encoding for the Album model to UTF-8
     #   Album.plugin :force_encoding
     #   Album.forced_encoding = 'UTF-8'
     module ForceEncoding

data/lib/sequel/plugins/hook_class_methods.rb

@@ -2,10 +2,10 @@
 
 module Sequel
   module Plugins
-    # Sequel's built-in hook class methods plugin is designed for backwards
+    # Sequel's built-in hook_class_methods plugin is designed for backwards
     # compatibility.  Its use is not encouraged, it is recommended to use
-    # instance methods and super instead of this plugin.  What this plugin
-    # allows you to do is, for example:
+    # instance methods and super instead of this plugin.  This plugin allows
+    # calling class methods with blocks to define hooks:
     #
     #   # Block only, can cause duplicate hooks if code is reloaded
     #   before_save{self.created_at = Time.now}
@@ -15,17 +15,14 @@ module Sequel
     #   before_save(:set_created_at)
     #
     # Pretty much anything you can do with a hook class method, you can also
-    # do with an instance method instead:
+    # do with an instance method instead (making sure to call super), which is
+    # the recommended way to add hooks in Sequel:
     #
     #    def before_save
-    #      return false if super == false
+    #      super
     #      self.created_at = Time.now
     #    end
     #
-    # Note that returning false in any before hook block will skip further
-    # before hooks and abort the action.  So if a before_save hook block returns
-    # false, future before_save hook blocks are not called, and the save is aborted.
-    # 
     # Usage:
     #
     #   # Allow use of hook class methods in all model subclasses (called before loading subclasses)
@@ -91,7 +88,6 @@ module Sequel
         # arbitrary code execution.
         def add_hook_type(*hooks)
           Sequel::Deprecation.deprecate("Sequel::Model.add_hook_type", "You should add your own hook types manually")
-          Model::HOOKS.concat(hooks)
           hooks.each do |hook|
             @hooks[hook] = []
             instance_eval("def #{hook}(method = nil, &block); add_hook(:#{hook}, method, &block) end", __FILE__, __LINE__)
@@ -141,7 +137,8 @@ module Sequel
       end
 
       module InstanceMethods
-        (Model::BEFORE_HOOKS - [:before_save, :before_destroy]).each do |h|
+        # SEQUEL5: Make :before_save, :before_destroy, :after_save, :after_destroy hooks use metaprogramming instead of specific definitions
+        [:before_create, :before_update, :before_validation].each do |h|
           class_eval(<<-END, __FILE__, __LINE__+1)
             def #{h}
               model.hook_blocks(:#{h}) do |b|
@@ -154,7 +151,7 @@ module Sequel
             end
           END
         end
-        (Model::AFTER_HOOKS - [:after_save, :after_destroy, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]).each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_eval(&b)}; end", __FILE__, __LINE__)}
+        [:after_create, :after_update, :after_validation].each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_eval(&b)}; end", __FILE__, __LINE__)}
 
         def after_destroy
           super

data/lib/sequel/plugins/identifier_columns.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+Sequel::Deprecation.deprecate("The identifier_columns plugin", "Set Sequel.split_symbols = false instead")
+
 module Sequel
   module Plugins
     # The identifier_columns plugin makes Sequel automatically

data/lib/sequel/plugins/instance_filters.rb

@@ -7,7 +7,9 @@ module Sequel
     # where you would normally have to drop down to the dataset level
     # to get the necessary control, because you only want to delete or
     # update the rows in certain cases based on the current status of
-    # the row in the database.
+    # the row in the database.  The main purpose of this plugin is to
+    # avoid race conditions by relying on the atomic properties of database
+    # transactions.
     # 
     #   class Item < Sequel::Model
     #     plugin :instance_filters

data/lib/sequel/plugins/instance_hooks.rb

@@ -9,8 +9,7 @@ module Sequel
     # All of the standard hooks are supported.
     # Instance level before hooks are executed in reverse order of addition before
     # calling super.  Instance level after hooks are executed in order of addition
-    # after calling super.  If any of the instance level before hook blocks return
-    # false, no more instance level before hooks are called and false is returned.
+    # after calling super.
     #
     # Instance level hooks for before and after are cleared after all related
     # after level instance hooks have run.  This means that if you add a before_create
@@ -29,9 +28,12 @@ module Sequel
     #   # Add the instance hook methods just to Album instances
     #   Album.plugin :instance_hooks
     module InstanceHooks
-      BEFORE_HOOKS = Sequel::Model::BEFORE_HOOKS
-      AFTER_HOOKS = Sequel::Model::AFTER_HOOKS
-      HOOKS = BEFORE_HOOKS + AFTER_HOOKS
+      BEFORE_HOOKS, AFTER_HOOKS = Sequel::Model::HOOKS.partition{|l| l.to_s.start_with?('before')}
+      Sequel::Deprecation.deprecate_constant(self, :BEFORE_HOOKS)
+      Sequel::Deprecation.deprecate_constant(self, :AFTER_HOOKS)
+      HOOKS = Sequel::Model::HOOKS
+      Sequel::Deprecation.deprecate_constant(self, :HOOKS)
+      
       # SEQUEL5: Remove
       DEPRECATION_REPLACEMENTS = {
         :after_commit=>"Use obj.after_save_hook{obj.db.after_commit{}} instead",
@@ -41,7 +43,7 @@ module Sequel
       }.freeze
 
       module InstanceMethods 
-        HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
+        Sequel::Model::HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
           def #{h}_hook(&block)
             #{"Sequel::Deprecation.deprecate('Sequel::Model##{h}_hook in the instance_hooks plugin', #{DEPRECATION_REPLACEMENTS[h].inspect})" if DEPRECATION_REPLACEMENTS[h]}
             raise Sequel::Error, "can't add hooks to frozen object" if frozen?
@@ -50,8 +52,8 @@ module Sequel
           end
         END
         
-        (BEFORE_HOOKS - [:before_destroy, :before_save]).each{|h| class_eval("def #{h}; (@instance_hooks && run_before_instance_hooks(:#{h}) == false) ? false : super end", __FILE__, __LINE__)}
-        (AFTER_HOOKS - [:after_validation, :after_save, :after_destroy, :after_commit, :after_destroy_commit, :after_destroy_rollback, :after_rollback]).each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
+        [:before_create, :before_update, :before_validation].each{|h| class_eval("def #{h}; (@instance_hooks && run_before_instance_hooks(:#{h}) == false) ? false : super end", __FILE__, __LINE__)}
+        [:after_create, :after_update].each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
           def #{h}
             super
             return unless @instance_hooks
@@ -65,6 +67,7 @@ module Sequel
         def after_destroy
           super
           return unless @instance_hooks
+          # SEQUEL5: Remove commit/rollback
           if ad = @instance_hooks[:after_destroy_commit]
             db.after_commit{ad.each(&:call)}
           end
@@ -86,6 +89,7 @@ module Sequel
         def after_save
           super
           return unless @instance_hooks
+          # SEQUEL5: Remove commit/rollback
           if (ac = @instance_hooks[:after_commit])
             db.after_commit{ac.each(&:call)}
           end
@@ -101,18 +105,22 @@ module Sequel
         # Run before_destroy instance hooks.
         def before_destroy
           return super unless @instance_hooks
+          # SEQUEL5: Remove commit/rollback
           if adr = @instance_hooks[:after_destroy_rollback]
             db.after_rollback{adr.each(&:call)}
           end
+          # SEQUEL5: No false checking
           run_before_instance_hooks(:before_destroy) == false ? false : super
         end
 
         # Run before_save instance hooks.
         def before_save
           return super unless @instance_hooks
+          # SEQUEL5: Remove commit/rollback
           if ar = @instance_hooks[:after_rollback]
             db.after_rollback{ar.each(&:call)}
           end
+          # SEQUEL5: No false checking
           run_before_instance_hooks(:before_save) == false ? false : super
         end
         
@@ -122,7 +130,7 @@ module Sequel
         # the beginning of the instance hook's array.  For after hooks, add it
         # to the end.
         def add_instance_hook(hook, &block)
-          instance_hooks(hook).send(BEFORE_HOOKS.include?(hook) ? :unshift : :push, block)
+          instance_hooks(hook).send(hook.to_s.start_with?('before') ? :unshift : :push, block)
         end
         
         # An array of instance level hook blocks for the given hook type.

data/lib/sequel/plugins/json_serializer.rb

@@ -62,6 +62,11 @@ module Sequel
     #
     #   Album.to_json(:array=>[Album[1], Album[2]])
     #
+    # All to_json methods take blocks, and if a block is given, it will yield
+    # the array or hash before serialization, and will serialize the value
+    # the block returns.  This allows you to customize the resulting JSON format
+    # on a per-call basis.
+    #
     # In addition to creating JSON, this plugin also enables Sequel::Model
     # classes to create instances directly from JSON using the from_json class
     # method:
@@ -126,9 +131,9 @@ module Sequel
     module JsonSerializer
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.
-      def self.configure(model, opts={})
+      def self.configure(model, opts=OPTS)
         model.instance_eval do
-          @json_serializer_opts = (@json_serializer_opts || {}).merge(opts)
+          @json_serializer_opts = (@json_serializer_opts || OPTS).merge(opts)
         end
       end
       
@@ -222,10 +227,10 @@ module Sequel
           if assocs = opts[:associations]
             assocs = case assocs
             when Symbol
-              {assocs=>{}}
+              {assocs=>OPTS}
             when Array
               assocs_tmp = {}
-              assocs.each{|v| assocs_tmp[v] = {}}
+              assocs.each{|v| assocs_tmp[v] = OPTS}
               assocs_tmp
             when Hash
               assocs
@@ -358,6 +363,7 @@ module Sequel
             h = {root => h}
           end
 
+          h = yield h if block_given?
           Sequel.object_to_json(h, *a)
         end
       end
@@ -370,6 +376,8 @@ module Sequel
         #
         # :array :: An array of instances.  If this is not provided,
         #           calls #all on the receiver to get the array.
+        # :instance_block :: A block to pass to #to_json for each
+        #                    value in the dataset (or :array option).
         # :root :: If set to :collection, wraps the collection
         #          in a root object using the pluralized, underscored model
         #          name as the key.  If set to :instance, only wraps
@@ -405,16 +413,15 @@ module Sequel
             else
               all
             end
-            array.map{|obj| Literal.new(Sequel.object_to_json(obj, opts))}
+            array.map{|obj| Literal.new(Sequel.object_to_json(obj, opts, &opts[:instance_block]))}
            else
             all
           end
 
-          if collection_root
-            Sequel.object_to_json({collection_root => res}, *a)
-          else
-            Sequel.object_to_json(res, *a)
-          end
+          res = {collection_root => res} if collection_root
+          res = yield res if block_given?
+
+          Sequel.object_to_json(res, *a)
         end
       end
     end

data/lib/sequel/plugins/lazy_attributes.rb

@@ -92,9 +92,8 @@ module Sequel
         # the attribute for just the current object.  Return the value of
         # the attribute for the current object.
         def lazy_attribute_lookup(a, opts=OPTS)
-          unless table = opts[:table]
-            table = model.table_name
-          end
+          table = opts[:table] || model.table_name
+          selection = Sequel.qualify(table, a)
 
           if base_ds = opts[:dataset]
             ds = base_ds.where(qualified_pk_hash(table))
@@ -103,10 +102,8 @@ module Sequel
             ds = this
           end
 
-          selection = Sequel.qualify(table, a)
-
           if frozen?
-            return ds.dup.get(selection)
+            return ds.get(selection)
           end
 
           if retrieved_with
@@ -115,7 +112,11 @@ module Sequel
             id_map = {}
             retrieved_with.each{|o| id_map[o.pk] = o unless o.values.has_key?(a) || o.frozen?}
             predicate_key = composite_pk ? primary_key.map{|k| Sequel.qualify(table, k)} : Sequel.qualify(table, primary_key)
-            base_ds.select(*(Array(primary_key).map{|k| Sequel.qualify(table, k)} + [selection])).where(predicate_key=>id_map.keys).naked.each do |row|
+            base_ds.
+             select(*(Array(primary_key).map{|k| Sequel.qualify(table, k)} + [selection])).
+             where(predicate_key=>id_map.keys).
+             naked.
+             each do |row|
               obj = id_map[composite_pk ? row.values_at(*primary_key) : row[primary_key]]
               if obj && !obj.values.has_key?(a)
                 obj.values[a] = row[a]

data/lib/sequel/plugins/modification_detection.rb

@@ -17,6 +17,9 @@ module Sequel
     # Note that for this plugin to work correctly, the column values must
     # correctly implement the #hash method, returning the same value if
     # the object is equal, and a different value if the object is not equal.
+    # As this solely uses hash values to check for modification, there may
+    # be cases where a modification is made and the hash value is the same,
+    # resulting in a false negative.
     #
     # Note that this plugin causes a performance hit for all retrieved
     # objects, so it shouldn't be used in cases where performance is a

data/lib/sequel/plugins/nested_attributes.rb

@@ -127,7 +127,11 @@ module Sequel
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|
             r[:nested_attributes] = opts
-            r[:nested_attributes][:unmatched_pk] ||= opts.delete(:strict) == false ? :ignore : :raise
+            r[:nested_attributes][:unmatched_pk] ||= (
+              if opts.has_key?(:strict)
+                Sequel::Deprecation.deprecate("The nested_attributes :strict option", "Use the :unmatched_pk option instead")
+              end
+              opts.delete(:strict) == false ? :ignore : :raise)
             r[:nested_attributes][:reject_if] ||= block
             def_nested_attribute_method(r)
           end

data/lib/sequel/plugins/pg_array_associations.rb

@@ -297,6 +297,11 @@ module Sequel
         end
       end
 
+      # Add the pg_array extension to the database
+      def self.apply(model)
+        model.db.extension(:pg_array)
+      end
+
       module ClassMethods
         # Create a many_to_pg_array association, for the case where the associated
         # table contains the array with foreign keys pointing to the current table.

data/lib/sequel/plugins/prepared_statements.rb

@@ -225,6 +225,7 @@ module Sequel
           case type
           when :insert, :insert_select, :update
             true
+          # SEQUEL5: Remove :delete/:refresh
           when :delete
             return true unless model.fast_instance_delete_sql
 

data/lib/sequel/plugins/rcte_tree.rb

@@ -133,7 +133,7 @@ module Sequel
           base_ds = model.where(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, key_array.zip(prkey_array))
           if c = a[:conditions]
-            (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
+            (base_ds, recursive_ds) = [base_ds, recursive_ds].map do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
@@ -181,7 +181,7 @@ module Sequel
           recursive_case = model.join(t, key_array.zip(prkey_array)).
            select(*recursive_case_columns)
           if c = r[:conditions]
-            (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
+            (base_case, recursive_case) = [base_case, recursive_case].map do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
@@ -228,7 +228,7 @@ module Sequel
           base_ds = model.where(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, prkey_array.zip(key_array))
           if c = d[:conditions]
-            (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
+            (base_ds, recursive_ds) = [base_ds, recursive_ds].map do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
@@ -279,7 +279,7 @@ module Sequel
           recursive_case = model.join(t, prkey_array.zip(key_array)).
            select(*recursive_case_columns)
           if c = r[:conditions]
-            (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
+            (base_case, recursive_case) = [base_case, recursive_case].map do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end

data/lib/sequel/plugins/serialization.rb

@@ -97,16 +97,9 @@ module Sequel
       end
       register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')},
         lambda do |v|
-          begin
-            Marshal.load(v.unpack('m')[0])
-          rescue => e
-            begin
-              # Backwards compatibility for unpacked marshal output.
-              Marshal.load(v)
-            rescue
-              raise e
-            end
-          end
+          # Handle unpacked marshalled data for backwards compat
+          v = v.unpack('m')[0] unless v[0..1] == "\x04\x08"
+          Marshal.load(v)
         end)
       register_format(:yaml, lambda(&:to_yaml), lambda{|v| YAML.load(v)})
       register_format(:json, lambda{|v| Sequel.object_to_json(v)}, lambda{|v| Sequel.parse_json(v)})

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -95,7 +95,7 @@ module Sequel
                 end
               end
               km.each do |k,v|
-                h[k.to_s] = [ ] unless h.key?(k.to_s)
+                h[k.to_s] = [] unless h.key?(k.to_s)
                 h[k.to_s].push( *Array(v) )
               end
               h
@@ -111,7 +111,7 @@ module Sequel
               end
             end
             sti_model_map.each do |k,v|
-              h[v.to_s] = [ ] unless h.key?(v.to_s)
+              h[v.to_s] = [] unless h.key?(v.to_s)
               h[v.to_s] << k
             end
             h

data/lib/sequel/plugins/split_values.rb

@@ -57,11 +57,12 @@ module Sequel
         # Check all entries in the values hash.  If any of the keys are not columns,
         # move the entry into the noncolumn_values hash.
         def split_noncolumn_values
-          @values.keys.each do |k|
-            unless columns.include?(k)
-              (@noncolumn_values ||= {})[k] = @values.delete(k)
-            end
-          end
+          cols = (@values.keys - columns)
+          return self if cols.empty?
+
+          nc = @noncolumn_values ||= {}
+          vals = @values
+          cols.each{|k| nc[k] = vals.delete(k)}
           self
         end
       end