viking-sequel 3.10.0

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -0,0 +1,74 @@
+module Sequel
+  module Plugins
+    # Sequel's built in Single Table Inheritance plugin makes subclasses
+    # of this model only load rows where the given key field matches the
+    # subclass's name.  If the key given has a NULL value or there are
+    # any problems looking up the class, uses the current class.
+    #   
+    # You should only use this in the parent class, not in the subclasses.
+    #   
+    # You shouldn't call set_dataset in the model after applying this
+    # plugin, otherwise subclasses might use the wrong dataset.
+    #   
+    # The filters and row_proc that sti_key sets up in subclasses may not work correctly if
+    # those subclasses have further subclasses.  For those middle subclasses,
+    # you may need to call set_dataset manually with the correct filter and
+    # row_proc.
+    module SingleTableInheritance
+      # Set the sti_key and sti_dataset for the model, and change the
+      # dataset's row_proc so that the dataset yields objects of varying classes,
+      # where the class used has the same name as the key field.
+      def self.configure(model, key)
+        model.instance_eval do
+          @sti_key = key 
+          @sti_dataset = dataset
+          dataset.row_proc = lambda{|r| model.sti_load(r)}
+        end
+      end
+
+      module ClassMethods
+        # The base dataset for STI, to which filters are added to get
+        # only the models for the specific STI subclass.
+        attr_reader :sti_dataset
+
+        # The column name holding the STI key for this model
+        attr_reader :sti_key
+
+        # Copy the sti_key and sti_dataset to the subclasses, and filter the
+        # subclass's dataset so it is restricted to rows where the key column
+        # matches the subclass's name.
+        def inherited(subclass)
+          super
+          sk = sti_key
+          sd = sti_dataset
+          subclass.set_dataset(sd.filter(SQL::QualifiedIdentifier.new(table_name, sk)=>subclass.name.to_s), :inherited=>true)
+          subclass.instance_eval do
+            @sti_key = sk
+            @sti_dataset = sd
+            @simple_table = nil
+          end
+        end
+
+        # Return an instance of the class specified by sti_key,
+        # used by the row_proc.
+        def sti_load(r)
+          v = r[sti_key]
+          model = if (v && v != '')
+            constantize(v) rescue self
+          else
+            self
+          end
+          model.load(r)
+        end
+      end
+
+      module InstanceMethods
+        # Set the sti_key column to the name of the model.
+        def before_create
+          return false if super == false
+          send("#{model.sti_key}=", model.name.to_s) unless send(model.sti_key)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/subclasses.rb

