sequel 3.48.0 → 4.0.0

data/lib/sequel/model/errors.rb

@@ -5,19 +5,6 @@ module Sequel
     class Errors < ::Hash
       ATTRIBUTE_JOINER = ' and '.freeze
 
-      # Assign an array of messages for each attribute on access.
-      # Using this message is discouraged in new code, use +add+
-      # to add new error messages, and +on+ to check existing
-      # error messages.
-      def [](k)
-        if has_key?(k)
-          super
-        else
-          Sequel::Deprecation.deprecate('Model::Errors#[] autovivification', 'Please switch to Model::Errors#add to add errors, and Model::Errors#on to get errors')
-          self[k] = []
-        end
-      end
-
       # Adds an error for the given attribute.
       #
       #   errors.add(:name, 'is not valid') if name == 'invalid'

data/lib/sequel/model/plugins.rb

@@ -9,10 +9,10 @@ module Sequel
   #   already loaded by an ancestor class), before including/extending
   #   any modules, with the arguments
   #   and block provided to the call to Model.plugin.
-  # * A module inside the plugin module named InstanceMethods,
-  #   which will be included in the model class.
   # * A module inside the plugin module named ClassMethods,
   #   which will extend the model class.
+  # * A module inside the plugin module named InstanceMethods,
+  #   which will be included in the model class.
   # * A module inside the plugin module named DatasetMethods,
   #   which will extend the model's dataset.
   # * A singleton method named configure, which takes a model, 

data/lib/sequel/no_core_ext.rb

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

data/lib/sequel/plugins/after_initialize.rb

@@ -13,30 +13,24 @@ module Sequel
     module AfterInitialize
       module ClassMethods
         # Call after_initialize for model objects loaded from the database.
-        #def call
-        #  v = super
-        #  v.after_initialize
-        #  v
-        #end
-
-        private
-
-        # REMOVE40
-        def check_deprecated_after_initialize(meths)
+        def call(h={})
+          v = super
+          v.after_initialize
+          v
         end
       end
 
       module InstanceMethods
         # Call after_initialize for new model objects.
-        #def initialize(h={})
-        #  super
-        #  after_initialize
-        #end
-        
+        def initialize(h={})
+          super
+          after_initialize
+        end
+       
         # An empty after_initialize hook, so that plugins that use this
         # can always call super to get the default behavior.
-        #def after_initialize
-        #end
+        def after_initialize
+        end
       end
     end
   end

data/lib/sequel/plugins/association_autoreloading.rb

@@ -1,53 +1,7 @@
 module Sequel
   module Plugins
-    # The AssociationAutoreloading plugin makes many_to_one association
-    # accessor methods automatically reload the cached object whenever
-    # the association's foreign key is modified:
-    #
-    #     Album.many_to_one :artists
-    #     album = Album.first
-    #     album.artist_id #=> 1
-    #     album.artist # caches associated artist
-    #     album.artist_id = 2
-    #     album.artist # reloads associated artist
-    #
+    # Empty plugin module for backwards compatibility
     module AssociationAutoreloading
-      def self.apply(model)
-        model.instance_variable_set(:@autoreloading_associations, {})
-      end
-
-      module ClassMethods
-        # Hash with column symbol keys and arrays of many_to_one
-        # association symbols that should be cleared when the column
-        # value changes.
-        attr_reader :autoreloading_associations
-
-        Plugins.inherited_instance_variables(self, :@autoreloading_associations=>:hash_dup)
-
-        private
-
-        # Add the association to the array of associations to clear for
-        # each of the foreign key columns.
-        def def_many_to_one(opts)
-          super
-          opts[:keys].each do |key|
-            (@autoreloading_associations[key] ||= []) << opts[:name]
-          end
-        end
-      end
-
-      module InstanceMethods
-        private
-
-        # If a foreign key column value changes, clear the related
-        # cached associations.
-        def change_column_value(column, value)
-          if assocs = model.autoreloading_associations[column]
-            assocs.each{|a| associations.delete(a)}
-          end
-          super
-        end
-      end
     end
   end
 end

