sequel 0.2.1.1 → 0.3.0

data/lib/sequel/model/base.rb

@@ -1,36 +1,41 @@
 module Sequel
   class Model
-    # returns the database associated with the model class
+    # Returns the database associated with the Model class.
     def self.db
-      @db ||= ((superclass != Object) && (superclass.db)) || \
-        raise(SequelError, "No database associated with #{self}.")
+      @db ||= (superclass != Object) && superclass.db or
+      raise SequelError, "No database associated with #{self}"
     end
     
-    # sets the database associated with the model class
-    def self.db=(db); @db = db; end
+    # Sets the database associated with the Model class.
+    def self.db=(db)
+      @db = db
+    end
     
-    # called when a database is opened in order to automatically associate the
+    # Called when a database is opened in order to automatically associate the
     # first opened database with model classes.
     def self.database_opened(db)
       @db = db if self == Model && !@db
     end
 
-    # returns the dataset associated with the model class.
+    # Returns the dataset associated with the Model class.
     def self.dataset
-      @dataset || super_dataset || raise(SequelError, "No dataset associated with #{self}.")
+      @dataset || super_dataset or
+      raise SequelError, "No dataset associated with #{self}"
     end
     
-    def self.super_dataset
-      if superclass && superclass.respond_to?(:dataset) && ds = superclass.dataset
-        ds
-      end
+    def self.super_dataset # :nodoc:
+      superclass.dataset if superclass and superclass.respond_to? :dataset
     end
     
+    # Returns the columns in the result set in their original order.
+    #
+    # See Dataset#columns for more information.
     def self.columns
-      @columns ||= @dataset.columns || raise(SequelError, "Could not fetch columns for #{self}")
+      @columns ||= @dataset.columns or
+      raise SequelError, "Could not fetch columns for #{self}"
     end
 
-    # Sets the dataset associated with the model class.
+    # Sets the dataset associated with the Model class.
     def self.set_dataset(ds)
       @db = ds.db
       @dataset = ds
@@ -38,42 +43,48 @@ module Sequel
       @dataset.transform(@transform) if @transform
     end
     
-    def model
-      @model ||= self.class
-    end
-    
-    # Returns the dataset assoiated with the object's model class.
+    # Returns the database assoiated with the object's Model class.
     def db
       @db ||= model.db
     end
 
-    # Returns the dataset assoiated with the object's model class.
+    # Returns the dataset assoiated with the object's Model class.
+    #
+    # See Dataset for more information.
     def dataset
-      @dataset ||= model.dataset
+      model.dataset
     end
     
+    # Returns the columns associated with the object's Model class.
     def columns
-      @columns ||= model.columns
+      model.columns
     end
 
-    SERIALIZE_FORMATS = {
-      :yaml => [proc {|v| YAML.load v if v}, proc {|v| v.to_yaml}],
-      :marshal => [proc {|v| Marshal.load(v) if v}, proc {|v| Marshal.dump(v)}]
-    }
-
+    # Serializes column with YAML or through marshalling.
     def self.serialize(*columns)
       format = columns.pop[:format] if Hash === columns.last
-      filters = SERIALIZE_FORMATS[format || :yaml]
-      # add error handling here
+      format ||= :yaml
       
       @transform = columns.inject({}) do |m, c|
-        m[c] = filters
+        m[c] = format
         m
       end
       @dataset.transform(@transform) if @dataset
     end
   end
 
+  # Lets you create a Model class with its table name already set or reopen
+  # an existing Model.
+  #
+  # Makes given dataset inherited.
+  #
+  # === Example:
+  #   class Comment < Sequel::Model(:comments)
+  #     table_name # => :comments
+  #
+  #     # ...
+  #
+  #   end
   def self.Model(source)
     @models ||= {}
     @models[source] ||= Class.new(Sequel::Model) do

data/lib/sequel/model/caching.rb

