not_naughty 0.3

data/CHANGELOG

@@ -0,0 +1,22 @@
+=== 0.3 (2008-02-09)
+
+* renamed to NotNaughty - The Validation Framework
+* made predefined Validation optional, you can load them with:
+
+   ::NotNaughty::Validation.load '*'
+
+  or ordered (should be preferred):
+
+   ::NotNaughty::Validation.load :acceptance, :confirmation, :format, :length,
+     :numericality, :presence
+
+* specs pass, 100% code coverage, 2 not complete, so pending specs
+* docs added
+
+=== 0.2 (2008-02-09)
+
+* complete rewrite
+
+=== 0.1 (2008-02-06)
+
+* initial release

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2007-2008 Florian Aßmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,62 @@
+= NotNaughty - The Validation Framework
+
+<b>Features:</b>
+* API compatible to Sequel as plugin (see Sequel::Plugins::NotNaughty for
+  details):
+
+   class User < Sequel::Model
+     is :not_naughty
+     validates { presence_of :username and length_of :username, :within => 4..16 }
+     has_validations? # => true
+     
+     # ...
+   end
+
+* Syntactical Sugar with Builder methods:
+
+   validates(:username, :password) {length :minimum => 6}
+   validates(:password) {confirmed and complexity :level => :high}
+   validates(:if => :necessary?) {bunchyness_of :crap}
+
+* Beautiful error messages:
+
+   validates_presence_of :person,
+     :message => '#{"%s".humanize} is gone missing.'
+
+* Conditional Validations:
+
+   validates(:if => :necessary?) {...}
+   validates(:unless => proc {|obj| obj.vip?}) {...}
+
+* Easy to adapt and to extent:
+
+  _adapt_
+   require 'rubygems'
+   require 'not_naughty'
+   Person = Struct.new(:name) do
+     extend NotNaughty
+     validates(:name) { presence and length :minimum => 4 }
+     validated_before :clone
+     validated_before :dup, :without => :exception
+   end
+   Person.new('Horst').valid? # => true
+   Person.new('Foo').valid? # => false
+   Person.new('Foo').clone # goes *boom* with NotNaughty::ValidationException
+   Person.new('Foo').dup # => false
+
+  _extend_
+   class BunchynessValidation < NotNaughty::Validation
+     def initialize(opts, attributes)
+       __message = opts[:message] || '#{"%s".humanize} is not bunchy.'
+       super opts, attributes do |o, a, v|
+         o.errors.add(a, __message) unless v.respond_to? :to_bunchy
+       end
+     end
+   end
+   
+   Thingy = Struct.new(:bunchy_item) do
+     extend NotNaughty
+     validates_bunchyness_of :bunchy_item
+   end
+
+:include: COPYING

data/Rakefile

