sequel 4.49.0 → 5.0.0

data/lib/sequel/plugins/input_transformer.rb

@@ -7,14 +7,14 @@ module Sequel
     #
     #   Album.plugin :input_transformer
     #   Album.add_input_transformer(:reverser){|v| v.is_a?(String) ? v.reverse : v}
-    #   album = Album.new(:name=>'foo')
+    #   album = Album.new(name: 'foo')
     #   album.name # => 'oof'
     #
     # You can specifically set some columns to skip some input
     # input transformers:
     #
     #   Album.skip_input_transformer(:reverser, :foo)
-    #   Album.new(:foo=>'bar').foo # => 'bar'
+    #   Album.new(foo: 'bar').foo # => 'bar'
     # 
     # Usage:
     #
@@ -25,9 +25,8 @@ module Sequel
     #   Album.plugin :input_transformer
     module InputTransformer
       def self.apply(model, *)
-        model.instance_eval do
+        model.instance_exec do
           @input_transformers = {}
-          @input_transformer_order = []
           @skip_input_transformer_columns = {}
         end
       end
@@ -42,23 +41,23 @@ module Sequel
         # Hash of input transformer name symbols to transformer callables.
         attr_reader :input_transformers
 
-        # The order in which to call the input transformers.
-        attr_reader :input_transformer_order
+        # The order in which to call the input transformers. For backwards compatibility only.
+        def input_transformer_order
+          input_transformers.keys.reverse
+        end
 
-        Plugins.inherited_instance_variables(self, :@skip_input_transformer_columns=>:hash_dup, :@input_transformers=>:dup, :@input_transformer_order=>:dup)
+        Plugins.inherited_instance_variables(self, :@skip_input_transformer_columns=>:hash_dup, :@input_transformers=>:dup)
 
         # Add an input transformer to this model.
         def add_input_transformer(transformer_name, &block)
           raise(Error, 'must provide both transformer name and block when adding input transformer') unless transformer_name && block
           @input_transformers[transformer_name] = block
-          @input_transformer_order.unshift(transformer_name)
           @skip_input_transformer_columns[transformer_name] = []
         end
 
         # Freeze input transformers when freezing model class
         def freeze
           @input_transformers.freeze
-          @input_transformer_order.freeze
           @skip_input_transformer_columns.freeze.each_value(&:freeze)
 
           super
@@ -79,8 +78,8 @@ module Sequel
         # Transform the input using all of the transformers, except those explicitly
         # skipped, before setting the value in the model object.
         def []=(k, v)
-          model.input_transformer_order.each do |transformer_name|
-            v = model.input_transformers[transformer_name].call(v) unless model.skip_input_transformer?(transformer_name, k)
+          model.input_transformers.reverse_each do |name, transformer|
+            v = transformer.call(v) unless model.skip_input_transformer?(name, k)
           end
           super
         end

data/lib/sequel/plugins/insert_returning_select.rb

@@ -21,7 +21,7 @@ module Sequel
       # Modify the current model's dataset selection, if the model
       # has a dataset.
       def self.configure(model)
-        model.instance_eval do
+        model.instance_exec do
           self.dataset = dataset if @dataset && @dataset.opts[:select]
         end
       end
@@ -30,14 +30,6 @@ module Sequel
         # The dataset to use to insert new rows.  For internal use only.
         attr_reader :instance_insert_dataset
 
-        # Freeze instance insert dataset when freezing model class.
-        def freeze
-          super
-
-          @instance_insert_dataset.freeze if @instance_insert_dataset
-          self
-        end
-
         private
 
         # When reseting the instance dataset, also reset the instance_insert_dataset.

data/lib/sequel/plugins/instance_filters.rb

@@ -17,12 +17,12 @@ module Sequel
     #
     #   # These are two separate objects that represent the same
     #   # database row. 
-    #   i1 = Item.first(:id=>1, :delete_allowed=>false)
-    #   i2 = Item.first(:id=>1, :delete_allowed=>false)
+    #   i1 = Item.first(id: 1, delete_allowed: false)
+    #   i2 = Item.first(id: 1, delete_allowed: false)
     #
     #   # Add an instance filter to the object. This filter is in effect
     #   # until the object is successfully updated or deleted.
-    #   i1.instance_filter(:delete_allowed=>true)
+    #   i1.instance_filter(delete_allowed: true)
     #
     #   # Attempting to delete the object where the filter doesn't
     #   # match any rows raises an error.
@@ -30,7 +30,7 @@ module Sequel
     #
     #   # The other object that represents the same row has no
     #   # instance filters, and can be updated normally.
-    #   i2.update(:delete_allowed=>true)
+    #   i2.update(delete_allowed: true)
     #
     #   # Even though the filter is now still in effect, since the
     #   # database row has been updated to allow deleting,
@@ -123,7 +123,7 @@ module Sequel
         # Only use prepared statements for update and delete queries
         # if there are no instance filters.
         def use_prepared_statements_for?(type)
-          if (type == :update || type == :delete) && !instance_filters.empty?
+          if type == :update && !instance_filters.empty?
             false
           else
             super if defined?(super)

data/lib/sequel/plugins/instance_hooks.rb

@@ -28,31 +28,16 @@ module Sequel
     #   # Add the instance hook methods just to Album instances
     #   Album.plugin :instance_hooks
     module InstanceHooks
