dm-validations 0.9.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Guy van den Berg
+
+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 OR COPYRIGHT HOLDERS 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,72 @@
+This is a DataMapper plugin that provides validations for DataMapper model
+classes.
+
+== Setup
+DataMapper validation capabilities are automatically available when you
+'require dm-validations' into your application.
+
+More specifically, DataMapper::Validate is automatically included into
+DataMapper::Resource when you require dm-validations.
+
+== Specifying Model Validations
+There are two primary ways to implement validations for your models:
+
+1) Placing validation methods with properties as params in your class
+   definitions like:
+   - validates_length :name
+   - validates_length [:name, :description]
+
+2) Using auto-validations, please see DataMapper::Validate::AutoValidate
+
+An example class with validations declared:
+
+  require 'dm-validations'
+
+  class Account
+    include DataMapper::Resource
+
+    property :name, String
+    validates_length :name
+  end
+
+See all of the DataMapper::Validate module's XYZValidator(s) to learn about the
+complete collections of validators available to you.
+
+== Validating
+DataMapper validations, when included, alter the default save/create/update
+process for a model.  Unless you specify a context the resource must be
+valid in the :default context before saving.
+
+You may manually validate a resource using the valid? method, which will
+return true if the resource is valid, and false if it is invalid.
+
+In addition to the valid? method, there is also an all_valid? method that
+recursively walks both the current object and its associated objects and returns
+its true/false result for the entire walk.
+
+== Working with Validation Errors
+If your validators find errors in your model, they will populate the
+DataMapper::Validate::ValidationErrors object that is available through each of
+your models via calls to your model's errors method.
+
+For example:
+
+  my_account = Account.new(:name => "Jose")
+  if my_account.save
+    # my_account is valid and has been saved
+  else
+    my_account.errors.each do |e|
+      puts e
+    end
+  end
+
+See DataMapper::Validate::ValidationErrors for all you can do with your model's
+errors method.
+
+== Contextual Validations
+
+DataMapper Validations also provide a means of grouping your validations into
+contexts. This enables you to run different sets of validations under ...
+different contexts.
+
+TO BE ADDED... For now, see

data/Rakefile

