sequel 3.46.0 → 3.47.0

data/lib/sequel/plugins/boolean_readers.rb

@@ -33,12 +33,7 @@ module Sequel
       end
 
       module ClassMethods
-        # Create boolean readers for the class using the columns from the new dataset.
-        def set_dataset(*args)
-          super
-          create_boolean_readers
-          self
-        end
+        Plugins.after_set_dataset(self, :create_boolean_readers)
 
         private
 

data/lib/sequel/plugins/caching.rb

@@ -70,18 +70,7 @@ module Sequel
           "#{self}:#{Array(pk).join(',')}"
         end
         
-        # Copy the necessary class instance variables to the subclass.
-        def inherited(subclass)
-          super
-          store = @cache_store
-          ttl = @cache_ttl
-          cache_ignore_exceptions = @cache_ignore_exceptions
-          subclass.instance_eval do
-            @cache_store = store
-            @cache_ttl = ttl
-            @cache_ignore_exceptions = cache_ignore_exceptions
-          end
-        end 
+        Plugins.inherited_instance_variables(self, :@cache_store=>nil, :@cache_ttl=>nil, :@cache_ignore_exceptions=>nil)
 
         # Set the time to live for the cache store, in seconds (default is 3600, # so 1 hour).
         def set_cache_ttl(ttl)
@@ -92,7 +81,11 @@ module Sequel
     
         # Delete the entry with the matching key from the cache
         def cache_delete(ck)
-          @cache_store.delete(ck)
+          if @cache_ignore_exceptions
+            @cache_store.delete(ck) rescue nil
+          else
+            @cache_store.delete(ck)
+          end
           nil
         end
         

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -187,6 +187,7 @@ module Sequel
         # Delete the row from all backing tables, starting from the
         # most recent table and going through all superclasses.
         def delete
+          raise Sequel::Error, "can't delete frozen object" if frozen?
           m = model
           m.cti_tables.reverse.each do |table|
             m.db.from(table).filter(m.primary_key=>pk).delete

data/lib/sequel/plugins/composition.rb

@@ -124,12 +124,7 @@ module Sequel
           define_composition_accessor(name, opts)
         end
         
-        # Copy the necessary class instance variables to the subclass.
-        def inherited(subclass)
-          super
-          c = compositions.dup
-          subclass.instance_eval{@compositions = c}
-        end
+        Plugins.inherited_instance_variables(self, :@compositions=>:dup)
         
         # Define getter and setter methods for the composition object.
         def define_composition_accessor(name, opts={})
@@ -137,7 +132,13 @@ module Sequel
           composer = opts[:composer]
           composition_module.class_eval do
             define_method(name) do 
-              compositions.include?(name) ? compositions[name] : (compositions[name] = instance_eval(&composer))
+              if compositions.has_key?(name)
+                compositions[name]
+              elsif frozen?
+                instance_eval(&composer)
+              else
+                compositions[name] = instance_eval(&composer)
+              end
             end
             define_method("#{name}=") do |v|
               modified!
@@ -165,6 +166,12 @@ module Sequel
         def compositions
           @compositions ||= {}
         end
+
+        # Freeze compositions hash when freezing model instance.
+        def freeze
+          compositions.freeze
+          super
+        end
       end
     end
   end

data/lib/sequel/plugins/constraint_validations.rb

@@ -61,19 +61,8 @@ module Sequel
         # The name of the table containing the constraint validations metadata.
         attr_reader :constraint_validations_table
 
-        # Copy the name of the constraint validations metadata table into the subclass.
-        def inherited(subclass)
-          super
-          subclass.instance_variable_set(:@constraint_validations_table, @constraint_validations_table)
-        end
-
-        # Parse the constraint validations from the database whenever the dataset
-        # changes.
-        def set_dataset(*)
-          r = super
-          parse_constraint_validations
-          r
-        end
+        Plugins.inherited_instance_variables(self, :@constraint_validations_table=>nil)
+        Plugins.after_set_dataset(self, :parse_constraint_validations)
 
         private
 

