ardm-validations 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9a6e3b907d785ecb7d7391fe2b8bca97c6e3634e
+  data.tar.gz: 16609fac5103d7fcd7bfa76d2a1fc03f57a3940d
+SHA512:
+  metadata.gz: 21b19deb551d6a604fb7cef0aea03725c92754d07a11f28c1d2d19c77869736b2a032f092745c7ef32dd2a4b0db1d8ea443eb025e80ce39e80faa86d8d539ec9
+  data.tar.gz: 6e24b74280d713ec077723b54dc30b775f3932495e186008266e2c2f73bd7dc7d630bc45b7dd9dc9ca135b00b83312993ff1b25706ad43e3c96f53b068f92795

data/.gitignore

@@ -0,0 +1,35 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## Rubinius
+*.rbc
+
+## PROJECT::GENERAL
+*.gem
+coverage
+rdoc
+pkg
+tmp
+doc
+log
+.yardoc
+measurements
+
+## BUNDLER
+.bundle
+Gemfile.*
+
+## PROJECT::SPECIFIC
+spec/db/

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+sudo: false
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - 2.2.0
+matrix:
+  allow_failures:
+    - rvm: 2.1.5
+    - rvm: 2.2.0

data/Gemfile

@@ -0,0 +1,51 @@
+require 'pathname'
+
+source 'https://rubygems.org'
+
+gemspec
+
+SOURCE         = ENV.fetch('SOURCE', :git).to_sym
+REPO_POSTFIX   = SOURCE == :path ? ''                                : '.git'
+DATAMAPPER     = SOURCE == :path ? Pathname(__FILE__).dirname.parent : 'http://github.com/ar-dm'
+DM_VERSION     = '~> 1.2.0'
+DO_VERSION     = '~> 0.10.4'
+DM_DO_ADAPTERS = %w[ sqlite postgres mysql oracle sqlserver ]
+CURRENT_BRANCH = ENV.fetch('GIT_BRANCH', 'master')
+
+gem 'ardm-core', DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-core#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+
+group :development do
+  gem 'ardm-types', DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-types#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+end
+
+group :datamapper do
+
+  adapters = ENV['ADAPTER'] || ENV['ADAPTERS']
+  adapters = adapters.to_s.tr(',', ' ').split.uniq - %w[ in_memory ]
+
+  if (do_adapters = DM_DO_ADAPTERS & adapters).any?
+    do_options = {}
+    do_options[:git] = "#{DATAMAPPER}/do#{REPO_POSTFIX}" if ENV['DO_GIT'] == 'true'
+
+    gem 'data_objects', DO_VERSION, do_options.dup
+
+    do_adapters.each do |adapter|
+      adapter = 'sqlite3' if adapter == 'sqlite'
+      gem "do_#{adapter}", DO_VERSION, do_options.dup
+    end
+
+    gem 'ardm-do-adapter', DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-do-adapter#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+  end
+
+  adapters.each do |adapter|
+    gem "ardm-#{adapter}-adapter", DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-#{adapter}-adapter#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+  end
+
+  plugins = ENV['PLUGINS'] || ENV['PLUGIN']
+  plugins = plugins.to_s.tr(',', ' ').split.push('ardm-migrations').uniq
+
+  plugins.each do |plugin|
+    gem plugin, DM_VERSION, SOURCE => "#{DATAMAPPER}/#{plugin}#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+  end
+
+end

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2007 Guy van den Berg
+Copyright (c) 2011 DataMapper development team
+
+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.rdoc

