sequel 4.36.0 → 5.61.0

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
@@ -30,10 +29,7 @@ module Sequel
     #   Album.plugin :instance_hooks
     module InstanceHooks
       module InstanceMethods 
-        BEFORE_HOOKS = Sequel::Model::BEFORE_HOOKS
-        AFTER_HOOKS = Sequel::Model::AFTER_HOOKS
-        HOOKS = BEFORE_HOOKS + AFTER_HOOKS
-        HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
+        Sequel::Model::HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
           def #{h}_hook(&block)
             raise Sequel::Error, "can't add hooks to frozen object" if frozen?
             add_instance_hook(:#{h}, &block)
@@ -41,31 +37,57 @@ module Sequel
           end
         END
         
-        BEFORE_HOOKS.each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) == false ? false : super end", __FILE__, __LINE__)}
-        (AFTER_HOOKS - [:after_validation, :after_save]).each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
+        [:before_create, :before_update, :before_validation].each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) if @instance_hooks; super end", __FILE__, __LINE__)}
+        [:after_create, :after_update].each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
           def #{h}
             super
+            return unless @instance_hooks
             run_after_instance_hooks(:#{h})
             @instance_hooks.delete(:#{h})
             @instance_hooks.delete(:#{h.to_s.sub('after', 'before')})
           end
         END
 
-        # Run after validation hooks, without clearing the validation hooks.
+        # Run after destroy instance hooks.
+        def after_destroy
+          super
+          return unless @instance_hooks
+          run_after_instance_hooks(:after_destroy)
+          @instance_hooks.delete(:after_destroy)
+          @instance_hooks.delete(:before_destroy)
+        end
+
+        # Run after validation instance hooks.
         def after_validation
           super
+          return unless @instance_hooks
           run_after_instance_hooks(:after_validation)
         end
         
-        # Run after save hooks, clearing both the save and validation hooks.
+        # Run after save instance hooks.
         def after_save
           super
+          return unless @instance_hooks
           run_after_instance_hooks(:after_save)
           @instance_hooks.delete(:after_save)
           @instance_hooks.delete(:before_save)
           @instance_hooks.delete(:after_validation)
           @instance_hooks.delete(:before_validation)
         end
+
+        # Run before_destroy instance hooks.
+        def before_destroy
+          return super unless @instance_hooks
+          run_before_instance_hooks(:before_destroy)
+          super
+        end
+
+        # Run before_save instance hooks.
+        def before_save
+          return super unless @instance_hooks
+          run_before_instance_hooks(:before_save)
+          super
+        end
         
         private
         
@@ -73,7 +95,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).public_send(hook.to_s.start_with?('before') ? :unshift : :push, block)
         end
         
         # An array of instance level hook blocks for the given hook type.
@@ -86,12 +108,7 @@ module Sequel
         def run_after_instance_hooks(hook)
           instance_hooks(hook).each(&:call)
         end
-
-        # Run all hook blocks of the given hook type.  If a hook block returns false,
-        # immediately return false without running the remaining blocks.
-        def run_before_instance_hooks(hook)
-          instance_hooks(hook).each{|b| return false if b.call == false}
-        end
+        alias run_before_instance_hooks run_after_instance_hooks
       end
     end
   end

data/lib/sequel/plugins/instance_specific_default.rb

@@ -0,0 +1,113 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The instance_specific_default plugin exists to make it easier to use a
+    # global :instance_specific association option, or to warn or raise when Sequel
+    # has to guess which value to use :instance_specific option (Sequel defaults to
+    # guessing true as that is the conservative setting).  It is helpful to
+    # use this plugin, particularly with the :warn or :raise settings, to determine
+    # which associations should have :instance_specific set.  Setting the
+    # :instance_specific to false for associations that are not instance specific
+    # can improve performance.
+    #
+    # Associations are instance-specific if their block calls
+    # a model instance method, or where the value of the block varies
+    # based on runtime state, and the variance is outside of a delayed evaluation.
+    # For example, with the following three associations:
+    #
+    #   Album.one_to_one :first_track, class: :Track do |ds|
+    #     ds.where(number: 1)
+    #   end
+    #
+    #   Album.one_to_one :last_track, class: :Track do |ds|
+    #     ds.where(number: num_tracks)
+    #   end
+    #
+    #   Album.one_to_many :recent_tracks, class: :Track do |ds|
+    #     ds.where{date_updated > Date.today - 10}
+    #   end
+    #
+    # +first_track+ is not instance specific, but +last_track+ and +recent_tracks+ are.
+    # +last_track+ is because the +num_tracks+ call in the block is calling
+    # <tt>Album#num_tracks</tt>.  +recent_tracks+ is because the value will change over
+    # time. This plugin allows you to find these cases, and set the :instance_specific
+    # option appropriately for them:
+    #
+    #   Album.one_to_one :first_track, class: :Track, instance_specific: false do |ds|
+    #     ds.where(number: 1)
+    #   end
+    #
+    #   Album.one_to_one :last_track, class: :Track, instance_specific: true do |ds|
+    #     ds.where(number: num_tracks)
+    #   end
+    #
+    #   Album.one_to_many :recent_tracks, class: :Track, instance_specific: true do |ds|
+    #     ds.where{date_updated > Date.today - 10}
+    #   end
+    #
+    # For the +recent_tracks+ association, instead of marking it instance_specific, you
+    # could also use a delayed evaluation, since it doesn't actually contain
+    # instance-specific code:
+    #
+    #   Album.one_to_many :recent_tracks, class: :Track, instance_specific: false do |ds|
+    #     ds.where{date_updated > Sequel.delay{Date.today - 10}}
+    #   end
+    #
+    # Possible arguments to provide when loading the plugin:
+    #
+    # true :: Set the :instance_specific option to true
+    # false :: Set the :instance_specific option to false
+    # :default :: Call super to set the :instance_specific option
+    # :warn :: Emit a warning before calling super to set the :instance_specific option
+    # :raise :: Raise a Sequel::Error if an :instance_specific option is not provided and
+    #           an association could be instance-specific.
+    #
+    # Note that this plugin only affects associations which could be instance
+    # specific (those with blocks), where the :instance_specific option was not
+    # specified when the association was created.
+    #
+    # Usage:
+    #
+    #   # Set how to handle associations that could be instance specific
+    #   # but did not specify an :instance_specific option, for all subclasses
+    #   # (set before creating subclasses).
+    #   Sequel::Model.plugin :instance_specific_default, :warn
+    #
+    #   # Set how to handle associations that could be instance specific
+    #   # but did not specify an :instance_specific option, for the Album class
+    #   Album.plugin :instance_specific_default, :warn
+    module InstanceSpecificDefault
+      # Set how to handle associations that could be instance specific but did
+      # not specify an :instance_specific value.
+      def self.configure(model, default)
+        model.instance_variable_set(:@instance_specific_default, default)
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@instance_specific_default=>nil)
+
+        private
+
+        # Return the appropriate :instance_specific value, or warn or raise if
+        # configured.
+        def _association_instance_specific_default(name)
+          case @instance_specific_default
+          when true, false
+            return @instance_specific_default
+          when :default
+            # nothing
+          when :warn
+            warn("possibly instance-specific association without :instance_specific option (class: #{self}, association: #{name})", :uplevel => 3)
+          when :raise
+            raise Sequel::Error, "possibly instance-specific association without :instance_specific option (class: #{self}, association: #{name})"
+          else
+            raise Sequel::Error, "invalid value passed to instance_specific_default plugin: #{@instance_specific_default.inspect}"
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/inverted_subsets.rb

@@ -18,7 +18,9 @@ module Sequel
     #   Album.plugin :inverted_subsets
     #
     #   # This will now create two methods, published and not_published
-    #   Album.subset :published, :published => true
+    #   Album.dataset_module do
+    #     where :published, published: true
+    #   end
     #
     #   Album.published.sql
     #   # SELECT * FROM albums WHERE (published IS TRUE)
@@ -27,22 +29,29 @@ module Sequel
     #   # SELECT * FROM albums WHERE (published IS NOT TRUE)
     #
     module InvertedSubsets
-      # Default naming for inverted subsets
-      DEFAULT_NAME_BLOCK = lambda{|name| "not_#{name}"}
-
-      # Store the supplied block for calling later when subsets are defined, or
-      # create a default one if we need to.
-      def self.configure(model, &block)
-        model.instance_variable_set(:@inverted_subsets_name_block, block || DEFAULT_NAME_BLOCK)
+      def self.apply(model, &block)
+        model.instance_exec do
+          @dataset_module_class = Class.new(@dataset_module_class) do
+            include DatasetModuleMethods
+            if block
+              define_method(:inverted_subset_name, &block)
+              private :inverted_subset_name
+            end
+          end
+        end
       end
 
-      module ClassMethods
-        Plugins.inherited_instance_variables(self, :@inverted_subsets_name_block => nil)
-
+      module DatasetModuleMethods
         # Define a not_ prefixed subset which inverts the subset condition.
-        def subset(name, *args, &block)
+        def where(name, *args, &block)
           super
-          def_dataset_method(@inverted_subsets_name_block.call(name)){exclude(*args, &block)}
+          exclude(inverted_subset_name(name), *args, &block)
+        end
+
+        private
+
+        def inverted_subset_name(name)
+          "not_#{name}"
         end
       end
     end

data/lib/sequel/plugins/json_serializer.rb

@@ -13,34 +13,41 @@ module Sequel
     #
     #   album = Album[1]
     #   album.to_json
-    #   # => '{"json_class"=>"Album","id"=>1,"name"=>"RF","artist_id"=>2}'
+    #   # => '{"id"=>1,"name"=>"RF","artist_id"=>2}'
     #
     # In addition, you can provide options to control the JSON output:
     #
-    #   album.to_json(:only=>:name)
-    #   album.to_json(:except=>[:id, :artist_id])
+    #   album.to_json(only: :name)
+    #   album.to_json(except: [:id, :artist_id])
     #   # => '{"json_class"="Album","name"=>"RF"}'
     #   
-    #   album.to_json(:include=>:artist)
-    #   # => '{"json_class":"Album","id":1,"name":"RF","artist_id":2,
-    #   #      "artist":{"json_class":"Artist","id":2,"name":"YJM"}}'
+    #   album.to_json(include: :artist)
+    #   # => '{"id":1,"name":"RF","artist_id":2,
+    #   #      "artist":{"id":2,"name":"YJM"}}'
     # 
     # You can use a hash value with <tt>:include</tt> to pass options
     # to associations:
     #
-    #   album.to_json(:include=>{:artist=>{:only=>:name}})
-    #   # => '{"json_class":"Album","id":1,"name":"RF","artist_id":2,
-    #   #      "artist":{"json_class":"Artist","name":"YJM"}}'
+    #   album.to_json(include: {artist: {only: :name}})
+    #   # => '{"id":1,"name":"RF","artist_id":2,
+    #   #      "artist":{"name":"YJM"}}'
     #
+    # You can specify a name for a given association by using an aliased
+    # expression as the key in the <tt>:include</tt> hash
+    #
+    #   album.to_json(include: {Sequel.as(:artist, :singer)=>{only: :name}})
+    #   # => '{"id":1,"name":"RF","artist_id":2,
+    #   #      "singer":{"name":"YJM"}}'
+    # 
     # You can specify the <tt>:root</tt> option to nest the JSON under the
     # name of the model:
     #
-    #   album.to_json(:root => true)
+    #   album.to_json(root: true)
     #   # => '{"album":{"id":1,"name":"RF","artist_id":2}}'
     #
     # You can specify JSON serialization options to use later:
     #
-    #   album.json_serializer_opts(:root => true)
+    #   album.json_serializer_opts(root: true)
     #   [album].to_json
     #   # => '[{"album":{"id":1,"name":"RF","artist_id":2}}]'
     #
@@ -48,12 +55,17 @@ module Sequel
     # of which return all objects in the dataset:
     #
     #   Album.to_json
-    #   Album.filter(:artist_id=>1).to_json(:include=>:tags)
+    #   Album.where(artist_id: 1).to_json(include: :tags)
     #
     # If you have an existing array of model instances you want to convert to
     # JSON, you can call the class to_json method with the :array option:
     #
-    #   Album.to_json(:array=>[Album[1], Album[2]])
+    #   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
@@ -65,7 +77,7 @@ module Sequel
     # The array_from_json class method exists to parse arrays of model instances
     # from json:
     #
-    #   json = Album.filter(:artist_id=>1).to_json
+    #   json = Album.where(artist_id: 1).to_json
     #   albums = Album.array_from_json(json)
     #
     # These does not necessarily round trip, since doing so would let users
@@ -74,7 +86,7 @@ module Sequel
     # fields, you can use the :fields option, which will call set_fields with
     # the given fields:
     #
-    #   Album.from_json(album.to_json, :fields=>%w'id name')
+    #   Album.from_json(album.to_json, fields: %w'id name')
     #
     # If you want to update an existing instance, you can use the from_json
     # instance method:
@@ -84,27 +96,23 @@ module Sequel
     # Both of these allow creation of cached associated objects, if you provide
     # the :associations option:
     #
-    #   album.from_json(json, :associations=>:artist)
+    #   album.from_json(json, associations: :artist)
     #
     # You can even provide options when setting up the associated objects:
     #
-    #   album.from_json(json, :associations=>{:artist=>{:fields=>%w'id name', :associations=>:tags}})
+    #   album.from_json(json, associations: {artist: {fields: %w'id name', associations: :tags}})
     #
     # Note that active_support/json makes incompatible changes to the to_json API,
     # and breaks some aspects of the json_serializer plugin.  You can undo the damage
     # done by active_support/json by doing:
     #
-    #   class Array
-    #     def to_json(options = {})
-    #       JSON.generate(self)
-    #     end
-    #   end
-    #
-    #   class Hash
+    #   module ActiveSupportBrokenJSONFix
     #     def to_json(options = {})
     #       JSON.generate(self)
     #     end
     #   end
+    #   Array.send(:prepend, ActiveSupportBrokenJSONFix)
+    #   Hash.send(:prepend, ActiveSupportBrokenJSONFix)
     #
     # Note that this will probably cause active_support/json to no longer work
     # correctly in some cases.
@@ -119,32 +127,59 @@ 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={})
-        model.instance_eval do
-          @json_serializer_opts = (@json_serializer_opts || {}).merge(opts)
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          @json_serializer_opts = (@json_serializer_opts || OPTS).merge(opts)
         end
       end
       
