sequel 4.21.0 → 4.22.0

data/lib/sequel/plugins/dirty.rb

@@ -201,9 +201,9 @@ module Sequel
         # Duplicate internal data structures
         def initialize_copy(other)
           super
-          @initial_values = other.initial_values.dup
+          @initial_values = Hash[other.initial_values]
           @missing_initial_values = other.send(:missing_initial_values).dup
-          @previous_changes = other.previous_changes.dup if other.previous_changes
+          @previous_changes = Hash[other.previous_changes] if other.previous_changes
           self
         end
 

data/lib/sequel/plugins/hook_class_methods.rb

@@ -63,7 +63,7 @@ module Sequel
         #
         #  class MyModel
         #   add_hook_type :before_move_to
-        #   before_move_to(:check_move_allowed){|o| o.allow_move?}
+        #   before_move_to(:check_move_allowed, &:allow_move?)
         #   def move_to(there)
         #     return if before_move_to == false
         #     # move MyModel object to there

data/lib/sequel/plugins/instance_hooks.rb

@@ -82,7 +82,7 @@ module Sequel
         
         # Run all hook blocks of the given hook type.
         def run_after_instance_hooks(hook)
-          instance_hooks(hook).each{|b| b.call}
+          instance_hooks(hook).each(&:call)
         end
 
         # Run all hook blocks of the given hook type.  If a hook block returns false,

data/lib/sequel/plugins/many_through_many.rb

@@ -263,7 +263,7 @@ module Sequel
                 select_all(egds.first_source).
                 select_append(*associated_key_array)
               egds = opts.apply_eager_graph_limit_strategy(egls, egds)
-              ds.graph(egds, associated_key_array.map{|v| v.alias}.zip(Array(lpkcs)) + conditions, :qualify=>:deep, :table_alias=>eo[:table_alias], :implicit_qualifier=>iq, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], :from_self_alias=>eo[:from_self_alias], :select=>select||orig_egds.columns, &graph_block)
+              ds.graph(egds, associated_key_array.map(&:alias).zip(Array(lpkcs)) + conditions, :qualify=>:deep, :table_alias=>eo[:table_alias], :implicit_qualifier=>iq, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], :from_self_alias=>eo[:from_self_alias], :select=>select||orig_egds.columns, &graph_block)
             else
               opts.edges.each do |t|
                 ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>eo[:join_type]||t[:join_type], :join_only=>eo[:join_only], :qualify=>:deep, :implicit_qualifier=>iq, :from_self_alias=>eo[:from_self_alias], &t[:block])

data/lib/sequel/plugins/nested_attributes.rb

@@ -137,7 +137,7 @@ module Sequel
         def set_nested_attributes(assoc, obj, opts=OPTS)
           raise(Error, "no association named #{assoc} for #{model.inspect}") unless ref = model.association_reflection(assoc)
           raise(Error, "nested attributes are not enabled for association #{assoc} for #{model.inspect}") unless meta = ref[:nested_attributes]
-          meta = meta.merge(opts)
+          meta = Hash[meta].merge!(opts)
           meta[:reflection] = ref
           if ref.returns_array?
             nested_attributes_list_setter(meta, obj)
@@ -195,7 +195,7 @@ module Sequel
         # If there is a limit on the nested attributes for this association,
         # make sure the length of the attributes_list is not greater than the limit.
         def nested_attributes_list_setter(meta, attributes_list)
-          attributes_list = attributes_list.sort_by{|x| x.to_s}.map{|k,v| v} if attributes_list.is_a?(Hash)
+          attributes_list = attributes_list.sort_by(&:to_s).map{|k,v| v} if attributes_list.is_a?(Hash)
           if (limit = meta[:limit]) && attributes_list.length > limit
             raise(Error, "number of nested attributes (#{attributes_list.length}) exceeds the limit (#{limit})")
           end