@@ -0,0 +1,42 @@
+module Sequel
+  class Model
+    def self.set_cache(store, opts = {})
+      @cache_store = store
+      if (ttl = opts[:ttl])
+        set_cache_ttl(ttl)
+      end
+      
+      meta_def(:[]) do |*args|
+        if (args.size == 1) && (Hash === (h = args.first))
+          return dataset[h]
+        end
+        
+        unless obj = @cache_store.get(cache_key_from_values(args))
+          obj = dataset[primary_key_hash((args.size == 1) ? args.first : args)]
+          @cache_store.set(cache_key_from_values(args), obj, cache_ttl)
+        end
+        obj
+      end
+      
+      class_def(:set) {|v| store.delete(cache_key); super}
+      class_def(:save) {store.delete(cache_key); super}
+      class_def(:delete) {store.delete(cache_key); super}
+    end
+    
+    def self.set_cache_ttl(ttl)
+      @cache_ttl = ttl
+    end
+    
+    def self.cache_store
+      @cache_store
+    end
+    
+    def self.cache_ttl
+      @cache_ttl ||= 3600
+    end
+    
+    def self.cache_key_from_values(values)
+      "#{self}:#{values.join(',')}"
+    end
+  end
+end

data/lib/sequel/model/hooks.rb

@@ -1,40 +1,126 @@
 module Sequel
   class Model
-    def self.get_hooks(key)
-      @hooks ||= {}
-      @hooks[key] ||= []
+
+    class ChainBroken < RuntimeError # :nodoc:
     end
-    
-    def self.has_hooks?(key)
-      !get_hooks(key).empty?
+
+    # This Hash translates verbs to methodnames used in chain manipulation
+    # methods.
+    VERB_TO_METHOD = {:prepend => :unshift, :append => :push}
+
+    # Returns @hooks which is an instance of Hash with its hook identifier
+    # (Symbol) as key and the chain of hooks (Array) as value.
+    #
+    # If it is not already set it'll be with an empty set of hooks.
+    # This behaviour will change in the future to allow inheritance.
+    #
+    # For the time being, you should be able to do:
+    #
+    #   class A < Sequel::Model(:a)
+    #     before_save { 'Do something...' }
+    #   end
+    #
+    #   class B < A
+    #     @hooks = superclass.hooks.clone
+    #     before_save # => [#<Proc:0x0000c6e8@(example.rb):123>]
+    #   end
+    #
+    # In this case you should remember that the clone doesn't create any new
+    # instances of your chains, so if you change the chain here it changes in
+    # its superclass, too.
+    def self.hooks
+      @hooks ||= Hash.new { |h, k| h[k] = [] }
     end
-    
-    def run_hooks(key)
-      self.class.get_hooks(key).each {|h| instance_eval(&h)}
+
+    # Adds block to chain of Hooks for <tt>:before_save</tt>.
+    # It can either be prepended (default) or appended.
+    #
+    # Returns the chain itself.
+    #
+    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
+    def self.before_save(verb = :prepend, &block)
+      hooks[:before_save].send VERB_TO_METHOD.fetch(verb), block if block
+      hooks[:before_save]
     end
-    
-    def self.before_save(&block)
-      get_hooks(:before_save).unshift(block)
+    # Adds block to chain of Hooks for <tt>:before_create</tt>.
+    # It can either be prepended (default) or appended.
+    #
+    # Returns the chain itself.
+    #
+    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
+    def self.before_create(verb = :prepend, &block)
+      hooks[:before_create].send VERB_TO_METHOD.fetch(verb), block if block
+      hooks[:before_create]
     end
-    
-    def self.before_create(&block)
-      get_hooks(:before_create).unshift(block)
+    # Adds block to chain of Hooks for <tt>:before_update</tt>.
+    # It can either be prepended (default) or appended.
+    #
+    # Returns the chain itself.
+    #
+    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
+    def self.before_update(verb = :prepend, &block)
+      hooks[:before_update].send VERB_TO_METHOD.fetch(verb), block if block
+      hooks[:before_update]
     end
-    
-    def self.before_destroy(&block)
-      get_hooks(:before_destroy).unshift(block)
+    # Adds block to chain of Hooks for <tt>:before_destroy</tt>.
+    # It can either be prepended (default) or appended.
+    #
+    # Returns the chain itself.
+    #
+    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
+    def self.before_destroy(verb = :prepend, &block)
+      hooks[:before_destroy].send VERB_TO_METHOD.fetch(verb), block if block
+      hooks[:before_destroy]
     end