-      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",
-        :after_destroy_commit=>"Use obj.after_destroy_hook{obj.db.after_commit{}} instead",
-        :after_destroy_rollback=>"Use obj.before_destroy_hook{obj.db.after_rollback{}} instead",
-        :after_rollback=>"Use obj.before_save_hook{obj.db.after_rollback{}} instead"
-      }.freeze
-
       module InstanceMethods 
         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?
             add_instance_hook(:#{h}, &block)
             self
           end
         END
         
-        [: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__)}
+        [: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
@@ -67,15 +52,9 @@ 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
           run_after_instance_hooks(:after_destroy)
           @instance_hooks.delete(:after_destroy)
           @instance_hooks.delete(:before_destroy)
-          @instance_hooks.delete(:after_destroy_commit)
-          @instance_hooks.delete(:after_destroy_rollback)
         end
 
         # Run after validation instance hooks.
@@ -89,39 +68,25 @@ 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
           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)
-          @instance_hooks.delete(:after_commit)
-          @instance_hooks.delete(:after_rollback)
         end
 
         # 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
+          run_before_instance_hooks(:before_destroy)
+          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
+          run_before_instance_hooks(:before_save)
+          super
         end
         
         private
@@ -130,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(hook.to_s.start_with?('before') ? :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.
@@ -143,17 +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 do |b|
-            if b.call == false
-              Sequel::Deprecation.deprecate("Having #{hook} instance hook block return false to stop evaluation of further #{hook} instance hook blocks", "Instead, call cancel_action inside #{hook} instance hook block")
-              return false
-            end
-          end
-        end
+        alias run_before_instance_hooks run_after_instance_hooks
       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)

data/lib/sequel/plugins/json_serializer.rb

@@ -17,37 +17,37 @@ module Sequel
     #
     # 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)
+    #   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}})
+    #   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 passing <tt>:name</tt>
-    # to the <tt>:include</tt> hash
+    # 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}})
+    #   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}}]'
     #
@@ -55,12 +55,12 @@ module Sequel
     # of which return all objects in the dataset:
     #
     #   Album.to_json
-    #   Album.where(: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
@@ -77,7 +77,7 @@ module Sequel
     # The array_from_json class method exists to parse arrays of model instances
     # from json:
     #
-    #   json = Album.where(: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
@@ -86,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:
@@ -96,11 +96,11 @@ 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
@@ -132,7 +132,7 @@ module Sequel
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.
       def self.configure(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           @json_serializer_opts = (@json_serializer_opts || OPTS).merge(opts)
         end
       end
@@ -276,7 +276,7 @@ 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)
@@ -329,7 +329,7 @@ module Sequel
 
                 v = v.empty? ? [] : [v]
 
-                objs = send(k)
+                objs = public_send(k)
 
                 is_array = if r = model.association_reflection(k)
                   r.returns_array?
@@ -351,7 +351,7 @@ module Sequel
                 else
                   key_name = c.to_s
                 end
-                h[key_name] = send(c)
+                h[key_name] = public_send(c)
               end
             end
           end

data/lib/sequel/plugins/lazy_attributes.rb

@@ -13,7 +13,7 @@ module Sequel
     # get the reviews for all of those albums:
     #
     #   Album.plugin :lazy_attributes, :review
-    #   Album.where{id<100}.all do |a|
+    #   Album.where{id < 100}.all do |a|
     #     a.review
     #   end
     #
@@ -38,15 +38,6 @@ module Sequel
       end
       
       module ClassMethods
-        def lazy_attributes_module
-          Sequel::Deprecation.deprecate('Sequel::Model.lazy_attributes_module', 'There is no replacement')
-          @lazy_attributes_module
-        end
-        def lazy_attributes_module=(v)
-          Sequel::Deprecation.deprecate('Sequel::Model.lazy_attributes_module=', 'There is no replacement')
-          @lazy_attributes_module= v
-        end
-
         # Freeze lazy attributes module when freezing model class.
         def freeze
           @lazy_attributes_module.freeze if @lazy_attributes_module

data/lib/sequel/plugins/list.rb

@@ -11,7 +11,7 @@ module Sequel
     #
     #   class Item < Sequel::Model(:items)
     #     plugin :list # will use :position field for position
-    #     plugin :list, :field=>:pos # will use :pos field for position
+    #     plugin :list, field: :pos # will use :pos field for position
     #   end
     #   
     #   item = Item[1]
@@ -38,7 +38,7 @@ module Sequel
     # For example, if each item has a +user_id+ field, and you want every user
     # to have their own list:
     #
-    #   Item.plugin :list, :scope=>:user_id
+    #   Item.plugin :list, scope: :user_id
     # 
     # Note that using this plugin modifies the order of the model's dataset to
     # sort by the position and scope fields.  Also note that this plugin is subject to
@@ -62,7 +62,7 @@ module Sequel
         model.scope_proc = case scope = opts[:scope]
         when Symbol
           model.dataset = model.dataset.order_prepend(scope)
-          proc{|obj| obj.model.where(scope=>obj.send(scope))}
+          proc{|obj| obj.model.where(scope=>obj.public_send(scope))}
         when Array
           model.dataset = model.dataset.order_prepend(*scope)
           proc{|obj| obj.model.where(scope.map{|s| [s, obj.get_column_value(s)]})}
@@ -170,17 +170,17 @@ module Sequel
           self.next(n * -1)
         end
 
-        private
-
         # Set the value of the position_field to the maximum value plus 1 unless the
         # position field already has a value.
-        def _before_validation
+        def before_validation
           unless get_column_value(position_field)
             set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
           end
           super
         end
 
+        private
+
         # The model's position field, an instance method for ease of use.
         def position_field
           model.position_field