sequel 2.0.1 → 2.1.0

data/lib/sequel_model/base.rb

@@ -1,5 +1,3 @@
-# This file holds general class methods for Sequel::Model
-
 module Sequel
   class Model
     # Whether to lazily load the schema for future subclasses.  Unless turned
@@ -7,15 +5,42 @@ module Sequel
     # created
     @@lazy_load_schema = false
 
-    # The default primary key for tables, inherited by future subclasses
+    @allowed_columns = nil
+    @dataset_methods = {}
     @primary_key = :id
-
-    # Whether to typecast attribute values on assignment, inherited by
-    # future subclasses.
+    @restrict_primary_key = true
+    @restricted_columns = nil
+    @sti_dataset = nil
+    @sti_key = nil
+    @strict_param_setting = true
     @typecast_on_assignment = true
 
+    # Which columns should be the only columns allowed in a call to set
+    # (default: all columns).
+    metaattr_reader :allowed_columns
+
+    # Hash of dataset methods to add to this class and subclasses when
+    # set_dataset is called.
+    metaattr_reader :dataset_methods
+
     # The default primary key for classes (default: :id)
-    metaattr_accessor :primary_key
+    metaattr_reader :primary_key
+
+    # Which columns should not be update in a call to set
+    # (default: no columns).
+    metaattr_reader :restricted_columns
+
+    # The base dataset for STI, to which filters are added to get
+    # only the models for the specific STI subclass.
+    metaattr_reader :sti_dataset
+
+    # The column name holding the STI key for this model
+    metaattr_reader :sti_key
+
+    # Whether new/set/update and their variants should raise an error
+    # if an invalid key is used (either that doesn't exist or that
+    # access is restricted to it).
+    metaattr_accessor :strict_param_setting
 
     # Whether to typecast attribute values on assignment (default: true)
     metaattr_accessor :typecast_on_assignment
@@ -28,8 +53,14 @@ module Sequel
        left_outer_join limit map multi_insert naked order order_by order_more 
        paginate print query range reverse_order right_outer_join select 
        select_all select_more set set_graph_aliases single_value size to_csv 
-       transform union uniq unordered update where'
-  
+       transform union uniq unordered update where'.map{|x| x.to_sym}
+
+    # Instance variables that are inherited in subclasses
+    INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup, :@dataset_methods=>:dup,
+      :@primary_key=>nil, :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
+      :@sti_dataset=>nil, :@sti_key=>nil, :@strict_param_setting=>nil,
+      :@typecast_on_assignment=>nil}
+
     # Returns the first record from the database matching the conditions.
     # If a hash is given, it is used as the conditions.  If another
     # object is given, it finds the first record whose primary key(s) match
@@ -102,7 +133,9 @@ module Sequel
       raise(Error, "No arguments given") if args.empty?
       if block_given?
         raise(Error, "Defining a dataset method using a block requires only one argument") if args.length > 1
-        dataset.meta_def(args.first, &block)
+        meth = args.first
+        @dataset_methods[meth] = block
+        dataset.meta_def(meth, &block)
       end
       args.each{|arg| instance_eval("def #{arg}(*args, &block); dataset.#{arg}(*args, &block) end", __FILE__, __LINE__)}
     end
@@ -136,19 +169,23 @@ module Sequel
     end
   
     # If possible, set the dataset for the model subclass as soon as it
-    # is created.  Also, inherit the typecast_on_assignment and primary_key
-    # attributes from the parent class.
+    # is created.  Also, inherit the INHERITED_INSTANCE_VARIABLES
+    # from the parent class.
     def self.inherited(subclass)
       sup_class = subclass.superclass
       ivs = subclass.instance_variables
-      subclass.instance_variable_set(:@typecast_on_assignment, sup_class.typecast_on_assignment) unless ivs.include?("@typecast_on_assignment")
-      subclass.instance_variable_set(:@primary_key, sup_class.primary_key) unless ivs.include?("@primary_key")
+      INHERITED_INSTANCE_VARIABLES.each do |iv, dup|
+        next if ivs.include?(iv.to_s)
+        sup_class_value = sup_class.instance_variable_get(iv)
+        sup_class_value = sup_class_value.dup if dup == :dup && sup_class_value
+        subclass.instance_variable_set(iv, sup_class_value)
+      end
       unless ivs.include?("@dataset")
         begin
           if sup_class == Model
             subclass.set_dataset(Model.db[subclass.implicit_table_name]) unless subclass.name.empty?
           elsif ds = sup_class.instance_variable_get(:@dataset)