@@ -0,0 +1,122 @@
+This is a DataMapper plugin that provides validations for DataMapper model classes.
+
+== Setup
+DataMapper validation capabilities are automatically available for DataMapper resources when you require dm-validations' in your application. There is no need to manually include anything, every DataMapper::Resource will be able to handle validations once this gem got required.
+
+== 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
+
+  require 'dm-core'
+  require 'dm-validations'
+
+  class ProgrammingLanguage
+    include DataMapper::Resource
+    property :name, String
+    validates_presence_of :name
+  end
+
+2) Using auto-validations, please see DataMapper::Validations::AutoValidations. Note that not all validations that are provided via validation methods, are also available as autovalidation options. If they are available, they're functionally equivalent though.
+
+  class ProgrammingLanguage
+    include DataMapper::Resource
+    property :name, String, :required => true
+  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.
+
+== Working with Validation Errors
+
+If your validators find errors in your model, they will populate the DataMapper::Validations::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::Validations::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 when you
+need it. For instance, the same model may not only behave differently
+when initially saved or saved on update, but also require special validation sets
+for publishing, exporting, importing and so on.
+
+Again, using our example for pure Ruby class validations:
+
+  class ProgrammingLanguage
+
+    include DataMapper::Resource
+
+    property :name, String
+
+    def ensure_allows_manual_memory_management
+      # ...
+    end
+
+    def ensure_allows_optional_parentheses
+      # ...
+    end
+
+    validates_presence_of :name
+    validates_with_method :ensure_allows_optional_parentheses,     :when => [:implementing_a_dsl]
+    validates_with_method :ensure_allows_manual_memory_management, :when => [:doing_system_programming]
+  end
+
+ProgrammingLanguage instance now use #valid? method with one of two context symbols:
+
+  @ruby.valid?(:implementing_a_dsl)       # => true
+  @ruby.valid?(:doing_system_programming) # => false
+
+  @c.valid?(:implementing_a_dsl)       # => false
+  @c.valid?(:doing_system_programming) # => true
+
+Each context causes different set of validations to be triggered. If you don't
+specify a context using :when, :on or :group options (they are all aliases and do
+the same thing), default context name is :default. When you do model.valid? (without
+specifying context explicitly), again, :default context is used. One validation
+can be used in two, three or five contexts if you like:
+
+  class Book
+
+    include ::DataMapper::Resource
+
+    property :id,           Serial
+    property :name,         String
+
+    property :agreed_title, String
+    property :finished_toc, Boolean
+
+    # used in all contexts, including default
+    validates_presence_of :name,         :when => [:default, :sending_to_print]
+    validates_presence_of :agreed_title, :when => [:sending_to_print]
+
+    validates_with_block :toc, :when => [:sending_to_print] do
+      if self.finished_toc
+        [true]
+      else
+        [false, "TOC must be finalized before you send a book to print"]
+      end
+    end
+  end
+
+In the example above, name is validated for presence in both :default context and
+:sending_to_print context, while TOC related block validation and title presence validation
+only take place in :sending_to_print context.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'rake'
+
+FileList['tasks/**/*.rake'].each { |task| import task }