@@ -254,10 +254,10 @@ module Sequel
           reflection = meta[:reflection]
           klass = reflection.associated_class
           sym_keys = Array(klass.primary_key)
-          str_keys = sym_keys.map{|k| k.to_s}
+          str_keys = sym_keys.map(&:to_s)
           if (pk = attributes.values_at(*sym_keys)).all? || (pk = attributes.values_at(*str_keys)).all?
-            pk = pk.map{|k| k.to_s}
-            obj = Array(send(reflection[:name])).find{|x| Array(x.pk).map{|k| k.to_s} == pk}
+            pk = pk.map(&:to_s)
+            obj = Array(send(reflection[:name])).find{|x| Array(x.pk).map(&:to_s) == pk}
           end
           if obj
             attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}

data/lib/sequel/plugins/pg_array_associations.rb

@@ -312,7 +312,7 @@ module Sequel
           opts[:eager_loader] ||= proc do |eo|
             id_map = eo[:id_map]
 
-            eager_load_results(opts, eo.merge(:loader=>false)) do |assoc_record|
+            eager_load_results(opts, Hash[eo].merge!(:loader=>false)) do |assoc_record|
               if pks ||= assoc_record.get_column_value(key)
                 pks.each do |pkv|
                   next unless objects = id_map[pkv]
@@ -348,7 +348,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
             ds
           end
 
@@ -402,7 +402,7 @@ module Sequel
               end
             end
 
-            eager_load_results(opts, eo.merge(:id_map=>id_map)) do |assoc_record|
+            eager_load_results(opts, Hash[eo].merge!(:id_map=>id_map)) do |assoc_record|
               if objects = id_map[assoc_record.get_column_value(pkm)]
                 objects.each do |object| 
                   object.associations[name].push(assoc_record)
@@ -435,7 +435,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
             ds
           end
 

data/lib/sequel/plugins/prepared_statements.rb

@@ -72,7 +72,7 @@ module Sequel
 
         # Return a sorted array of columns for use as a hash key.
         def prepared_columns(cols)
-          RUBY_VERSION >= '1.9' ? cols.sort : cols.sort_by{|c| c.to_s}
+          RUBY_VERSION >= '1.9' ? cols.sort : cols.sort_by(&:to_s)
         end
 
         # Return a prepared statement that can be used to delete a row from this model's dataset.
@@ -194,7 +194,7 @@ module Sequel
         # Use a prepared statement to update this model's columns in the database.
         def _update_without_checking(columns)
           if use_prepared_statements_for?(:update)
-            model.send(:prepared_update, columns.keys).call(columns.merge(pk_hash))
+            model.send(:prepared_update, columns.keys).call(Hash[columns].merge!(pk_hash))
           else
             super
           end

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -57,7 +57,7 @@ module Sequel
         # of free columns.
         def before_create
           if v = model.prepared_statements_column_defaults
-            @values = v.merge(values)
+            @values = Hash[v].merge!(values)
           end
           super
         end

data/lib/sequel/plugins/serialization.rb

@@ -36,8 +36,8 @@ module Sequel
     #   # Register custom serializer/deserializer pair, if desired
     #   require 'sequel/plugins/serialization'
     #   Sequel::Plugins::Serialization.register_format(:reverse,
-    #     lambda{|v| v.reverse},
-    #     lambda{|v| v.reverse})
+    #     lambda(&:reverse),
+    #     lambda(&:reverse))
     #
     #   class User < Sequel::Model
     #     # Built-in format support when loading the plugin
@@ -51,7 +51,7 @@ module Sequel
     #     serialize_attributes :reverse, :password
     #
     #     # Use a custom serializer/deserializer pair without registering
-    #     serialize_attributes [lambda{|v| v.reverse}, lambda{|v| v.reverse}], :password
+    #     serialize_attributes [lambda(&:reverse), lambda(&:reverse)], :password
     #   end
     #   user = User.create
     #   user.permissions = { :global => 'read-only' }
