diff --git a/lib/couchrest/mixins/extended_document_mixins.rb b/lib/couchrest/mixins/extended_document_mixins.rb index 786fd37..8149090 100644 --- a/lib/couchrest/mixins/extended_document_mixins.rb +++ b/lib/couchrest/mixins/extended_document_mixins.rb @@ -1,4 +1,5 @@ require File.join(File.dirname(__FILE__), 'properties') require File.join(File.dirname(__FILE__), 'document_queries') require File.join(File.dirname(__FILE__), 'views') -require File.join(File.dirname(__FILE__), 'design_doc') \ No newline at end of file +require File.join(File.dirname(__FILE__), 'design_doc') +require File.join(File.dirname(__FILE__), 'validation') \ No newline at end of file diff --git a/lib/couchrest/mixins/validation.rb b/lib/couchrest/mixins/validation.rb new file mode 100644 index 0000000..14f9c52 --- /dev/null +++ b/lib/couchrest/mixins/validation.rb @@ -0,0 +1,203 @@ +# Extracted from dm-validations 0.9.10 +# +# 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. + +require 'rubygems' +require 'pathname' + +class Object + def validatable? + false + end +end + +dir = File.join(Pathname(__FILE__).dirname.expand_path, '..', 'validation') + +require File.join(dir, 'validation_errors') +require File.join(dir, 'contextual_validators') + +require File.join(dir, 'validators', 'generic_validator') +require File.join(dir, 'validators', 'required_field_validator') +require File.join(dir, 'validators', 'absent_field_validator') +require File.join(dir, 'validators', 'format_validator') +require File.join(dir, 'validators', 'length_validator') +require File.join(dir, 'validators', 'numeric_validator') +require File.join(dir, 'validators', 'method_validator') + +module CouchRest + module Validation + + def self.included(base) + base.extend(ClassMethods) + 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) + self.respond_to?(name, true) ? self.send(name) : nil + end + + # Get the corresponding Resource property, if it exists. + # + # Note: CouchRest validations can be used on non-CouchRest resources. + # In such cases, the return value will be nil. + def validation_property(field_name) + properties.find{|p| p.name == field_name} + end + + module ClassMethods + include CouchRest::Validation::ValidatesPresent + include CouchRest::Validation::ValidatesAbsent + # include CouchRest::Validation::ValidatesIsConfirmed + # include CouchRest::Validation::ValidatesIsPrimitive + # include CouchRest::Validation::ValidatesIsAccepted + include CouchRest::Validation::ValidatesFormat + include CouchRest::Validation::ValidatesLength + # include CouchRest::Validation::ValidatesWithin + include CouchRest::Validation::ValidatesIsNumber + include CouchRest::Validation::ValidatesWithMethod + # include CouchRest::Validation::ValidatesWithBlock + # include CouchRest::Validation::ValidatesIsUnique + # include CouchRest::Validation::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_? which simply calls valid?(context) + # if it does not already exist + # + def create_context_instance_methods(context) + name = "valid_for_#{context.to_s}?" # valid_for_signup? + if !self.instance_methods.include?(name) + class_eval <<-EOS, __FILE__, __LINE__ + def #{name} # def valid_for_signup? + valid?('#{context.to_s}'.to_sym) # valid?('signup'.to_sym) + end # end + EOS + end + + all = "all_valid_for_#{context.to_s}?" # all_valid_for_signup? + if !self.instance_methods.include?(all) + class_eval <<-EOS, __FILE__, __LINE__ + def #{all} # def all_valid_for_signup? + all_valid?('#{context.to_s}'.to_sym) # all_valid?('signup'.to_sym) + end # 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| + validator = klazz.new(field, opts) + if opts[:context].is_a?(Symbol) + unless validators.context(opts[:context]).include?(validator) + validators.context(opts[:context]) << validator + create_context_instance_methods(opts[:context]) + end + elsif opts[:context].is_a?(Array) + opts[:context].each do |c| + unless validators.context(c).include?(validator) + validators.context(c) << validator + create_context_instance_methods(c) + end + end + end + end + end + + end # module ClassMethods + end # module Validation + +end # module CouchRest diff --git a/lib/couchrest/mixins/views.rb b/lib/couchrest/mixins/views.rb new file mode 100644 index 0000000..9de7a14 --- /dev/null +++ b/lib/couchrest/mixins/views.rb @@ -0,0 +1,169 @@ +module CouchRest + module Mixins + module Views + + def self.included(base) + base.extend(ClassMethods) + # extlib is required for the following code + base.send(:class_inheritable_accessor, :design_doc) + base.send(:class_inheritable_accessor, :design_doc_slug_cache) + base.send(:class_inheritable_accessor, :design_doc_fresh) + end + + module ClassMethods + + # Define a CouchDB view. The name of the view will be the concatenation + # of by and the keys joined by _and_ + # + # ==== Example views: + # + # class Post + # # view with default options + # # query with Post.by_date + # view_by :date, :descending => true + # + # # view with compound sort-keys + # # query with Post.by_user_id_and_date + # view_by :user_id, :date + # + # # view with custom map/reduce functions + # # query with Post.by_tags :reduce => true + # view_by :tags, + # :map => + # "function(doc) { + # if (doc['couchrest-type'] == 'Post' && doc.tags) { + # doc.tags.forEach(function(tag){ + # emit(doc.tag, 1); + # }); + # } + # }", + # :reduce => + # "function(keys, values, rereduce) { + # return sum(values); + # }" + # end + # + # view_by :date will create a view defined by this Javascript + # function: + # + # function(doc) { + # if (doc['couchrest-type'] == 'Post' && doc.date) { + # emit(doc.date, null); + # } + # } + # + # It can be queried by calling Post.by_date which accepts all + # valid options for CouchRest::Database#view. In addition, calling with + # the :raw => true option will return the view rows + # themselves. By default Post.by_date will return the + # documents included in the generated view. + # + # CouchRest::Database#view options can be applied at view definition + # time as defaults, and they will be curried and used at view query + # time. Or they can be overridden at query time. + # + # Custom views can be queried with :reduce => true to return + # reduce results. The default for custom views is to query with + # :reduce => false. + # + # Views are generated (on a per-model basis) lazily on first-access. + # This means that if you are deploying changes to a view, the views for + # that model won't be available until generation is complete. This can + # take some time with large databases. Strategies are in the works. + # + # To understand the capabilities of this view system more compeletly, + # it is recommended that you read the RSpec file at + # spec/core/model_spec.rb. + + def view_by(*keys) + self.design_doc ||= Design.new(default_design_doc) + opts = keys.pop if keys.last.is_a?(Hash) + opts ||= {} + ducktype = opts.delete(:ducktype) + unless ducktype || opts[:map] + opts[:guards] ||= [] + opts[:guards].push "(doc['couchrest-type'] == '#{self.to_s}')" + end + keys.push opts + self.design_doc.view_by(*keys) + self.design_doc_fresh = false + end + + # returns stored defaults if the there is a view named this in the design doc + def has_view?(view) + view = view.to_s + design_doc && design_doc['views'] && design_doc['views'][view] + end + + # Dispatches to any named view. + def view name, query={}, &block + unless design_doc_fresh + refresh_design_doc + end + query[:raw] = true if query[:reduce] + raw = query.delete(:raw) + fetch_view_with_docs(name, query, raw, &block) + end + + def all_design_doc_versions + database.documents :startkey => "_design/#{self.to_s}-", + :endkey => "_design/#{self.to_s}-\u9999" + end + + # Deletes any non-current design docs that were created by this class. + # Running this when you're deployed version of your application is steadily + # and consistently using the latest code, is the way to clear out old design + # docs. Running it to early could mean that live code has to regenerate + # potentially large indexes. + def cleanup_design_docs! + ddocs = all_design_doc_versions + ddocs["rows"].each do |row| + if (row['id'] != design_doc_id) + database.delete_doc({ + "_id" => row['id'], + "_rev" => row['value']['rev'] + }) + end + end + end + + private + + def fetch_view_with_docs name, opts, raw=false, &block + if raw + fetch_view name, opts, &block + else + begin + view = fetch_view name, opts.merge({:include_docs => true}), &block + view['rows'].collect{|r|new(r['doc'])} if view['rows'] + rescue + # fallback for old versions of couchdb that don't + # have include_docs support + view = fetch_view name, opts, &block + view['rows'].collect{|r|new(database.get(r['id']))} if view['rows'] + end + end + end + + def fetch_view view_name, opts, &block + retryable = true + begin + design_doc.view(view_name, opts, &block) + # the design doc could have been deleted by a rouge process + rescue RestClient::ResourceNotFound => e + if retryable + refresh_design_doc + retryable = false + retry + else + raise e + end + end + end + + end # module ClassMethods + + + end + end +end \ No newline at end of file diff --git a/lib/couchrest/validation/contextual_validators.rb b/lib/couchrest/validation/contextual_validators.rb new file mode 100644 index 0000000..5c00baa --- /dev/null +++ b/lib/couchrest/validation/contextual_validators.rb @@ -0,0 +1,55 @@ +module CouchRest + module Validation + + ## + # + # @author Guy van den Berg + # @since 0.9 + class ContextualValidators + + def dump + contexts.each_pair do |key, context| + puts "Key=#{key} Context: #{context}" + end + end + + # Get a hash of named context validators for the resource + # + # @return a hash of validators + def contexts + @contexts ||= {} + end + + # Return an array of validators for a named context + # + # @return An array of validators + def context(name) + contexts[name] ||= [] + end + + # Clear all named context validators off of the resource + # + def clear! + contexts.clear + end + + # Execute all validators in the named context against the target + # + # @param named_context the context we are validating against + # @param target the resource that we are validating + # @return true if all are valid, otherwise false + def execute(named_context, target) + raise(ArgumentError, 'invalid context specified') if !named_context || (contexts.length > 0 && !contexts[named_context]) + target.errors.clear! + result = true + context(named_context).each do |validator| + next unless validator.execute?(target) + result = false unless validator.call(target) + end + + result + end + + end # module ContextualValidators + end # module Validation +end # module CouchRest diff --git a/lib/couchrest/validation/validation_errors.rb b/lib/couchrest/validation/validation_errors.rb new file mode 100644 index 0000000..671348e --- /dev/null +++ b/lib/couchrest/validation/validation_errors.rb @@ -0,0 +1,118 @@ +# Extracted from dm-validations 0.9.10 +# +# 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. + +module CouchRest + module Validation + + ## + # + # @author Guy van den Berg + # @since 0.9 + class ValidationErrors + + include Enumerable + + @@default_error_messages = { + :absent => '%s must be absent', + :inclusion => '%s must be one of [%s]', + :invalid => '%s has an invalid format', + :confirmation => '%s does not match the confirmation', + :accepted => "%s is not accepted", + :nil => '%s must not be nil', + :blank => '%s must not be blank', + :length_between => '%s must be between %s and %s characters long', + :too_long => '%s must be less than %s characters long', + :too_short => '%s must be more than %s characters long', + :wrong_length => '%s must be %s characters long', + :taken => '%s is already taken', + :not_a_number => '%s must be a number', + :not_an_integer => '%s must be an integer', + :greater_than => '%s must be greater than %s', + :greater_than_or_equal_to => "%s must be greater than or equal to %s", + :equal_to => "%s must be equal to %s", + :less_than => '%s must be less than %s', + :less_than_or_equal_to => "%s must be less than or equal to %s", + :value_between => '%s must be between %s and %s', + :primitive => '%s must be of type %s' + } + + # Holds a hash with all the default error messages that can be replaced by your own copy or localizations. + cattr_writer :default_error_messages + + def self.default_error_message(key, field, *values) + field = Extlib::Inflection.humanize(field) + @@default_error_messages[key] % [field, *values].flatten + end + + # Clear existing validation errors. + def clear! + errors.clear + end + + # Add a validation error. Use the field_name :general if the errors does + # not apply to a specific field of the Resource. + # + # @param field_name the name of the field that caused the error + # @param message the message to add + def add(field_name, message) + (errors[field_name] ||= []) << message + end + + # Collect all errors into a single list. + def full_messages + errors.inject([]) do |list, pair| + list += pair.last + end + end + + # Return validation errors for a particular field_name. + # + # @param field_name the name of the field you want an error for + def on(field_name) + errors_for_field = errors[field_name] + errors_for_field.blank? ? nil : errors_for_field + end + + def each + errors.map.each do |k, v| + next if v.blank? + yield(v) + end + end + + def empty? + entries.empty? + end + + def method_missing(meth, *args, &block) + errors.send(meth, *args, &block) + end + + private + def errors + @errors ||= {} + end + + end # class ValidationErrors + end # module Validation +end # module CouchRest diff --git a/lib/couchrest/validation/validators/absent_field_validator.rb b/lib/couchrest/validation/validators/absent_field_validator.rb new file mode 100644 index 0000000..3ba4b9d --- /dev/null +++ b/lib/couchrest/validation/validators/absent_field_validator.rb @@ -0,0 +1,75 @@ +# Extracted from dm-validations 0.9.10 +# +# 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. + +module CouchRest + module Validation + + ## + # + # @author Guy van den Berg + class AbsentFieldValidator < GenericValidator + + def initialize(field_name, options={}) + super + @field_name, @options = field_name, options + end + + def call(target) + value = target.send(field_name) + return true if (value.nil? || (value.respond_to?(:empty?) && value.empty?)) + + error_message = @options[:message] || ValidationErrors.default_error_message(:absent, field_name) + add_error(target, error_message, field_name) + + return false + end + end # class AbsentFieldValidator + + module ValidatesAbsent + + ## + # + # @example [Usage] + # require 'dm-validations' + # + # class Page + # + # 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, CouchRest::Validation::AbsentFieldValidator) + end + + end # module ValidatesAbsent + end # module Validation +end # module CouchRest diff --git a/lib/couchrest/validation/validators/format_validator.rb b/lib/couchrest/validation/validators/format_validator.rb new file mode 100644 index 0000000..192f715 --- /dev/null +++ b/lib/couchrest/validation/validators/format_validator.rb @@ -0,0 +1,117 @@ +# Extracted from dm-validations 0.9.10 +# +# 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. + +require 'pathname' +require Pathname(__FILE__).dirname.expand_path + 'formats/email' +require Pathname(__FILE__).dirname.expand_path + 'formats/url' + +module CouchRest + module Validation + + ## + # + # @author Guy van den Berg + # @since 0.9 + class FormatValidator < GenericValidator + + FORMATS = {} + include CouchRest::Validation::Format::Email + include CouchRest::Validation::Format::Url + + def initialize(field_name, options = {}, &b) + super(field_name, options) + @field_name, @options = field_name, options + @options[:allow_nil] = false unless @options.has_key?(:allow_nil) + end + + def call(target) + value = target.validation_property_value(field_name) + return true if @options[:allow_nil] && value.nil? + + validation = @options[:as] || @options[:with] + + raise "No such predefined format '#{validation}'" if validation.is_a?(Symbol) && !FORMATS.has_key?(validation) + validator = validation.is_a?(Symbol) ? FORMATS[validation][0] : validation + + valid = case validator + when Proc then validator.call(value) + when Regexp then value =~ validator + else + raise UnknownValidationFormat, "Can't determine how to validate #{target.class}##{field_name} with #{validator.inspect}" + end + + return true if valid + + error_message = @options[:message] || ValidationErrors.default_error_message(:invalid, field_name) + + field = Extlib::Inflection.humanize(field_name) + error_message = error_message.call(field, value) if error_message.respond_to?(:call) + + add_error(target, error_message, field_name) + + false + end + + #class UnknownValidationFormat < StandardError; end + + end # class FormatValidator + + module ValidatesFormat + + ## + # Validates that the attribute is in the specified format. You may use the + # :as (or :with, it's an alias) option to specify the pre-defined format + # that you want to validate against. You may also specify your own format + # via a Proc or Regexp passed to the the :as or :with options. + # + # @option :allow_nil true/false (default is true) + # @option :as the pre-defined format, Proc or Regexp to validate against + # @option :with an alias for :as + # + # @details [Pre-defined Formats] + # :email_address (format is specified in DataMapper::Validation::Format::Email) + # :url (format is specified in DataMapper::Validation::Format::Url) + # + # @example [Usage] + # + # class Page + # + # property :email, String + # property :zip_code, String + # + # validates_format :email, :as => :email_address + # validates_format :zip_code, :with => /^\d{5}$/ + # + # # a call to valid? will return false unless: + # # email is formatted like an email address + # # and + # # zip_code is a string of 5 digits + # + def validates_format(*fields) + opts = opts_from_validator_args(fields) + add_validator_to_context(opts, fields, CouchRest::Validation::FormatValidator) + end + + end # module ValidatesFormat + end # module Validation +end # module CouchRest diff --git a/lib/couchrest/validation/validators/formats/email.rb b/lib/couchrest/validation/validators/formats/email.rb new file mode 100644 index 0000000..22006a7 --- /dev/null +++ b/lib/couchrest/validation/validators/formats/email.rb @@ -0,0 +1,66 @@ +# encoding: binary + +# Extracted from dm-validations 0.9.10 +# +# 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. + +module CouchRest + module Validation + module Format + module Email + + def self.included(base) + CouchRest::Validation::FormatValidator::FORMATS.merge!( + :email_address => [ EmailAddress, lambda { |field, value| '%s is not a valid email address'.t(value) }] + ) + end + + # RFC2822 (No attribution reference available) + EmailAddress = begin + alpha = "a-zA-Z" + digit = "0-9" + atext = "[#{alpha}#{digit}\!\#\$\%\&\'\*+\/\=\?\^\_\`\{\|\}\~\-]" + dot_atom_text = "#{atext}+([.]#{atext}*)*" + dot_atom = "#{dot_atom_text}" + qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]' + text = "[\\x01-\\x09\\x11\\x12\\x14-\\x7f]" + quoted_pair = "(\\x5c#{text})" + qcontent = "(?:#{qtext}|#{quoted_pair})" + quoted_string = "[\"]#{qcontent}+[\"]" + atom = "#{atext}+" + word = "(?:#{atom}|#{quoted_string})" + obs_local_part = "#{word}([.]#{word})*" + local_part = "(?:#{dot_atom}|#{quoted_string}|#{obs_local_part})" + no_ws_ctl = "\\x01-\\x08\\x11\\x12\\x14-\\x1f\\x7f" + dtext = "[#{no_ws_ctl}\\x21-\\x5a\\x5e-\\x7e]" + dcontent = "(?:#{dtext}|#{quoted_pair})" + domain_literal = "\\[#{dcontent}+\\]" + obs_domain = "#{atom}([.]#{atom})*" + domain = "(?:#{dot_atom}|#{domain_literal}|#{obs_domain})" + addr_spec = "#{local_part}\@#{domain}" + pattern = /^#{addr_spec}$/ + end + + end # module Email + end # module Format + end # module Validation +end # module CouchRest diff --git a/lib/couchrest/validation/validators/formats/url.rb b/lib/couchrest/validation/validators/formats/url.rb new file mode 100644 index 0000000..675f0c4 --- /dev/null +++ b/lib/couchrest/validation/validators/formats/url.rb @@ -0,0 +1,43 @@ +# Extracted from dm-validations 0.9.10 +# +# 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. + +module CouchRest + module Validation + module Format + module Url + + def self.included(base) + CouchRest::Validation::FormatValidator::FORMATS.merge!( + :url => [ Url, lambda { |field, value| '%s is not a valid URL'.t(value) }] + ) + end + + Url = begin + # Regex from http://www.igvita.com/2006/09/07/validating-url-in-ruby-on-rails/ + /(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$)/ix + end + + end # module Url + end # module Format + end # module Validation +end # module CouchRest \ No newline at end of file diff --git a/lib/couchrest/validation/validators/generic_validator.rb b/lib/couchrest/validation/validators/generic_validator.rb new file mode 100644 index 0000000..f353cf6 --- /dev/null +++ b/lib/couchrest/validation/validators/generic_validator.rb @@ -0,0 +1,120 @@ +# -*- coding: utf-8 -*- + +# Extracted from dm-validations 0.9.10 +# +# 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. + +module CouchRest + module Validation + + # All validators extend this base class. Validators must: + # + # * Implement the initialize method to capture its parameters, also calling + # super to have this parent class capture the optional, general :if and + # :unless parameters. + # * Implement the call method, returning true or false. The call method + # provides the validation logic. + # + # @author Guy van den Berg + class GenericValidator + + attr_accessor :if_clause, :unless_clause + attr_reader :field_name + + # Construct a validator. Capture the :if and :unless clauses when present. + # + # @param field The property specified for validation + # + # @option :if The name of a method or a Proc to call to + # determine if the validation should occur. + # @option :unless The name of a method or a Proc to call to + # determine if the validation should not occur + # All additional key/value pairs are passed through to the validator + # that is sub-classing this GenericValidator + # + def initialize(field, opts = {}) + @if_clause = opts.delete(:if) + @unless_clause = opts.delete(:unless) + end + + # Add an error message to a target resource. If the error corresponds to a + # specific field of the resource, add it to that field, otherwise add it + # as a :general message. + # + # @param target the resource that has the error + # @param message the message to add + # @param field_name the name of the field that caused the error + # + # TODO - should the field_name for a general message be :default??? + # + def add_error(target, message, field_name = :general) + target.errors.add(field_name, message) + end + + # Call the validator. "call" is used so the operation is BoundMethod and + # Block compatible. This must be implemented in all concrete classes. + # + # @param target the resource that the validator must be called + # against + # @return true if valid, otherwise false + def call(target) + raise NotImplementedError, "CouchRest::Validation::GenericValidator::call must be overriden in a subclass" + end + + # Determines if this validator should be run against the + # target by evaluating the :if and :unless clauses + # optionally passed while specifying any validator. + # + # @param target the resource that we check against + # @return true if should be run, otherwise false + def execute?(target) + if unless_clause = self.unless_clause + if unless_clause.is_a?(Symbol) + return false if target.send(unless_clause) + elsif unless_clause.respond_to?(:call) + return false if unless_clause.call(target) + end + end + + if if_clause = self.if_clause + if if_clause.is_a?(Symbol) + return target.send(if_clause) + elsif if_clause.respond_to?(:call) + return if_clause.call(target) + end + end + + true + end + + def ==(other) + self.class == other.class && + self.field_name == other.field_name && + self.class == other.class && + self.if_clause == other.if_clause && + self.unless_clause == other.unless_clause && + self.instance_variable_get(:@options) == other.instance_variable_get(:@options) + end + + end # class GenericValidator + end # module Validation +end # module CouchRest diff --git a/lib/couchrest/validation/validators/length_validator.rb b/lib/couchrest/validation/validators/length_validator.rb new file mode 100644 index 0000000..104d5af --- /dev/null +++ b/lib/couchrest/validation/validators/length_validator.rb @@ -0,0 +1,134 @@ +# Extracted from dm-validations 0.9.10 +# +# 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. + +module CouchRest + module Validation + + ## + # + # @author Guy van den Berg + # @since 0.9 + class LengthValidator < GenericValidator + + def initialize(field_name, options) + super + @field_name = field_name + @options = options + + @min = options[:minimum] || options[:min] + @max = options[:maximum] || options[:max] + @equal = options[:is] || options[:equals] + @range = options[:within] || options[:in] + + @validation_method ||= :range if @range + @validation_method ||= :min if @min && @max.nil? + @validation_method ||= :max if @max && @min.nil? + @validation_method ||= :equals unless @equal.nil? + end + + def call(target) + field_value = target.validation_property_value(field_name) + return true if @options[:allow_nil] && field_value.nil? + + field_value = '' if field_value.nil? + + # XXX: HACK seems hacky to do this on every validation, probably should + # do this elsewhere? + field = Extlib::Inflection.humanize(field_name) + min = @range ? @range.min : @min + max = @range ? @range.max : @max + equal = @equal + + case @validation_method + when :range then + unless valid = @range.include?(field_value.size) + error_message = ValidationErrors.default_error_message(:length_between, field, min, max) + end + when :min then + unless valid = field_value.size >= min + error_message = ValidationErrors.default_error_message(:too_short, field, min) + end + when :max then + unless valid = field_value.size <= max + error_message = ValidationErrors.default_error_message(:too_long, field, max) + end + when :equals then + unless valid = field_value.size == equal + error_message = ValidationErrors.default_error_message(:wrong_length, field, equal) + end + end + + error_message = @options[:message] || error_message + + add_error(target, error_message, field_name) unless valid + + return valid + end + + end # class LengthValidator + + module ValidatesLength + + # Validates that the length of the attribute is equal to, less than, + # greater than or within a certain range (depending upon the options + # you specify). + # + # @option :allow_nil true/false (default is true) + # @option :minimum ensures that the attribute's length is greater than + # or equal to the supplied value + # @option :min alias for :minimum + # @option :maximum ensures the attribute's length is less than or equal + # to the supplied value + # @option :max alias for :maximum + # @option :equals ensures the attribute's length is equal to the + # supplied value + # @option :is alias for :equals + # @option :in given a Range, ensures that the attributes length is + # include?'ed in the Range + # @option :within alias for :in + # + # @example [Usage] + # + # class Page + # + # property high, Integer + # property low, Integer + # property just_right, Integer + # + # validates_length :high, :min => 100000000000 + # validates_length :low, :equals => 0 + # validates_length :just_right, :within => 1..10 + # + # # a call to valid? will return false unless: + # # high is greater than or equal to 100000000000 + # # low is equal to 0 + # # just_right is between 1 and 10 (inclusive of both 1 and 10) + # + def validates_length(*fields) + opts = opts_from_validator_args(fields) + add_validator_to_context(opts, fields, CouchRest::Validation::LengthValidator) + end + + end # module ValidatesLength + end # module Validation +end # module CouchRest diff --git a/lib/couchrest/validation/validators/method_validator.rb b/lib/couchrest/validation/validators/method_validator.rb new file mode 100644 index 0000000..4bc4527 --- /dev/null +++ b/lib/couchrest/validation/validators/method_validator.rb @@ -0,0 +1,66 @@ +module CouchRest + module Validation + + ## + # + # @author Guy van den Berg + # @since 0.9 + class MethodValidator < GenericValidator + + def initialize(field_name, options={}) + super + @field_name, @options = field_name, options.clone + @options[:method] = @field_name unless @options.has_key?(:method) + end + + def call(target) + result, message = target.send(@options[:method]) + add_error(target, message, field_name) unless result + result + end + + def ==(other) + @options[:method] == other.instance_variable_get(:@options)[:method] && super + end + end # class MethodValidator + + module ValidatesWithMethod + + ## + # Validate using the given method. The method given needs to return: + # [result::, Error Message::] + # + # @example [Usage] + # + # class Page + # + # property :zip_code, String + # + # validates_with_method :in_the_right_location? + # + # def in_the_right_location? + # if @zip_code == "94301" + # return true + # else + # return [false, "You're in the wrong zip code"] + # end + # end + # + # # A call to valid? will return false and + # # populate the object's errors with "You're in the + # # wrong zip code" unless zip_code == "94301" + # + # # You can also specify field: + # + # validates_with_method :zip_code, :in_the_right_location? + # + # # it will add returned error message to :zip_code field + # + def validates_with_method(*fields) + opts = opts_from_validator_args(fields) + add_validator_to_context(opts, fields, CouchRest::Validation::MethodValidator) + end + + end # module ValidatesWithMethod + end # module Validation +end # module CouchRest diff --git a/lib/couchrest/validation/validators/numeric_validator.rb b/lib/couchrest/validation/validators/numeric_validator.rb new file mode 100644 index 0000000..9410102 --- /dev/null +++ b/lib/couchrest/validation/validators/numeric_validator.rb @@ -0,0 +1,81 @@ +module CouchRest + module Validation + + ## + # + # @author Guy van den Berg + # @since 0.9 + class NumericValidator < GenericValidator + + def initialize(field_name, options={}) + super + @field_name, @options = field_name, options + @options[:integer_only] = false unless @options.has_key?(:integer_only) + end + + def call(target) + value = target.send(field_name) + return true if @options[:allow_nil] && value.nil? + + value = value.kind_of?(BigDecimal) ? value.to_s('F') : value.to_s + + error_message = @options[:message] + precision = @options[:precision] + scale = @options[:scale] + + if @options[:integer_only] + return true if value =~ /\A[+-]?\d+\z/ + error_message ||= ValidationErrors.default_error_message(:not_an_integer, field_name) + else + # FIXME: if precision and scale are not specified, can we assume that it is an integer? + # probably not, as floating point numbers don't have hard + # defined scale. the scale floats with the length of the + # integral and precision. Ie. if precision = 10 and integral + # portion of the number is 9834 (4 digits), the max scale will + # be 6 (10 - 4). But if the integral length is 1, max scale + # will be (10 - 1) = 9, so 1.234567890. + if precision && scale + #handles both Float when it has scale specified and BigDecimal + if precision > scale && scale > 0 + return true if value =~ /\A[+-]?(?:\d{1,#{precision - scale}}|\d{0,#{precision - scale}}\.\d{1,#{scale}})\z/ + elsif precision > scale && scale == 0 + return true if value =~ /\A[+-]?(?:\d{1,#{precision}}(?:\.0)?)\z/ + elsif precision == scale + return true if value =~ /\A[+-]?(?:0(?:\.\d{1,#{scale}})?)\z/ + else + raise ArgumentError, "Invalid precision #{precision.inspect} and scale #{scale.inspect} for #{field_name} (value: #{value.inspect} #{value.class})" + end + elsif precision && scale.nil? + # for floats, if scale is not set + + #total number of digits is less or equal precision + return true if value.gsub(/[^\d]/, '').length <= precision + + #number of digits before decimal == precision, and the number is x.0. same as scale = 0 + return true if value =~ /\A[+-]?(?:\d{1,#{precision}}(?:\.0)?)\z/ + else + return true if value =~ /\A[+-]?(?:\d+|\d*\.\d+)\z/ + end + error_message ||= ValidationErrors.default_error_message(:not_a_number, field_name) + end + + add_error(target, error_message, field_name) + + # TODO: check the gt, gte, lt, lte, and eq options + + return false + end + end # class NumericValidator + + module ValidatesIsNumber + + # Validate whether a field is numeric + # + def validates_is_number(*fields) + opts = opts_from_validator_args(fields) + add_validator_to_context(opts, fields, CouchRest::Validation::NumericValidator) + end + + end # module ValidatesIsNumber + end # module Validation +end # module CouchRest diff --git a/lib/couchrest/validation/validators/required_field_validator.rb b/lib/couchrest/validation/validators/required_field_validator.rb new file mode 100644 index 0000000..e68b009 --- /dev/null +++ b/lib/couchrest/validation/validators/required_field_validator.rb @@ -0,0 +1,86 @@ +module CouchRest + module Validation + + ## + # + # @author Guy van den Berg + # @since 0.9 + class RequiredFieldValidator < GenericValidator + + def initialize(field_name, options={}) + super + @field_name, @options = field_name, options + end + + def call(target) + value = target.validation_property_value(field_name) + property = target.validation_property(field_name) + return true if present?(value, property) + + error_message = @options[:message] || default_error(property) + add_error(target, error_message, field_name) + + false + end + + protected + + # Boolean property types are considered present if non-nil. + # Other property types are considered present if non-blank. + # Non-properties are considered present if non-blank. + def present?(value, property) + boolean_type?(property) ? !value.nil? : !value.blank? + end + + def default_error(property) + actual = boolean_type?(property) ? :nil : :blank + ValidationErrors.default_error_message(actual, field_name) + end + + # Is +property+ a boolean property? + # + # Returns true for Boolean, ParanoidBoolean, TrueClass, etc. properties. + # Returns false for other property types. + # Returns false for non-properties. + def boolean_type?(property) + property ? property.primitive == TrueClass : false + end + + end # class RequiredFieldValidator + + module ValidatesPresent + + ## + # Validates that the specified attribute is present. + # + # For most property types "being present" is the same as being "not + # blank" as determined by the attribute's #blank? method. However, in + # the case of Boolean, "being present" means not nil; i.e. true or + # false. + # + # @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] + # + # class Page + # + # property :required_attribute, String + # property :another_required, String + # property :yet_again, String + # + # validates_present :required_attribute + # validates_present :another_required, :yet_again + # + # # a call to valid? will return false unless + # # all three attributes are !blank? + # end + def validates_present(*fields) + opts = opts_from_validator_args(fields) + add_validator_to_context(opts, fields, CouchRest::Validation::RequiredFieldValidator) + end + + end # module ValidatesPresent + end # module Validation +end # module CouchRest diff --git a/spec/couchrest/more/property_spec.rb b/spec/couchrest/more/property_spec.rb index 0731fce..1eaec4e 100644 --- a/spec/couchrest/more/property_spec.rb +++ b/spec/couchrest/more/property_spec.rb @@ -2,6 +2,7 @@ require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper') # check the following file to see how to use the spec'd features. require File.join(FIXTURE_PATH, 'more', 'card') +require File.join(FIXTURE_PATH, 'more', 'invoice') describe "ExtendedDocument properties" do @@ -33,11 +34,37 @@ describe "ExtendedDocument properties" do @card.family_name.should == @card.last_name end - it "should be able to be validated" do - pending("need to add validation") do + describe "validation" do + + before(:each) do + @invoice = Invoice.new(:client_name => "matt", :employee_name => "Chris", :location => "San Diego, CA") + end + + it "should be able to be validated" do @card.should be_valid end - #Card.property(:company, :required => true) + + it "should let you validate the presence of an attribute" do + @card.first_name = nil + @card.should_not be_valid + @card.errors.should_not be_empty + @card.errors.on(:first_name).should == ["First name must not be blank"] + end + + it "should validate the presence of 2 attributes" do + @invoice.clear + @invoice.should_not be_valid + @invoice.errors.should_not be_empty + @invoice.errors.on(:client_name).should == ["Client name must not be blank"] + @invoice.errors.on(:employee_name).should_not be_empty + end + + it "should let you set an error message" do + @invoice.location = nil + @invoice.valid? + @invoice.errors.on(:location).first.should == "Hey stupid!, you forgot the location" + end + end end \ No newline at end of file diff --git a/spec/fixtures/more/card.rb b/spec/fixtures/more/card.rb index b6f1420..f83c280 100644 --- a/spec/fixtures/more/card.rb +++ b/spec/fixtures/more/card.rb @@ -1,7 +1,16 @@ class Card < CouchRest::ExtendedDocument + # Include the validation module to get access to the validation methods + include CouchRest::Validation + + # Set the default database to use use_database TEST_SERVER.default_database + + # Official Schema property :first_name property :last_name, :alias => :family_name property :read_only_value, :read_only => true + # Validation + validates_present :first_name + end \ No newline at end of file diff --git a/spec/fixtures/more/invoice.rb b/spec/fixtures/more/invoice.rb new file mode 100644 index 0000000..f308f7c --- /dev/null +++ b/spec/fixtures/more/invoice.rb @@ -0,0 +1,17 @@ +class Invoice < CouchRest::ExtendedDocument + # Include the validation module to get access to the validation methods + include CouchRest::Validation + + # Set the default database to use + use_database TEST_SERVER.default_database + + # Official Schema + property :client_name + property :employee_name + property :location + + # Validation + validates_present :client_name, :employee_name + validates_present :location, :message => "Hey stupid!, you forgot the location" + +end \ No newline at end of file