@@ -0,0 +1,45 @@
+module Sequel
+  module Plugins
+    # The Subclasses plugin keeps track of all subclasses of the
+    # current model class.  Direct subclasses are available via the
+    # subclasses method, and all descendent classes are available via the
+    # descendents method.
+    #
+    #   c = Class.new(Sequel::Model)
+    #   c.plugin :subclasses
+    #   sc1 = Class.new(c)
+    #   sc2 = Class.new(c)
+    #   ssc1 = Class.new(sc1)
+    #   c.subclasses    # [sc1, sc2]
+    #   sc1.subclasses  # [ssc1]
+    #   sc2.subclasses  # []
+    #   ssc1.subclasses # []
+    #   c.descendents   # [sc1, ssc1, sc2]
+    module Subclasses
+      # Initialize the subclasses instance variable for the model.
+      def self.apply(model, &block)
+        model.instance_variable_set(:@subclasses, [])
+      end
+
+      module ClassMethods
+        # All subclasses for the current model.  Does not
+        # include the model itself.
+        attr_reader :subclasses
+
+        # All descendent classes of this model.
+        def descendents
+          subclasses.map{|x| [x] + x.descendents}.flatten
+        end
+
+        # Add the subclass to this model's current subclasses,
+        # and initialize a new subclasses instance variable
+        # in the subclass.
+        def inherited(subclass)
+          super
+          subclasses << subclass
+          subclass.instance_variable_set(:@subclasses, [])
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -0,0 +1,61 @@
+module Sequel
+  module Plugins
+    # The tactical_eager_loading plugin allows you to eagerly load
+    # an association for all objects retrieved from the same dataset
+    # without calling eager on the dataset.  If you attempt to load
+    # associated objects for a record and the association for that
+    # object is currently not cached, it assumes you want to get
+    # the associated objects for all objects retrieved with the dataset that
+    # retrieved the current object.
+    #
+    # Tactical eager loading only takes affect if you retrieved the
+    # current object with Dataset#all, it doesn't work if you
+    # retrieved the current object with Dataset#each.
+    #
+    # Basically, this allows the following code to issue only two queries:
+    #
+    #   Album.filter{id<100}.all do |a|
+    #     a.artists
+    #   end
+    module TacticalEagerLoading
+      module InstanceMethods
+        # The dataset that retrieved this object, set if the object was
+        # reteived via Dataset#all with an active identity map.
+        attr_accessor :retrieved_by
+
+        # All model objects retrieved with this object, set if the object was
+        # reteived via Dataset#all with an active identity map.
+        attr_accessor :retrieved_with
+
+        private
+
+        # If there is an active identity map and the association is not in the
+        # associations cache and the object was reteived via Dataset#all,
+        # eagerly load the association for all model objects retrieved with the
+        # current object.
+        def load_associated_objects(opts, reload=false)
+          name = opts[:name]
+          if !associations.include?(name) && retrieved_by
+            retrieved_by.send(:eager_load, retrieved_with, name=>{})
+          end
+          super
+        end
+      end
+
+      module DatasetMethods
+        private
+
+        # If there is an active identity map, set the reteived_with attribute for the object
+        # with the current dataset and array of all objects.
+        def post_load(objects)
+          super
+          objects.each do |o|
+            next unless o.is_a?(Sequel::Model)
+            o.retrieved_by = self
+            o.retrieved_with = objects
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/timestamps.rb

@@ -0,0 +1,87 @@
+module Sequel
+  module Plugins
+    # The timestamps plugin creates hooks that automatically set create and
+    # update timestamp fields.  Both field names used are configurable, and you 
+    # can also set whether to overwrite existing create timestamps (false
+    # by default), or whether to set the update timestamp when creating (also
+    # false by default).
+    module Timestamps
+      # Configure the plugin by setting the avialable options.  Note that
+      # if this method is run more than once, previous settings are ignored,
+      # and it will just use the settings given or the default settings.  Options:
+      # * :create - The field to hold the create timestamp (default: :created_at)
+      # * :force - Whether to overwrite an existing create timestamp (default: false)
+      # * :update - The field to hold the update timestamp (default: :updated_at)
+      # * :update_on_create - Whether to set the update timestamp to the create timestamp when creating (default: false)
+      def self.configure(model, opts={})
+        model.instance_eval do
+          @create_timestamp_field = opts[:create]||:created_at
+          @update_timestamp_field = opts[:update]||:updated_at
+          @create_timestamp_overwrite = opts[:force]||false
+          @set_update_timestamp_on_create = opts[:update_on_create]||false
+        end
+      end
+
+      module ClassMethods
+        # The field to store the create timestamp
+        attr_reader :create_timestamp_field
+
+        # The field to store the update timestamp
+        attr_reader :update_timestamp_field
+        
+        # Whether to overwrite the create timestamp if it already exists
+        def create_timestamp_overwrite?
+          @create_timestamp_overwrite
+        end
+        
+        # Copy the class instance variables used from the superclass to the subclass
+        def inherited(subclass)
+          super
+          [:@create_timestamp_field, :@update_timestamp_field, :@create_timestamp_overwrite, :@set_update_timestamp_on_create].each do |iv|
+            subclass.instance_variable_set(iv, instance_variable_get(iv))
+          end
+        end
+        
+        # Whether to set the update timestamp to the create timestamp when creating
+        def set_update_timestamp_on_create?
+          @set_update_timestamp_on_create
+        end
+      end
+
+      module InstanceMethods
+        # Set the create timestamp when creating
+        def before_create
+          super
+          set_create_timestamp
+        end
+        
+        # Set the update timestamp when updating
+        def before_update
+          super
+          set_update_timestamp
+        end
+        
+        private
+        
+        # If the object has accessor methods for the create timestamp field, and
+        # the create timestamp value is nil or overwriting it is allowed, set the
+        # create timestamp field to the time given or the current time.  If setting
+        # the update timestamp on creation is configured, set the update timestamp
+        # as well.
+        def set_create_timestamp(time=nil)
+          field = model.create_timestamp_field
+          meth = :"#{field}="
+          self.send(meth, time||=Sequel.datetime_class.now) if respond_to?(field) && respond_to?(meth) && (model.create_timestamp_overwrite? || send(field).nil?)
+          set_update_timestamp(time) if model.set_update_timestamp_on_create?
+        end
+        
+        # Set the update timestamp to the time given or the current time if the
+        # object has a setter method for the update timestamp field.
+        def set_update_timestamp(time=nil)
+          meth = :"#{model.update_timestamp_field}="
+          self.send(meth, time||Sequel.datetime_class.now) if respond_to?(meth)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/touch.rb