-    
-    def self.after_save(&block)
-      get_hooks(:after_save) << block
+
+    # Adds block to chain of Hooks for <tt>:after_save</tt>.
+    # It can either be prepended or appended (default).
+    #
+    # Returns the chain itself.
+    #
+    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
+    def self.after_save(verb = :append, &block)
+      hooks[:after_save].send VERB_TO_METHOD.fetch(verb), block if block
+      hooks[:after_save]
     end
-    
-    def self.after_create(&block)
-      get_hooks(:after_create) << block
+    # Adds block to chain of Hooks for <tt>:after_create</tt>.
+    # It can either be prepended or appended (default).
+    #
+    # Returns the chain itself.
+    #
+    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
+    def self.after_create(verb = :append, &block)
+      hooks[:after_create].send VERB_TO_METHOD.fetch(verb), block if block
+      hooks[:after_create]
+    end
+    # Adds block to chain of Hooks for <tt>:after_update</tt>.
+    # It can either be prepended or appended (default).
+    #
+    # Returns the chain itself.
+    #
+    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
+    def self.after_update(verb = :append, &block)
+      hooks[:after_update].send VERB_TO_METHOD.fetch(verb), block if block
+      hooks[:after_update]
+    end
+    # Adds block to chain of Hooks for <tt>:after_destroy</tt>.
+    # It can either be prepended or appended (default).
+    #
+    # Returns the chain itself.
+    #
+    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
+    def self.after_destroy(verb = :append, &block)
+      hooks[:after_destroy].send VERB_TO_METHOD.fetch(verb), block if block
+      hooks[:after_destroy]
+    end
+
+    # Evaluates specified chain of Hooks through <tt>instance_eval</tt>.
+    def run_hooks(key)
+      model.hooks[key].each { |h| instance_eval &h }
     end
     
-    def self.after_destroy(&block)
-      get_hooks(:after_destroy) << block
+    def self.has_hooks?(key)
+      hooks[key] && !hooks[key].empty?
     end
   end
-end
+end

data/lib/sequel/model/record.rb

@@ -2,41 +2,75 @@ module Sequel
   class Model
     attr_reader :values
 
-    def self.primary_key; :id; end
-    def self.primary_key_hash(v); {:id => v}; end
+    # Returns key for primary key.
+    def self.primary_key
+      :id
+    end
+    
+    # Returns primary key attribute hash.
+    def self.primary_key_hash(value)
+      {:id => value}
+    end
     
-    def self.set_primary_key(key)
+    # Sets primary key, regular and composite are possible.
+    #
+    # == Example:
+    #   class Tagging < Sequel::Model(:taggins)
+    #     # composite key
+    #     set_primary_key :taggable_id, :tag_id
+    #   end
+    #
+    #   class Person < Sequel::Model(:person)
+    #     # regular key
+    #     set_primary_key :person_id
+    #   end
+    #
+    # <i>You can even set it to nil!</i>
+    def self.set_primary_key(*key)
       # if k is nil, we go to no_primary_key
       return no_primary_key unless key
       
+      # backwards compat
+      key = (key.length == 1) ? key[0] : key.flatten
+
       # redefine primary_key
       meta_def(:primary_key) {key}
       
-      if key.is_a?(Array) # composite key
+      unless key.is_a? Array # regular primary key
         class_def(:this) do
-          @this ||= self.class.dataset.filter( \
-            @values.reject {|k, v| !key.include?(k)} \
-          ).naked
+          @this ||= dataset.filter(key => @values[key]).limit(1).naked
         end
-        meta_def(:primary_key_hash) do |v|
-          key.inject({}) {|m, i| m[i] = v.shift; m}
-        end
-      else # regular key
-        class_def(:this) do
-          @this ||= self.class.dataset.filter(key => @values[key]).naked
+        class_def(:cache_key) do
+          pk = @values[key] || (raise SequelError, 'no primary key for this record')
+          @cache_key ||= "#{self.class}:#{pk}"
         end
         meta_def(:primary_key_hash) do |v|
           {key => v}
         end