-      # Helper class used for making sure that cascading options
-      # for model associations works correctly.  Cascaded options
-      # work by creating instances of this class, which take a
-      # literal JSON string and have +to_json+ return it.
+      # SEQUEL6: Remove
+      # :nocov:
       class Literal
-        # Store the literal JSON to use
         def initialize(json)
           @json = json
         end
         
-        # Return the literal JSON to use
         def to_json(*a)
           @json
         end
       end
+      # :nocov:
+      Sequel::Deprecation.deprecate_constant(self, :Literal)
+
+      # Convert the given object to a JSON data structure using the given arguments.
+      def self.object_to_json_data(obj, *args, &block)
+        if obj.is_a?(Array)
+          obj.map{|x| object_to_json_data(x, *args, &block)}
+        else
+          if obj.respond_to?(:to_json_data)
+            obj.to_json_data(*args, &block)
+          else
+            begin
+              Sequel.parse_json(Sequel.object_to_json(obj, *args, &block))
+            # :nocov:
+            rescue Sequel.json_parser_error_class
+              # Support for old Ruby code that only supports parsing JSON object/array
+              Sequel.parse_json(Sequel.object_to_json([obj], *args, &block))[0]
+            # :nocov:
+            end
+          end
+        end
+      end
 
       module ClassMethods
         # The default opts to use when serializing model objects to JSON.
         attr_reader :json_serializer_opts
 