data/lib/sequel/plugins/association_dependencies.rb

@@ -29,12 +29,12 @@ module Sequel
       DEPENDENCE_ACTIONS = [:delete, :destroy, :nullify]
 
       # Initialize the association_dependencies hash for this model.
-      def self.apply(model, hash={})
+      def self.apply(model, hash=OPTS)
         model.instance_eval{@association_dependencies = {:before_delete=>[], :before_destroy=>[], :before_nullify=>[], :after_delete=>[], :after_destroy=>[]}}
       end
 
       # Call add_association_dependencies with any dependencies given in the plugin call.
-      def self.configure(model, hash={})
+      def self.configure(model, hash=OPTS)
         model.add_association_dependencies(hash) unless hash.empty?
       end
 

data/lib/sequel/plugins/auto_validations.rb

@@ -43,7 +43,7 @@ module Sequel
     #   # Make the Album class use auto validations
     #   Album.plugin :auto_validations
     module AutoValidations
-      def self.apply(model, opts={})
+      def self.apply(model, opts=OPTS)
         model.instance_eval do
           plugin :validation_helpers
           @auto_validate_presence = false
@@ -55,7 +55,7 @@ module Sequel
       end
 
       # Setup auto validations for the model if it has a dataset.
-      def self.configure(model, opts={})
+      def self.configure(model, opts=OPTS)
         model.instance_eval do
           setup_auto_validations if @dataset
           if opts[:not_null] == :presence
@@ -77,12 +77,6 @@ module Sequel
         Plugins.inherited_instance_variables(self, :@auto_validate_presence=>nil, :@auto_validate_types=>nil, :@auto_validate_not_null_columns=>:dup, :@auto_validate_explicit_not_null_columns=>:dup, :@auto_validate_unique_columns=>:dup)
         Plugins.after_set_dataset(self, :setup_auto_validations)
 
-        # REMOVE40
-        def auto_validate_presence_columns
-          Sequel::Deprecation.deprecate('Model.auto_validate_presence_columns', 'Please switch to auto_validate_not_null_columns')
-          auto_validate_not_null_columns
-        end
-
         # Whether to use a presence validation for not null columns
         def auto_validate_presence?
           @auto_validate_presence

data/lib/sequel/plugins/blacklist_security.rb

@@ -36,9 +36,25 @@ module Sequel
           clear_setter_methods_cache
           @restricted_columns = cols
         end
+
+        private
+
+        # If allowed_columns is not set but restricted_columns is, remove the
+        # restricted_columns.
+        def get_setter_methods
+          meths = super
+          if !allowed_columns && restricted_columns
+            meths -= restricted_columns.map{|x| "#{x}="}
+          end
+          meths
+        end
       end
 
       module InstanceMethods
+        # Special array subclass used for marking methods to be removed.
+        class ExceptionList < Array
+        end
+
         # Set all values using the entries in the hash, except for the keys
         # given in except.  You should probably use +set_fields+ or +set_only+
         # instead of this method, as blacklist approaches to security are a bad idea.
@@ -46,7 +62,7 @@ module Sequel
         #   artist.set_except({:name=>'Jim'}, :hometown)
         #   artist.name # => 'Jim'
         def set_except(hash, *except)
-          set_restricted(hash, false, except.flatten)
+          set_restricted(hash, ExceptionList.new(except.flatten))
         end
     
         # Update all values using the entries in the hash, except for the keys
@@ -55,7 +71,21 @@ module Sequel
         #
         #   artist.update_except({:name=>'Jim'}, :hometown) # UPDATE artists SET name = 'Jim' WHERE (id = 1)
         def update_except(hash, *except)
-          update_restricted(hash, false, except.flatten)
+          update_restricted(hash, ExceptionList.new(except.flatten))
+        end
+
+        private
+
+        # If set_except or update_except was used, remove the related methods from the list.
+        def setter_methods(type)
+          if type.is_a?(ExceptionList)
+            meths = super(:all)
+            meths -= Array(primary_key).map{|x| "#{x}="} if primary_key && model.restrict_primary_key?
+            meths -= type.map{|x| "#{x}="}
+            meths
+          else
+            super
+          end
         end
       end
     end