@@ -106,7 +106,7 @@ module Sequel
             end
           end
         end)
-      register_format(:yaml, lambda{|v| v.to_yaml}, lambda{|v| YAML.load(v)})
+      register_format(:yaml, lambda(&:to_yaml), lambda{|v| YAML.load(v)})
       register_format(:json, lambda{|v| Sequel.object_to_json(v)}, lambda{|v| Sequel.parse_json(v)})
 
       module ClassMethods
@@ -129,7 +129,7 @@ module Sequel
         def serialize_attributes(format, *columns)
           if format.is_a?(Symbol)
             unless format = REGISTERED_FORMATS[format]
-              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{REGISTERED_FORMATS.keys.map{|k| k.inspect}.join})")
+              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{REGISTERED_FORMATS.keys.map(&:inspect).join})")
             end
           end
           serializer, deserializer = format
@@ -212,7 +212,7 @@ module Sequel
         # Dup the deserialized values when duping model instance.
         def initialize_copy(other)
           super
-          @deserialized_values = other.deserialized_values.dup
+          @deserialized_values = Hash[other.deserialized_values]
           self
         end
 

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -58,7 +58,7 @@ module Sequel
         def initialize_copy(other)
           super
           if o = other.instance_variable_get(:@original_deserialized_values)
-            @original_deserialized_values = o.dup
+            @original_deserialized_values = Hash[o]
           end
           self
         end

data/lib/sequel/plugins/sharding.rb

@@ -33,7 +33,9 @@ module Sequel
               ds = ds.server?(server)
               ds
             end
-            eo = eo.merge(:eager_block=>set_server)
+            eo = Hash[eo]
+            eo[:eager_block] = set_server
+            eo
           end
 
           super

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -59,7 +59,7 @@ module Sequel
     #   # and :key_map taking a class object and returning the column
     #   # value to use
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>proc{|v| v.reverse},
+    #     :model_map=>proc(&:reverse),
     #     :key_map=>proc{|klass| klass.name.reverse}
     #
     #   # You can use the same class for multiple values.
@@ -147,27 +147,19 @@ module Sequel
         # This defaults to a lookup in the key map.
         attr_reader :sti_key_chooser
 
+        Plugins.inherited_instance_variables(self, :@sti_dataset=>nil, :@sti_key=>nil, :@sti_key_map=>nil, :@sti_model_map=>nil, :@sti_key_chooser=>nil)
+
         # Copy the necessary attributes to the subclasses, and filter the
         # subclass's dataset based on the sti_kep_map entry for the class.
         def inherited(subclass)
           super
-          sk = sti_key
-          sd = sti_dataset
-          skm = sti_key_map
-          smm = sti_model_map
-          skc = sti_key_chooser
-          key = Array(skm[subclass]).dup
+          key = Array(sti_key_map[subclass]).dup
           sti_subclass_added(key)
           rp = dataset.row_proc
-          subclass.set_dataset(sd.filter(SQL::QualifiedIdentifier.new(table_name, sk)=>key), :inherited=>true)
+          subclass.set_dataset(sti_dataset.filter(SQL::QualifiedIdentifier.new(sti_dataset.first_source_alias, sti_key)=>key), :inherited=>true)
           subclass.instance_eval do
             dataset.row_proc = rp
-            @sti_key = sk
             @sti_key_array = key
-            @sti_dataset = sd
-            @sti_key_map = skm
-            @sti_model_map = smm
-            @sti_key_chooser = skc
             self.simple_table = nil
           end
         end

data/lib/sequel/plugins/static_cache.rb

@@ -111,7 +111,7 @@ module Sequel
         def to_hash(key_column = nil, value_column = nil)
         if key_column.nil? && value_column.nil?
           if @static_cache_frozen
-            return cache.dup
+            return Hash[cache]
           else
             key_column = primary_key
           end
@@ -198,7 +198,7 @@ module Sequel
           if @static_cache_frozen
             o
           elsif o