data/ardm-validations.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dm-validations/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name             = "ardm-validations"
+  gem.version          = DataMapper::Validations::VERSION
+
+  gem.authors          = ['Martin Emde', "Guy van den Berg"]
+  gem.email            = ['me@martinemde.com', "vandenberg.guy [a] gmail [d] com"]
+  gem.description      = "Ardm fork of dm-validations"
+  gem.summary          = gem.description
+  gem.license          = "MIT"
+
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- {spec}/*`.split("\n")
+  gem.extra_rdoc_files = %w[LICENSE README.rdoc]
+
+  gem.homepage         = "http://github.com/ar-dm/ardm-validations"
+  gem.require_paths    = ["lib"]
+  gem.rubygems_version = "1.8.11"
+
+  gem.add_runtime_dependency 'ardm-core', '~> 1.2'
+
+  gem.add_development_dependency 'ardm-types', '~> 1.2'
+  gem.add_development_dependency 'rake',       '~> 0.9'
+  gem.add_development_dependency 'rspec',      '~> 1.3'
+end
+

data/lib/ardm-validations.rb

@@ -0,0 +1 @@
+require 'dm-validations'

data/lib/dm-validations.rb

@@ -0,0 +1,169 @@
+require 'dm-core'
+require 'dm-validations/support/ordered_hash'
+require 'dm-validations/support/object'
+
+require 'dm-validations/exceptions'
+require 'dm-validations/validation_errors'
+require 'dm-validations/contextual_validators'
+require 'dm-validations/auto_validate'
+require 'dm-validations/context'
+
+require 'dm-validations/validators/generic_validator'
+require 'dm-validations/validators/required_field_validator'
+require 'dm-validations/validators/primitive_validator'
+require 'dm-validations/validators/absent_field_validator'
+require 'dm-validations/validators/confirmation_validator'
+require 'dm-validations/validators/format_validator'
+require 'dm-validations/validators/length_validator'
+require 'dm-validations/validators/within_validator'
+require 'dm-validations/validators/numeric_validator'
+require 'dm-validations/validators/method_validator'
+require 'dm-validations/validators/block_validator'
+require 'dm-validations/validators/uniqueness_validator'
+require 'dm-validations/validators/acceptance_validator'
+
+module DataMapper
+  module Validations
+
+    Model.append_inclusions self
+
+    def self.included(model)
+      model.extend ClassMethods
+    end
+
+    # Ensures the object is valid for the context provided, and otherwise
+    # throws :halt and returns false.
+    #
+    # @api public
+    def save(context = default_validation_context)
+      model.validators.assert_valid(context)
+      Validations::Context.in_context(context) { super() }
+    end
+
+    # @api public
+    def update(attributes = {}, context = default_validation_context)
+      model.validators.assert_valid(context)
+      Validations::Context.in_context(context) { super(attributes) }
+    end
+
+    # @api private
+    def save_self(*)
+      if Validations::Context.any? && !valid?(model.validators.current_context)
+        false
+      else
+        super
+      end
+    end
+
+    # Return the ValidationErrors
+    #
+    # @api public
+    def errors
+      @errors ||= ValidationErrors.new(self)
+    end
+
+    # Mark this resource as validatable. When we validate associations of a
+    # resource we can check if they respond to validatable? before trying to
+    # recursively validate them
+    #
+    # @api semipublic
+    def validatable?
+      true
+    end
+
+    # Alias for valid?(:default)
+    #
+    # TODO: deprecate
+    def valid_for_default?
+      valid?(:default)
+    end
+
+    # Check if a resource is valid in a given context
+    #
+    # @api public
+    def valid?(context = :default)
+      model = respond_to?(:model) ? self.model : self.class
+      model.validators.execute(context, self)
+    end
+
+    # @api semipublic
+    def validation_property_value(name)
+      __send__(name) if respond_to?(name, true)
+    end
+
+    module ClassMethods
+      include DataMapper::Validations::ValidatesPresence
+      include DataMapper::Validations::ValidatesAbsence
+      include DataMapper::Validations::ValidatesConfirmation
+      include DataMapper::Validations::ValidatesPrimitiveType
+      include DataMapper::Validations::ValidatesAcceptance
+      include DataMapper::Validations::ValidatesFormat
+      include DataMapper::Validations::ValidatesLength
+      include DataMapper::Validations::ValidatesWithin
+      include DataMapper::Validations::ValidatesNumericality
+      include DataMapper::Validations::ValidatesWithMethod
+      include DataMapper::Validations::ValidatesWithBlock
+      include DataMapper::Validations::ValidatesUniqueness
+      include DataMapper::Validations::AutoValidations
+
+      # Return the set of contextual validators or create a new one
+      #
+      # @api public
+      def validators
+        @validators ||= ContextualValidators.new(self)
+      end
+
+      # @api private
+      def inherited(base)
+        super
+        self.validators.contexts.each do |context, validators|
+          validators.each do |v|
+            options = v.options.merge(:context => context)
+            base.validators.add(v.class, v.field_name, options)
+          end
+        end
+      end
+
+      # @api public
+      def create(attributes = {}, *args)
+        resource = new(attributes)
+        resource.save(*args)
+        resource
+      end
+
+    private
+
+      # Given a new context create an instance method of
+      # valid_for_<context>? which simply calls valid?(context)
+      # if it does not already exist
+      #
+      # @api private
+      def self.create_context_instance_methods(model, context)
+        # TODO: deprecate `valid_for_#{context}?`
+        # what's wrong with requiring the caller to pass the context as an arg?
+        #   eg, `valid?(:context)`
+        # these methods are handy for symbol-based callbacks,
+        #   eg. `:if => :valid_for_context?`
+        # but these methods are so trivial to add where needed, making it
+        # overkill to do this for all contexts on all validated objects.
+        context = context.to_sym
+
+        name = "valid_for_#{context}?"
+        present = model.respond_to?(:resource_method_defined) ? model.resource_method_defined?(name) : model.instance_methods.include?(name)
+        unless present
+          model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}                         # def valid_for_signup?
+              valid?(#{context.inspect})        #   valid?(:signup)
+            end                                 # end
+          RUBY
+        end
+      end
+
+    end # module ClassMethods
+  end # module Validations
+
+  # Provide a const alias for backward compatibility with plugins
+  # This is scheduled to go away though, definitely before 1.0
+  Validate = Validations
+
+end # module DataMapper