data/lib/sequel/plugins/caching.rb

@@ -34,7 +34,7 @@ module Sequel
     module Caching
       # Set the cache_store and cache_ttl attributes for the given model.
       # If the :ttl option is not given, 3600 seconds is the default.
-      def self.configure(model, store, opts={})
+      def self.configure(model, store, opts=OPTS)
         model.instance_eval do
           @cache_store = store
           @cache_ttl = opts[:ttl] || 3600

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -68,7 +68,7 @@ module Sequel
       # The class_table_inheritance plugin requires the lazy_attributes plugin
       # to handle lazily-loaded attributes for subclass instances returned
       # by superclass methods.
-      def self.apply(model, opts={})
+      def self.apply(model, opts=OPTS)
         model.plugin :lazy_attributes
       end
       
@@ -81,7 +81,7 @@ module Sequel
       # * :table_map - Hash with class name symbol keys and table name symbol
       #   values.  Necessary if the implicit table name for the model class
       #   does not match the database table name
-      def self.configure(model, opts={})
+      def self.configure(model, opts=OPTS)
         model.instance_eval do
           m = method(:constantize)
           @cti_base_model = self

data/lib/sequel/plugins/composition.rb

@@ -90,7 +90,7 @@ module Sequel
         #     # for example y in the composition object represents year
         #     # in the model object.
         #     :mapping=>[[:year, :y], [:month, :m], [:day, :d]]
-        def composition(name, opts={})
+        def composition(name, opts=OPTS)
           opts = opts.dup
           compositions[name] = opts
           if mapping = opts[:mapping]
@@ -127,7 +127,7 @@ module Sequel
         Plugins.inherited_instance_variables(self, :@compositions=>:dup)
         
         # Define getter and setter methods for the composition object.
-        def define_composition_accessor(name, opts={})
+        def define_composition_accessor(name, opts=OPTS)
           include(@composition_module ||= Module.new) unless composition_module
           composer = opts[:composer]
           composition_module.class_eval do
@@ -149,12 +149,6 @@ module Sequel
       end
 
       module InstanceMethods
-        # Clear the cached compositions when setting values.
-        def set_values(hash)
-          @compositions.clear if @compositions
-          super
-        end
-
         # For each composition, set the columns in the model class based
         # on the composition object.
         def before_save
@@ -172,6 +166,14 @@ module Sequel
           compositions.freeze
           super
         end
+
+        private
+
+        # Clear the cached compositions when manually refreshing.
+        def _refresh_set_values(hash)
+          @compositions.clear if @compositions
+          super
+        end
       end
     end
   end

data/lib/sequel/plugins/constraint_validations.rb

@@ -32,7 +32,7 @@ module Sequel
       DEFAULT_CONSTRAINT_VALIDATIONS_TABLE = :sequel_constraint_validations
 
       # Automatically load the validation_helpers plugin to run the actual validations.
-      def self.apply(model, opts={})
+      def self.apply(model, opts=OPTS)
         model.instance_eval do
           plugin :validation_helpers
           @constraint_validations_table = DEFAULT_CONSTRAINT_VALIDATIONS_TABLE
@@ -49,7 +49,7 @@ module Sequel
       #                        given options.  Keys should be validation type symbols (e.g.
       #                        :presence) and values should be hashes of options specific
       #                        to that validation type.
-      def self.configure(model, opts={})
+      def self.configure(model, opts=OPTS)
         model.instance_eval do
           if table = opts[:constraint_validations_table]
             @constraint_validations_table = table

data/lib/sequel/plugins/dataset_associations.rb