-            subclass.set_dataset(ds.clone)
+            subclass.set_dataset(sup_class.sti_key ? sup_class.sti_dataset.filter(sup_class.sti_key=>subclass.name) : ds.clone)
           end
         rescue
         end
@@ -199,6 +236,19 @@ module Sequel
       end
     end
 
+    # Restrict the setting of the primary key(s) inside new/set/update.  Because
+    # this is the default, this only make sense to use in a subclass where the
+    # parent class has used unrestrict_primary_key.
+    def self.restrict_primary_key
+      @restrict_primary_key = true
+    end
+
+    # Whether or not setting the primary key inside new/set/update is
+    # restricted, true by default.
+    def self.restrict_primary_key?
+      @restrict_primary_key
+    end
+
     # Serializes column with YAML or through marshalling.  Arguments should be
     # column symbols, with an optional trailing hash with a :format key
     # set to :yaml or :marshal (:yaml is the default).  Setting this adds
@@ -213,6 +263,17 @@ module Sequel
       @dataset.transform(@transform) if @dataset
     end
   
+    # Set the columns to allow in new/set/update.  Using this means that
+    # any columns not listed here will not be modified.  If you have any virtual
+    # setter methods (methods that end in =) that you want to be used in
+    # new/set/update, they need to be listed here as well (without the =).
+    #
+    # It may be better to use (set|update)_only instead of this in places where
+    # only certain columns may be allowed.
+    def self.set_allowed_columns(*cols)
+      @allowed_columns = cols
+    end
+
     # Sets the dataset associated with the Model class. ds can be a Symbol
     # (specifying a table name in the current database), or a Dataset.
     # If a dataset is used, the model's database is changed to the given
@@ -236,14 +297,10 @@ module Sequel
         raise(Error, "Model.set_dataset takes a Symbol or a Sequel::Dataset")
       end
       @dataset.set_model(self)
-      def_dataset_method(:destroy) do
-        raise(Error, "No model associated with this dataset") unless @opts[:models]
-        count = 0
-        @db.transaction {each {|r| count += 1; r.destroy}}
-        count
-      end
+      @dataset.extend(DatasetMethods)
       @dataset.extend(Associations::EagerLoading)
       @dataset.transform(@transform) if @transform
+      @dataset_methods.each{|meth, block| @dataset.meta_def(meth, &block)} if @dataset_methods
       begin
         (@db_schema = get_db_schema) unless @@lazy_load_schema
       rescue
@@ -271,6 +328,39 @@ module Sequel
       @primary_key = (key.length == 1) ? key[0] : key.flatten
     end
 
+    # Set the columns to restrict in new/set/update.  Using this means that
+    # any columns listed here will not be modified.  If you have any virtual
+    # setter methods (methods that end in =) that you want not to be used in
+    # new/set/update, they need to be listed here as well (without the =).
+    #
+    # It may be better to use (set|update)_except instead of this in places where
+    # only certain columns may be allowed.
+    def self.set_restricted_columns(*cols)
+      @restricted_columns = cols
+    end
+
+    # Makes this model a polymorphic model with the given key being a string
+    # field in the database holding the name of the class to use.  If the
+    # key given has a NULL value or there are any problems looking up the
+    # class, uses the current class.
+    #
+    # This should be used to set up single table inheritance for the model,
+    # and it only makes sense to use this in the parent class.
+    #
+    # You should call sti_key after any calls to set_dataset in the model,
+    # otherwise subclasses might not have the filters set up correctly.
+    #
+    # The filters that sti_key sets up in subclasses will not work if
+    # those subclasses have further subclasses.  For those middle subclasses,
+    # you will need to call set_dataset manually with the correct filter set.
+    def self.set_sti_key(key)
+      m = self
+      @sti_key = key
+      @sti_dataset = dataset
+      dataset.set_model(key, Hash.new{|h,k| h[k] = (k.constantize rescue m)})
+      before_create(:set_sti_key){send("#{key}=", model.name)}
+    end
+
     # Returns the columns as a list of frozen strings instead
     # of a list of symbols.  This makes it possible to check
     # whether a column exists without creating a symbol, which