@@ -0,0 +1,118 @@
+module Sequel
+  module Plugins
+    # The touch plugin adds a touch method to model instances, which saves
+    # the object with a modified timestamp.  By default, it uses the
+    # :updated_at column, but you can set which column to use.
+    # It also supports touching of associations, so that when the current
+    # model object is updated or destroyed, the associated rows in the
+    # database can have their modified timestamp updated to the current
+    # timestamp.
+    #
+    # Since the instance touch method works on model instances,
+    # it uses Time.now for the timestamp.  The association touching works
+    # on datasets, so it updates all related rows in a single query, using
+    # the SQL standard CURRENT_TIMESTAMP.  Both of these can be overridden
+    # easily if necessary.
+    module Touch
+      # The default column to update when touching
+      TOUCH_COLUMN_DEFAULT = :updated_at
+
+      # Set the touch_column and touched_associations variables for the model.
+      # Options:
+      # * :associations - The associations to touch when a model instance is
+      #   updated or destroyed.  Can be a symbol for a single association,
+      #   a hash with association keys and column values, or an array of
+      #   symbols and/or hashes.  If a symbol is used, the column used
+      #   when updating the associated objects is the model's touch_column.
+      #   If a hash is used, the value is used as the column to update.
+      # * :column - The column to modify when touching a model instance.
+      def self.configure(model, opts={})
+        model.touch_column = opts[:column] || TOUCH_COLUMN_DEFAULT if opts[:column] || !model.touch_column
+        model.instance_variable_set(:@touched_associations, {})
+        model.touch_associations(opts[:associations]) if opts[:associations]
+      end
+
+      module ClassMethods
+        # The column to modify when touching a model instance, as a symbol.  Also used
+        # as the default column when touching associations, if
+        # the associations don't specify a column.
+        attr_accessor :touch_column
+
+        # A hash specifying the associations to touch when instances are
+        # updated or destroyed. Keys are association dataset method name symbols and values
+        # are column name symbols.
+        attr_reader :touched_associations
+
+        # Set the touch_column for the subclass to be the same as the current class.
+        # Also, create a copy of the touched_associations in the subclass.
+        def inherited(subclass)
+          super
+          subclass.touch_column = touch_column
+          subclass.instance_variable_set(:@touched_associations, touched_associations.dup)
+        end
+
+        # Add additional associations to be touched.  See the :association option
+        # of the Sequel::Plugin::Touch.configure method for the format of the associations
+        # arguments.
+        def touch_associations(*associations)
+          associations.flatten.each do |a|
+            a = {a=>touch_column} if a.is_a?(Symbol)
+            a.each do |k,v|
+              raise(Error, "invalid association: #{k}") unless r = association_reflection(k)
+              touched_associations[r.dataset_method] = v
+            end
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Touch all of the model's touched_associations when destroying the object.
+        def after_destroy
+          super
+          touch_associations
+        end
+
+        # Touch all of the model's touched_associations when updating the object.
+        def after_update
+          super
+          touch_associations
+        end
+
+        # Touch the model object.  If a column is not given, use the model's touch_column
+        # as the column.  If the column to use is not one of the model's columns, just
+        # save the changes to the object instead of attempting to a value that doesn't
+        # exist.
+        def touch(column=nil)
+          if column
+            set(column=>touch_instance_value)
+          else
+            column = model.touch_column
+            set(column=>touch_instance_value) if columns.include?(column)
+          end
+          save_changes
+        end
+
+        private
+
+        # The value to use when modifying the touch column for the association datasets.  Uses
+        # the SQL standard CURRENT_TIMESTAMP.
+        def touch_association_value
+          Sequel::CURRENT_TIMESTAMP
+        end
+
+        # Directly update the database using the association dataset for each association.
+        def touch_associations
+          model.touched_associations.each do |meth, column|
+            send(meth).update(column=>touch_association_value)
+          end
+        end
+
+        # The value to use when modifying the touch column for the model instance.
+        # Uses Time.now to work well with typecasting.
+        def touch_instance_value
+          Time.now
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/typecast_on_load.rb

