veto 0.0.1

data/lib/veto/builder.rb

@@ -0,0 +1,65 @@
+require 'veto/conditions'
+require 'veto/attribute_validator_factory'
+require 'veto/validators/custom_method_validator'
+
+module Veto			
+	class Builder
+		attr_reader :context, :conditions_context
+
+		def initialize context, conditions_context={}, &block
+			@context = context
+			@conditions_context = conditions_context
+			instance_eval(&block) if block_given?
+		end
+
+		def with_options conditions={}, &block
+			mc = ::Veto::Conditions.merge(conditions_context, conditions)
+			::Veto::Builder.new(context, mc, &block)
+		end
+
+		def validates attribute, options={}
+			a = attribute
+			c = ::Veto::Conditions.select(options)
+			mc = ::Veto::Conditions.merge(conditions_context, c)
+			o = ::Veto::Conditions.reject(options)
+			vs = o.map do |t, vopts|
+				vo = case vopts
+				when TrueClass
+					{}
+				when Hash
+					vopts
+				when Range, Array
+					{ :in => vopts }
+				else
+					{ :with => vopts }
+				end
+
+				vc = ::Veto::Conditions.select(vo)
+				mvc = ::Veto::Conditions.merge(mc, vc)
+				mvo = vo.merge(mvc)
+				::Veto::AttributeValidatorFactory.new_validator(t, a, mvo)
+			end
+			validate_with vs
+		end
+
+		def validate *method_names
+			if method_names.last.is_a?(Hash)
+				c = method_names.last
+				mns = method_names[0..-2]
+			else
+				c = {}
+				mns = method_names
+			end
+
+			mc = ::Veto::Conditions.merge(conditions_context, c)
+			vs = mns.map do |mn|
+				::Veto::CustomMethodValidator.new(mn, mc)
+			end
+			validate_with vs
+		end
+
+		def validate_with *args
+			context.validate_with *args
+		end
+	end
+end

data/lib/veto/conditions.rb

@@ -0,0 +1,23 @@
+module Veto
+	class Conditions
+		CONDITION_KEYS = [:if, :unless].freeze
+
+		def self.reject hash={}
+			hash.reject{|k,v| CONDITION_KEYS.include?(k) }
+		end
+
+		def self.select hash={}
+			hash.select{|k,v| CONDITION_KEYS.include?(k) }
+		end
+
+		def self.merge dest_hash, source_hash
+			CONDITION_KEYS.inject({}) do |m, k|
+				c = []
+				c << dest_hash[k]
+				c << source_hash[k]
+				m[k] = c.flatten.compact
+				m
+			end
+		end
+	end
+end

data/lib/veto/conditions_evaluator.rb

@@ -0,0 +1,30 @@
+module Veto
+	class ConditionsEvaluator
+		def self.truthy? condition, context, entity
+			case condition
+			when String
+				!!entity.instance_eval(condition)
+			when Symbol
+				!!context.send(condition)
+			when Proc
+				!!condition.call(entity)
+			else
+				!!condition
+			end
+		end
+
+		def self.truthy_conditions? conditions, context, entity
+			return true if !conditions.key?(:if) && !conditions.key?(:unless)
+
+			[*conditions[:if]].each do |condition| 
+				return false unless truthy?(condition, context, entity) 
+			end
+
+			[*conditions[:unless]].each do |condition| 
+				return false if truthy?(condition, context, entity) 
+			end
+
+			true
+		end
+	end
+end

data/lib/veto/configuration.rb

