sequel 4.21.0 → 4.22.0

data/lib/sequel/extensions/split_array_nil.rb

@@ -43,7 +43,7 @@ module Sequel
       case op
       when :IN, :"NOT IN"
         vals = args.at(1)
-        if vals.is_a?(Array) && vals.any?{|v| v.nil?}
+        if vals.is_a?(Array) && vals.any?(&:nil?)
           cols = args.at(0)
           vals = vals.compact
           c = Sequel::SQL::BooleanExpression

data/lib/sequel/model.rb

@@ -170,6 +170,6 @@ module Sequel
 
     # The setter methods (methods ending with =) that are never allowed
     # to be called automatically via +set+/+update+/+new+/etc..
-    RESTRICTED_SETTER_METHODS = instance_methods.map{|x| x.to_s}.grep(SETTER_METHOD_REGEXP)
+    RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).grep(SETTER_METHOD_REGEXP)
   end
 end

data/lib/sequel/model/associations.rb

@@ -604,7 +604,7 @@ module Sequel
           key = qualify(associated_class.table_name, associated_class.primary_key)
           case obj
           when Array
-            {key=>obj.map{|o| o.pk}}
+            {key=>obj.map(&:pk)}
           when Sequel::Dataset
             {key=>obj.select(*Array(qualify(associated_class.table_name, associated_class.primary_key)))}
           else
@@ -1001,7 +1001,7 @@ module Sequel
         end
 
         def filter_by_associations_limit_aliases
-          filter_by_associations_limit_alias_key.map{|v| v.column}
+          filter_by_associations_limit_alias_key.map(&:column)
         end
 
         def filter_by_associations_limit_key
@@ -1289,7 +1289,7 @@ module Sequel
         end
 
         def filter_by_associations_limit_aliases
-          filter_by_associations_limit_alias_key.map{|v| v.alias}
+          filter_by_associations_limit_alias_key.map(&:alias)
         end
 
         def filter_by_associations_limit_key
@@ -1846,7 +1846,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(lpkcs) + conditions, :qualify=>:deep, :table_alias=>eo[:table_alias], :implicit_qualifier=>eo[:implicit_qualifier], :join_type=>eo[:join_type]||join_type, :from_self_alias=>eo[:from_self_alias], :join_only=>eo[:join_only], :select=>select||orig_egds.columns, &graph_block)
+              ds.graph(egds, associated_key_array.map(&:alias).zip(lpkcs) + conditions, :qualify=>:deep, :table_alias=>eo[:table_alias], :implicit_qualifier=>eo[:implicit_qualifier], :join_type=>eo[:join_type]||join_type, :from_self_alias=>eo[:from_self_alias], :join_only=>eo[:join_only], :select=>select||orig_egds.columns, &graph_block)
             else
               ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lpkcs) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table, [eo[:table_alias]]), :join_type=>eo[:join_type]||jt_join_type, :join_only=>eo[:join_only], :implicit_qualifier=>eo[:implicit_qualifier], :qualify=>:deep, :from_self_alias=>eo[:from_self_alias], &jt_graph_block)
               ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + conditions, :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
@@ -1920,7 +1920,7 @@ module Sequel
           graph_cks = opts[:graph_keys]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
           end
       
           return if opts[:read_only]
