sequel 3.44.0 → 3.45.0

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -287,6 +287,7 @@ module Sequel
   end
 end
 
+# :nocov:
 if Sequel.core_extensions?
   class Symbol
     include Sequel::Postgres::HStoreOpMethods
@@ -300,3 +301,4 @@ if defined?(Sequel::CoreRefinements)
     end
   end
 end
+# :nocov:

data/lib/sequel/extensions/pg_json.rb

@@ -98,7 +98,7 @@ module Sequel
       # parsing does not yield an array or hash.
       def self.parse_json(s)
         begin
-          value = JSON.parse(s)
+          value = Sequel.parse_json(s)
         rescue JSON::ParserError=>e
           raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
         end
@@ -192,6 +192,7 @@ module Sequel
   Database.register_extension(:pg_json, Postgres::JSONDatabaseMethods)
 end
 
+# :nocov:
 if Sequel.core_extensions?
   class Array
     # Return a Sequel::Postgres::JSONArray proxy to the receiver.
@@ -227,3 +228,4 @@ if defined?(Sequel::CoreRefinements)
     end
   end
 end
+# :nocov:

data/lib/sequel/extensions/pg_range.rb

@@ -503,6 +503,7 @@ module Sequel
   Database.register_extension(:pg_range, Postgres::PGRange::DatabaseMethods)
 end
 
+# :nocov:
 if Sequel.core_extensions?
   class Range 
     # Create a new PGRange using the receiver as the input range,
@@ -522,3 +523,4 @@ if defined?(Sequel::CoreRefinements)
     end
   end
 end
+# :nocov:

data/lib/sequel/extensions/pg_range_ops.rb

@@ -144,6 +144,7 @@ module Sequel
   end
 end
 
+# :nocov:
 if Sequel.core_extensions?
   class Symbol
     include Sequel::Postgres::RangeOpMethods
@@ -157,3 +158,4 @@ if defined?(Sequel::CoreRefinements)
     end
   end
 end
+# :nocov:

data/lib/sequel/extensions/pg_row.rb

@@ -572,6 +572,7 @@ module Sequel
   Database.register_extension(:pg_row, Postgres::PGRow::DatabaseMethods)
 end
 
+# :nocov:
 if Sequel.core_extensions?
   class Array
     # Wraps the receiver in an anonymous Sequel::Postgres::PGRow::ArrayRow instance.
@@ -590,3 +591,4 @@ if defined?(Sequel::CoreRefinements)
     end
   end
 end
+# :nocov:

data/lib/sequel/extensions/pg_row_ops.rb

@@ -176,6 +176,7 @@ module Sequel
   end
 end
 
+# :nocov:
 if Sequel.core_extensions?
   class Symbol
     include Sequel::Postgres::PGRowOp::ExpressionMethods
@@ -189,3 +190,4 @@ if defined?(Sequel::CoreRefinements)
     end
   end
 end
+# :nocov:

data/lib/sequel/extensions/query.rb

@@ -1,12 +1,10 @@
 # The query extension adds Sequel::Dataset#query which allows
 # a different way to construct queries instead of the usual
-# method chaining.
+# method chaining.  See Sequel::Dataset#query for details.
 #
 # To load the extension, do:
 #
 #   Sequel.extension :query
-#
-# This extension uses Object#extend at runtime, which can hurt performance.
 
 module Sequel
   class Database
@@ -17,8 +15,9 @@ module Sequel
   end
 
   class Dataset
-    # Translates a query block into a dataset. Query blocks can be useful
-    # when expressing complex SELECT statements, e.g.:
+    # Translates a query block into a dataset. Query blocks are an
+    # alternative to Sequel's usual method chaining, by using
+    # instance_eval with a proxy object:
     #
     #   dataset = DB[:items].query do
     #     select :x, :y, :z
@@ -29,28 +28,25 @@ module Sequel
     # Which is the same as:
     #
     #  dataset = DB[:items].select(:x, :y, :z).filter{(x > 1) & (y > 2)}.reverse(:z)
-    #
-    # Note that inside a call to query, you cannot call each, insert, update,
-    # or delete (or any method that calls those), or Sequel will raise an
-    # error.
     def query(&block)
-      copy = clone({})
-      copy.extend(QueryBlockCopy)
-      copy.instance_eval(&block)
-      clone(copy.opts)
+      query = Query.new(self)
+      query.instance_eval(&block)
+      query.dataset
     end
 