@@ -302,6 +392,11 @@ module Sequel
       dataset.opts[:from].first
     end
 
+    # Allow the setting of the primary key(s) inside new/set/update.
+    def self.unrestrict_primary_key
+      @restrict_primary_key = false
+    end
+
     # Add model methods that call dataset methods
     def_dataset_method(*DATASET_METHODS)
 
@@ -366,6 +461,6 @@ module Sequel
       @columns
     end
 
-    metaprivate :def_column_accessor, :get_db_schema, :set_columns
+    private_class_method :def_column_accessor, :get_db_schema, :set_columns
   end
 end

data/lib/sequel_model/caching.rb

@@ -54,7 +54,7 @@ module Sequel
       obj
     end
 
-    metaprivate :cache_delete, :cache_key, :cache_lookup
+    private_class_method :cache_delete, :cache_key, :cache_lookup
 
     ### Instance Methods ###
 

data/lib/sequel_model/dataset_methods.rb

@@ -0,0 +1,26 @@
+# Dataset methods are methods that the model class extends its dataset with in
+# the call to set_dataset.
+module Sequel::Model::DatasetMethods
+  # Destroy each row in the dataset by instantiating it and then calling
+  # destroy on the resulting model object.  This isn't as fast as deleting
+  # the object, which does a single SQL call, but this runs any destroy
+  # hooks.
+  def destroy
+    raise(Error, "No model associated with this dataset") unless @opts[:models]
+    count = 0
+    @db.transaction {each {|r| count += 1; r.destroy}}
+    count
+  end
+
+  # This allows you to call to_hash without any arguments, which will
+  # result in a hash with the primary key value being the key and the
+  # model object being the value.
+  def to_hash(key_column=nil, value_column=nil)
+    if key_column
+      super
+    else
+      raise(Sequel::Error, "No primary key for model") unless pk = @opts[:models][nil].primary_key
+      super(pk, value_column) 
+    end
+  end
+end

data/lib/sequel_model/eager_loading.rb

@@ -132,17 +132,18 @@ module Sequel::Model::Associations::EagerLoading
     assoc_table_alias = ds.eager_unique_table_alias(ds, assoc_name)
     join_type = r[:graph_join_type]
     conditions = r[:graph_conditions]
+    select = r[:graph_select]
     ds = case assoc_type = r[:type]
     when :many_to_one
