sequel 1.4.0 → 1.5.0

data/lib/sequel_model/plugins.rb

@@ -28,20 +28,21 @@ module Sequel
       end
       alias_method :is_a, :is
     
-      # Returns the module for the specified plugin. If the module is not 
-      # defined, the corresponding plugin gem is automatically loaded.
-      def plugin_module(plugin)
-        module_name = plugin.to_s.gsub(/(^|_)(.)/) {$2.upcase}
-        if not Sequel::Plugins.const_defined?(module_name)
-          require plugin_gem(plugin)
+      private
+        # Returns the module for the specified plugin. If the module is not 
+        # defined, the corresponding plugin gem is automatically loaded.
+        def plugin_module(plugin)
+          module_name = plugin.to_s.gsub(/(^|_)(.)/) {$2.upcase}
+          if not Sequel::Plugins.const_defined?(module_name)
+            require plugin_gem(plugin)
+          end
+          Sequel::Plugins.const_get(module_name)
+        end
+  
+        # Returns the gem name for the given plugin.
+        def plugin_gem(plugin)
+          "sequel_#{plugin}"
         end
-        Sequel::Plugins.const_get(module_name)
-      end
-
-      # Returns the gem name for the given plugin.
-      def plugin_gem(plugin)
-        "sequel_#{plugin}"
-      end
     end
   end
-end
+end

data/lib/sequel_model/record.rb

@@ -40,10 +40,18 @@ module Sequel
     def ==(obj)
       (obj.class == model) && (obj.values == @values)
     end
+    alias_method :eql?, :"=="
 
-    # Compares model instances by pkey.
+    # If pk is not nil, true only if the objects have the same class and pk.
+    # If pk is nil, false.
     def ===(obj)
-      (obj.class == model) && (obj.pk == pk)
+      pk.nil? ? false : (obj.class == model) && (obj.pk == pk)
+    end
+
+    # Unique for objects with the same class and pk (if pk is not nil), or
+    # the same class and values (if pk is nil).
+    def hash
+      [model, pk.nil? ? @values.sort_by{|k,v| k.to_s} : pk].hash
     end
 
     # Returns key for primary key.
@@ -131,36 +139,39 @@ module Sequel
       class_def(:cache_key) {raise Error, "No primary key is associated with this model"}
     end
     
-    # Creates new instance with values set to passed-in Hash ensuring that
-    # new? returns true.
+    # Creates new instance with values set to passed-in Hash, saves it
+    # (running any callbacks), and returns the instance.
     def self.create(values = {}, &block)
-      db.transaction do
-        obj = new(values, &block)
-        obj.save
-        obj
-      end
+      obj = new(values, &block)
+      obj.save
+      obj
     end
     
     # Updates the instance with the supplied values with support for virtual
     # attributes, ignoring any values for which no setter method is available.
-    def update_with_params(values)
-      c = columns
-      values.each do |k, v| m = :"#{k}="
-        send(m, v) if c.include?(k) || respond_to?(m)
+    # 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)
+      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
-      save_changes
     end
-    alias_method :update_with, :update_with_params
 
-    class << self
-      def create_with_params(params)
-        record = new
-        record.update_with_params(params)
-        record
-      end
-      alias_method :create_with, :create_with_params
+    # Runs set_with_params and saves the changes (which runs any callback methods).
+    def update_with_params(values)
+      set_with_params(values)
+      save_changes
     end
-    
+
     # Returns (naked) dataset bound to current instance.
     def this
       @this ||= self.class.dataset.filter(:id => @values[:id]).limit(1).naked
@@ -194,27 +205,19 @@ module Sequel
     # This method guesses whether the record exists when
     # <tt>new_record</tt> is set to false.
     def initialize(values = nil, from_db = false, &block)
+      values ||=  {}
       @changed_columns = []
-      unless from_db
-        @values = {}
-        if values
-          values.each do |k, v| m = :"#{k}="
-            if respond_to?(m)
-              send(m, v)
-              values.delete(k)
-            end
-          end
-          values.inject(@values) {|m, kv| m[kv[0].to_sym] = kv[1]; m}
-          # @values.merge!(values)
-        end
+      if from_db
+        @new = false
+        @values = values
       else
