sequel 3.47.0 → 3.48.0

data/lib/sequel/plugins/dataset_associations.rb

@@ -57,6 +57,8 @@ module Sequel
           def_dataset_method(meth){associated(name)}
           ret
         end
+
+        Plugins.def_dataset_methods(self, :associated)
       end
 
       module DatasetMethods

data/lib/sequel/plugins/hook_class_methods.rb

@@ -39,7 +39,13 @@ module Sequel
       end
 
       module ClassMethods
-        Model::HOOKS.each{|h| class_eval("def #{h}(method = nil, &block); add_hook(:#{h}, method, &block) end", __FILE__, __LINE__)}
+        (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
 
         # 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/identity_map.rb

@@ -33,6 +33,10 @@ module Sequel
     #   Album.plugin :identity_map
     #   # would need to do Album.with_identity_map{} to use the identity map
     module IdentityMap
+      def self.apply(mod)
+        Sequel::Deprecation.deprecate('The identity_map plugin', 'Please stop loading it') unless defined?(SEQUEL_EXTENSIONS_NO_DEPRECATION_WARNING)
+      end
+
       module ClassMethods
         # Override the default :eager_loader option for many_*_many associations to work
         # with an identity_map.  If the :eager_graph association option is used, you'll probably have to use

data/lib/sequel/plugins/json_serializer.rb

@@ -1,6 +1,6 @@
-module Sequel
-  tsk_require 'json'
+require 'json'
 
+module Sequel
   module Plugins
     # The json_serializer plugin handles serializing entire Sequel::Model
     # objects to JSON, as well as support for deserializing JSON directly
@@ -143,6 +143,9 @@ 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
           v = Sequel.parse_json(json)
           case v
           when self
@@ -157,6 +160,9 @@ 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
           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,6 +178,7 @@ module Sequel
         # :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
 
@@ -188,6 +195,9 @@ module Sequel
         # 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
           from_json_node(Sequel.parse_json(json), opts)
         end
 
@@ -214,7 +224,10 @@ module Sequel
           unless hash.is_a?(Hash)
             raise Error, "parsed json doesn't return a hash"
           end
-          hash.delete(JSON.create_id)
+          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]
@@ -289,9 +302,6 @@ module Sequel
         #             to include in the JSON output.  Using a nested
         #             hash, you can pass options to associations
         #             to affect the JSON used for associated objects.
-        # :naked :: Not to add the JSON.create_id (json_class) key to the JSON
-        #           output hash, so when the JSON is parsed, it
-        #           will yield a hash instead of a model object.
         # :only :: Symbol or Array of Symbols of columns to only
         #          include in the JSON output, ignoring all other
         #          columns.
@@ -310,7 +320,13 @@ module Sequel
           else
             vals.keys - Array(opts[:except])
           end
-          h = (JSON.create_id && !opts[:naked] && !opts[:root]) ? {JSON.create_id=>model.name} : {}
+
+          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]
             if inc.is_a?(Hash)
@@ -318,9 +334,9 @@ module Sequel
                 v = v.empty? ? [] : [v]
                 h[k.to_s] = case objs = send(k)
                 when Array
-                  objs.map{|obj| Literal.new(obj.to_json(*v))}
+                  objs.map{|obj| Literal.new(Sequel.object_to_json(obj, *v))}
                 else
-                  Literal.new(objs.to_json(*v))
+                  Literal.new(Sequel.object_to_json(objs, *v))
                 end
               end
             else
@@ -328,7 +344,7 @@ module Sequel
             end
           end
           h = {model.send(:underscore, model.to_s) => h} if opts[:root]
-          h.to_json(*a)
+          Sequel.object_to_json(h, *a)
         end
       end
 
@@ -366,7 +382,10 @@ module Sequel
             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.')
             true
           end
 
@@ -377,15 +396,15 @@ module Sequel
             else
               all
             end
-            array.map{|obj| Literal.new(obj.to_json(opts))}
+            array.map{|obj| Literal.new(Sequel.object_to_json(obj, opts))}
            else
             all
           end
 
           if collection_root
-            {model.send(:pluralize, model.send(:underscore, model.to_s)) => res}.to_json(*a)
+            Sequel.object_to_json({model.send(:pluralize, model.send(:underscore, model.to_s)) => res}, *a)
           else
-            res.to_json(*a)
+            Sequel.object_to_json(res, *a)
           end
         end
       end

