not-naughty 0.6.0

data/CHANGELOG.rdoc

@@ -0,0 +1,46 @@
+=== 0.6 (2008-10-08)
+* fixed Rakefile
+* removed whitespaces
+* removed Ruby-Sequel adapter (becomes an extra gem)
+* removed assistance gem dependency
+
+=== 0.5.1 (2008-03-17)
+* fixed missing dependency
+
+=== 0.5 (2008-03-17)
+* added an error handler, can now handle SQL validation errors
+* renamed Errors to Violation and merged it with ValidationException
+* changed specs for 0.4.1
+
+=== 0.4.2 (2008-03-12)
+* fixed bug that causes infinite recursion in some apps that reload classes
+
+=== 0.4.1 (2008-03-12)
+* some minor changes in validator method
+
+=== 0.4 (2008-02-18)
+* completed documentation
+* added spec for :each in Builder::ValidationDelegator
+
+=== 0.3.1 (2008-02-14)
+* fixed missing require
+
+=== 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.rdoc

@@ -0,0 +1,59 @@
+= NotNaughty - The Validation Framework
+
+NotNaughty extends your ruby Project with a highly custumizable validation API.
+
+== Features
+
+<b>Easy to adapt:</b>
+
+   require 'rubygems'
+   require 'not_naughty'
+
+   Person = Struct.new(:name) do
+     extend NotNaughty
+     validates(:name) { presence and length :minimum => 4 }
+   end
+
+   Person.new('Horst').valid? # => true
+   Person.new('Foo').valid? # => false
+
+<b>Easy to extent:</b>
+
+   class ExampleValidation < NotNaughty::Validation
+     def initialize(options, attributes)
+       msg = options[:message] || '#{"%s".humanize} is not an example.'
+
+       super options, attributes do |record, attribute, value|
+         record.errors.add(attribute, msg) unless value.is_a? Example
+       end
+     end
+   end
+
+   Person.instance_eval do
+     validates_example_of :example_attribute
+   end
+
+<b>Handle SQL error gracefully:</b>
+
+   Person.instance_eval do
+     validator.error_handler.handle(SQLError) { |err| '...' }
+   end
+
+<b>Syntactical Sugar with Builder methods:</b>
+
+   validates(:username, :password, :if => :new?) {length :minimum => 6}
+   validates(:password, :allow_blank => 1) {confirmation and complexity :high}
+
+<b>Beautiful error messages:</b>
+
+   validates_presence_of :red_shoes,
+     :message => '#{"%s".humanize} are not here.' # => Red shoes are not here.
+
+<b>Conditional Validations:</b>
+
+   validates(:if => :necessary?) {...}
+   validates(:unless => proc {|obj| obj.vip?}) { '...' }
+
+== Copying
+
+:include: COPYING

data/Rakefile