+        # Freeze json serializier opts when freezing model class
+        def freeze
+          @json_serializer_opts.freeze.each_value do |v|
+            v.freeze if v.is_a?(Array) || v.is_a?(Hash)
+          end
+
+          super
+        end
+
         # Attempt to parse a single instance from the given JSON string,
         # with options passed to InstanceMethods#from_json_node.
         def from_json(json, opts=OPTS)
@@ -206,10 +241,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
@@ -255,10 +290,10 @@ module Sequel
         #
         # Example:
         #
-        #   obj.json_serializer_opts(:only=>:name)
+        #   obj.json_serializer_opts(only: :name)
         #   [obj].to_json # => '[{"name":"..."}]'
         def json_serializer_opts(opts=OPTS)
-          @json_serializer_opts = Hash[@json_serializer_opts||OPTS].merge!(opts)
+          @json_serializer_opts = (@json_serializer_opts||OPTS).merge(opts)
         end
 
         # Return a string in JSON format.  Accepts the following
@@ -280,9 +315,9 @@ module Sequel
         #          use an underscored version of the model's name.
         def to_json(*a)
           opts = model.json_serializer_opts
-          opts = Hash[opts].merge!(@json_serializer_opts) if @json_serializer_opts
+          opts = opts.merge(@json_serializer_opts) if @json_serializer_opts
           if (arg_opts = a.first).is_a?(Hash)