-    # Module used by Dataset#query that has the effect of making all
-    # dataset methods into !-style methods that modify the receiver.
-    module QueryBlockCopy
-      %w'each insert update delete'.each do |meth|
-        define_method(meth){|*args| raise Error, "##{meth} cannot be invoked inside a query block."}
+    # Proxy object used by Dataset#query.
+    class Query < Sequel::BasicObject
+      # The current dataset in the query.  This changes on each method call.
+      attr_reader :dataset
+     
+      def initialize(dataset)
+        @dataset = dataset
       end
 
-      # Merge the given options into the receiver's options and return the receiver
-      # instead of cloning the receiver.
-      def clone(opts = {})
-        @opts.merge!(opts)
+      # Replace the query's dataset with dataset returned by the method call.
+      def method_missing(method, *args, &block)
+        @dataset = @dataset.send(method, *args, &block)
+        raise(Sequel::Error, "method #{method.inspect} did not return a dataset") unless @dataset.is_a?(Dataset)
         self
       end
     end

data/lib/sequel/model/associations.rb

@@ -254,6 +254,7 @@ module Sequel
         private
 
         if defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby'
+        # :nocov:
           # On non-GVL rubies, assume the need to synchronize access.  Store the key
           # in a special sub-hash that always uses this method to synchronize access.
           def cached_fetch(key)
@@ -270,6 +271,7 @@ module Sequel
             h = self[:cache]
             Sequel.synchronize{h[key] = value}
           end
+        # :nocov:
         else
           # On MRI, use a plain fetch, since the GVL will synchronize access.
           def cached_fetch(key)
@@ -1749,10 +1751,7 @@ module Sequel
       #
       #   Artist.eager(:albums => {proc{|ds| ds.where{year > 1990}}=>{:tracks => :genre}})
       module DatasetMethods
-        # Add the <tt>eager!</tt> and <tt>eager_graph!</tt> mutation methods to the dataset.
-        def self.extended(obj)
-          obj.def_mutation_method(:eager, :eager_graph)
-        end
+        Sequel::Dataset.def_mutation_method(:eager, :eager_graph, :module=>self)
       
         # If the expression is in the form <tt>x = y</tt> where +y+ is a <tt>Sequel::Model</tt>
         # instance, array of <tt>Sequel::Model</tt> instances, or a <tt>Sequel::Model</tt> dataset,

data/lib/sequel/model/base.rb

@@ -780,7 +780,9 @@ module Sequel
         if RUBY_VERSION >= '1.9'
           plugin.const_defined?(submod, false)
         else
+        # :nocov:
           plugin.const_defined?(submod)
+        # :nocov:
         end
       end
   

data/lib/sequel/plugins/force_encoding.rb

@@ -74,5 +74,7 @@ module Sequel
   end
 end
 else
+# :nocov:
   raise LoadError, 'ForceEncoding plugin only works on Ruby 1.9+'
+# :nocov:
 end

data/lib/sequel/plugins/json_serializer.rb

@@ -36,30 +36,54 @@ module Sequel
     #   album.to_json(:root => true)
     #   # => '{"album":{"id":1,"name":"RF","artist_id":2}}'
     #
+    # Additionally, +to_json+ also exists as a class and dataset method, both
+    # of which return all objects in the dataset:
+    #
+    #   Album.to_json
+    #   Album.filter(: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]])
+    #
     # In addition to creating JSON, this plugin also enables Sequel::Model
-    # objects to be automatically created when JSON is parsed:
+    # classes to create instances directly from JSON using the from_json class
+    # method:
     #
     #   json = album.to_json
-    #   album = JSON.parse(json)
+    #   album = Album.from_json(json)
+    #
+    # The array_from_json class method exists to parse arrays of model instances
+    # from json:
+    #
+    #   json = Album.filter(:artist_id=>1).to_json
+    #   albums = Album.array_from_json(json)
+    #
+    # These does not necessarily round trip, since doing so would let users
+    # create model objects with arbitrary values.  By default, from_json will
+    # call set with the values in the hash.  If you want to specify the allowed
+    # 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')
     #
-    # In addition, you can update existing model objects directly from JSON
-    # using +from_json+:
+    # If you want to update an existing instance, you can use the from_json
+    # instance method:
     #
     #   album.from_json(json)
     #
-    # This works by parsing the JSON (which should return a hash), and then
-    # calling +set+ with the returned hash.
+    # Both of these allow creation of cached associated objects, if you provide
+    # the :associations option:
     #
-    # Additionally, +to_json+ also exists as a class and dataset method, both
-    # of which return all objects in the dataset:
+    #   album.from_json(json, :associations=>:artist)
     #
-    #   Album.to_json
-    #   Album.filter(:artist_id=>1).to_json(:include=>:tags)
+    # You can even provide options when setting up the associated objects:
     #