-        @values = values || {}
+        @values = {}
+        @new = true
+        set_with_params(values)
       end
-
-      k = primary_key
-      @new = !from_db
+      @changed_columns.clear 
       
-      block[self] if block
+      yield self if block
       after_initialize
     end
     
@@ -228,7 +231,6 @@ module Sequel
     def new?
       @new
     end
-    alias :new_record? :new?
     
     # Returns true when current instance exists, false otherwise.
     def exists?
@@ -274,17 +276,47 @@ module Sequel
       save(*@changed_columns) unless @changed_columns.empty?
     end
 
-    # Updates and saves values to database from the passed-in Hash.
-    def set(values)
-      v = values.inject({}) {|m, kv| m[kv[0].to_sym] = kv[1]; m}
-      this.update(v)
-      v.each {|k, v| @values[k] = v}
+    # 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.
+    def set_values(values)
+      s = str_columns
+      vals = values.inject({}) do |m, kv| 
+        k, v = kv
+        k = case k
+        when Symbol
+          k
+        when String
+          # Prevent denial of service via memory exhaustion by only 
+          # calling to_sym if the symbol already exists.
+          raise(::Sequel::Error, "all string keys must be a valid columns") unless s.include?(k)
+          k.to_sym
+        else
+          raise(::Sequel::Error, "Only symbols and strings allows as keys")
+        end
+        m[k] = v
+        m
+      end
+      vals.each {|k, v| @values[k] = v}
+      vals
+    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.
+    # It should probably be avoided.  Look into using update_with_params instead.
+    def update_values(values)
+      this.update(set_values(values))
     end
-    alias_method :update, :set
     
     # Reloads values from database and returns self.
     def refresh
       @values = this.first || raise(Error, "Record not found")
+      model.all_association_reflections.each do |r|
+        instance_variable_set("@#{r[:name]}", nil)
+      end
       self
     end
     alias_method :reload, :refresh
@@ -296,41 +328,21 @@ module Sequel
         delete
         after_destroy
       end
+      self
     end
     
-    # Deletes and returns self.
+    # Deletes and returns self.  Does not run callbacks.
+    # Look into using destroy instead.
     def delete
       this.delete
       self
     end
     
-    ATTR_RE = /^([a-zA-Z_]\w*)(=)?$/.freeze
-    EQUAL_SIGN = '='.freeze
-
-    def method_missing(m, *args) #:nodoc:
-      if m.to_s =~ ATTR_RE
-        att = $1.to_sym
-        write = $2 == EQUAL_SIGN
-        
-        # check whether the column is legal
-        unless @values.has_key?(att) || columns.include?(att)
-          raise Error, "Invalid column (#{att.inspect}) for #{self}"
-        end
-
-        # define the column accessor
-        Thread.exclusive do
-          if write
-            model.class_def(m) {|v| self[att] = v}
-          else
-            model.class_def(m) {self[att]}
-          end
-        end
-        
-        # call the accessor
-        respond_to?(m) ? send(m, *args) : super(m, *args)
-      else
-        super(m, *args)
+    private
+      # Returns all methods that can be used for attribute
+      # assignment (those that end with =)
+      def setter_methods
+        methods.grep(/=\z/)
       end
-    end
   end
 end

data/lib/sequel_model/schema.rb

@@ -32,6 +32,8 @@ module Sequel
     # Creates table.
     def self.create_table
       db.create_table_sql_list(table_name, *schema.create_info).each {|s| db << s} 
+      @columns = nil
+      columns
     end
     
     # Drops table.

data/lib/sequel_model/validations.rb