-            call(o.values.dup)
+            call(Hash[o.values])
           end
         end
       end

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -53,7 +53,7 @@ module Sequel
           name = opts[:name]
           if !associations.include?(name) && retrieved_by && !frozen?
             begin
-              retrieved_by.send(:eager_load, retrieved_with.reject{|o| o.frozen?}, name=>{})
+              retrieved_by.send(:eager_load, retrieved_with.reject(&:frozen?), name=>{})
             rescue Sequel::UndefinedAssociation
               # This can happen if class table inheritance is used and the association
               # is only defined in a subclass.  This particular instance can use the

data/lib/sequel/plugins/tree.rb

@@ -43,7 +43,7 @@ module Sequel
         children = chi.fetch(:name, :children)
 
         par[:reciprocal] = children
-        chi[:recripocal] = parent
+        chi[:reciprocal] = parent
 
         model.many_to_one parent, par
         model.one_to_many children, chi

data/lib/sequel/plugins/validation_class_methods.rb

@@ -182,8 +182,8 @@ module Sequel
           blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
             proc do |o,a,v|
               next if i && !validation_if_proc(o, i)
-              next if an && Array(v).all?{|x| x.nil?}
-              next if ab && Array(v).all?{|x| x.blank?}
+              next if an && Array(v).all?(&:nil?)
+              next if ab && Array(v).all?(&:blank?)
               next if am && Array(a).all?{|x| !o.values.has_key?(x)}
               block.call(o,a,v)
             end

data/lib/sequel/plugins/validation_helpers.rb

@@ -156,7 +156,7 @@ module Sequel
         def validates_schema_types(atts=keys, opts=OPTS)
           Array(atts).each do |k|
             if type = schema_type_class(k)
-              validates_type(type, k, {:allow_nil=>true}.merge(opts))
+              validates_type(type, k, {:allow_nil=>true}.merge!(opts))
             end
           end
         end
@@ -224,7 +224,7 @@ module Sequel
         def validates_unique(*atts)
           opts = default_validation_helpers_options(:unique)
           if atts.last.is_a?(Hash)
-            opts = opts.merge(atts.pop)
+            opts = Hash[opts].merge!(atts.pop)
           end
           message = validation_error_message(opts[:message])
           where = opts[:where]
@@ -237,7 +237,7 @@ module Sequel
               where.call(ds, self, arr)
             else
               vals = arr.map{|x| get_column_value(x)}
-              next if vals.any?{|v| v.nil?}
+              next if vals.any?(&:nil?)
               ds.where(arr.zip(vals))
             end
             ds = yield(ds) if block_given?
@@ -279,7 +279,7 @@ module Sequel
         # Merge the given options with the default options for the given type
         # and call validatable_attributes with the merged options.
         def validatable_attributes_for_type(type, atts, opts, &block)
-          validatable_attributes(atts, default_validation_helpers_options(type).merge(opts), &block)
+          validatable_attributes(atts, Hash[default_validation_helpers_options(type)].merge!(opts), &block)
         end
         
         # The validation error message to use, as a string.  If message

data/lib/sequel/plugins/xml_serializer.rb

@@ -113,17 +113,17 @@ module Sequel
     module XmlSerializer
       module ClassMethods
         # Proc that camelizes the input string, used for the :camelize option
-        CAMELIZE = proc{|s| s.camelize}
+        CAMELIZE = proc(&:camelize)
 
         # Proc that dasherizes the input string, used for the :dasherize option
-        DASHERIZE = proc{|s| s.dasherize}
+        DASHERIZE = proc(&:dasherize)
 
         # Proc that returns the input string as is, used if
         # no :name_proc, :dasherize, or :camelize option is used.
         IDENTITY = proc{|s| s}
 
         # Proc that underscores the input string, used for the :underscore option
-        UNDERSCORE = proc{|s| s.underscore}
+        UNDERSCORE = proc(&:underscore)
 
         # Return an array of instances of this class based on
         # the provided XML.