@@ -0,0 +1,74 @@
+require 'rubygems'
+require 'spec'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+require 'pathname'
+
+CLEAN.include '{log,pkg}/'
+
+desc "Generate Documentation"
+rd = Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "DataMapper Validations"
+  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  rdoc.rdoc_files.include(FileList[ 'lib/**/*.rb', 'README', 'LICENSE'])
+end
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'dm-validations'
+  s.version          = '0.9.2'
+  s.platform         = Gem::Platform::RUBY
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w[ README LICENSE TODO ]
+  s.summary          = 'DataMapper plugin for performing validations on data models'
+  s.description      = s.summary
+  s.author           = 'Guy van den Berg'
+  s.email            = 'vandenberg.guy@gmail.com'
+  s.homepage         = 'http://github.com/sam/dm-more/tree/master/dm-validations'
+  s.require_path     = 'lib'
+  s.files            = FileList[ '{lib,spec}/**/*.rb', 'spec/spec.opts', 'Rakefile', *s.extra_rdoc_files ]
+  s.add_dependency('dm-core', "=#{s.version}")
+end
+
+task :default => [ :spec ]
+
+WIN32 = (RUBY_PLATFORM =~ /win32|mingw|cygwin/) rescue nil
+SUDO  = WIN32 ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Install #{spec.name} #{spec.version} (default ruby)"
+task :install => [ :package ] do
+  sh "#{SUDO} gem install --local pkg/#{spec.name}-#{spec.version} --no-update-sources", :verbose => false
+end
+
+desc "Uninstall #{spec.name} #{spec.version} (default ruby)"
+task :uninstall => [ :clobber ] do
+  sh "#{SUDO} gem uninstall #{spec.name} -v#{spec.version} -I -x", :verbose => false
+end
+
+namespace :jruby do
+  desc "Install #{spec.name} #{spec.version} with JRuby"
+  task :install => [ :package ] do
+    sh %{#{SUDO} jruby -S gem install --local pkg/#{spec.name}-#{spec.version} --no-update-sources}, :verbose => false
+  end
+end
+
+desc 'Run specifications'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.spec_files = Pathname.glob(Pathname.new(__FILE__).dirname + 'spec/**/*_spec.rb')
+
+  begin
+    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+    t.rcov_opts << '--exclude' << 'spec'
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  rescue Exception
+    # rcov not installed
+  end
+end

data/TODO

@@ -0,0 +1,16 @@
+ Short TODO list
+ ===============
+
+ * Add logic_validator -- validates(“You need more money!”) { |instance| instance.money < 1_000_000 }
+ * Allow for the translation of strings in messages
+ * Add the canned RFC2822 email format to format_validator
+ * Add a validates_acceptance_of validator
+ * Add a validates_each validator
+ * Add a validates_true validator
+
+ * Validators do not accept associations except validates_uniqueness_of - fix this
+ * Add auto validation on cardinality of associations
+
+ ---
+ TODO tickets may also be found in the DataMapper Issue Tracker:
+ http://wm.lighthouseapp.com/projects/4819-datamapper/overview

data/lib/dm-validations.rb

@@ -0,0 +1,208 @@
+require 'rubygems'
+require 'pathname'
+
+gem 'dm-core', '=0.9.2'
+require 'dm-core'
+
+dir = Pathname(__FILE__).dirname.expand_path / 'dm-validations'
+
+require dir / 'validation_errors'
+require dir / 'contextual_validators'
+require dir / 'auto_validate'
+
+require dir / 'generic_validator'
+require dir / 'required_field_validator'
+require dir / 'primitive_validator'
+require dir / 'absent_field_validator'
+require dir / 'confirmation_validator'
+require dir / 'format_validator'
+require dir / 'length_validator'
+require dir / 'within_validator'
+require dir / 'numeric_validator'
+require dir / 'method_validator'
+require dir / 'uniqueness_validator'
+require dir / 'acceptance_validator'
+require dir / 'custom_validator'
+
+require dir / 'support' / 'object'
+
+module DataMapper
+  module Validate
+
+    def self.included(model)
+      if model.method_defined?(:save) && !model.method_defined?(:save!)
+        model.send(:alias_method, :save!, :save)
+        model.send(:alias_method, :save,  :save_with_validations)
+      end
+    end
+
+    # Validate the resource before saving. Use #save! to save
+    # the record without validations.
+    #
+    def save_with_validations(context = :default)
+      return false unless valid?(context)
+      save!
+    end
+
+    # Return the ValidationErrors
+    #
+    def errors
+      @errors ||= ValidationErrors.new
+    end
+
+    # Mark this resource as validatable. When we validate associations of a
+    # resource we can check if they respond to validatable? before trying to
+    # recursivly validate them
+    #
+    def validatable?()
+      true
+    end
+
+    # Alias for valid?(:default)
+    #
+    def valid_for_default?
+      valid?(:default)
+    end
+
+    # Check if a resource is valid in a given context
+    #
+    def valid?(context = :default)
+      self.class.validators.execute(context,self)
+    end
+
+    # Begin a recursive walk of the model checking validity
+    #
+    def all_valid?(context = :default)
+      recursive_valid?(self,context,true)
+    end
+
+    # Do recursive validity checking
+    #
+    def recursive_valid?(target, context, state)
+      valid = state
+      target.instance_variables.each do |ivar|
+        ivar_value = target.instance_variable_get(ivar)
+        if ivar_value.validatable?
+          valid = valid && recursive_valid?(ivar_value,context,valid)
+        elsif ivar_value.respond_to?(:each)
+          ivar_value.each do |item|
+            if item.validatable?
+              valid = valid && recursive_valid?(item,context,valid)
+            end
+          end
+        end
+      end
+      return valid && target.valid?
+    end
+
+
+    def validation_property_value(name)
+      return self.instance_variable_get("@#{name}") if self.instance_variables.include?(name)
+      return self.send(name) if self.respond_to?(name)
+      nil
+    end
+
+    # Get the corresponding Resource property, if it exists.
+    #
+    # Note: DataMapper validations can be used on non-DataMapper resources.
+    # In such cases, the return value will be nil.
+    def validation_property(field_name)
+      if DataMapper::Resource > self.class
+        self.class.properties(self.repository.name)[field_name]
+      end
+    end
+
+    def validation_association_keys(name)
+      if self.class.relationships.has_key?(name)
+        result = []
+        relation = self.class.relationships[name]
+        relation.child_key.each do |key|
+          result << key.name
+        end
+        return result
+      end
+      nil
+    end
+
+    module ClassMethods
+      include DataMapper::Validate::ValidatesPresent
+      include DataMapper::Validate::ValidatesAbsent
+      include DataMapper::Validate::ValidatesIsConfirmed
+      include DataMapper::Validate::ValidatesIsPrimitive
+      include DataMapper::Validate::ValidatesIsAccepted
+      include DataMapper::Validate::ValidatesFormat
+      include DataMapper::Validate::ValidatesLength
+      include DataMapper::Validate::ValidatesWithin
+      include DataMapper::Validate::ValidatesIsNumber
+      include DataMapper::Validate::ValidatesWithMethod
+      include DataMapper::Validate::ValidatesIsUnique
+      include DataMapper::Validate::AutoValidate
+
+      # Return the set of contextual validators or create a new one
+      #
+      def validators
+        @validations ||= ContextualValidators.new
+      end
+
+      # Clean up the argument list and return a opts hash, including the
+      # merging of any default opts. Set the context to default if none is
+      # provided. Also allow :context to be aliased to :on, :when & group
+      #
+      def opts_from_validator_args(args, defaults = nil)
+        opts = args.last.kind_of?(Hash) ? args.pop : {}
+        context = :default
+        context = opts[:context] if opts.has_key?(:context)
+        context = opts.delete(:on) if opts.has_key?(:on)
+        context = opts.delete(:when) if opts.has_key?(:when)
+        context = opts.delete(:group) if opts.has_key?(:group)
+        opts[:context] = context
+        opts.mergs!(defaults) unless defaults.nil?
+        opts
+      end
+
+      # Given a new context create an instance method of
+      # valid_for_<context>? which simply calls valid?(context)
+      # if it does not already exist
+      #
+      def create_context_instance_methods(context)
+        name = "valid_for_#{context.to_s}?"
+        if !self.instance_methods.include?(name)
+          class_eval <<-EOS
+            def #{name}
+              valid?('#{context.to_s}'.to_sym)
+            end
+          EOS
+        end
+
+        all = "all_valid_for_#{context.to_s}?"
+        if !self.instance_methods.include?(all)
+          class_eval <<-EOS
+            def #{all}
+              all_valid?('#{context.to_s}'.to_sym)
+            end
+          EOS
+        end
+      end
+
+      # Create a new validator of the given klazz and push it onto the
+      # requested context for each of the attributes in the fields list
+      #
+      def add_validator_to_context(opts, fields, klazz)
+        fields.each do |field|
+          if opts[:context].is_a?(Symbol)
+            validators.context(opts[:context]) << klazz.new(field, opts)
+            create_context_instance_methods(opts[:context])
+          elsif opts[:context].is_a?(Array)
+            opts[:context].each do |c|
+              validators.context(c) << klazz.new(field, opts)
+              create_context_instance_methods(c)
+            end
+          end
+        end
+      end
+    end # module ClassMethods
+  end # module Validate
+
+  Resource.append_inclusions Validate
+  Model.append_extensions Validate::ClassMethods
+end # module DataMapper

data/lib/dm-validations/absent_field_validator.rb

@@ -0,0 +1,60 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class AbsentFieldValidator < GenericValidator
+
+      def initialize(field_name, options={})
+        super
+        @field_name, @options = field_name, options
+      end
+
+      def call(target)
+        field_value = target.send(field_name).blank?
+        return true if field_value
+
+        error_message = @options[:message] || "%s must be absent".t(Extlib::Inflection.humanize(@field_name))
+        add_error(target, error_message , @field_name)
+
+        return false
+      end
+    end # class AbsentFieldValidator
+
+    module ValidatesAbsent
+
+      ##
+      # Validates that the specified attribute is "blank" via the attribute's
+      # #blank? method.
+      #
+      # @note
+      #   dm-core's support lib adds the #blank? method to many classes,
+      # @see lib/dm-core/support/blank.rb (dm-core) for more information.
+      #
+      # @example [Usage]
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :unwanted_attribute, String
+      #     property :another_unwanted, String
+      #     property :yet_again, String
+      #
+      #     validates_absent :unwanted_attribute
+      #     validates_absent :another_unwanted, :yet_again
+      #
+      #     # a call to valid? will return false unless
+      #     # all three attributes are blank
+      #   end
+      #
+      def validates_absent(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::AbsentFieldValidator)
+      end
+
+    end # module ValidatesAbsent
+  end # module Validate
+end # module DataMapper