-            opts = Hash[opts].merge!(arg_opts)
+            opts = opts.merge(arg_opts)
             a = []
           end
 
@@ -299,24 +334,27 @@ module Sequel
           if inc = opts[:include]
             if inc.is_a?(Hash)
               inc.each do |k, v|
-                v = v.empty? ? [] : [v]
-
-                objs = send(k)
-
-                is_array = if r = model.association_reflection(k)
-                  r.returns_array?
+                if k.is_a?(Sequel::SQL::AliasedExpression)
+                  key_name = k.alias.to_s
+                  k = k.expression
                 else
-                  objs.is_a?(Array)
+                  key_name = k.to_s
                 end
-                
-                h[k.to_s] = if is_array
-                  objs.map{|obj| Literal.new(Sequel.object_to_json(obj, *v))}
+
+                v = v.empty? ? [] : [v]
+                h[key_name] = JsonSerializer.object_to_json_data(public_send(k), *v)
+              end
+            else
+              Array(inc).each do |c|
+                if c.is_a?(Sequel::SQL::AliasedExpression)
+                  key_name = c.alias.to_s
+                  c = c.expression
                 else
-                  Literal.new(Sequel.object_to_json(objs, *v))
+                  key_name = c.to_s
                 end
+
+                h[key_name] = JsonSerializer.object_to_json_data(public_send(c))
               end