@@ -0,0 +1,42 @@
+module Veto
+	class Configuration
+		class Message
+			DEFAULT_MESSAGES = {
+				:exact_length 	=> lambda{|exact| "is not #{exact} characters"},
+				:format 		=> lambda{"is not valid"},
+				:inclusion 		=> lambda{|set| "is not in set: #{set.inspect}"},
+				:integer 		=> lambda{"is not a number"},
+				:length_range 	=> lambda{"is too short or too long"},
+				:max_length 	=> lambda{|max| "is longer than #{max} characters"},
+				:min_length 	=> lambda{|min| "is shorter than #{min} characters"},
+				:not_null 		=> lambda{"is not present"},
+				:numeric 		=> lambda{"is not a number"},
+				:presence 		=> lambda{"is not present"}
+			}	
+
+			def get type, *args
+				args.compact.length > 0 ? message(type).call(*args) : message(type).call
+			end
+
+			def set type, proc
+				custom_messages[type] = proc
+			end
+
+			private
+
+			def custom_messages
+				@custom_messages ||= {}
+			end
+
+			def message type
+				custom_messages[type] || DEFAULT_MESSAGES.fetch(type)
+			end
+		end
+
+		attr_reader :message
+
+		def initialize
+			@message = Message.new
+		end
+	end
+end

data/lib/veto/errors.rb

@@ -0,0 +1,35 @@
+module Veto
+	class Errors < ::Hash
+		def add atr, msg, *msg_opts
+			fetch(atr){self[atr] = []} << msg_lookup(msg, *msg_opts)
+		end
+
+		def count
+			values.inject(0){|m, v| m + v.length}
+		end
+
+		def empty?
+			count == 0
+		end
+
+		def full_messages
+			inject([]) do |m, kv| 
+				atr, errors = *kv
+				errors.each {|e| m << "#{atr} #{e}"}
+				m
+			end
+		end
+
+		def on(atr)
+			if v = fetch(atr, nil) and !v.empty?
+				v
+			end
+		end
+
+		private
+
+		def msg_lookup msg, *msg_opts
+			msg.is_a?(Symbol) ? ::Veto.configuration.message.get(msg, *msg_opts) : msg
+		end
+	end
+end

data/lib/veto/exceptions.rb

@@ -0,0 +1,5 @@
+module Veto
+	class VetoError < StandardError; end
+	class InvalidEntity < VetoError; end
+	class ValidatorNotAssigned < VetoError; end
+end

data/lib/veto/model.rb

@@ -0,0 +1,37 @@
+require 'veto/exceptions'
+
+module Veto
+	module Model
+		def self.included(base)
+			base.extend ClassMethods
+		end
+
+		module ClassMethods
+			def validates_with veto_validator
+				@validator = veto_validator
+			end
+
+			def validator
+				@validator || raise(::Veto::ValidatorNotAssigned, 'validator not assigned')
+			end
+		end
+
+		def valid?
+			validator.valid?
+		end
+
+		def validate!
+			validator.validate!
+		end
+
+		def errors
+			validator.errors
+		end
+
+		private
+
+		def validator
+			@validator ||= self.class.validator.new(self)
+		end
+	end
+end

data/lib/veto/validator.rb