@@ -0,0 +1,130 @@
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "fileutils"
+include FileUtils
+
+##############################################################################
+# Configuration
+##############################################################################
+NAME = "not_naughty"
+VERS = "0.3"
+CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
+RDOC_OPTS = [
+  "--quiet", 
+  "--title", "NotNaughty: The Validation Framework",
+  "--opname", "index.html",
+  "--inline-source",
+  "--line-numbers", 
+  "--main", "README",
+  "--inline-source",
+  "--charset", "utf-8"
+]
+
+##############################################################################
+# RDoc
+##############################################################################
+task :doc => [:rdoc]
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "doc/rdoc"
+  rdoc.options += RDOC_OPTS
+  rdoc.main = "README"
+  rdoc.title = "NotNaughty: The Validation Framework"
+  rdoc.rdoc_files.add %w[README COPYING lib/**/*.rb]
+end
+
+task :doc_rforge => [:doc]
+
+desc "Update docs and upload to rubyforge.org"
+task :doc_rforge do
+  # sh %{scp -r doc/rdoc/* boof@rubyforge.org:/var/www/gforge-projects/not-naughty}
+end
+
+##############################################################################
+# specs
+##############################################################################
+require "spec/rake/spectask"
+
+desc "Run specs with coverage"
+Spec::Rake::SpecTask.new("spec") do |t|
+  t.spec_files = FileList["spec/**/*_spec.rb"]
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
+  t.rcov_opts  = File.read("spec/rcov.opts").split("\n")
+  t.rcov = true
+end
+
+desc "Run specs without coverage"
+Spec::Rake::SpecTask.new("spec_no_cov") do |t|
+  t.spec_files = FileList["spec/**/*_spec.rb"]
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
+end
+
+desc "check documentation coverage"
+task :dcov do
+  sh "find lib -name '*.rb' | xargs dcov"
+end
+
+##############################################################################
+# Gem packaging
+##############################################################################
+desc "Packages up NotNaughty."
+task :default => [:package]
+task :package => [:clean]
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.rubyforge_project = NAME
+  s.version = VERS
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
+  s.summary = "Heavily armed validation framework."
+  s.description = s.summary
+  s.author = "Florian Aßmann"
+  s.email = "florian.assmann@oniversus.de"
+  s.homepage = "http://not-naughty.rubyforge.org"
+  s.required_ruby_version = ">= 1.8.4"
+
+  s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*")
+
+  s.require_path = "lib"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true
+  p.gem_spec = spec
+end
+
+##############################################################################
+# installation & removal
+##############################################################################
+task :install do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERS}}
+end
+
+task :install_no_docs do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERS} --no-rdoc --no-ri}
+end
+
+task :uninstall => [:clean] do
+  sh %{sudo gem uninstall #{NAME}}
+end
+
+task :tag do
+  cwd = FileUtils.pwd
+  sh %{cd .. && svn copy #{cwd} tags/#{NAME}-#{VERS} && svn commit -m "#{NAME}-#{VERS} tag." tags}
+end
+
+##############################################################################
+# gem and rdoc release
+##############################################################################
+task :release => [:package] do
+  sh %{rubyforge login}
+  sh %{rubyforge add_release #{NAME} #{NAME} #{VERS} pkg/#{NAME}-#{VERS}.tgz}
+  sh %{rubyforge add_file #{NAME} #{NAME} #{VERS} pkg/#{NAME}-#{VERS}.gem}
+end
+

data/lib/not_naughty/builder.rb

@@ -0,0 +1,68 @@
+module NotNaughty
+  
+  # == Builder that builds
+  #
+  # With this you get syntactical sugar for all descendants of Validation, see
+  # validates for examples.
+  module Builder
+    
+    # Observer method that creates Validation builder methods.
+    #
+    # A Validation with the class name TestValidation will get the
+    # builder method <tt>validate_test_of</tt> that adds a validation via
+    # add_validation in the current <tt>validator</tt>.
+    def self.update(validation)
+      if basename = validation.name[/([^:]+)Validation$/, 1]
+        define_method 'validates_%s_of' % basename.downcase do |*params|
+          validator.add_validation(validation, *params)
+        end
+      end
+    end
+    
+    # == Syntactic sugar.
+    #
+    # <b>Example:</b>
+    #   validates { presence_of :example, :if => :reading? }
+    #     # => validate_presence_of :example, :if => :reading?
+    #   validates(:name) { presence and length :minimum => 6 }
+    #     # => validates_presence_of :name
+    #          validates_length_of :name, :minimum => 6
+    #   validates(:temp, :if => water?) { value :lt => 100 }
+    #     # => validates_value_of :temp, :lt => 100, :if => water?
+    def validates(*params, &block)
+      ValidationDelegator.new(self, *params).instance_eval(&block)
+    end
+    
+    # Allows adding validations the legacy way.
+    def validates_each(*attributes, &block)
+      validator.add_validation(*attributes, &block)
+    end
+    
+    class ValidationDelegator < SimpleDelegator #:nodoc:all
+      def initialize(receiver, *params)
+        @_sd_obj_opts   = params.extract_options!
+        @_sd_obj_params = params
+        
+        super receiver
+      end
+      def method_missing(method_sym, *params) #:nodoc:
+        method_sym, params = if @_sd_obj_params.any?
+          opts = @_sd_obj_opts.update params.extract_options!
+          [:"validates_#{method_sym}_of", @_sd_obj_params + [opts]]
+        else
+          opts = @_sd_obj_opts.update params.extract_options!
+          [:"validates_#{method_sym}", params + [opts]]
+        end
+        
+        if @_sd_obj.respond_to? method_sym
+          @_sd_obj.send!(method_sym, *params)
+          return true
+        else
+          raise NoMethodError,
+            "unable to evaluate ´#{method_sym}(*#{params.inspect})'"
+        end
+      end
+    end
+    
+  end
+end

data/lib/not_naughty/errors.rb

@@ -0,0 +1,61 @@
+module NotNaughty
+  
+  # == Container for failed validations.
+  #
+  # ...
+  class Errors
+    extend Forwardable
+    
+    def_delegators :@errors, :empty?, :clear, :[], :each, :to_yaml
+    
+    include Enumerable
+    
+    def initialize() #:nodoc:
+      @errors = Hash.new {|h, k| h[k] = []}
+    end
+    # Adds an error for the given attribute.
+    def add(k, msg)  @errors[k] << msg end
+    
+    # Returns an array of fully-formatted error messages.
+    def full_messages
+      @errors.inject([]) do |messages, k_errors| k, errors = *k_errors
+        errors.each {|e| messages << eval(e.inspect.delete('\\') % k) }
+        messages
+      end
+    end
+    
+    # Returns an array of evaluated error messages for given attribute.
+    def on(attribute)
+      @errors[attribute].map do |message|
+        eval(message.inspect.delete('\\') % attribute)
+      end
+    end
+    
+    # Returns a ValidationException with <tt>self</tt> in <tt>:errors</tt>.
+    def to_exception
+      ValidationException.new self
+    end
+  end
+  
+  # == Exception class for NotNaughty
+  #
+  # Includes the instance of Errors that caused the Exception.
+  class ValidationException < RuntimeError
+    extend Forwardable
+    
+    attr_reader :errors
+    def_delegators :@errors, :on, :full_messages, :each
+    
+    # Returns instance of ValidationError with errors set
+    def initialize(errors)
+      @errors = errors
+
+      if errors.any?
+        super 'validation errors'
+      else
+        super 'no validation errors'
+      end
+    end
+  end
+
+end

data/lib/not_naughty/instance_methods.rb

@@ -0,0 +1,20 @@
+module NotNaughty
+  module InstanceMethods
+    
+    # Returns instance of Errors.
+    def errors() @errors ||= ::NotNaughty::Errors.new end
+    
+    # Returns true if all validations passed
+    def valid?
+      validate
+      errors.empty?
+    end
+    
+    # Clears errors and validates.
+    def validate
+      errors.clear
+      self.class.validator.invoke self
+    end
+    
+  end
+end

data/lib/not_naughty/validation.rb

@@ -0,0 +1,126 @@
+module NotNaughty
+  
+  # == The superclass for Validations.
+  #
+  # See new for more information.
+  class Validation
+    
+    BASEDIR = File.dirname __FILE__
+    # Loader pattern
+    PATTERN = File.join BASEDIR, %w[validations %s_validation.rb]
+    
+    # Loads validations.
+    def self.load(*validations)
+      validations.each do |validation|
+        Dir.glob(PATTERN % validation).each { |path| require path }
+      end
+    end
+    
+    extend Observable
+    def self.inherited(descendant) #:nodoc:
+      changed and notify_observers(descendant)
+
+      descendant.
+      instance_variable_set :@observer_peers, @observer_peers.clone
+    end
+    
+    # Builds validations.
+    #
+    # <b>Example:</b>
+    #   NotNaughty::Validation.new :temp, :if => :water? do |obj, attr, val|
+    #     obj.errors.add attr, 'too hot' unless val < 100
+    #   end
+    #
+    # <b>Like:</b>
+    #   class TempValidation < NotNaughty::Validation
+    #     def initialize(opts, attributes)
+    #       super opts, attributes method(:temp_validation)
+    #     end
+    #     def temp_validation(obj, attr, val)
+    #       obj.errors.add attr, 'too hot' unless val < 100
+    #     end
+    #   end
+    #
+    #   Validation.new TempValidation, :temp, :if => :water?
+    #
+    # The last one also notifies all Observers of Validation (see
+    # Builder#update). If Builder#update is called because <Name>Validation
+    # is inherited from Validation the ValidationBuilder gets the method
+    # validates_<name>_of and so does the classes that included the Builder.
+    def self.new(*params, &block)
+      attributes = if params.first.is_a? Class and params.first < self
+        klass = params.shift
+        klass.new(*params, &block)
+      else
+        options = params.extract_options!
+        instance = allocate
+        instance.send! :initialize, options, params.map {|p|p.to_sym}, &block
+        instance
+      end
+    end
+    
+    attr_reader :attributes
+    
+    def initialize(opts, attributes, &block) #:nodoc:
+      build_conditions opts[:if], opts[:unless]
+      @attributes, @block, @opts = attributes, block, opts
+    end
+    
+    def call_without_conditions(obj, attr, value) #:nodoc:
+      @block.call obj, attr, value
+    end
+    alias_method :call, :call_without_conditions
+    
+    def call_with_conditions(obj, attr, value) #:nodoc:
+      if @conditions.all? { |c| c.evaluate obj }
+        call_without_conditions obj, attr, value
+      end
+    end
+    
+    protected
+    def build_conditions(p, n) #:nodoc:
+      @conditions = []
+      [p].flatten.each {|c| @conditions << Condition.new(c) if c }
+      [n].flatten.each {|c| @conditions << Condition.new(c, false) if c }
+      
+      (class << self; self; end).module_eval do
+        alias_method :call, :call_with_conditions
+      end if @conditions.any?
+    end
+    
+    # Conditions for use in Validations are usually used with Validations.
+    class Condition
+
+      # An instance of Condition accepts Symbols, UnboundMethods or anything
+      # that responds to :call.
+      #
+      # The following examples are similiar to each other:
+      #
+      #   NotNaughty::Validation::Condition.new proc {|o| o.nil?}
+      #   NotNaughty::Validation::Condition.new :nil?
+      #   NotNaughty::Validation::Condition.new Object.instance_method(:nil?)
+      def self.new(condition, positive = true)
+        instance = allocate
+        instance.instance_variable_set :@condition, condition
+
+        block = case condition
+        when Symbol then positive ?
+          proc { |o| o.send! @condition } :
+          proc { |o| not o.send! @condition }
+        when UnboundMethod then positive ?
+          proc { |o| @condition.bind(o).call } :
+          proc { |o| not @condition.bind(o).call }
+        else positive ?
+          proc { |o| @condition.call o } :
+          proc { |o| not @condition.call o }
+        end
+        
+        (class << instance; self; end).
+        module_eval { define_method(:evaluate, &block) }
+        
+        instance
+      end
+
+    end
+  end
+end

data/lib/not_naughty/validations/acceptance_validation.rb

@@ -0,0 +1,39 @@
+module NotNaughty
+  
+  # == Validates acceptance of obj's attribute against a fixed value.
+  #
+  # Unless the validation succeeds an error hash (:attribute => :message)
+  # is added to the obj's instance of Errors.
+  #
+  # <b>Options:</b>
+  # <tt>:accept</tt>::   object that that'll check via a <tt>:match</tt> call
+  # <tt>:message</tt>:: see NotNaughty::Errors for details
+  # <tt>:if</tt>::      see NotNaughty::Validation::Condition for details
+  # <tt>:unless</tt>::  see NotNaughty::Validation::Condition for details
+  #
+  # <b>Example:</b>
+  #
+  #   obj = 'abc'
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  class AcceptanceValidation < Validation
+    
+    def initialize(opts, attributes)
+      __message, __accept =
+        opts[:message] || '#{"%s".humanize} not accepted.',
+        opts[:accept] || '1'
+      
+      if opts[:allow_blank] or opts.fetch(:allow_nil, true)
+        __allow = if opts[:allow_blank] then :blank? else :nil? end
+        super opts, attributes do |o, a, v|
+          o.errors.add a, __message unless v.send! __allow or __accept.eql? v
+        end
+      else
+        super opts, attributes do |o, a, v|
+          o.errors.add a, __message unless __accept.eql? v
+        end
+      end
+    end
+    
+  end
+end

data/lib/not_naughty/validations/confirmation_validation.rb

@@ -0,0 +1,41 @@
+module NotNaughty
+  
+  # == Validates confirmaton of obj's attribute via <tt>:eql?</tt> method against the _appropiate_ confirmation attribute.
+  #
+  # Unless the validation succeeds an error hash (:attribute => :message)
+  # is added to the obj's instance of Errors.
+  #
+  # <b>Options:</b>
+  # <tt>:message</tt>:: see NotNaughty::Errors for details
+  # <tt>:if</tt>::      see NotNaughty::Validation::Condition for details
+  # <tt>:unless</tt>::  see NotNaughty::Validation::Condition for details
+  #
+  # <b>Example:</b>
+  #
+  #   obj = 'abc'
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #   def obj.to_s_confirmation() '123 end
+  #
+  #   ConfirmationValidation.new({}, :to_s).call obj, :to_s, 'abc'
+  #   obj.errors.on(:to_s).any? # => true
+  class ConfirmationValidation < Validation
+    
+    def initialize(opts, attributes) #:nodoc:
+      __message = opts[:message] || '#{"%s".humanize} could not be confirmed.'  
+
+      if opts[:allow_blank] or opts[:allow_nil]
+        __allow = if opts[:allow_blank] then :blank? else :nil? end
+        super opts, attributes do |o, a, v|
+          o.errors.add a, __message unless
+          v.send! __allow or o.send!(:"#{a}_confirmation").eql? v
+        end
+      else
+        super opts, attributes do |o, a, v|
+          o.errors.add a, __message unless
+          o.send!(:"#{a}_confirmation").eql? v
+        end
+      end
+    end
+    
+  end
+end

data/lib/not_naughty/validations/format_validation.rb

@@ -0,0 +1,45 @@
+module NotNaughty
+  
+  # == Validates format of obj's attribute via the <tt>:match</tt> method.
+  #
+  # Unless the validation succeeds an error hash (:attribute => :message)
+  # is added to the obj's instance of Errors.
+  #
+  # <b>Options:</b>
+  # <tt>:with</tt>::   object that that'll check via a <tt>:match</tt> call
+  # <tt>:message</tt>:: see NotNaughty::Errors for details
+  # <tt>:if</tt>::      see NotNaughty::Validation::Condition for details
+  # <tt>:unless</tt>::  see NotNaughty::Validation::Condition for details
+  #
+  # <b>Example:</b>
+  #
+  #   obj = 'abc'
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  #   FormatValidation.new({:with => /[a-z]/}, :to_s).call obj, :to_s, 'abc'
+  #   obj.errors.on(:to_s).any? # => false
+  #
+  #   FormatValidation.new({:with => /[A-Z]/}, :to_s).call obj, :to_s, 'abc'
+  #   obj.errors.on(:to_s) # => ["Format of to_s does not match."]
+  class FormatValidation < Validation
+    
+    def initialize(opts, attributes) #:nodoc:
+      (__format = opts[:with]).respond_to? :match or
+      raise ArgumentError, "#{__format.inspect} doesn't respond to :match"
+      
+      __message = opts[:message] || 'Format of %s does not match.'
+      
+      if opts[:allow_blank] or opts[:allow_nil]
+        __allow = if opts[:allow_blank] then :blank? else :nil? end
+        super opts, attributes do |o, a, v|
+          o.errors.add a, __message unless v.send! __allow or __format.match v
+        end
+      else
+        super opts, attributes do |o, a, v|
+          o.errors.add a, __message unless __format.match v
+        end
+      end
+    end
+    
+  end
+end