@@ -89,6 +89,10 @@ module Sequel
               join(fe[:table], Array(fe[:right]).zip(Array(fe[:left])), :implicit_qualifier=>model.table_name)
             edges.each{|e| sds = sds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
             ds.filter(r.qualified_right_primary_key=>sds)
+          when :pg_array_to_many
+            ds.filter(Sequel.expr(r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}))
+          when :many_to_pg_array
+            ds.filter(Sequel.function(:coalesce, Sequel.pg_array_op(r[:key]).overlaps(sds.select{array_agg(r.qualify(r[:model].table_name, r.primary_key))}), false))
           else
             raise Error, "unrecognized association type for association #{name.inspect}: #{r[:type].inspect}"
           end

data/lib/sequel/plugins/defaults_setter.rb

@@ -54,12 +54,14 @@ module Sequel
       end
 
       module InstanceMethods
-        private
-
-        # Set default values if they are not already set by the hash provided to initialize.
-        def initialize_set(h)
-          super
-          model.default_values.each{|k,v| self[k] = (v.respond_to?(:call) ? v.call : v) unless values.has_key?(k)}
+        # Use default value for a new record if values doesn't already contain an entry for it.
+        def [](k)
+          if new? && !values.has_key?(k)
+            v = model.default_values[k]
+            v.respond_to?(:call) ? v.call : v
+          else
+            super
+          end
         end
       end
     end

data/lib/sequel/plugins/dirty.rb

@@ -123,12 +123,6 @@ module Sequel
           end
         end
 
-        # Reset the initial values when setting values.
-        def set_values(hash)
-          reset_initial_values
-          super
-        end
-
         # Manually specify that a column will change.  This should only be used
         # if you plan to modify a column value in place, which is not recommended.
         #
@@ -158,6 +152,12 @@ module Sequel
 
         private
 
+        # Reset the initial values when setting values.
+        def _refresh_set_values(hash)
+          reset_initial_values
+          super
+        end
+
         # Reset the initial values after saving.
         def after_save
           super

data/lib/sequel/plugins/force_encoding.rb

@@ -33,21 +33,26 @@ module Sequel
         attr_accessor :forced_encoding
         
         Plugins.inherited_instance_variables(self, :@forced_encoding=>nil)
+
+        def call(values)
+          o = super
+          o.send(:force_hash_encoding, o.values)
+          o
+        end
       end
     
       module InstanceMethods
-        # Allow the force encoding plugin to work with the identity_map
-        # plugin by typecasting new values.
-        def merge_db_update(row)
-          super(force_hash_encoding(row))
-        end
+        private
         
         # Force the encoding of all string values when setting the instance's values.
-        def set_values(row)
-          super(force_hash_encoding(row))
+        def _refresh_set_values(values)
+          super(force_hash_encoding(values))
         end
         
-        private
+        # Force the encoding of all string values when setting the instance's values.
+        def _save_set_values(values)
+          super(force_hash_encoding(values))
+        end
         
         # Force the encoding for all string values in the given row hash.
         def force_hash_encoding(row)

data/lib/sequel/plugins/hook_class_methods.rb

@@ -39,13 +39,7 @@ module Sequel
       end
 
       module ClassMethods
-        (Model::HOOKS - [:after_initialize]).each{|h| class_eval("def #{h}(method = nil, &block); add_hook(:#{h}, method, &block) end", __FILE__, __LINE__)}
-
-        # REMOVE40
-        def after_initialize(method = nil, &block)
-          Sequel::Deprecation.deprecate('The Model after_initialize hook', 'The hook_class_methods plugin will no longer support the hook.  Please use the after_initialize plugin and define the after_initialize hook directly')
-          add_hook(:after_initialize, method, &block)
-        end
+        Model::HOOKS.each{|h| class_eval("def #{h}(method = nil, &block); add_hook(:#{h}, method, &block) end", __FILE__, __LINE__)}
 
         # This adds a new hook type. It will define both a class
         # method that you can use to add hooks, as well as an instance method

data/lib/sequel/plugins/json_serializer.rb

@@ -82,9 +82,6 @@ module Sequel
     #
     #   album.from_json(json, :associations=>{:artist=>{:fields=>%w'id name', :associations=>:tags}})
     #