@@ -0,0 +1,150 @@
+require 'veto/errors'
+require 'veto/exceptions'
+require 'veto/builder'
+
+module Veto
+	module Validator
+		def self.included(base)
+			base.extend ClassMethods
+		end
+
+		module ClassMethods
+			def with_options *args, &block
+				builder.with_options(*args, &block)
+			end
+
+			def validates *args
+				builder.validates(*args)
+			end
+
+			def validate *args
+				builder.validate(*args)
+			end
+
+			# Used to add a validator, or set of validators, to the 
+			# validators list. Generally used by the `validates` and `validate`
+			# methods internally.
+			#
+			# @example 
+			#   PersonValidator.validates_with PresenceValidator.new(:first_name)
+			#     # OR
+			#   PersonValidator.validates_with PresenceValidator.new(:first_name), IntegerValidator.new(:age)
+			#
+			# @param validator_set [Array] A single, or list, of validator instances
+			def validate_with *validator_set
+				validators.concat validator_set.flatten
+			end	
+
+			# Memoizes a flat list of internal validator instances that 
+			# will perform validations on the assigned entity.
+			#
+			# @example
+			#   PersonValidator.validators # => [
+			#       <Veto::FormatValidator:0xXXXXXX @attribute=#<Mock:0xXXXXXX>, @options=#<Mock:0xXXXXXX>>,
+			#       <Veto::PresenceValidator:0xXXXXXX @attribute=#<Mock:0xXXXXXX>, @options=#<Mock:0xXXXXXX>>,
+			#       <Veto::ExactLengthValidator:0xXXXXXX @attribute=#<Mock:0xXXXXXX>, @options=#<Mock:0xXXXXXX>>]
+			#
+			# @return [Array]
+			def validators
+				@validators ||= []
+			end
+			
+			# Returns boolean value representing the validaty of the entity
+			#
+			# @param entity [Object] the entity instance to validate.
+        	#
+        	# @return [Boolean]
+			def valid? entity
+				new(entity).valid?
+			end
+
+			# Raises exception if entity is invalid
+			#
+			# @example
+			#   person = Person.new
+			#   PersonValidator.validate!(person) # => Veto::InvalidEntity, ["first name is not present", "..."]    
+			#
+			# @param entity [Object] the entity instance to be validated.
+			# @raise [Veto::InvalidEntity] if the entity is invalid
+			def validate! entity
+				new(entity).validate!
+			end
+
+			private
+
+			def builder
+				@builder ||= ::Veto::Builder.new(self)
+			end
+		end
+
+		# Initializes validator
+		#
+		# @param entity [Object] the entity instance to validate.
+		def initialize entity
+			@entity = entity
+		end
+
+		# Returns validating entity instance
+		# @return [Object]
+		def entity
+			@entity
+		end
+
+		# Returns errors object
+		#
+        # @return [Veto::Errors]
+		def errors
+			@errors ||= ::Veto::Errors.new
+		end
+
+		# Sets errors to nil. 
+		def clear_errors
+			@errors = nil
+		end
+
+		# Returns boolean value representing the validaty of the entity
+		#
+        # @return [Boolean]
+		def valid?
+			execute
+			errors.empty?
+		end
+
+		# Raises exception if entity is invalid
+		#
+		# @example
+		#   person = Person.new
+		#   validator = PersonValidator.new(person)
+		#   validator.validate! # => Veto::InvalidEntity, ["first name is not present", "..."]    
+		#
+		# @raise [Veto::InvalidEntity] if the entity is invalid
+		def validate!
+			raise(::Veto::InvalidEntity, errors.full_messages) unless valid?
+		end
+
+		private
+
+		# Executes validation on the entity
+		def execute
+			clear_errors
+			run_validators
+			populate_entity_errors
+		end
+
+		# Runs each of the classes configured validators, passing the 
+		# validator instance, entity, and errors object as arguments.
+		# Each validator will inspect the entity, run validations, and 
+		# update the errors object according the the validation rules.
+		def run_validators
+			self.class.validators.each { |validator| validator.execute(self, entity, errors) }
+		end
+
+		# If the entity being validated has an errors accessor defined,
+		# assign the errors object to the entity.
+		def populate_entity_errors
+			if entity.respond_to?(:errors=)
+				entity.errors = errors
+			end
+		end
+	end
+end

data/lib/veto/validators/abstract_validator.rb

@@ -0,0 +1,15 @@
+require 'veto/conditions_evaluator'
+
+module Veto
+	class AbstractValidator
+		def execute(context, entity, errors)
+			raise NotImplementedError
+		end
+
+		private
+
+		def truthy_conditions?(conditions, context, entity)
+			ConditionsEvaluator.truthy_conditions?(conditions, context, entity)
+		end
+	end
+end

data/lib/veto/validators/attribute_validator.rb