data/lib/sequel/plugins/defaults_setter.rb

@@ -28,12 +28,7 @@ module Sequel
         # this hash to set specific default values, by default the ones will be parsed from the database.
         attr_reader :default_values
         
-        # Set the default values when loading the dataset.
-        def set_dataset(*)
-          x = super
-          set_default_values
-          x
-        end
+        Plugins.after_set_dataset(self, :set_default_values)
 
         private
 

data/lib/sequel/plugins/dirty.rb

@@ -101,6 +101,14 @@ module Sequel
           @initial_values ||= {}
         end
 
+        # Freeze internal data structures
+        def freeze
+          initial_values.freeze
+          missing_initial_values.freeze
+          @previous_changes.freeze if @previous_changes
+          super
+        end
+
         # Reset the column to its initial value.  If the column was not set
         # initial, removes it from the values.
         #

data/lib/sequel/plugins/error_splitter.rb

@@ -0,0 +1,54 @@
+module Sequel
+  module Plugins
+    # The error_splitter plugin automatically splits errors entries related to
+    # multiple columns to have separate error entries, one per column.  For example,
+    # a multiple column uniqueness entry:
+    #
+    #   validates_unique([:artist_id, :name])
+    #
+    # would by default result in errors entries such as:
+    #
+    #   {[:artist_id, :name]=>'is already taken'}
+    #
+    # This plugin transforms those errors into:
+    #
+    #   {:artist_id=>'is already taken', :name=>'is already taken'}
+    #
+    # The main reason to split errors is if you have a list of fields that you
+    # are checking for validation errors.  If you don't split the errors, then:
+    #
+    #   errors.on(:artist_id)
+    #
+    # would not return the uniqueness error.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances split errors (called before loading subclasses)
+    #   Sequel::Model.plugin :error_splitter
+    #
+    #   # Make the Album class split errors
+    #   Album.plugin :error_splitter
+    module ErrorSplitter
+      module InstanceMethods
+        # If the model instance is not valid, go through all of the errors entries.  For
+        # any that apply to multiple columns, remove them and add separate error entries,
+        # one per column.
+        def _valid?(*)
+          v = super
+          unless v
+            errors.keys.select{|k| k.is_a?(Array)}.each do |ks|
+              msgs = errors.delete(ks)
+              ks.each do |k|
+                msgs.each do |msg|
+                  errors.add(k, msg)
+                end
+              end
+            end
+          end
+          v
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/plugins/force_encoding.rb

@@ -32,11 +32,7 @@ module Sequel
         # The string encoding to force on a column string values
         attr_accessor :forced_encoding
         
-        # Copy the forced_encoding value into the subclass
-        def inherited(subclass)
-          super
-          subclass.forced_encoding = forced_encoding
-        end
+        Plugins.inherited_instance_variables(self, :@forced_encoding=>nil)
       end
     
       module InstanceMethods

data/lib/sequel/plugins/hook_class_methods.rb

@@ -91,12 +91,7 @@ module Sequel
           @hooks[hook].each{|k,v| yield v}
         end
 
-        # Make a copy of the current class's hooks for the subclass.
-        def inherited(subclass)
-          hooks = subclass.instance_variable_set(:@hooks, {}) 
-          instance_variable_get(:@hooks).each{|k,v| hooks[k] = v.dup}
-          super
-        end
+        Plugins.inherited_instance_variables(self, :@hooks=>:hash_dup)
     
         private
     

data/lib/sequel/plugins/input_transformer.rb