data/lib/sequel/plugins/optimistic_locking.rb

@@ -1,5 +1,5 @@
 module Sequel
-  tsk_require 'sequel/plugins/instance_filters'
+  require 'plugins/instance_filters'
   
   module Plugins
     # This plugin implements a simple database-independent locking mechanism

data/lib/sequel/plugins/rcte_tree.rb

@@ -132,7 +132,7 @@ module Sequel
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
-          model.from(t => table_alias).
+          model.from(SQL::AliasedExpression.new(t, table_alias)).
            with_recursive(t, col_aliases ? base_ds.select(*col_aliases) : base_ds.select_all,
             recursive_ds.select(*c_all),
             :args=>col_aliases)
@@ -181,7 +181,7 @@ module Sequel
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
           elds = model.eager_loading_dataset(r,
-           model.from(t => table_alias).
+           model.from(SQL::AliasedExpression.new(t, table_alias)).
             with_recursive(t, base_case,
              recursive_case,
              :args=>(([ka] + col_aliases) if col_aliases)),
@@ -232,7 +232,7 @@ module Sequel
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
-          model.from(t => table_alias).
+          model.from(SQL::AliasedExpression.new(t, table_alias)).
            with_recursive(t, col_aliases ? base_ds.select(*col_aliases) : base_ds.select_all,
             recursive_ds.select(*c_all),
             :args=>col_aliases)
@@ -287,7 +287,7 @@ module Sequel
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
           elds = model.eager_loading_dataset(r,
-           model.from(t => table_alias).with_recursive(t, base_case, recursive_case,
+           model.from(SQL::AliasedExpression.new(t, table_alias)).with_recursive(t, base_case, recursive_case,
             :args=>(([ka] + col_aliases + (level ? [la] : [])) if col_aliases)),
            r.select,
            associations, eo)

data/lib/sequel/plugins/scissors.rb

@@ -0,0 +1,33 @@
+module Sequel
+  module Plugins
+    # The scissors plugin adds class methods for update, delete, and destroy.
+    # It is so named because this is considered dangerous, since it is easy
+    # to write:
+    #
+    #   Album.delete
+    #
+    # and delete all rows in the table, when you meant to write:
+    #
+    #   album.delete
+    #
+    # and only delete a single row.
+    #
+    # This plugin is mostly useful for backwards compatibility, and not
+    # recommended for use in production.  However, it can cut down on
+    # verbosity in non-transactional test code, so it may be appropriate
+    # to use when testing.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass run with scissors
+    #   Sequel::Model.plugin :scissors
+    #
+    #   # Make the Album class run with scissors
+    #   Album.plugin :scissors
+    module Scissors
+      module ClassMethods
+        Plugins.def_dataset_methods(self, [:update, :delete, :destroy])
+      end
+    end
+  end
+end

data/lib/sequel/plugins/serialization.rb

@@ -96,7 +96,7 @@ module Sequel
           end
         end)
       register_format(:yaml, lambda{|v| v.to_yaml}, lambda{|v| YAML.load(v)})
-      register_format(:json, lambda{|v| v.to_json}, lambda{|v| Sequel.parse_json(v)})
+      register_format(:json, lambda{|v| Sequel.object_to_json(v)}, lambda{|v| Sequel.parse_json(v)})
 
       module ClassMethods
         # A hash with column name symbols and callable values, with the value

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -181,6 +181,12 @@ module Sequel
 
         private
 
+        # If calling set_dataset manually, make sure to set the dataset
+        # row proc to one that handles inheritance correctly.
+        def set_dataset_row_proc(ds)
+          ds.row_proc = @dataset.row_proc if @dataset
+        end
+
         # Return a class object.  If a class is given, return it directly.
         # Treat strings and symbols as class names.  If nil is given or
         # an invalid class name string or symbol is used, return self.

data/lib/sequel/plugins/tree.rb

@@ -38,10 +38,14 @@ module Sequel
         
         par = opts.merge(opts.fetch(:parent, {}))
         parent = par.fetch(:name, :parent)
-        model.many_to_one parent, par
         
         chi = opts.merge(opts.fetch(:children, {}))
         children = chi.fetch(:name, :children)
+
+        par[:reciprocal] = children
+        chi[:recripocal] = parent
+
+        model.many_to_one parent, par
         model.one_to_many children, chi
 
         model.plugin SingleRoot if opts[:single_root]

data/lib/sequel/plugins/validation_class_methods.rb

@@ -76,7 +76,7 @@ module Sequel
         
         # Instructs the model to skip validations defined in superclasses
         def skip_superclass_validations?
-          defined?(@skip_superclass_validations) && @skip_superclass_validations
+          @skip_superclass_validations
         end
 
         # Defines validations by converting a longhand block into a series of 
@@ -274,6 +274,7 @@ module Sequel
         # Possible Options:
         # * :message - The message to use (default: 'is a string' or 'is not a valid (integer|datetime|etc.)' if the type is known)
         def validates_not_string(*atts)
+          Sequel::Deprecation.deprecate('validates_not_string', "Please switch to validates_schema_type")
           opts = {
             :tag => :not_string,
           }.merge!(extract_options!(atts))

data/lib/sequel/plugins/validation_helpers.rb

@@ -11,8 +11,7 @@ module Sequel
     #     end
     #   end
     #
-    # The validates_unique and validates_schema_types methods have a unique API, but the other
-    # validations have the API explained here:
+    # The validates_unique method has a unique API, but the other validations have the API explained here:
     #
     # Arguments:
     # atts :: Single attribute symbol or an array of attribute symbols specifying the
@@ -95,7 +94,7 @@ module Sequel
       module InstanceMethods 
         # Check that the attribute values are the given exact length.
         def validates_exact_length(exact, atts, opts={})
-          validatable_attributes_for_type(:exact_length, atts, opts){|a,v,m| validation_error_message(m, exact) unless v && v.length == exact}
+          validatable_attributes_for_type(:exact_length, atts, opts){|a,v,m| validation_error_message(m, exact) if v.nil? || v.length != exact}
         end
 
         # Check the string representation of the attribute value(s) against the regular expression with.
@@ -122,7 +121,7 @@ module Sequel
 
         # Check that the attribute values length is in the specified range.
         def validates_length_range(range, atts, opts={})
-          validatable_attributes_for_type(:length_range, atts, opts){|a,v,m| validation_error_message(m, range) unless v && range.send(range.respond_to?(:cover?) ? :cover? : :include?, v.length)}
+          validatable_attributes_for_type(:length_range, atts, opts){|a,v,m| validation_error_message(m, range) if v.nil? || !range.send(range.respond_to?(:cover?) ? :cover? : :include?, v.length)}
         end
     
         # Check that the attribute values are not longer than the given max length.
@@ -130,12 +129,12 @@ module Sequel
         # Accepts a :nil_message option that is the error message to use when the
         # value is nil instead of being too long.
         def validates_max_length(max, atts, opts={})
-          validatable_attributes_for_type(:max_length, atts, opts){|a,v,m| v ? validation_error_message(m, max) : validation_error_message(opts[:nil_message] || DEFAULT_OPTIONS[:max_length][:nil_message]) unless v && v.length <= max}
+          validatable_attributes_for_type(:max_length, atts, opts){|a,v,m| v ? validation_error_message(m, max) : validation_error_message(opts[:nil_message] || DEFAULT_OPTIONS[:max_length][:nil_message]) if v.nil? || v.length > max}
         end
 
         # Check that the attribute values are not shorter than the given min length.
         def validates_min_length(min, atts, opts={})
-          validatable_attributes_for_type(:min_length, atts, opts){|a,v,m| validation_error_message(m, min) unless v && v.length >= min}
+          validatable_attributes_for_type(:min_length, atts, opts){|a,v,m| validation_error_message(m, min) if v.nil? || v.length < min}
         end
 
         # Check attribute value(s) are not NULL/nil.
@@ -150,6 +149,7 @@ module Sequel
         # be a string in an invalid format, and if typecasting succeeds, the value will
         # not be a string.
         def validates_not_string(atts, opts={})
+          Sequel::Deprecation.deprecate('validates_not_string', "Please switch to validates_schema_types")
           validatable_attributes_for_type(:not_string, atts, opts){|a,v,m| validation_error_message(m, (db_schema[a]||{})[:type]) if v.is_a?(String)}
         end
 
@@ -168,10 +168,11 @@ module Sequel
         # Validates for all of the model columns (or just the given columns)
         # that the column value is an instance of the expected class based on
         # the column's schema type.
-        def validates_schema_types(atts=keys)
+        def validates_schema_types(atts=keys, opts={})
           Array(atts).each do |k|
-            next unless type = schema_type_class(k)
-            validates_type(type, k)
+            if type = schema_type_class(k)
+              validates_type(type, k, {:allow_nil=>true}.merge(opts))
+            end
           end
         end
 
@@ -180,7 +181,10 @@ module Sequel
         def validates_type(klass, atts, opts={})
           klass = klass.to_s.constantize if klass.is_a?(String) || klass.is_a?(Symbol)
           validatable_attributes_for_type(:type, atts, opts) do |a,v,m|
-            next if v.nil?
+            if v.nil?
+              Sequel::Deprecation.deprecate('validates_type will no longer allow nil values by default in Sequel 4.  Use the :allow_nil=>true option to allow nil values.')
+              next
+            end
             if klass.is_a?(Array) ? !klass.any?{|kls| v.is_a?(kls)} : !v.is_a?(klass)
               validation_error_message(m, klass)
             end
@@ -249,7 +253,7 @@ module Sequel
               where.call(model.dataset, self, arr)
             else
               vals = arr.map{|x| send(x)}
-              next unless vals.all?
+              next if vals.any?{|v| v.nil?}
               model.where(arr.zip(vals))
             end
             ds = yield(ds) if block_given?

data/lib/sequel/plugins/xml_serializer.rb

@@ -1,6 +1,6 @@
-module Sequel
-  tsk_require 'nokogiri'
+require 'nokogiri'
 
+module Sequel
   module Plugins
     # The xml_serializer plugin handles serializing entire Sequel::Model
     # objects to XML, and deserializing XML into a single Sequel::Model
@@ -45,7 +45,7 @@ module Sequel
     # You can use a hash value with <tt>:include</tt> to pass options
     # to associations:
     #
-    #   album.to_json(:include=>{:artist=>{:only=>:name}})
+    #   album.to_xml(:include=>{:artist=>{:only=>:name}})
     #   # Output:
     #   <?xml version="1.0"?>
     #   <album>
@@ -131,6 +131,9 @@ module Sequel
         # Return an array of instances of this class based on
         # the provided XML.
         def array_from_xml(xml, opts={})
+          if opts[:all_associations] || opts[:all_columns]
+            Sequel::Deprecation.deprecate("The array_from_xml :all_associations and :all_columns", 'You need to explicitly specify the associations and columns via the :associations and :fields options')
+          end
           node = Nokogiri::XML(xml).children.first
           unless node 
             raise Error, "Malformed XML used"
@@ -141,6 +144,9 @@ module Sequel
         # Return an instance of this class based on the provided
         # XML.
         def from_xml(xml, opts={})
+          if opts[:all_associations] || opts[:all_columns]
+            Sequel::Deprecation.deprecate("The from_xml :all_associations and :all_columns", 'You need to explicitly specify the associations and columns via the :associations and :fields options')
+          end
           from_xml_node(Nokogiri::XML(xml).children.first, opts)
         end
 
@@ -211,6 +217,9 @@ module Sequel
         #                on the input string.  Requires that you load the inflector
         #                extension or another library that adds String#underscore.
         def from_xml(xml, opts={})
+          if opts[:all_associations] || opts[:all_columns]
+            Sequel::Deprecation.deprecate("The from_xml :all_associations and :all_columns", 'You need to explicitly specify the associations and columns via the :associations and :fields options')
+          end
           from_xml_node(Nokogiri::XML(xml).children.first, opts)
         end
 

data/lib/sequel/sql.rb

@@ -93,7 +93,15 @@ module Sequel
         # Do not call this method with untrusted input, as that can result in
         # arbitrary code execution.
         def to_s_method(meth, args=:self) # :nodoc:
-          class_eval("def to_s(ds) ds.#{meth}(#{args}) end", __FILE__, __LINE__)
+          # REMOVE40
+          class_eval(<<-END, __FILE__, __LINE__+1)
+            def to_s(ds)
+              Sequel::Deprecation.deprecate('SQL::Expression#to_s', "Please switch to using Dataset#literal to literalize expressions")
+              s = ''
+              to_s_append(ds, s)
+              s
+            end
+          END
           class_eval("def to_s_append(ds, sql) ds.#{meth}_append(sql, #{args}) end", __FILE__, __LINE__)
         end
       end
@@ -127,7 +135,9 @@ module Sequel
       
       # Alias of +to_s+
       def sql_literal(ds)
-        to_s(ds)
+        s = ''
+        to_s_append(ds, s)
+        s
       end
     end