-    # If the json is trusted and should be allowed to set all column and association
-    # values, you can use the :all_columns and :all_associations options.
-    #
     # 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:
@@ -142,10 +139,7 @@ module Sequel
 
         # Attempt to parse a single instance from the given JSON string,
         # with options passed to InstanceMethods#from_json_node.
-        def from_json(json, opts={})
-          if opts[:all_associations] || opts[:all_columns]
-            Sequel::Deprecation.deprecate("The from_json :all_associations and :all_columns", 'You need to explicitly specify the associations and columns via the :associations and :fields options')
-          end
+        def from_json(json, opts=OPTS)
           v = Sequel.parse_json(json)
           case v
           when self
@@ -159,10 +153,7 @@ module Sequel
 
         # Attempt to parse an array of instances from the given JSON string,
         # with options passed to InstanceMethods#from_json_node.
-        def array_from_json(json, opts={})
-          if opts[:all_associations] || opts[:all_columns]
-            Sequel::Deprecation.deprecate("The from_json :all_associations and :all_columns", 'You need to explicitly specify the associations and columns via the :associations and :fields options')
-          end
+        def array_from_json(json, opts=OPTS)
           v = Sequel.parse_json(json)
           if v.is_a?(Array)
             raise(Error, 'parsed json returned an array containing non-hashes') unless v.all?{|ve| ve.is_a?(Hash) || ve.is_a?(self)}
@@ -172,16 +163,6 @@ module Sequel
           end
         end
 
