sequel_model 0.3.1 → 0.3.2

data/CHANGELOG

@@ -1,4 +1,12 @@
-=== 0.3.1
+=== 0.3.2 (2008-01-24)
+
+* Added Model#update_with_params method with support for virtual attributes and auto-filtering of unrelated parameters, and changed Model.create_with_params to support virtual attributes (#128).
+
+* Cleaned up gem spec (#132).
+
+* Removed validations code. Now relying on validations in assistance gem.
+
+=== 0.3.1 (2008-01-21)
 
 * Changed Model.dataset to use inflector to pluralize the class name into the table name. Works in similar fashion to table names in AR or DM.
 

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_model"
-VERS = "0.3.1"
+VERS = "0.3.2"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 
@@ -57,15 +57,14 @@ spec = Gem::Specification.new do |s|
   s.required_ruby_version = ">= 1.8.4"
 
   case RUBY_PLATFORM
-  when /mswin/
-    s.platform = Gem::Platform::CURRENT
   when /java/
     s.platform = "jruby"
   else
     s.platform = Gem::Platform::RUBY
   end
 
-  s.add_dependency("sequel_core", '>= 0.5')
+  s.add_dependency("assistance", '>= 0.1.2')
+  s.add_dependency("sequel_core", '>= 1.0')
   
   s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*")
 
@@ -96,6 +95,9 @@ end
 
 task :tag do
   cwd = FileUtils.pwd
+  sh %{rm -rf doc/*}
+  sh %{rm -rf pkg/*}
+  sh %{rm -rf coverage/*}
   sh %{cd ../.. && svn copy #{cwd} tags/#{NAME}-#{VERS} && svn commit -m "#{NAME}-#{VERS} tag." tags}
 end
 

data/lib/sequel_model/record.rb

@@ -135,9 +135,22 @@ module Sequel
       end
     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)
+      end
+      save_changes
+    end
+    alias_method :update_with, :update_with_params
+
     class << self
       def create_with_params(params)
-        create(params.reject {|k, v| !columns.include?(k.to_sym)})
+        record = new
+        record.update_with_params(params)
+        record
       end
       alias_method :create_with, :create_with_params
     end

data/lib/sequel_model/validations.rb

@@ -1,248 +1,8 @@
-gem 'assistance', '>= 0.1.1' # because we need Array#extract_options!
+gem 'assistance', '>= 0.1.2' # because we need Validations
 
 module Sequel
-  # The Validatable 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 Validatable 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 Validatable module in your
-  # class:
-  #
-  #   class MyClass
-  #     include Sequel::Validatable
-  #     validates_length_of :password, :minimum => 6
-  #   end
-  module Validatable
-    # Includes the Validatable 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
-
-    # Validatable::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 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)
-        @receiver.send(:"validates_#{m}", *args)
-      end
-    end
-    
-    # Validatable class methods.
-    module ClassMethods
-      # Defines validations by converting a longhand block into a series of 
-      # shorthand definitions. For example:
-      #
-      #   class MyClass
-      #     include Sequel::Validatable
-      #     validates do
-      #       length_of :name, :minimum => 6
-      #       length_of :password, :minimum => 8
-      #     end
-      #   end
-      #
-      # is equivalent to:
-      #   class MyClass
-      #     include Sequel::Validatable
-      #     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
-      
-      # Returns true if validations are defined.
-      def has_validations?
-        !validations.empty?
-      end
-
-      # Validates the given instance.
-      def validate(o)
-        validations.each do |att, procs|
-          v = o.send(att)
-          procs.each {|p| p[o, att, v]}
-        end
-      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 Sequel::Error, "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
-    end
-  end
-
   class Model
-    include Validatable
+    include Validation
     
     alias_method :save!, :save
     def save(*args)

data/spec/record_spec.rb

@@ -282,6 +282,43 @@ describe "Model#pk_hash" do
   end
 end
 
+describe Sequel::Model, "update_with_params" do
+
+  before(:each) do
+    MODEL_DB.reset
+    
+    @c = Class.new(Sequel::Model(:items)) do
+      def self.columns; [:x, :y]; end
+    end
+    @o1 = @c.new
+    @o2 = @c.new(:id => 5)
+  end
+  
+  it "should filter the given params using the model columns" do
+    @o1.update_with_params(:x => 1, :z => 2)
+    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
+
+    MODEL_DB.reset
+    @o2.update_with_params(:y => 1, :abc => 2)
+    MODEL_DB.sqls.first.should == "UPDATE items SET y = 1 WHERE (id = 5)"
+  end
+  
+  it "should be aliased by create_with" do
+    @o1.update_with(:x => 1, :z => 2)
+    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
+
+    MODEL_DB.reset
+    @o2.update_with(:y => 1, :abc => 2)
+    MODEL_DB.sqls.first.should == "UPDATE items SET y = 1 WHERE (id = 5)"
+  end
+  
+  it "should support virtual attributes" do
+    @c.class_def(:blah=) {|v| self.x = v}
+    @o1.update_with(:blah => 333)
+    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (333)"
+  end
+end
+
 describe Sequel::Model, "create_with_params" do
 
   before(:each) do
@@ -310,6 +347,11 @@ describe Sequel::Model, "create_with_params" do
     MODEL_DB.sqls.first.should == "INSERT INTO items (y) VALUES (1)"
   end
   
+  it "should support virtual attributes" do
+    @c.class_def(:blah=) {|v| self.x = v}
+    o = @c.create_with(:blah => 333)
+    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (333)"
+  end
 end
 
 describe Sequel::Model, "#destroy" do

data/spec/validations_spec.rb

@@ -1,295 +1,5 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
-describe "Sequel::Validatable::Errors" do
-  setup do
-    @errors = Sequel::Validatable::Errors.new
-    class Sequel::Validatable::Errors
-      attr_accessor :errors
-    end
-  end
-  
-  specify "should be clearable using #clear" do
-    @errors.errors = {1 => 2, 3 => 4}
-    @errors.clear
-    @errors.errors.should == {}
-  end
-  
-  specify "should be empty if no errors are added" do
-    @errors.should be_empty
-    @errors[:blah] << "blah"
-    @errors.should_not be_empty
-  end
-  
-  specify "should return errors for a specific attribute using #on or #[]" do
-    @errors[:blah].should == []
-    @errors.on(:blah).should == []
-
-    @errors[:blah] << 'blah'
-    @errors[:blah].should == ['blah']
-    @errors.on(:blah).should == ['blah']
-
-    @errors[:bleu].should == []
-    @errors.on(:bleu).should == []
-  end
-  
-  specify "should accept errors using #[] << or #add" do
-    @errors[:blah] << 'blah'
-    @errors[:blah].should == ['blah']
-    
-    @errors.add :blah, 'zzzz'
-    @errors[:blah].should == ['blah', 'zzzz']
-  end
-  
-  specify "should return full messages using #full_messages" do
-    @errors.full_messages.should == []
-    
-    @errors[:blow] << 'blieuh'
-    @errors[:blow] << 'blich'
-    @errors[:blay] << 'bliu'
-    msgs = @errors.full_messages
-    msgs.size.should == 3
-    msgs.should include('blow blieuh', 'blow blich', 'blay bliu')
-  end
-end
-
-describe Sequel::Validatable do
-  setup do
-    @c = Class.new do
-      include Sequel::Validatable
-      
-      def self.validates_coolness_of(attr)
-        validates_each(attr) {|o, a, v| o.errors[a] << 'is not cool' if v != :cool}
-      end
-    end
-    
-    @d = Class.new do
-      attr_accessor :errors
-      def initialize; @errors = Sequel::Validatable::Errors.new; end
-    end
-  end
-  
-  specify "should respond to validates, validations, has_validations?" do
-    @c.should respond_to(:validations)
-    @c.should respond_to(:has_validations?)
-  end
-  
-  specify "should acccept validation definitions using validates_each" do
-    @c.validates_each(:xx, :yy) {|o, a, v| o.errors[a] << 'too low' if v < 50}
-    
-    @c.validations[:xx].size.should == 1
-    @c.validations[:yy].size.should == 1
-    
-    o = @d.new
-    @c.validations[:xx].first.call(o, :aa, 40)
-    @c.validations[:yy].first.call(o, :bb, 60)
-    
-    o.errors.full_messages.should == ['aa too low']
-  end
-
-  specify "should return true/false for has_validations?" do
-    @c.has_validations?.should == false
-    @c.validates_each(:xx) {1}
-    @c.has_validations?.should == true
-  end
-  
-  specify "should provide a validates method that takes block with validation definitions" do
-    @c.validates do
-      coolness_of :blah
-    end
-    @c.validations[:blah].should_not be_empty
-
-    o = @d.new
-    @c.validations[:blah].first.call(o, :ttt, 40)
-    o.errors.full_messages.should == ['ttt is not cool']
-    o.errors.clear
-    @c.validations[:blah].first.call(o, :ttt, :cool)
-    o.errors.should be_empty
-  end
-end
-
-describe "A Validatable instance" do
-  setup do
-    @c = Class.new do
-      attr_accessor :score
-      
-      include Sequel::Validatable
-      
-      validates_each :score do |o, a, v|
-        o.errors[a] << 'too low' if v < 87
-      end
-    end
-    
-    @o = @c.new
-  end
-  
-  specify "should supply a #valid? method that returns true if validations pass" do
-    @o.score = 50
-    @o.should_not be_valid
-    @o.score = 100
-    @o.should be_valid
-  end
-  
-  specify "should provide an errors object" do
-    @o.score = 100
-    @o.should be_valid
-    @o.errors.should be_empty
-    
-    @o.score = 86
-    @o.should_not be_valid
-    @o.errors[:score].should == ['too low']
-    @o.errors[:blah].should be_empty
-  end
-end
-
-describe Sequel::Validatable::Generator do
-  setup do
-    $testit = nil
-    
-    @c = Class.new do
-      include Sequel::Validatable
-      
-      def self.validates_blah
-        $testit = 1324
-      end
-    end
-  end
-  
-  specify "should instance_eval the block, sending everything to its receiver" do
-    Sequel::Validatable::Generator.new(@c) do
-      blah
-    end
-    $testit.should == 1324
-  end
-end
-
-describe "Sequel validations" do
-  setup do
-    @c = Class.new do
-      attr_accessor :value
-      include Sequel::Validatable
-    end
-    @m = @c.new
-  end
-
-  specify "should validate acceptance_of" do
-    @c.validates_acceptance_of :value
-    @m.should be_valid
-    @m.value = '1'
-    @m.should be_valid
-  end
-  
-  specify "should validate acceptance_of with accept" do
-    @c.validates_acceptance_of :value, :accept => 'true'
-    @m.value = '1'
-    @m.should_not be_valid
-    @m.value = 'true'
-    @m.should be_valid
-  end
-  
-  specify "should validate acceptance_of with allow_nil => false" do
-    @c.validates_acceptance_of :value, :allow_nil => false
-    @m.should_not be_valid
-  end
-
-  specify "should validate confirmation_of" do
-    @c.send(:attr_accessor, :value_confirmation)
-    @c.validates_confirmation_of :value
-    
-    @m.value = 'blah'
-    @m.should_not be_valid
-    
-    @m.value_confirmation = 'blah'
-    @m.should be_valid
-  end
-
-  specify "should validate format_of" do
-    @c.validates_format_of :value, :with => /.+_.+/
-    @m.value = 'abc_'
-    @m.should_not be_valid
-    @m.value = 'abc_def'
-    @m.should be_valid
-  end
-  
-  specify "should raise for validate_format_of without regexp" do
-    proc {@c.validates_format_of :value}.should raise_error(Sequel::Error)
-    proc {@c.validates_format_of :value, :with => :blah}.should raise_error(Sequel::Error)
-  end
-  
-  specify "should validate length_of with maximum" do
-    @c.validates_length_of :value, :maximum => 5
-    @m.should_not be_valid
-    @m.value = '12345'
-    @m.should be_valid
-    @m.value = '123456'
-    @m.should_not be_valid
-  end
-
-  specify "should validate length_of with minimum" do
-    @c.validates_length_of :value, :minimum => 5
-    @m.should_not be_valid
-    @m.value = '12345'
-    @m.should be_valid
-    @m.value = '1234'
-    @m.should_not be_valid
-  end
-
-  specify "should validate length_of with within" do
-    @c.validates_length_of :value, :within => 2..5
-    @m.should_not be_valid
-    @m.value = '12345'
-    @m.should be_valid
-    @m.value = '1'
-    @m.should_not be_valid
-    @m.value = '123456'
-    @m.should_not be_valid
-  end
-
-  specify "should validate length_of with is" do
-    @c.validates_length_of :value, :is => 3
-    @m.should_not be_valid
-    @m.value = '123'
-    @m.should be_valid
-    @m.value = '12'
-    @m.should_not be_valid
-    @m.value = '1234'
-    @m.should_not be_valid
-  end
-  
-  specify "should validate length_of with allow_nil" do
-    @c.validates_length_of :value, :is => 3, :allow_nil => true
-    @m.should be_valid
-  end
-
-  specify "should validate numericality_of" do
-    @c.validates_numericality_of :value
-    @m.value = 'blah'
-    @m.should_not be_valid
-    @m.value = '123'
-    @m.should be_valid
-    @m.value = '123.1231'
-    @m.should be_valid
-  end
-
-  specify "should validate numericality_of with only_integer" do
-    @c.validates_numericality_of :value, :only_integer => true
-    @m.value = 'blah'
-    @m.should_not be_valid
-    @m.value = '123'
-    @m.should be_valid
-    @m.value = '123.1231'
-    @m.should_not be_valid
-  end
-  
-  specify "should validate presence_of" do
-    @c.validates_presence_of :value
-    @m.should_not be_valid
-    @m.value = ''
-    @m.should_not be_valid
-    @m.value = 1234
-    @m.should be_valid
-  end
-end
-
 describe Sequel::Model, "Validations" do
 
   before(:all) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_model
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,9 +9,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-21 00:00:00 +02:00
+date: 2008-01-24 00:00:00 +02:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: assistance
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.2
+    version: 
 - !ruby/object:Gem::Dependency 
   name: sequel_core
   version_requirement: 
@@ -19,7 +28,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0.5"
+        version: "1.0"
     version: 
 description: Lightweight ORM for Ruby
 email: ciconia@gmail.com