@@ -0,0 +1,22 @@
+require 'veto/validators/abstract_validator'
+
+module Veto
+	class AttributeValidator < AbstractValidator
+		def initialize attribute, options={}
+			@attribute = attribute
+			@options = options
+		end
+
+		def execute context, entity, errors
+			if truthy_conditions?(@options, context, entity)
+				value = entity.public_send(@attribute)
+				validate(entity, @attribute, value, errors, @options)
+			end
+		end
+
+		def validate entity, attribute, value, errors, options={}
+			raise NotImplementedError
+		end
+	end
+end
+

data/lib/veto/validators/custom_method_validator.rb

@@ -0,0 +1,19 @@
+require 'veto/validators/abstract_validator'
+
+module Veto
+	class CustomMethodValidator < AbstractValidator
+
+		attr_reader :method_name, :conditions
+
+		def initialize method_name, conditions
+			@method_name = method_name
+			@conditions = conditions
+		end
+
+		def execute context, entity, errors
+			if truthy_conditions?(@conditions, context, entity)
+				context.send(method_name)
+			end
+		end
+	end
+end

data/lib/veto/validators/exact_length_validator.rb

@@ -0,0 +1,15 @@
+require 'veto/validators/attribute_validator'
+
+module Veto
+	class ExactLengthValidator < AttributeValidator
+		def validate entity, attribute, value, errors, options={}
+			exact = options.fetch(:with)
+			message = options.fetch(:message, :exact_length)
+			on = options.fetch(:on, attribute)
+			
+			if value.nil? || value.length != exact
+				errors.add(on, message, exact)
+			end
+		end
+	end
+end

data/lib/veto/validators/format_validator.rb

@@ -0,0 +1,15 @@
+require 'veto/validators/attribute_validator'
+
+module Veto
+	class FormatValidator < AttributeValidator
+		def validate entity, attribute, value, errors, options={}
+			pattern = options.fetch(:with)
+			message = options.fetch(:message, :format)
+			on = options.fetch(:on, attribute)
+			
+			unless value.to_s =~ pattern
+				errors.add(on, message)
+			end
+		end
+	end
+end

data/lib/veto/validators/inclusion_validator.rb

@@ -0,0 +1,16 @@
+require 'veto/validators/attribute_validator'
+
+module Veto
+	class InclusionValidator < AttributeValidator
+		def validate entity, attribute, value, errors, options={}
+			set = options.fetch(:in)
+			inclusion_method = set.respond_to?(:cover?) ? :cover? : :include?
+			message = options.fetch(:message, :inclusion)
+			on = options.fetch(:on, attribute)
+			
+			unless set.send(inclusion_method, value)
+				errors.add(on, message, set)
+			end
+		end
+	end
+end

data/lib/veto/validators/integer_validator.rb

@@ -0,0 +1,17 @@
+require 'veto/validators/attribute_validator'
+
+module Veto
+	class IntegerValidator < AttributeValidator
+		def validate entity, attribute, value, errors, options={}
+			message = options.fetch(:message, :integer)
+			on = options.fetch(:on, attribute)
+			
+			begin
+				Kernel.Integer(value.to_s)
+				nil
+			rescue
+				errors.add(on, message)
+			end
+		end
+	end
+end

data/lib/veto/validators/length_range_validator.rb

@@ -0,0 +1,16 @@
+require 'veto/validators/attribute_validator'
+
+module Veto
+	class LengthRangeValidator < AttributeValidator
+		def validate entity, attribute, value, errors, options={}
+			range = options.fetch(:in)
+			inclusion_method = range.respond_to?(:cover?) ? :cover? : :include?
+			message = options.fetch(:message, :length_range)
+			on = options.fetch(:on, attribute)
+			
+			if value.nil? || !range.send(inclusion_method, value.length)
+				errors.add(on, message)
+			end
+		end
+	end
+end

data/lib/veto/validators/max_length_validator.rb