-    # 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.from_json(json, :associations=>{:artist=>{:fields=>%w'id name', :associations=>:tags}})
     #
-    #   Album.to_json(:array=>[Album[1], Album[2]])
+    # 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
@@ -116,29 +140,39 @@ module Sequel
         # The default opts to use when serializing model objects to JSON.
         attr_reader :json_serializer_opts
 
-        # Create a new model object from the hash provided by parsing
-        # JSON.  Handles column values (stored in +values+), associations
-        # (stored in +associations+), and other values (by calling a
-        # setter method).  If an entry in the hash is not a column or
-        # an association, and no setter method exists, raises an Error.
-        def json_create(hash)
-          obj = new
-          cols = columns.map{|x| x.to_s}
-          assocs = associations.map{|x| x.to_s}
-          meths = obj.send(:setter_methods, nil, nil)
-          hash.delete(JSON.create_id)
-          hash.each do |k, v|
-            if assocs.include?(k)
-              obj.associations[k.to_sym] = v
-            elsif meths.include?("#{k}=")
-              obj.send("#{k}=", v)
-            elsif cols.include?(k)
-              obj.values[k.to_sym] = v
-            else
-              raise Error, "Entry in JSON hash not an association or column and no setter method exists: #{k}"
-            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={})
+          v = Sequel.parse_json(json)
+          case v
+          when self
+            v
+          when Hash
+            new.from_json_node(v, opts)
+          else
+            raise Error, "parsed json doesn't return a hash or instance of #{self}"
+          end
+        end
+
+        # 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={})
+          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)}
+            v.map{|ve| ve.is_a?(self) ? ve : new.from_json_node(ve, opts)}
+          else
+            raise(Error, 'parsed json did not return an array')
           end
-          obj
+        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={})
+          new.from_json_node(hash, {:all_columns=>true, :all_associations=>true}.merge(opts))
         end
 
         # Call the dataset +to_json+ method.
@@ -157,14 +191,96 @@ module Sequel
 
       module InstanceMethods
         # Parse the provided JSON, which should return a hash,
-        # and call +set+ with that hash.
+        # and process the hash with from_json_node.
         def from_json(json, opts={})
-          h = JSON.parse(json)
+          from_json_node(Sequel.parse_json(json), opts)
+        end
+
+        # Using the provided hash, update the instance with data contained in the hash. By default, just
+        # 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={})
+          unless hash.is_a?(Hash)
+            raise Error, "parsed json doesn't return a hash"
+          end
+          hash.delete(JSON.create_id)
+
+          unless assocs = opts[:associations]
+            if opts[:all_associations]
+              assocs = {}
+              model.associations.each{|v| assocs[v] = {:all_associations=>true}}
+            end
+          end
+
+          if assocs
+            assocs = case assocs
+            when Symbol
+              {assocs=>{}}
+            when Array
+              assocs_tmp = {}
+              assocs.each{|v| assocs_tmp[v] = {}}
+              assocs_tmp
+            when Hash
+              assocs
+            else
+              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?
+                  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
+                  raise Error, "Attempt to populate non-array association with an array" if assoc_values.is_a?(Array)
+                  assoc_values.is_a?(r.associated_class) ? assoc_values : r.associated_class.new.from_json_node(assoc_values, assoc_opts)
+                end
+              end
+            end
+          end
+
           if fields = opts[:fields]
-            set_fields(h, fields, opts)
+            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(h)
+            set(hash)
           end
+
+          self
         end
 
         # Return a string in JSON format.  Accepts the following

data/lib/sequel/plugins/serialization.rb

@@ -82,9 +82,21 @@ module Sequel
       def self.register_format(format, serializer, deserializer)
         REGISTERED_FORMATS[format] = [serializer, deserializer]
       end
-      register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')}, lambda{|v| Marshal.load(v.unpack('m')[0]) rescue Marshal.load(v)})
+      register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')},
+        lambda do |v|
+          begin
+            Marshal.load(v.unpack('m')[0])
+          rescue => e
+            begin
+              # Backwards compatibility for unpacked marshal output.
+              Marshal.load(v)
+            rescue
+              raise e
+            end
+          end
+        end)
       register_format(:yaml, lambda{|v| v.to_yaml}, lambda{|v| YAML.load(v)})
-      register_format(:json, lambda{|v| v.to_json}, lambda{|v| JSON.parse(v)})
+      register_format(:json, lambda{|v| v.to_json}, lambda{|v| Sequel.parse_json(v)})
 
       module ClassMethods
         # A hash with column name symbols and callable values, with the value