sequel/lib/sequel_model/inflections.rb sequel/lib/sequel_model/inflector.rb sequel/spec/inflector_spec.rb sequel_core/lib/sequel_core/connection_pool.rb sequel_core/spec/connection_pool_spec.rb @@ -2,7 +2,6 @@ require 'delegate' require 'observer' require 'rubygems' -require 'assistance' module Kernel#:nodoc:all methods.include? 'send!' or model_plugins/not_naughty/lib/not_naughty.rb @@ -1,5 +1,7 @@ === HEAD +* No longer depend on the assistance gem, merge the Inflector and Validations code (jeremyevans) + * Add Model#set_with_params, which is Model#update_with_params without the save (jeremyevans) * Fix Model#destroy so that it returns self, not the result of after_destroy (jeremyevans) sequel/CHANGELOG @@ -63,7 +63,6 @@ spec = Gem::Specification.new do |s| s.platform = Gem::Platform::RUBY end - s.add_dependency("assistance", '>= 0.1.2') s.add_dependency("sequel_core", "= #{SEQUEL_CORE_VERS}") s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*") sequel/Rakefile @@ -7,7 +7,7 @@ module Sequel end files = %w[ - base hooks record schema associations + inflector inflections base hooks record schema associations caching plugins validations eager_loading ] dir = File.join(File.dirname(__FILE__), "sequel_model") sequel/lib/sequel_model.rb @@ -1,12 +1,266 @@ -gem "assistance", ">= 0.1.2" # because we need Validations - -require "assistance" +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 -# custom model validations +# 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 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 + + # 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 - def validates_uniqueness_of(*atts) # field value uniqueness validation + # 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!) @@ -15,7 +269,6 @@ module Validation o.errors[a] << opts[:message] unless v && !v.blank? && !o.class[a => v] end end - end end sequel/lib/sequel_model/validations.rb @@ -1,5 +1,366 @@ require File.join(File.dirname(__FILE__), "spec_helper") +describe "Validation::Errors" do + setup do + @errors = Validation::Errors.new + class Validation::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 Validation do + setup do + @c = Class.new do + include Validation + + 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 = Validation::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 Validation instance" do + setup do + @c = Class.new do + attr_accessor :score + + include Validation + + 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 Validation::Generator do + setup do + $testit = nil + + @c = Class.new do + include Validation + + def self.validates_blah + $testit = 1324 + end + end + end + + specify "should instance_eval the block, sending everything to its receiver" do + Validation::Generator.new(@c) do + blah + end + $testit.should == 1324 + end +end + +describe "Validations" do + setup do + @c = Class.new do + attr_accessor :value + include Validation + 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(ArgumentError) + proc {@c.validates_format_of :value, :with => :blah}.should raise_error(ArgumentError) + 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 + +context "Superclass validations" do + setup do + @c1 = Class.new do + include Validation + attr_accessor :value + validates_length_of :value, :minimum => 5 + end + + @c2 = Class.new(@c1) do + validates_format_of :value, :with => /^[a-z]+$/ + end + end + + specify "should be checked when validating" do + o = @c2.new + o.value = 'ab' + o.valid?.should == false + o.errors.full_messages.should == [ + 'value is too short' + ] + + o.value = '12' + o.valid?.should == false + o.errors.full_messages.should == [ + 'value is too short', + 'value is invalid' + ] + + o.value = 'abcde' + o.valid?.should be_true + end + + specify "should be skipped if skip_superclass_validations is called" do + @c2.skip_superclass_validations + + o = @c2.new + o.value = 'ab' + o.valid?.should be_true + + o.value = '12' + o.valid?.should == false + o.errors.full_messages.should == [ + 'value is invalid' + ] + + o.value = 'abcde' + o.valid?.should be_true + end +end + +context ".validates with block" do + specify "should support calling .each" do + @c = Class.new do + attr_accessor :vvv + + include Validation + validates do + each :vvv do |o, a, v| + o.errors[a] << "is less than zero" if v.to_i < 0 + end + end + end + + o = @c.new + o.vvv = 1 + o.should be_valid + o.vvv = -1 + o.should_not be_valid + end +end + describe Sequel::Model, "Validations" do before(:all) do sequel/spec/validations_spec.rb @@ -1,5 +1,9 @@ === HEAD +* No longer depend on the assistance gem, merge in the ConnectionPool and .blank methods (jeremyevans) + +* No longer depend on ParseTree, RubyInline, or ruby2ruby, but you still need them if you want to use the block filters (jeremyevans) + * Fix JDBC adapter by issuing index things start at 1 (pdamer) * Fix connecting to a database via the ADO adapter (now requires options instead of URI) (timuckun, jeremyevans) (#204) sequel_core/CHANGELOG @@ -57,7 +57,6 @@ spec = Gem::Specification.new do |s| s.required_ruby_version = ">= 1.8.4" s.add_dependency("metaid") - s.add_dependency("assistance", ">= 0.1") case RUBY_PLATFORM when /java/ sequel_core/Rakefile @@ -1,12 +1,9 @@ -gem "assistance", ">= 0.1" - require "metaid" -require "assistance" require "bigdecimal" require "bigdecimal/util" files = %w[ - core_ext core_sql exceptions pretty_table + core_ext core_sql connection_pool exceptions pretty_table dataset migration schema database worker object_graph ] dir = File.join(File.dirname(__FILE__), "sequel_core") sequel_core/lib/sequel_core.rb @@ -17,9 +17,50 @@ end # Object extensions class Object + # Returns true if the object is a object of one of the classes def is_one_of?(*classes) classes.each {|c| return c if is_a?(c)} nil end + + # Objects are blank if they respond true to empty? + def blank? + nil? || (respond_to?(:empty?) && empty?) + end +end + +class Numeric + # Numerics are never blank (not even 0) + def blank? + false + end +end + +class NilClass + # nil is always blank + def blank? + true + end end +class TrueClass + # true is never blank + def blank? + false + end +end + +class FalseClass + # false is always blank + def blank? + true + end +end + +class String + BLANK_STRING_REGEXP = /\A\s*\z/ + # Strings are blank if they are empty or include only whitespace + def blank? + empty? || BLANK_STRING_REGEXP.match(self) + end +end sequel_core/lib/sequel_core/core_ext.rb c0e6084b00977156aa91a1f9383a80f326347363 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/34e109f5cb9d16e1d26bc294c299a6ffb719aa77 34e109f5cb9d16e1d26bc294c299a6ffb719aa77 2008-04-17T11:55:21-07:00 2008-04-17T11:55:21-07:00 Discontinue dependence on assitance The ConnectionPool and .blank? methods are being brought into sequel_core The Inflection (with Inflections) and Validations are being brought into sequel The Numeric time extensions (minutes, hours, days, weeks, ago, before, from_now, since) are not being brought over 1f553d8d1ed1c8aa49fb975d813cd16ff6dfe728 Jeremy Evans code@jeremyevans.net