-            else
-              Array(inc).each{|c| h[c.to_s] = send(c)}
             end
           end
 
@@ -327,11 +365,28 @@ module Sequel
             h = {root => h}
           end
 
+          h = yield h if defined?(yield)
           Sequel.object_to_json(h, *a)
         end
+
+        # Convert the receiver to a JSON data structure using the given arguments.
+        def to_json_data(*args, &block)
+          if block
+            to_json(*args){|x| return block.call(x)}
+          else
+            to_json(*args){|x| return x}
+          end
+        end
       end
 
       module DatasetMethods
+        # Store default options used when calling to_json on this dataset.
+        # These options take precedence over the class level options,
+        # and can be overridden by passing options directly to to_json.
+        def json_serializer_opts(opts=OPTS)
+          clone(:json_serializer_opts=>opts)
+        end
+
         # Return a JSON string representing an array of all objects in
         # this dataset.  Takes the same options as the instance
         # method, and passes them to every instance.  Additionally,
@@ -339,6 +394,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
@@ -347,11 +404,15 @@ module Sequel
         #          object.  If set to a string, wraps the collection in
         #          a root object using the string as the key.  
         def to_json(*a)
-          if opts = a.first.is_a?(Hash)
-            opts = model.json_serializer_opts.merge(a.first)
+          opts = model.json_serializer_opts
+
+          if ds_opts = @opts[:json_serializer_opts]
+            opts = opts.merge(ds_opts)
+          end
+
+          if (arg = a.first).is_a?(Hash)
+            opts = opts.merge(arg)
             a = []
-          else
-            opts = model.json_serializer_opts
           end
 
           case collection_root = opts[:root]
@@ -367,23 +428,22 @@ module Sequel
             end
           end
 
-          res = if row_proc 
+          res = if row_proc || @opts[:eager_graph] 
             array = if opts[:array]
               opts = opts.dup
               opts.delete(:array)
             else
               all
             end
-            array.map{|obj| Literal.new(Sequel.object_to_json(obj, opts))}
-           else
+            JsonSerializer.object_to_json_data(array, 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 defined?(yield)
+
+          Sequel.object_to_json(res, *a)
         end
       end
     end