@@ -0,0 +1,72 @@
+module Sequel
+  module Plugins
+    # The TypecastOnLoad plugin exists because most of Sequel's database adapters don't
+    # have complete control over typecasting, and may return columns that aren't
+    # typecast correctly (with correct being defined as how the model object
+    # would typecast the same column values).
+    #
+    # This plugin modifies Model.load to call the setter methods (which typecast
+    # by default) for all columns given.  You can either specify the columns to
+    # typecast on load in the plugin call itself, or afterwards using 
+    # add_typecast_on_load_columns:
+    #
+    #   Album.plugin :typecast_on_load, :release_date, :record_date
+    #   # or:
+    #   Album.plugin :typecast_on_load
+    #   Album.add_typecast_on_load_columns :release_date, :record_date
+    #
+    # If the database returns release_date and record_date columns as strings
+    # instead of dates, this will ensure that if you access those columns through
+    # the model object, you'll get Date objects instead of strings.
+    module TypecastOnLoad
+      # Call add_typecast_on_load_columns on the passed column arguments.
+      def self.configure(model, *columns, &block)
+        model.instance_eval do
+          @typecast_on_load_columns ||= []
+          add_typecast_on_load_columns(*columns)
+        end
+      end
+
+      module ClassMethods
+        # The columns to typecast on load for this model.
+        attr_reader :typecast_on_load_columns
+
+        # Add additional columns to typecast on load for this model.
+        def add_typecast_on_load_columns(*columns)
+          @typecast_on_load_columns.concat(columns)
+        end
+
+        # Give the subclass a copy of the typecast on load columns.
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@typecast_on_load_columns, typecast_on_load_columns.dup)
+        end
+
+        # Call the setter method for each of the typecast on load columns,
+        # ensuring the model object will have the correct typecasting even
+        # if the database doesn't typecast the columns correctly.
+        def load(values)
+          super.load_typecast
+        end
+      end
+
+      module InstanceMethods
+        def load_typecast
+          model.typecast_on_load_columns.each do |c|
+            if v = values[c]
+              send("#{c}=", v)
+            end
+          end
+          changed_columns.clear
+          self
+        end
+
+        private
+
+        def _refresh(dataset)
+          super.load_typecast
+        end
+      end
+    end
+  end
+end