+      else # composite key
+        exp_list = key.map {|k| "#{k.inspect} => @values[#{k.inspect}]"}
+        block = eval("proc {@this ||= self.class.dataset.filter(#{exp_list.join(',')}).limit(1).naked}")
+        class_def(:this, &block)
+        
+        exp_list = key.map {|k| '#{@values[%s]}' % k.inspect}.join(',')
+        block = eval('proc {@cache_key ||= "#{self.class}:%s"}' % exp_list)
+        class_def(:cache_key, &block)
+
+        meta_def(:primary_key_hash) do |v|
+          key.inject({}) {|m, i| m[i] = v.shift; m}
+        end
       end
     end
     
-    def self.no_primary_key
+    def self.no_primary_key #:nodoc:
       meta_def(:primary_key) {nil}
       meta_def(:primary_key_hash) {|v| raise SequelError, "#{self} does not have a primary key"}
       class_def(:this) {raise SequelError, "No primary key is associated with this model"}
+      class_def(:cache_key) {raise SequelError, "No primary key is associated with this model"}
     end
     
+    # Creates new instance with values set to passed-in Hash ensuring that
+    # new? returns true.
     def self.create(values = {})
       db.transaction do
         obj = new(values, true)
@@ -45,36 +79,55 @@ module Sequel
       end
     end
     
+    # Returns (naked) dataset bound to current instance.
     def this
-      @this ||= self.class.dataset.filter(:id => @values[:id]).naked
+      @this ||= self.class.dataset.filter(:id => @values[:id]).limit(1).naked
     end
     
-    # instance method
+    # Returns a key unique to the underlying record for caching
+    def cache_key
+      pk = @values[:id] || (raise SequelError, 'no primary key for this record')
+      @cache_key ||= "#{self.class}:#{pk}"
+    end
+
+    # Returns primary key column(s) for object's Model class.
     def primary_key
       @primary_key ||= self.class.primary_key
     end
     
+    # Returns value for primary key.
     def pkey
       @pkey ||= @values[primary_key]
     end
     
-    def initialize(values = {}, new = false)
+    # Creates new instance with values set to passed-in Hash.
+    #
+    # This method guesses whether the record exists when
+    # <tt>new_record</tt> is set to false.
+    def initialize(values = {}, new_record = false)
       @values = values
-      @new = new
-      if !new # determine if it's a new record
+
+      @new = new_record
+      unless @new # determine if it's a new record
         pk = primary_key
+        # if there's no primary key for the model class, or
+        # @values doesn't contain a primary key value, then 
+        # we regard this instance as new.
         @new = (pk == nil) || (!(Array === pk) && !@values[pk])
       end
     end
     
+    # Returns true if the current instance represents a new record.
     def new?
       @new
     end
     
+    # Returns true when current instance exists, false otherwise.
     def exists?
       this.count > 0
     end
     
+    # Creates or updates dataset for Model and runs hooks.
     def save
       run_hooks(:before_save)
       if @new
@@ -100,16 +153,19 @@ module Sequel
       self
     end
 
+    # Updates and saves values to database from the passed-in Hash.
     def set(values)
       this.update(values)
-      @values.merge!(values)
+      values.each {|k, v| @values[k] = v}
     end
     
+    # Reloads values from database and returns self.
     def refresh
       @values = this.first || raise(SequelError, "Record not found")
       self
     end
 
+    # Like delete but runs hooks before and after delete.
     def destroy
       db.transaction do
         run_hooks(:before_destroy)
@@ -118,6 +174,7 @@ module Sequel
       end
     end
     
+    # Deletes and returns self.
     def delete
       this.delete
       self
@@ -125,7 +182,7 @@ module Sequel
     
     ATTR_RE = /^([a-zA-Z_]\w*)(=)?$/.freeze
 
-    def method_missing(m, *args)
+    def method_missing(m, *args) #:nodoc:
       if m.to_s =~ ATTR_RE
         att = $1.to_sym
         write = $2 == '='