@@ -0,0 +1,126 @@
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "fileutils"
+include FileUtils
+
+##############################################################################
+# Configuration
+##############################################################################
+NAME = "not-naughty"
+VERS = "0.6.0"
+CLEAN.include %w[ pkg doc coverage ]
+RDOC_OPTS = [
+  "--quiet",
+  "--title", "NotNaughty: The Validation Framework",
+  "--opname", "index.html",
+  "--inline-source",
+  "--line-numbers",
+  "--main", "README.rdoc",
+  "--inline-source",
+  "--charset", "utf-8"
+]
+
+##############################################################################
+# RDoc
+##############################################################################
+task :doc => [:rdoc]
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "doc"
+  rdoc.options += RDOC_OPTS
+  rdoc.main = "README.rdoc"
+  rdoc.title = "NotNaughty: The Validation Framework"
+  rdoc.rdoc_files.add %w[README.rdoc COPYING CHANGELOG.rdoc 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.rdoc", "CHANGELOG.rdoc", "COPYING"]
+  s.summary = "Heavily armed validation framework."
+  s.description = s.summary
+  s.author = "Florian Aßmann"
+  s.email = "boof@monkey-patch.me"
+  s.homepage = "http://monkey-patch.me/p/notnaughty"
+  s.required_ruby_version = ">= 1.8.6"
+  s.add_dependency("rubytree", ">= 0.5.2")
+
+  s.files = %w(COPYING README.rdoc Rakefile) + Dir.glob("{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
+
+##############################################################################
+# 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/core_extensions.rb

@@ -0,0 +1,20 @@
+class Array #:nodoc:
+  instance_methods.include? 'extract_options!' or
+  define_method(:extract_options!) { Hash === last ? pop : {} }
+end
+class Object #:nodoc:
+  instance_methods.include? 'blank?' or
+  define_method(:blank?) { respond_to?(:empty?) ? empty? : !self }
+end
+class String #:nodoc:
+  instance_methods.include? 'blank?' or
+  define_method(:blank?) { self !~ /\S/ }
+end
+class Numeric #:nodoc:
+  instance_methods.include? 'blank?' or
+  define_method(:blank?) { false }
+end
+
+def nil.blank?() true end unless nil.respond_to? :blank?
+def true.blank?() false end unless true.respond_to? :blank?
+def false.blank?() true end unless false.respond_to? :blank?

data/lib/not_naughty.rb

@@ -0,0 +1,86 @@
+require 'delegate'
+require 'forwardable'
+require 'observer'
+
+require 'rubygems'
+gem 'rubytree', '>= 0.5.2'
+require 'tree'
+
+$:.unshift File.dirname(__FILE__)
+require 'core_extensions'
+
+module NotNaughty
+  require 'not_naughty/validator'
+
+  require 'not_naughty/builder'
+  require 'not_naughty/validation'
+  Validation.add_observer Builder
+
+  require 'not_naughty/violation'
+  require 'not_naughty/error_handler'
+  require 'not_naughty/instance_methods'
+
+  # Extended classes get NotNaughty::Builder and NotNaughty::InstanceMethods.
+  def self.extended(base)
+    base.instance_eval do
+      include InstanceMethods
+      extend Builder
+    end
+  end
+
+  # call-seq:
+  # validator(validator_klass = NotNaughty::Validator, *states = [:default])
+  #
+  # Returns instance of Validator. This is either the validator's clone of
+  # superclass, an instance of the the given descendant of or the
+  # <tt>NotNaughty:Validator</tt> himself.
+  #
+  # <b>Examples:</b>
+  #   validator # => Instance of NotNaughty::Validator with :default state
+  #   validator :create, :update # ~ - but with :create and :update states
+  #   validator AnotherValidator # Instance of AnotherValidator
+  #
+  #   validator AnotherValidator, :state_a, :state_b
+  #
+  # The above examples work as long validator is not already called. To reset
+  # an already assigned validator set <tt>@validator</tt> to nil.
+  def validator(*states)
+    @validator ||= if !states.empty?
+      validator_klass =
+        if states.first.is_a? Class and states.first <= NotNaughty::Validator
+          states.shift
+        else
+          NotNaughty::Validator
+        end
+
+      validator_klass.new(*states)
+
+    elsif superclass.respond_to? :validator
+      superclass.validator.clone
+
+    else
+      NotNaughty::Validator.new
+
+    end
+  end
+
+  # Prepends a call for validation before then given method. If, on call, the
+  # validation passes the method is called. Otherwise it raises an
+  # NotNaughty::ValidationException or returns false.
+  #
+  # <b>Example:</b>
+  #   validated_before :save # raise ValidationException unless valid?
+  def validated_before(method)
+    __method = :"#{method}_without_validations"
+    alias_method __method, method
+
+    define_method method do |*params|
+      begin
+        if valid? then send __method else raise errors end
+      rescue Exception => error
+        self.class.validator.error_handler.raise error
+      end
+    end
+  end
+
+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 = unless @_sd_obj_params.empty?
+          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/error_handler.rb

@@ -0,0 +1,48 @@
+module Tree #:nodoc:
+  class TreeNode #:nodoc:
+
+    def closest(obj)
+      if @name == obj then self
+      elsif @name > obj
+        closest = self
+        @children.any? { |child| node = child.closest(obj) and closest = node }
+
+        closest
+      end
+    end
+
+  end
+end
+
+module NotNaughty
+  class ErrorHandler
+
+    def initialize(handler = Kernel)
+      @handles = Tree::TreeNode.new Exception, proc { |e| handler.raise e }
+    end
+
+    # Calls closest handle with exception.
+    def raise(exception)
+      handle = @handles.closest exception.class
+      handle.content.call exception
+    end
+
+    # Inserts handle into the ordered tree.
+    def handle(exception_class, &block)
+      closest_handle = @handles.closest exception_class
+
+      if closest_handle == exception_class then closest_handle.content = block
+      else
+        new_handle = Tree::TreeNode.new exception_class, block
+
+        closest_handle.children do |child|
+          exception_class > child.name and
+          new_handle << closest_handle.remove!(child)
+        end
+
+        closest_handle << new_handle
+      end
+    end
+
+  end
+end