@@ -0,0 +1,79 @@
+module Sequel
+  module Plugins
+    # InputTransformer is a plugin that allows generic transformations
+    # of input values in model column setters.  Example:
+    #
+    #   Album.plugin :input_transformer
+    #   Album.add_input_transformer(:reverser){|v| v.is_a?(String) ? v.reverse : v}
+    #   album = Album.new(:name=>'foo')
+    #   album.name # => 'oof'
+    #
+    # You can specifically set some columns to skip some input
+    # input transformers:
+    #
+    #   Album.skip_input_transformer(:reverser, :foo)
+    #   Album.new(:foo=>'bar').foo # => 'bar'
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances support input transformers (called before loading subclasses)
+    #   Sequel::Model.plugin :input_transformer
+    #
+    #   # Make the Album class support input transformers 
+    #   Album.plugin :input_transformer
+    module InputTransformer
+      def self.apply(model, *)
+        model.instance_eval do
+          @input_transformers = {}
+          @input_transformer_order = []
+          @skip_input_transformer_columns = {}
+        end
+      end
+
+      # If an input transformer is given in the plugin call,
+      # add it as a transformer
+      def self.configure(model, transformer_name=nil, &block)
+        model.add_input_transformer(transformer_name, &block) if transformer_name || block
+      end
+
+      module ClassMethods
+        # Hash of input transformer name symbols to transformer callables.
+        attr_reader :input_transformers
+
+        # The order in which to call the input transformers.
+        attr_reader :input_transformer_order
+
+        Plugins.inherited_instance_variables(self, :@skip_input_transformer_columns=>:hash_dup, :@input_transformers=>:dup, :@input_transformer_order=>:dup)
+
+        # Add an input transformer to this model.
+        def add_input_transformer(transformer_name, &block)
+          raise(Error, 'must provide both transformer name and block when adding input transformer') unless transformer_name && block
+          @input_transformers[transformer_name] = block
+          @input_transformer_order.unshift(transformer_name)
+          @skip_input_transformer_columns[transformer_name] = []
+        end
+
+        # Set columns that the transformer should skip.
+        def skip_input_transformer(transformer_name, *columns)
+          @skip_input_transformer_columns[transformer_name].concat(columns).uniq!
+        end
+
+        # Return true if the transformer should not be called for the given column.
+        def skip_input_transformer?(transformer_name, column)
+          @skip_input_transformer_columns[transformer_name].include?(column)
+        end
+      end
+
+      module InstanceMethods
+        # Transform the input using all of the transformers, except those explicitly
+        # skipped, before setting the value in the model object.
+        def []=(k, v)
+          model.input_transformer_order.each do |transformer_name|
+            v = model.input_transformers[transformer_name].call(v) unless model.skip_input_transformer?(transformer_name, k)
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/instance_filters.rb

@@ -58,6 +58,12 @@ module Sequel
           super
           clear_instance_filters
         end
+
+        # Freeze the instance filters when freezing the object
+        def freeze
+          instance_filters.freeze
+          super
+        end
       
         # Add an instance filter to the array of instance filters
         # Both the arguments given and the block are passed to the
@@ -85,7 +91,7 @@ module Sequel
         
         # Apply the instance filters to the given dataset
         def apply_instance_filters(ds)
-          instance_filters.inject(ds){|ds, i| ds.filter(*i[0], &i[1])}
+          instance_filters.inject(ds){|ds1, i| ds1.filter(*i[0], &i[1])}
         end
         
         # Clear the instance filters.

data/lib/sequel/plugins/instance_hooks.rb

@@ -29,7 +29,13 @@ module Sequel
         BEFORE_HOOKS = Sequel::Model::BEFORE_HOOKS
         AFTER_HOOKS = Sequel::Model::AFTER_HOOKS - [:after_initialize]
         HOOKS = BEFORE_HOOKS + AFTER_HOOKS
-        HOOKS.each{|h| class_eval("def #{h}_hook(&block); add_instance_hook(:#{h}, &block); self end", __FILE__, __LINE__)}
+        HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
+          def #{h}_hook(&block)
+            raise Sequel::Error, "can't add hooks to frozen object" if frozen?
+            add_instance_hook(:#{h}, &block)
+            self
+          end
+        END
         
         BEFORE_HOOKS.each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) == false ? false : super end", __FILE__, __LINE__)}
         AFTER_HOOKS.each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}