@@ -1,6 +1,304 @@
-gem "assistance", ">= 0.1.2" # because we need Validations
+class Array
+  # Removes and returns the last member of the array if it is a hash. Otherwise,
+  # an empty hash is returned This method is useful when writing methods that
+  # take an options hash as the last parameter. For example:
+  #
+  #   def validate_each(*args, &block)
+  #     opts = args.extract_options!
+  #     ...
+  #   end
+  def extract_options!
+    last.is_a?(Hash) ? pop : {}
+  end
+end
+
+# The Validations module provides validation capabilities as a mixin. When
+# included into a class, it enhances the class with class and instance
+# methods for defining validations and validating class instances.
+# 
+# The Validation emulates the validation capabilities of ActiveRecord, and
+# provides methods for validating acceptance, confirmation, presence, format, 
+# length and numericality of attributes.
+#
+# To use validations, you need to include the Validation module in your
+# class:
+#
+#   class MyClass
+#     include Validation
+#     validates_length_of :password, :minimum => 6
+#   end
+module Validation
+  # Includes the Validation class methods into the including class.
+  def self.included(c)
+    c.extend ClassMethods
+  end
+  
+  # Returns the validation errors associated with the object.
+  def errors
+    @errors ||= Errors.new
+  end
+
+  # Validates the object.
+  def validate
+    errors.clear
+    self.class.validate(self)
+  end
+
+  # Validates the object and returns true if no errors are reported.
+  def valid?
+    validate
+    errors.empty?
+  end
+
+  # Validation::Errors represents validation errors.
+  class Errors
+    # Initializes a new instance of validation errors.
+    def initialize
+      @errors = Hash.new {|h, k| h[k] = []}
+    end
+    
+    # Returns true if no errors are stored.
+    def empty?
+      @errors.empty?
+    end
+    
+    # Clears all errors.
+    def clear
+      @errors.clear
+    end
+    
+    # Returns size of errors array
+    def size
+      @errors.size
+    end
+    
+    # Iterates over errors
+    def each(&block)
+      @errors.each(&block)
+    end
+    
+    # Returns the errors for the given attribute.
+    def on(att)
+      @errors[att]
+    end
+    alias_method :[], :on
+    
+    # Adds an error for the given attribute.
+    def add(att, msg)
+      @errors[att] << msg
+    end
+    
+    # Returns an array of fully-formatted error messages.
+    def full_messages
+      @errors.inject([]) do |m, kv| att, errors = *kv
+        errors.each {|e| m << "#{att} #{e}"}
+        m
+      end
+    end
+  end
+  
+  # The Generator class is used to generate validation definitions using 
+  # the validates {} idiom.
+  class Generator
+    # Initializes a new generator.
+    def initialize(receiver ,&block)
+      @receiver = receiver
+      instance_eval(&block)
+    end
+
+    # Delegates method calls to the receiver by calling receiver.validates_xxx.
+    def method_missing(m, *args, &block)
+      @receiver.send(:"validates_#{m}", *args, &block)
+    end
+  end
+  
+  # Validation class methods.
+  module ClassMethods
+    # Defines validations by converting a longhand block into a series of 
+    # shorthand definitions. For example:
+    #
+    #   class MyClass
+    #     include Validation
+    #     validates do
+    #       length_of :name, :minimum => 6
+    #       length_of :password, :minimum => 8
+    #     end
+    #   end
+    #
+    # is equivalent to:
+    #   class MyClass
+    #     include Validation
+    #     validates_length_of :name, :minimum => 6
+    #     validates_length_of :password, :minimum => 8
+    #   end
+    def validates(&block)
+      Generator.new(self, &block)
+    end
+
+    # Returns the validations hash for the class.
+    def validations
+      @validations ||= Hash.new {|h, k| h[k] = []}
+    end
 