data/lib/sequel/sql.rb

@@ -1378,7 +1378,7 @@ module Sequel
 
       # Return a new function call with the given opts merged into the current opts.
       def with_opts(opts)
-        self.class.new!(name, args, @opts.merge(opts))
+        self.class.new!(name, args, Hash[@opts].merge!(opts))
       end
     end
 

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 21
+  MINOR = 22
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -2162,6 +2162,23 @@ describe 'PostgreSQL array handling' do
     end
   end
 
+  specify 'convert ruby array :default values' do
+    @db.create_table!(:items) do
+      column :n, 'integer[]', :default=>[]
+    end
+    @ds.insert
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      rs.should == [{:n=>[]}]
+      rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
+      rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
   specify 'insert and retrieve custom array types' do
     int2vector = Class.new do
       attr_reader :array

data/spec/core/connection_pool_spec.rb

@@ -33,7 +33,7 @@ describe "ConnectionPool options" do
     cpool = Sequel::ConnectionPool.get_pool(mock_db.call, {:max_connections=>'5', :pool_timeout=>'3', :pool_sleep_time=>'0.01'})
     cpool.max_size.should == 5
     cpool.instance_variable_get(:@timeout).should == 3
-    cpool.instance_variable_get(:@sleep_time).should == 0.01
+    cpool.instance_variable_get(:@sleep_time).should == 0.01 unless cpool.class::USE_WAITER
   end
 
   specify "should raise an error unless size is positive" do

data/spec/core/dataset_spec.rb

@@ -1758,6 +1758,17 @@ describe "Dataset#to_hash" do
     @d.to_hash(:b).should == {4 => {:a => 2, :b => 4}, 8 => {:a => 6, :b => 8}, 12 => {:a => 10, :b => 12}}
     @d.to_hash([:a, :b]).should == {[2, 4] => {:a => 2, :b => 4}, [6, 8] => {:a => 6, :b => 8}, [10, 12] => {:a => 10, :b => 12}}
   end
+
+  specify "should handle a single composite key when using a row_proc" do
+    c = @d.row_proc = Class.new do
+      def self.call(h); new(h); end
+      def initialize(h); @h = h; end
+      def [](k) @h[k]; end
+      def h; @h; end
+      def ==(o) @h == o.h; end
+    end
+    @d.to_hash([:a, :b]).should == {[1, 2] => c.call(:a => 1, :b => 2), [3, 4] => c.call(:a => 3, :b => 4), [5, 6] => c.call(:a => 5, :b => 6)}
+  end
 end
 
 describe "Dataset#to_hash_groups" do
@@ -1797,6 +1808,17 @@ describe "Dataset#to_hash_groups" do
     @d.to_hash_groups(:b).should == {4 => [{:a => 2, :b => 4}], 8 => [{:a => 6, :b => 8}, {:a => 14, :b => 8}], 12 => [{:a => 2, :b => 12}]}
     @d.to_hash_groups([:a, :b]).should == {[2, 4] => [{:a => 2, :b => 4}], [6, 8] => [{:a => 6, :b => 8}], [2, 12] => [{:a => 2, :b => 12}], [14, 8] => [{:a => 14, :b => 8}]}
   end
+
+  specify "should handle a single composite key when using a row_proc" do
+    c = @d.row_proc = Class.new do
+      def self.call(h); new(h); end
+      def initialize(h); @h = h; end
+      def [](k) @h[k]; end
+      def h; @h; end
+      def ==(o) @h == o.h; end
+    end
+    @d.to_hash_groups([:a, :b]).should == {[1, 2] => [c.call(:a => 1, :b => 2)], [3, 4] => [c.call(:a => 3, :b => 4)], [1, 6] => [c.call(:a => 1, :b => 6)], [7, 4] => [c.call(:a => 7, :b => 4)]}
+  end
 end
 
 describe "Dataset#distinct" do