data/lib/sequel/plugins/json_serializer.rb

@@ -175,18 +175,13 @@ module Sequel
           new.from_json_node(hash, {:all_columns=>true, :all_associations=>true}.merge(opts))
         end
 
-        # Call the dataset +to_json+ method.
-        def to_json(*a)
-          dataset.to_json(*a)
-        end
-        
-        # Copy the current model object's default json options into the subclass.
-        def inherited(subclass)
-          super
+        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}
-          subclass.instance_variable_set(:@json_serializer_opts, opts)
-        end
+          opts
+        end)
+
+        Plugins.def_dataset_methods(self, :to_json)
       end
 
       module InstanceMethods

data/lib/sequel/plugins/lazy_attributes.rb

@@ -5,7 +5,7 @@ module Sequel
     # is needed after the instance has been retrieved, a database query is made to
     # retreive the value of the attribute.
     #
-    # This plugin depends on the identity_map and tactical_eager_loading plugin, and allows you to
+    # This plugin depends on the tactical_eager_loading plugin, and allows you to
     # eagerly load lazy attributes for all objects retrieved with the current object.
     # So the following code should issue one query to get the albums and one query to
     # get the reviews for all of those albums:
@@ -20,9 +20,8 @@ module Sequel
     #   # You can specify multiple columns to lazily load:
     #   Album.plugin :lazy_attributes, :review, :tracklist
     module LazyAttributes
-      # Lazy attributes requires the identity map and tactical eager loading plugins
+      # Lazy attributes requires the tactical_eager_loading plugin
       def self.apply(model, *attrs)
-        model.plugin :identity_map
         model.plugin :tactical_eager_loading  
       end
       
@@ -51,7 +50,7 @@ module Sequel
           include(self.lazy_attributes_module ||= Module.new) unless lazy_attributes_module
           lazy_attributes_module.class_eval do
             define_method(a) do
-              if !values.include?(a) && !new?
+              if !values.has_key?(a) && !new?
                 lazy_attribute_lookup(a)
               else
                 super()
@@ -69,9 +68,23 @@ module Sequel
         # the attribute for just the current object.  Return the value of
         # the attribute for the current object.
         def lazy_attribute_lookup(a)
-          primary_key = model.primary_key
-          model.select(*(Array(primary_key) + [a])).filter(primary_key=>retrieved_with.map{|o| o.pk}).all if model.identity_map && retrieved_with
-          values[a] = this.select(a).first[a] unless values.include?(a)
+          if frozen?
+            return this.dup.select(a).get(a)
+          end
+
+          if retrieved_with
+            raise(Error, "Invalid primary key column for #{model}: #{pkc.inspect}") unless primary_key = model.primary_key
+            composite_pk = true if primary_key.is_a?(Array)
+            id_map = {}
+            retrieved_with.each{|o| id_map[o.pk] = o unless o.values.has_key?(a) || o.frozen?}
+            model.select(*(Array(primary_key) + [a])).filter(primary_key=>id_map.keys).naked.each do |row|
+              obj = id_map[composite_pk ? row.values_at(*primary_key) : row[primary_key]]
+              if obj && !obj.values.has_key?(a)
+                obj.values[a] = row[a]
+              end
+            end
+          end
+          values[a] = this.select(a).get(a) unless values.has_key?(a)
           values[a]
         end
       end

data/lib/sequel/plugins/list.rb

@@ -78,12 +78,7 @@ module Sequel
         # proc should accept an instance and return a dataset representing the list.
         attr_accessor :scope_proc
 
-        # Copy the +position_field+ and +scope_proc+ to the subclass.
-        def inherited(subclass)
-          super
-          subclass.position_field = position_field
-          subclass.scope_proc = scope_proc
-        end
+        Plugins.inherited_instance_variables(self, :@position_field=>nil, :@scope_proc=>nil)
       end
 
       module InstanceMethods