-require "assistance"
+    # Returns true if validations are defined.
+    def has_validations?
+      !validations.empty?
+    end
+
+    # Validates the given instance.
+    def validate(o)
+      if superclass.respond_to?(:validate) && !@skip_superclass_validations
+        superclass.validate(o)
+      end
+      validations.each do |att, procs|
+        v = o.send(att)
+        procs.each {|p| p[o, att, v]}
+      end
+    end
+    
+    def skip_superclass_validations
+      @skip_superclass_validations = true
+    end
+    
+    # Adds a validation for each of the given attributes using the supplied
+    # block. The block must accept three arguments: instance, attribute and 
+    # value, e.g.:
+    #
+    #   validates_each :name, :password do |object, attribute, value|
+    #     object.errors[attribute] << 'is not nice' unless value.nice?
+    #   end
+    def validates_each(*atts, &block)
+      atts.each {|a| validations[a] << block}
+    end
+
+    # Validates acceptance of an attribute.
+    def validates_acceptance_of(*atts)
+      opts = {
+        :message => 'is not accepted',
+        :allow_nil => true,
+        :accept => '1'
+      }.merge!(atts.extract_options!)
+      
+      validates_each(*atts) do |o, a, v|
+        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+        o.errors[a] << opts[:message] unless v == opts[:accept]
+      end
+    end
+
+    # Validates confirmation of an attribute.
+    def validates_confirmation_of(*atts)
+      opts = {
+        :message => 'is not confirmed',
+      }.merge!(atts.extract_options!)
+      
+      validates_each(*atts) do |o, a, v|
+        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+        c = o.send(:"#{a}_confirmation")
+        o.errors[a] << opts[:message] unless v == c
+      end
+    end
+
+    # Validates the format of an attribute.
+    def validates_format_of(*atts)
+      opts = {
+        :message => 'is invalid',
+      }.merge!(atts.extract_options!)
+      
+      unless opts[:with].is_a?(Regexp)
+        raise ArgumentError, "A regular expression must be supplied as the :with option of the options hash"
+      end
+      
+      validates_each(*atts) do |o, a, v|
+        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+        o.errors[a] << opts[:message] unless v.to_s =~ opts[:with]
+      end
+    end
+
+    # Validates the length of an attribute.
+    def validates_length_of(*atts)
+      opts = {
+        :too_long     => 'is too long',
+        :too_short    => 'is too short',
+        :wrong_length => 'is the wrong length'
+      }.merge!(atts.extract_options!)
+      
+      validates_each(*atts) do |o, a, v|
+        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+        if m = opts[:maximum]
+          o.errors[a] << (opts[:message] || opts[:too_long]) unless v && v.size <= m
+        end
+        if m = opts[:minimum]
+          o.errors[a] << (opts[:message] || opts[:too_short]) unless v && v.size >= m
+        end
+        if i = opts[:is]
+          o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && v.size == i
+        end
+        if w = opts[:within]
+          o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && w.include?(v.size)
+        end
+      end
+    end
+
+    NUMBER_RE = /^\d*\.{0,1}\d+$/
+    INTEGER_RE = /\A[+-]?\d+\Z/
+
+    # Validates whether an attribute is a number.
+    def validates_numericality_of(*atts)
+      opts = {
+        :message => 'is not a number',
+      }.merge!(atts.extract_options!)
+      
+      re = opts[:only_integer] ? INTEGER_RE : NUMBER_RE
+      
+      validates_each(*atts) do |o, a, v|
+        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+        o.errors[a] << opts[:message] unless v.to_s =~ re
+      end
+    end
+
+    # Validates the presence of an attribute.
+    def validates_presence_of(*atts)
+      opts = {
+        :message => 'is not present',
+      }.merge!(atts.extract_options!)
+      
+      validates_each(*atts) do |o, a, v|
+        o.errors[a] << opts[:message] unless v && !v.blank?
+      end
+    end
+
+    # Validates only if the fields in the model (specified by atts) are
+    # unique in the database.  You should also add a unique index in the
+    # database, as this suffers from a fairly obvious race condition.
+    def validates_uniqueness_of(*atts)
+      opts = {
+        :message => 'is already taken',
+      }.merge!(atts.extract_options!)
+
+      validates_each(*atts) do |o, a, v|
+        next if v.blank? 
+        num_dups = o.class.filter(a => v).count
+        allow = if num_dups == 0
+          # No unique value in the database
+          true
+        elsif num_dups > 1
+          # Multiple "unique" values in the database!!
+          # Someone didn't add a unique index
+          false
+        elsif o.new?
+          # New record, but unique value already exists in the database
+          false
+        elsif o.class[a => v].pk == o.pk
+          # Unique value exists in database, but for the same record, so the update won't cause a duplicate record
+          true
+        else
+          false
+        end
+        o.errors[a] << opts[:message] unless allow
+      end
+    end
+  end
+end
 
 module Sequel
   class Model