@@ -0,0 +1,15 @@
+require 'veto/validators/attribute_validator'
+
+module Veto
+	class MaxLengthValidator < AttributeValidator
+		def validate entity, attribute, value, errors, options={}
+			max = options.fetch(:with)
+			message = options.fetch(:message, :max_length)
+			on = options.fetch(:on, attribute)
+			
+			if value.nil? || value.length > max
+				errors.add(on, message, max)
+			end
+		end
+	end
+end

data/lib/veto/validators/min_length_validator.rb

@@ -0,0 +1,15 @@
+require 'veto/validators/attribute_validator'
+
+module Veto
+	class MinLengthValidator < AttributeValidator
+		def validate entity, attribute, value, errors, options={}
+			min = options.fetch(:with)
+			message = options.fetch(:message, :min_length)
+			on = options.fetch(:on, attribute)
+			
+			if value.nil? || value.length < min
+				errors.add(on, message, min)
+			end
+		end
+	end
+end

data/lib/veto/validators/not_null_validator.rb

@@ -0,0 +1,14 @@
+require 'veto/validators/attribute_validator'
+
+module Veto
+	class NotNullValidator < AttributeValidator
+		def validate entity, attribute, value, errors, options={}
+			message = options.fetch(:message, :not_null)
+			on = options.fetch(:on, attribute)
+			
+			if value.nil?
+				errors.add(on, message)
+			end
+		end
+	end
+end

data/lib/veto/validators/numeric_validator.rb

@@ -0,0 +1,17 @@
+require 'veto/validators/attribute_validator'
+
+module Veto
+	class NumericValidator < AttributeValidator
+		def validate entity, attribute, value, errors, options={}
+			message = options.fetch(:message, :numeric)
+			on = options.fetch(:on, attribute)
+			
+			begin
+				Kernel.Float(value.to_s)
+				nil
+			rescue
+				errors.add(on, message)
+			end
+		end
+	end
+end

data/lib/veto/validators/presence_validator.rb

@@ -0,0 +1,15 @@
+require 'veto/validators/attribute_validator'
+
+module Veto
+	class PresenceValidator < AttributeValidator
+		def validate entity, attribute, value, errors, options={}
+			msg = options.fetch(:message, :presence)
+			on = options.fetch(:on, attribute)
+			v = value.is_a?(String) ? value.gsub(/\s+/, '') : value
+
+			if v.nil? || v.respond_to?(:empty?) && v.empty?
+				errors.add(on, msg)
+			end	
+		end
+	end
+end

data/lib/veto/version.rb

@@ -0,0 +1,3 @@
+module Veto
+  	VERSION = "0.0.1"
+end

data/lib/veto.rb

@@ -0,0 +1,53 @@
+require 'veto/version'
+require 'veto/model'
+require 'veto/validator'
+require 'veto/configuration'
+
+module Veto
+
+	# Provides access to the anonymous validator extension module
+	#
+	# @example 
+	# 	class PersonValidator
+	#    include Veto.validator
+	# 	end	
+	#
+	# @return [Module] the object converted into the expected format.
+	def self.validator
+		mod = Module.new
+		mod.define_singleton_method :included do |base|
+			base.send(:include, ::Veto::Validator)
+		end
+		mod
+	end
+
+	# Provides access to the anonymous model extension module
+	#
+	# @example 
+	# 	class Person
+	#    include Veto.model(PersonValidator)
+	# 	end	
+	#
+	# @param validator [Class] the Veto validator class
+	# @return [Module] the object converted into the expected format.
+	def self.model validator
+		mod = Module.new
+		mod.define_singleton_method :included do |base|
+			base.send(:include, ::Veto::Model)
+			base.validates_with validator
+		end
+		mod
+	end
+
+	def self.configure
+		yield(configuration)
+	end
+
+	def self.configuration
+		@configuration ||= ::Veto::Configuration.new
+	end
+
+	def self.configuration= val
+		@configuration = val
+	end
+end