-        # Exists for compatibility with old json library which allows creation
-        # of arbitrary ruby objects by JSON.parse.  Creates a new instance
-        # and populates it using InstanceMethods#from_json_node with the
-        # :all_columns and :all_associations options.  Not recommended for usage
-        # in new code, consider calling the from_json method directly with the JSON string.
-        def json_create(hash, opts={})
-          Sequel::Deprecation.deprecate("Model.json_create", 'Switch to Model.from_json')
-          new.from_json_node(hash, {:all_columns=>true, :all_associations=>true}.merge(opts))
-        end
-
         Plugins.inherited_instance_variables(self, :@json_serializer_opts=>lambda do |json_serializer_opts|
           opts = {}
           json_serializer_opts.each{|k, v| opts[k] = (v.is_a?(Array) || v.is_a?(Hash)) ? v.dup : v}
@@ -194,10 +175,7 @@ module Sequel
       module InstanceMethods
         # Parse the provided JSON, which should return a hash,
         # and process the hash with from_json_node.
-        def from_json(json, opts={})
-          if opts[:all_associations] || opts[:all_columns]
-            Sequel::Deprecation.deprecate("The from_json :all_associations and :all_columns", 'You need to explicitly specify the associations and columns via the :associations and :fields options')
-          end
+        def from_json(json, opts=OPTS)
           from_json_node(Sequel.parse_json(json), opts)
         end
 
@@ -205,38 +183,19 @@ module Sequel
         # calls set with the hash values.
         # 
         # Options:
-        # :all_associations :: Indicates that all associations supported by the model should be tried.
-        #                      This option also cascades to associations if used. It is better to use the
-        #                      :associations option instead of this option. This option only exists for
-        #                      backwards compatibility.
-        # :all_columns :: Overrides the setting logic allowing all setter methods be used,
-        #                 even if access to the setter method is restricted.
-        #                 This option cascades to associations if used, and can be reset in those associations
-        #                 using the :all_columns=>false or :fields options.  This option is considered a
-        #                 security risk, and only exists for backwards compatibility.  It is better to use
-        #                 the :fields option appropriately instead of this option, or no option at all.
         # :associations :: Indicates that the associations cache should be updated by creating
         #                  a new associated object using data from the hash.  Should be a Symbol
         #                  for a single association, an array of symbols for multiple associations,
         #                  or a hash with symbol keys and dependent association option hash values.
         # :fields :: Changes the behavior to call set_fields using the provided fields, instead of calling set.
-        def from_json_node(hash, opts={})
+        def from_json_node(hash, opts=OPTS)
           unless hash.is_a?(Hash)
             raise Error, "parsed json doesn't return a hash"
           end
-          if hash.has_key?(JSON.create_id)
-            Sequel::Deprecation.deprecate('Attempting to use Model#from_json with a hash value that includes JSON.create_id is deprecated.  Starting in Sequel 4.0, the create_id will not be removed automatically.')
-            hash.delete(JSON.create_id)
-          end
 
-          unless assocs = opts[:associations]
-            if opts[:all_associations]
-              assocs = {}
-              model.associations.each{|v| assocs[v] = {:all_associations=>true}}
-            end
-          end
+          populate_associations = {}
 
-          if assocs
+          if assocs = opts[:associations]
             assocs = case assocs
             when Symbol
               {assocs=>{}}
@@ -250,19 +209,13 @@ module Sequel
               raise Error, ":associations should be Symbol, Array, or Hash if present"
             end
 
-            if opts[:all_columns]
-              assocs.each_value do |assoc_opts|
-                assoc_opts[:all_columns] = true unless assoc_opts.has_key?(:fields) || assoc_opts.has_key?(:all_columns)
-              end
-            end
-
             assocs.each do |assoc, assoc_opts|
               if assoc_values = hash.delete(assoc.to_s)
                 unless r = model.association_reflection(assoc)
                   raise Error, "Association #{assoc} is not defined for #{model}"
                 end
 
-                associations[assoc] = if r.returns_array?
+                populate_associations[assoc] = if r.returns_array?
                   raise Error, "Attempt to populate array association with a non-array" unless assoc_values.is_a?(Array)
                   assoc_values.map{|v| v.is_a?(r.associated_class) ? v : r.associated_class.new.from_json_node(v, assoc_opts)}
                 else
@@ -275,19 +228,14 @@ module Sequel
 
           if fields = opts[:fields]
             set_fields(hash, fields, opts)
-          elsif opts[:all_columns]
-            meths = methods.collect{|x| x.to_s}.grep(Model::SETTER_METHOD_REGEXP) - Model::RESTRICTED_SETTER_METHODS
-            hash.each do |k, v|
-              if meths.include?(setter_meth = "#{k}=")
-                send(setter_meth, v)
-              else
-                raise Error, "Entry in JSON does not have a matching setter method: #{k}"
-              end
-            end
           else
             set(hash)
           end
 
+          populate_associations.each do |assoc, values|
+            associations[assoc] = values
+          end
+
           self
         end
 
@@ -306,7 +254,6 @@ module Sequel
         #          include in the JSON output, ignoring all other
         #          columns.
         # :root :: Qualify the JSON with the name of the object.
-        #          Implies :naked since the object name is explicit.
         def to_json(*a)
           if opts = a.first.is_a?(Hash)
             opts = model.json_serializer_opts.merge(a.first)
@@ -322,10 +269,6 @@ module Sequel
           end
 
           h = {}
-          if  JSON.create_id && !opts[:naked] && !opts[:root]
-            Sequel::Deprecation.deprecate('The :naked and :root options have not been used, so adding JSON.create_id to the to_json output.  This is deprecated, starting in Sequel 4, the JSON.create_id will never be added.')
-            h[JSON.create_id] = model.name
-          end
 
           cols.each{|c| h[c.to_s] = send(c)}
           if inc = opts[:include]
@@ -377,15 +320,11 @@ module Sequel
           collection_root = case opts[:root]
           when nil, false, :instance
             false
-          when :collection
-            opts = opts.dup
-            opts.delete(:root)
-            opts[:naked] = true unless opts.has_key?(:naked)
-            true
           when :both
             true
           else
-            Sequel::Deprecation.deprecate('The to_json :root=>true option will mean :root=>:collection starting in Sequel 4.  Use :root=>:both if you want to wrap both the collection and each item in a wrapper.')
+            opts = opts.dup
+            opts.delete(:root)
             true
           end