@@ -1980,7 +1980,7 @@ module Sequel
           graph_block = opts[:graph_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + 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(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
             # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
             ds.opts[:eager_graph][:reciprocals][eo[:table_alias]] = opts.reciprocal
             ds
@@ -2219,7 +2219,7 @@ module Sequel
         # Duplicate the associations hash when duplicating the object.
         def initialize_copy(other)
           super
-          @associations = @associations.dup if @associations
+          @associations = Hash[@associations] if @associations
           self
         end
 
@@ -2231,7 +2231,7 @@ module Sequel
             dynamic_opts = {:callback=>dynamic_opts}
           end
           if block_given?
-            dynamic_opts = dynamic_opts.merge(:callback=>Proc.new)
+            dynamic_opts = Hash[dynamic_opts].merge!(:callback=>Proc.new)
           end
           name = opts[:name]
           if associations.include?(name) and !dynamic_opts[:callback] and !dynamic_opts[:reload]
@@ -2316,6 +2316,10 @@ module Sequel
 
         # Run the callback for the association with the object.
         def run_association_callbacks(reflection, callback_type, object)
+          # The reason we automatically set raise_error for singular associations is that
+          # assignment in ruby always returns the argument instead of the result of the
+          # method, so we can't return nil to signal that the association callback prevented
+          # the modification
           raise_error = raise_on_save_failure || !reflection.returns_array?
           stop_on_false = [:before_add, :before_remove, :before_set].include?(callback_type)
           reflection[callback_type].each do |cb|
@@ -2327,11 +2331,14 @@ module Sequel
             else
               raise Error, "callbacks should either be Procs or Symbols"
             end
+
             if res == false and stop_on_false
-              raise(HookFailed, "Unable to modify association for #{inspect}: one of the #{callback_type} hooks returned false") if raise_error
-              return false
+              raise(HookFailed, "Unable to modify association for #{inspect}: one of the #{callback_type} hooks returned false")
             end
           end
+        rescue HookFailed
+          return false unless raise_error
+          raise
         end
 
         # Set the given object as the associated object for the given *_to_one association reflection
@@ -2514,7 +2521,7 @@ END
         def eager(*associations)
           opts = @opts[:eager]
           association_opts = eager_options_for_associations(associations)
-          opts = opts ? opts.merge(association_opts) : association_opts
+          opts = opts ? Hash[opts].merge!(association_opts) : association_opts
           clone(:eager=>opts)
         end
 

data/lib/sequel/model/base.rb

@@ -489,7 +489,7 @@ module Sequel
       #   end
       def inherited(subclass)
         super
-        ivs = subclass.instance_variables.collect{|x| x.to_s}
+        ivs = subclass.instance_variables.collect(&:to_s)
         inherited_instance_variables.each do |iv, dup|
           next if ivs.include?(iv.to_s)
           if (sup_class_value = instance_variable_get(iv)) && dup
@@ -851,7 +851,7 @@ module Sequel
         clear_setter_methods_cache
         columns, bad_columns = columns.partition{|x| NORMAL_METHOD_NAME_REGEXP.match(x.to_s)}
         bad_columns.each{|x| def_bad_column_accessor(x)}
-        im = instance_methods.collect{|x| x.to_s}
+        im = instance_methods.collect(&:to_s)
         columns.each do |column|
           meth = "#{column}="
           overridable_methods_module.module_eval("def #{column}; self[:#{column}] end", __FILE__, __LINE__) unless im.include?(column.to_s)
@@ -948,7 +948,7 @@ module Sequel
         if allowed_columns
           allowed_columns.map{|x| "#{x}="}
         else
-          meths = instance_methods.collect{|x| x.to_s}.grep(SETTER_METHOD_REGEXP) - RESTRICTED_SETTER_METHODS
+          meths = instance_methods.collect(&:to_s).grep(SETTER_METHOD_REGEXP) - RESTRICTED_SETTER_METHODS
           meths -= Array(primary_key).map{|x| "#{x}="} if primary_key && restrict_primary_key?
           meths
         end
@@ -1559,7 +1559,7 @@ module Sequel
       #   a.save_changes # UPDATE artists SET name = 'Bob' WHERE (id = 1)
       #   # => #<Artist {:id=>1, :name=>'Jim', ...}
       def save_changes(opts=OPTS)
-        save(opts.merge(:changed=>true)) || false if modified? 
+        save(Hash[opts].merge!(:changed=>true)) || false if modified? 
       end
   
       # Updates the instance with the supplied values with support for virtual
@@ -1611,7 +1611,7 @@ module Sequel
       #   # Sequel::Error raised
       def set_fields(hash, fields, opts=nil)
         opts = if opts
-          model.default_set_fields_options.merge(opts)
+          Hash[model.default_set_fields_options].merge!(opts)
         else
           model.default_set_fields_options
         end
@@ -1942,7 +1942,7 @@ module Sequel
       # databases don't like you setting primary key values even
       # to their existing values.
       def _save_update_all_columns_hash
-        v = @values.dup
+        v = Hash[@values]
         Array(primary_key).each{|x| v.delete(x) unless changed_columns.include?(x)}
         v
       end
@@ -2029,7 +2029,7 @@ module Sequel
       
       # If transactions should be used, wrap the yield in a transaction block.
       def checked_transaction(opts=OPTS)
-        use_transaction?(opts) ? db.transaction({:server=>this_server}.merge(opts)){yield} : yield
+        use_transaction?(opts) ? db.transaction({:server=>this_server}.merge!(opts)){yield} : yield
       end
 
       # Change the value of the column to given value, recording the change.
@@ -2067,7 +2067,7 @@ module Sequel
       # Copy constructor -- Duplicate internal data structures.
       def initialize_copy(other)
         super
-        @values = @values.dup
+        @values = Hash[@values]
         @changed_columns = @changed_columns.dup if @changed_columns
         @errors = @errors.dup if @errors
         @this = @this.dup if @this
@@ -2128,14 +2128,14 @@ module Sequel
             set_column_value(m, v)
           elsif strict
             # Avoid using respond_to? or creating symbols from user input
-            if public_methods.map{|s| s.to_s}.include?(m)
-              if Array(model.primary_key).map{|s| s.to_s}.member?(k.to_s) && model.restrict_primary_key?
-                raise Error, "#{k} is a restricted primary key"
+            if public_methods.map(&:to_s).include?(m)
+              if Array(model.primary_key).map(&:to_s).member?(k.to_s) && model.restrict_primary_key?
+                raise MassAssignmentRestriction, "#{k} is a restricted primary key"
               else
-                raise Error, "#{k} is a restricted column"
+                raise MassAssignmentRestriction, "#{k} is a restricted column"
               end
             else
-              raise Error, "method #{m} doesn't exist"
+              raise MassAssignmentRestriction, "method #{m} doesn't exist"
             end
           end
         end
@@ -2158,7 +2158,7 @@ module Sequel
         if type.is_a?(Array)
           type.map{|x| "#{x}="}
         else
-          meths = methods.collect{|x| x.to_s}.grep(SETTER_METHOD_REGEXP) - RESTRICTED_SETTER_METHODS
+          meths = methods.collect(&:to_s).grep(SETTER_METHOD_REGEXP) - RESTRICTED_SETTER_METHODS
           meths -= Array(primary_key).map{|x| "#{x}="} if type != :all && primary_key && model.restrict_primary_key?
           meths
         end
@@ -2239,7 +2239,7 @@ module Sequel
       #   # DELETE FROM artists WHERE (id = 2)
       #   # ...
       def destroy
-        pr = proc{all{|r| r.destroy}.length}
+        pr = proc{all(&:destroy).length}
         model.use_transactions ? @db.transaction(:server=>opts[:server], &pr) : pr.call
       end
 

data/lib/sequel/model/exceptions.rb

@@ -16,10 +16,14 @@ module Sequel
   
   # Exception class raised when +require_modification+ is set and an UPDATE or DELETE statement to modify the dataset doesn't
   # modify a single row.
-  class NoExistingObject < Error; end
+  NoExistingObject = Class.new(Error)
   
   # Raised when an undefined association is used when eager loading.
-  class UndefinedAssociation < Error; end
+  UndefinedAssociation = Class.new(Error)
+
+  # Raised when a mass assignment method is called in strict mode with either a restricted column
+  # or a column without a setter method.
+  MassAssignmentRestriction = Class.new(Error)
   
   # Exception class raised when +raise_on_save_failure+ is set and validation fails
   class ValidationFailed < Error
@@ -43,4 +47,9 @@ module Sequel
       end
     end
   end
+
+  # Call name on each class to set the name for the class, so it gets cached.
+  constants.map{|c| const_get(c)}.each do |c|
+    Class === c && c.name
+  end
 end

data/lib/sequel/plugins/accessed_columns.rb

@@ -44,7 +44,7 @@ module Sequel
 
         # Copy the accessed columns when duping and cloning.
         def initialize_copy(other)
-          other.instance_variable_set(:@accessed_columns, @accessed_columns.dup) if @accessed_columns
+          other.instance_variable_set(:@accessed_columns, Hash[@accessed_columns]) if @accessed_columns
           super
         end
 

data/lib/sequel/plugins/auto_validations.rb

@@ -109,7 +109,7 @@ module Sequel
 
         # Parse the database schema and indexes and record the columns to automatically validate.
         def setup_auto_validations
-          not_null_cols, explicit_not_null_cols = db_schema.select{|col, sch| sch[:allow_null] == false}.partition{|col, sch| sch[:ruby_default].nil?}.map{|cs| cs.map{|col, sch| col}}
+          not_null_cols, explicit_not_null_cols = db_schema.select{|col, sch| sch[:allow_null] == false}.partition{|col, sch| sch[:default].nil?}.map{|cs| cs.map{|col, sch| col}}
           @auto_validate_not_null_columns = not_null_cols - Array(primary_key)
           explicit_not_null_cols += Array(primary_key)
           @auto_validate_explicit_not_null_columns = explicit_not_null_cols.uniq

data/lib/sequel/plugins/boolean_readers.rb

@@ -46,7 +46,7 @@ module Sequel
 
         # Add attribute? methods for all of the boolean attributes for this model.
         def create_boolean_readers
-          im = instance_methods.collect{|x| x.to_s}
+          im = instance_methods.collect(&:to_s)
           cs = columns rescue return
           cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
         end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -153,17 +153,17 @@ module Sequel
         # Specified with the :table_map option to the plugin, and used if
         # the implicit naming is incorrect.
         attr_reader :cti_table_map
-        
+
+        Plugins.inherited_instance_variables(self, :@cti_key=>nil, :@cti_model_map=>nil, :@cti_table_map=>nil)
+
         # Add the appropriate data structures to the subclass.  Does not
         # allow anonymous subclasses to be created, since they would not
         # be mappable to a table.
         def inherited(subclass)
           cc = cti_columns
-          ck = cti_key
           ct = cti_tables.dup
-          ctm = cti_table_map.dup
+          ctm = cti_table_map
           cbm = cti_base_model
-          cmm = cti_model_map
           pk = primary_key
           ds = dataset
           table = nil
@@ -172,12 +172,9 @@ module Sequel
             raise(Error, "cannot create anonymous subclass for model class using class_table_inheritance") if !(n = name) || n.empty?
             table = ctm[n.to_sym] || implicit_table_name
             columns = db.from(table).columns
-            @cti_key = ck 
             @cti_tables = ct + [table]
             @cti_columns = cc.merge(table=>columns)
-            @cti_table_map = ctm
             @cti_base_model = cbm
-            @cti_model_map = cmm
             # Need to set dataset and columns before calling super so that
             # the main column accessor module is included in the class before any
             # plugin accessor modules (such as the lazy attributes accessor module).

data/lib/sequel/plugins/composition.rb

@@ -178,7 +178,7 @@ module Sequel
         # Duplicate compositions hash when duplicating model instance.
         def initialize_copy(other)
           super
-          @compositions = other.compositions.dup
+          @compositions = Hash[other.compositions]
           self
         end
       end

data/lib/sequel/plugins/constraint_validations.rb

@@ -147,7 +147,7 @@ module Sequel
             arg = arg.split(',')
             type = :includes
           when :includes_int_array
-            arg = arg.split(',').map{|x| x.to_i}
+            arg = arg.split(',').map(&:to_i)
             type = :includes
           when :includes_int_range
             arg = constraint_validation_int_range(arg)
@@ -155,7 +155,7 @@ module Sequel
           end
 
           column = if type == :unique
-            column.split(',').map{|c| c.to_sym}
+            column.split(',').map(&:to_sym)
           else
             column.to_sym
           end

data/lib/sequel/plugins/csv_serializer.rb

@@ -0,0 +1,171 @@
+if RUBY_VERSION < "1.9"
+  require 'fastercsv'
+else
+  require 'csv'
+end
+
+module Sequel
+  module Plugins
+    # csv_serializer handles serializing entire Sequel::Model objects to CSV,
+    # as well as support for deserializing CSV directly into Sequel::Model
+    # objects.  It requires either the csv standard library when usnig ruby 1.9+,
+    # or the fastercsv gem when using ruby 1.8.
+    #
+    # Basic Example:
+    #
+    #   album = Album[1]
+    #   album.to_csv(:write_headers=>true)
+    #   # => "id,name,artist_id\n1,RF,2\n"
+    #
+    # You can provide options to control the CSV output:
+    #
+    #   album.to_csv(:only=>:name)
+    #   album.to_csv(:except=>[:id, :artist_id])
+    #   # => "RF\n"
+    #
+    # +to_csv+ also exists as a class and dataset method, both of which return
+    # all objects in the dataset:
+    #
+    #   Album.to_csv
+    #   Album.filter(:artist_id=>1).to_csv
+    #
+    # If you have an existing array of model instance you want to convert to
+    # CSV, you can call the class to_csv method with the :array option:
+    #
+    #   Album.to_csv(:array=>[Album[1], Album[2]])
+    #
+    # In addition to creating CSV, this plugin also enables Sequel::Model
+    # classes to create instances directly from CSV using the from_csv class
+    # method:
+    #
+    #   csv = album.to_csv
+    #   album = Album.from_csv(csv)
+    #
+    # The array_from_csv class method exists to parse arrays of model instances
+    # from CSV:
+    #
+    #   csv = Album.filter(:artist_id=>1).to_csv
+    #   albums = Album.array_from_csv(csv)
+    #
+    # These do not necessarily round trip, since doing so would let users
+    # create model objects with arbitrary values.  By default, from_csv will
+    # call set with the values in the hash.  If you want to specify the allowed
+    # fields, you can use the :headers option.
+    #
+    #   Album.from_csv(album.to_csv, :headers=>%w'id name')
+    #
+    # If you want to update an existing instance, you can use the from_csv
+    # instance method:
+    #
+    #   album.from_csv(csv)
+    #
+    # Usage:
+    #
+    #   # Add CSV output capability to all model subclass instances (called
+    #   # before loading subclasses)
+    #   Sequel::Model.plugin :csv_serializer
+    #
+    #   # Add CSV output capability to Album class instances
+    #   Album.plugin :csv_serializer
+    module CsvSerializer
+      CSV = Object.const_defined?(:CSV) ? ::CSV : ::FasterCSV
+
+      # Set up the column readers to do deserialization and the column writers
+      # to save the value in deserialized_values
+      def self.configure(model, opts = {})
+        model.instance_eval do
+          @csv_serializer_opts = (@csv_serializer_opts || {}).merge(opts)
+        end
+      end
+
+      module ClassMethods
+        # The default opts to use when serializing model objects to CSV
+        attr_reader :csv_serializer_opts
+
+        # Attempt to parse an array of instances from the given CSV string
+        def array_from_csv(csv, opts = {})
+          CSV.parse(csv, process_csv_serializer_opts(opts)).map do |row|
+            row = row.to_hash
+            row.delete(nil)
+            new(row)
+          end
+        end
+
+        # Attempt to parse a single instance from the given CSV string
+        def from_csv(csv, opts = {})
+          new.from_csv(csv, opts)
+        end
+
+        # Convert the options hash to one that can be passed to CSV.
+        def process_csv_serializer_opts(opts)
+          opts = (csv_serializer_opts || {}).merge(opts)
+          opts_cols = opts.delete(:columns)
+          opts_include = opts.delete(:include)
+          opts_except = opts.delete(:except)
+          opts[:headers] ||= Array(opts.delete(:only) || opts_cols || columns) + Array(opts_include) - Array(opts_except)
+          opts
+        end
+
+        Plugins.inherited_instance_variables(
+          self, :@csv_serializer_opts => lambda do |csv_serializer_opts|
+            opts = {}
+            csv_serializer_opts.each do |k, v|
+              opts[k] = (v.is_a?(Array) || v.is_a?(Hash)) ? v.dup : v
+            end
+            opts
+          end)
+
+        Plugins.def_dataset_methods(self, :to_csv)
+      end
+
+      module InstanceMethods
+        # Update the object using the data provided in the first line in CSV. Options:
+        #
+        # :headers :: The headers to use for the CSV line. Use nil for a header
+        #             to specify the column should be ignored.
+        def from_csv(csv, opts = {})
+          row = CSV.parse_line(csv, model.process_csv_serializer_opts(opts)).to_hash
+          row.delete(nil)
+          set(row)
+        end
+
+        # Return a string in CSV format.  Accepts the same options as CSV.new,
+        # as well as the following options:
+        #
+        # :except :: Symbol or Array of Symbols of columns not to include in
+        #            the CSV output.
+        # :only :: Symbol or Array of Symbols of columns to include in the CSV
+        #          output, ignoring all other columns
+        # :include :: Symbol or Array of Symbols specifying non-column
+        #             attributes to include in the CSV output.
+        def to_csv(opts = {})
+          opts = model.process_csv_serializer_opts(opts)
+
+          CSV.generate(opts) do |csv|
+            csv << opts[:headers].map{|k| send(k)}
+          end
+        end
+      end
+
+      module DatasetMethods
+        # Return a CSV string representing an array of all objects in this
+        # dataset.  Takes the same options as the instance method, and passes
+        # them to every instance.  Accepts the same options as CSV.new, as well
+        # as the following options:
+        #
+        # :array :: An array of instances.  If this is not provided, calls #all
+        #           on the receiver to get the array.
+        def to_csv(opts = {})
+          opts = model.process_csv_serializer_opts({:columns=>columns}.merge!(opts))
+          items = opts.delete(:array) || self
+
+          CSV.generate(opts) do |csv|
+            items.each do |object|
+              csv << opts[:headers].map{|header| object[header]}
+            end
+          end
+        end
+      end
+    end
+  end
+end