-      ds.graph(klass, [[klass.primary_key, :"#{ta}__#{r[:key]}"]] + conditions, :table_alias=>assoc_table_alias, :join_type=>join_type)
+      ds.graph(klass, [[klass.primary_key, :"#{ta}__#{r[:key]}"]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type)
     when :one_to_many
-      ds = ds.graph(klass, [[r[:key], :"#{ta}__#{model.primary_key}"]] + conditions, :table_alias=>assoc_table_alias, :join_type=>join_type)
+      ds = ds.graph(klass, [[r[:key], :"#{ta}__#{model.primary_key}"]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type)
       # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
       ds.opts[:eager_graph][:reciprocals][assoc_table_alias] = r.reciprocal
       ds
     when :many_to_many
       ds = ds.graph(r[:join_table], [[r[:left_key], :"#{ta}__#{model.primary_key}"]] + r[:graph_join_table_conditions], :select=>false, :table_alias=>ds.eager_unique_table_alias(ds, r[:join_table]), :join_type=>join_type)
-      ds.graph(klass, [[klass.primary_key, r[:right_key]]] + conditions, :table_alias=>assoc_table_alias, :join_type=>join_type)
+      ds.graph(klass, [[klass.primary_key, r[:right_key]]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type)
     end
     eager_graph = ds.opts[:eager_graph]
     eager_graph[:requirements][assoc_table_alias] = requirements.dup
@@ -278,7 +279,8 @@ module Sequel::Model::Associations::EagerLoading
     return if dependency_map.empty?
     # Don't clobber the instance variable array for *_to_many associations if it has already been setup
     dependency_map.keys.each do |ta|
-      current.instance_variable_set("@#{alias_map[ta]}", type_map[ta] == :many_to_one ? :null : []) unless current.instance_variable_get("@#{alias_map[ta]}")
+      assoc_name = alias_map[ta]
+      current.associations[assoc_name] = type_map[ta] == :many_to_one ? nil : [] unless current.associations.include?(assoc_name)
     end
     dependency_map.each do |ta, deps|
       next unless rec = record_graph[ta]
@@ -288,15 +290,14 @@ module Sequel::Model::Associations::EagerLoading
       else
         records_map[ta][rec.pk] = rec
       end
-      ivar = "@#{alias_map[ta]}"
+      assoc_name = alias_map[ta]
       case assoc_type = type_map[ta]
       when :many_to_one
-        current.instance_variable_set(ivar, rec)
+        current.associations[assoc_name] = rec
       else
-        list = current.instance_variable_get(ivar)
-        list.push(rec) 
-        if (assoc_type == :one_to_many) && (reciprocal = reciprocal_map[ta])
-          rec.instance_variable_set(reciprocal, current)
+        current.associations[assoc_name].push(rec) 
+        if assoc_type == :one_to_many and reciprocal = reciprocal_map[ta]
+          rec.associations[reciprocal] = current
         end
       end
       # Recurse into dependencies of the current object
@@ -362,7 +363,6 @@ module Sequel::Model::Associations::EagerLoading
     reflections.each do |reflection|
       assoc_class = reflection.associated_class
       assoc_name = reflection[:name]
-      assoc_iv = :"@#{assoc_name}"
       # Proc for setting cascaded eager loading
       assoc_block = Proc.new do |d|
         if order = reflection[:order]
@@ -389,13 +389,11 @@ module Sequel::Model::Associations::EagerLoading
           # Set the instance variable to null by default, so records that
           # don't have a associated records will cache the negative lookup.
           a.each do |object|
-            object.instance_variable_set(assoc_iv, :null)
+            object.associations[assoc_name] = nil
           end
           assoc_block.call(assoc_class.select(*reflection.select).filter(assoc_class.primary_key=>keys)).all do |assoc_object|
             next unless objects = h[assoc_object.pk]
-            objects.each do |object|
-              object.instance_variable_set(assoc_iv, assoc_object)
-            end
+            objects.each{|object| object.associations[assoc_name] = assoc_object}
           end
         when :one_to_many, :many_to_many
           h = key_hash[model.primary_key]
@@ -408,9 +406,7 @@ module Sequel::Model::Associations::EagerLoading
             assoc_class.select(*(Array(reflection.select)+Array(reflection[:left_key_select]))).inner_join(reflection[:join_table], [[reflection[:right_key], reflection.associated_primary_key], [reflection[:left_key], h.keys]])
           end
           h.values.each do |object_array|
-            object_array.each do |object|
-              object.instance_variable_set(assoc_iv, [])
-            end
+            object_array.each{|object| object.associations[assoc_name] = []}
           end
           assoc_block.call(ds).all do |assoc_object|
             fk = if rtype == :many_to_many
@@ -420,8 +416,8 @@ module Sequel::Model::Associations::EagerLoading
             end
             next unless objects = h[fk]
             objects.each do |object|
-              object.instance_variable_get(assoc_iv) << assoc_object
-              assoc_object.instance_variable_set(reciprocal, object) if reciprocal
+              object.associations[assoc_name].push(assoc_object)
+              assoc_object.associations[reciprocal] = object if reciprocal
             end
           end
       end

data/lib/sequel_model/hooks.rb

@@ -51,7 +51,7 @@ module Sequel
       all_hooks(hook).each{|b| return false if object.instance_eval(&b) == false}
     end
 
-    metaprivate :add_hook, :all_hooks, :hooks, :run_hooks
+    private_class_method :add_hook, :all_hooks, :hooks, :run_hooks
 
     (HOOKS + PRIVATE_HOOKS).each do |hook|
       instance_eval("def #{hook}(method = nil, &block); add_hook(:#{hook}, method, &block) end")

data/lib/sequel_model/plugins.rb

@@ -57,6 +57,6 @@ module Sequel
       Sequel::Plugins.const_get(module_name)
     end
 
-    metaprivate :plugin_gem, :plugin_module
+    private_class_method :plugin_gem, :plugin_module
   end
 end

data/lib/sequel_model/record.rb

@@ -1,18 +1,30 @@
-# This file holds general instance methods for Sequel::Model
-
 module Sequel
   class Model
+    # The setter methods (methods ending with =) that are never allowed
+    # to be called automatically via set.
+    RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_on_assignment="
+
+    # The current cached associations.  A hash with the keys being the
+    # association name symbols and the values being the associated object
+    # or nil (many_to_one), or the array of associated objects (*_to_many).
+    attr_reader :associations
+
     # The columns that have been updated.  This isn't completely accurate,
     # see Model#[]=.
     attr_reader :changed_columns
     
-    # The hash of attribute values.  Keys are symbols with the names of the
-    # underlying database columns.
-    attr_reader :values
+    # Whether this model instance should raise an error if attempting
+    # to call a method through set/update and their variants that either
+    # doesn't exist or access to it is denied.
+    attr_writer :strict_param_setting
 
     # Whether this model instance should typecast on attribute assignment
     attr_writer :typecast_on_assignment
 
+    # The hash of attribute values.  Keys are symbols with the names of the
+    # underlying database columns.
+    attr_reader :values
+
     class_attr_reader :columns, :dataset, :db, :primary_key, :str_columns
     
     # Creates new instance with values set to passed-in Hash.
@@ -27,16 +39,18 @@ module Sequel
     #   exists.
     def initialize(values = nil, from_db = false, &block)
       values ||=  {}
+      @associations = {}
+      @db_schema = model.db_schema
       @changed_columns = []
+      @strict_param_setting = model.strict_param_setting
       @typecast_on_assignment = model.typecast_on_assignment
-      @db_schema = model.db_schema
       if from_db
         @new = false
         @values = values
       else
         @values = {}
         @new = true
-        set_with_params(values)
+        set(values)
       end
       @changed_columns.clear 
       
@@ -167,9 +181,7 @@ module Sequel
     # exists in the database.
     def refresh
       @values = this.first || raise(Error, "Record not found")
-      model.all_association_reflections.each do |r|
-        instance_variable_set("@#{r[:name]}", nil)
-      end
+      @associations.clear
       self
     end
     alias_method :reload, :refresh
@@ -227,11 +239,40 @@ module Sequel
       save(*@changed_columns) unless @changed_columns.empty?
     end
 
+    # Updates the instance with the supplied values with support for virtual
+    # attributes, ignoring any values for which no setter method is available.
+    # Does not save the record.
+    #
+    # If no columns have been set for this model (very unlikely), assume symbol
+    # keys are valid column names, and assign the column value based on that.
+    def set(hash)
+      set_restricted(hash, nil, nil)
+    end
+    alias_method :set_with_params, :set
+
+    # Set all values using the entries in the hash, ignoring any setting of
+    # allowed_columns or restricted columns in the model.
+    def set_all(hash)
+      set_restricted(hash, false, false)
+    end
+
+    # Set all values using the entries in the hash, except for the keys
+    # given in except.
+    def set_except(hash, *except)
+      set_restricted(hash, false, except.flatten)
+    end
+
+    # Set the values using the entries in the hash, only if the key
+    # is included in only.
+    def set_only(hash, *only)
+      set_restricted(hash, only.flatten, false)
+    end
+
     # Sets the value attributes without saving the record.  Returns
     # the values changed.  Raises an error if the keys are not symbols
     # or strings or a string key was passed that was not a valid column.
     # This is a low level method that does not respect virtual attributes.  It
-    # should probably be avoided.  Look into using set_with_params instead.
+    # should probably be avoided.  Look into using set instead.
     def set_values(values)
       s = str_columns
       vals = values.inject({}) do |m, kv| 
@@ -254,30 +295,35 @@ module Sequel
       vals
     end
 
-    # Updates the instance with the supplied values with support for virtual
-    # attributes, ignoring any values for which no setter method is available.
-    # Does not save the record.
-    #
-    # If no columns have been set for this model (very unlikely), assume symbol
-    # keys are valid column names, and assign the column value based on that.
-    def set_with_params(hash)
-      columns_not_set = model.instance_variable_get(:@columns).blank?
-      meths = setter_methods
-      hash.each do |k,v|
-        m = "#{k}="
-        if meths.include?(m)
-          send(m, v)
-        elsif columns_not_set && (Symbol === k)
-          self[k] = v
-        end
-      end
-    end
-
     # Returns (naked) dataset that should return only this instance.
     def this
       @this ||= dataset.filter(pk_hash).limit(1).naked
     end
     
+    # Runs set with the passed hash and runs save_changes (which runs any callback methods).
+    def update(hash)
+      update_restricted(hash, nil, nil)
+    end
+    alias_method :update_with_params, :update
+
+    # Update all values using the entries in the hash, ignoring any setting of
+    # allowed_columns or restricted columns in the model.
+    def update_all(hash)
+      update_restricted(hash, false, false)
+    end
+
+    # Update all values using the entries in the hash, except for the keys
+    # given in except.
+    def update_except(hash, *except)
+      update_restricted(hash, false, except.flatten)
+    end
+
+    # Update the values using the entries in the hash, only if the key
+    # is included in only.
+    def update_only(hash, *only)
+      update_restricted(hash, only.flatten, false)
+    end
+
     # Sets the values attributes with set_values and then updates
     # the record in the database using those values.  This is a
     # low level method that does not run the usual save callbacks.
@@ -287,18 +333,52 @@ module Sequel
       this.update(set_values(values))
     end
     
-    # Runs set_with_params and runs save_changes (which runs any callback methods).
-    def update_with_params(values)
-      set_with_params(values)
-      save_changes
-    end
-
     private
 
+    # Set the columns, filtered by the only and except arrays.
+    def set_restricted(hash, only, except)
+      columns_not_set = model.instance_variable_get(:@columns).blank?
+      meths = setter_methods(only, except)
+      strict_param_setting = @strict_param_setting
+      hash.each do |k,v|
+        m = "#{k}="
+        if meths.include?(m)
+          send(m, v)
+        elsif columns_not_set && (Symbol === k)
+          self[k] = v
+        elsif strict_param_setting
+          raise Error, "method #{m} doesn't exist or access is restricted to it"
+        end
+      end
+    end
+
     # Returns all methods that can be used for attribute
-    # assignment (those that end with =)
-    def setter_methods
-      methods.grep(/=\z/)
+    # assignment (those that end with =), modified by the only
+    # and except arguments:
+    #
+    # * only
+    #   * false - Don't modify the results
+    #   * nil - if the model has allowed_columns, use only these, otherwise, don't modify
+    #   * Array - allow only the given methods to be used
+    # * except
+    #   * false - Don't modify the results
+    #   * nil - if the model has restricted_columns, remove these, otherwise, don't modify
+    #   * Array - remove the given methods
+    #
+    # only takes precedence over except, and if only is not used, certain methods are always
+    # restricted (RESTRICTED_SETTER_METHODS).  The primary key is restricted by default as
+    # well, see Model.unrestrict_primary_key to change this.
+    def setter_methods(only, except)
+      only = only.nil? ? model.allowed_columns : only
+      except = except.nil? ? model.restricted_columns : except
+      if only
+        only.map{|x| "#{x}="}
+      else
+        meths = methods.grep(/=\z/) - RESTRICTED_SETTER_METHODS
+        meths -= Array(primary_key).map{|x| "#{x}="} if primary_key && model.restrict_primary_key?
+        meths -= except.map{|x| "#{x}="} if except
+        meths
+      end
     end
 
     # Typecast the value to the column's type if typecasting.  Calls the database's
@@ -309,5 +389,11 @@ module Sequel
       raise(Error, "nil/NULL is not allowed for the #{column} column") if value.nil? && (col_schema[:allow_null] == false)
       model.db.typecast_value(col_schema[:type], value)
     end
+
+    # Set the columns, filtered by the only and except arrays.
+    def update_restricted(hash, only, except)
+      set_restricted(hash, only, except)
+      save_changes
+    end
   end
 end