veto 0.1.3 → 1.0.0

data/lib/veto/conditions/primative_condition.rb

@@ -0,0 +1,11 @@
+module Veto
+  class PrimativeCondition < Condition
+    def initialize(object)
+      @object = object
+    end
+
+    def pass?(*args)
+      !!@object
+    end
+  end
+end

data/lib/veto/conditions/proc_condition.rb

@@ -0,0 +1,11 @@
+module Veto
+  class ProcCondition < Condition
+    def initialize(proc)
+      @proc = proc
+    end
+
+    def pass?(cco)
+      !!@proc.call(cco.entity)
+    end
+  end
+end

data/lib/veto/conditions/unless_conditions.rb

@@ -0,0 +1,8 @@
+module Veto
+  class UnlessConditions < Conditions
+    def pass?(*args)
+      conditions.each {|c| return(false) if c.pass?(*args) } 
+      true
+    end
+  end
+end

data/lib/veto/configuration.rb

@@ -1,46 +1,47 @@
 module Veto
-	class Configuration
-		class Message
-			DEFAULT_MESSAGES = {
-				:exact_length 				=> lambda{|exact| "is not #{exact} characters"},
-				:format 					=> lambda{"is not valid"},
-				:greater_than				=> lambda{|boundary| "must be greater than #{boundary}"},
-				:greater_than_or_equal_to	=> lambda{|boundary| "must be greater than or equal to #{boundary}"},
-				:inclusion 					=> lambda{|set| "is not in set: #{set.inspect}"},
-				:integer 					=> lambda{"is not a number"},
-				:length_range 				=> lambda{"is too short or too long"},
-				:less_than					=> lambda{|boundary| "must be less than #{boundary}"},
-				:less_than_or_equal_to		=> lambda{|boundary| "must be less than or equal to #{boundary}"},
-				: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"}
-			}	
+  class Configuration
+    class Message
+      DEFAULT_MESSAGES = {
+        :default                  => lambda {"is not valid"},
+        :exact_length             => lambda {|exact| "is not #{exact} characters"},
+        :format                   => lambda {"is not valid"},
+        :greater_than             => lambda {|boundary| "must be greater than #{boundary}"},
+        :greater_than_or_equal_to => lambda {|boundary| "must be greater than or equal to #{boundary}"},
+        :inclusion                => lambda {|set| "is not in set: #{set.inspect}"},
+        :integer                  => lambda {"is not a number"},
+        :length_range             => lambda {"is too short or too long"},
+        :less_than                => lambda {|boundary| "must be less than #{boundary}"},
+        :less_than_or_equal_to    => lambda {|boundary| "must be less than or equal to #{boundary}"},
+        :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 initialize
+        @messages = {}
+      end
 
-			def set type, proc
-				custom_messages[type] = proc
-			end
+      def get(type, *args)
+        args.compact.length > 0 ? message(type).call(*args) : message(type).call
+      end
 
-			private
+      def set(type, proc)
+        @messages[type] = proc
+      end
 
-			def custom_messages
-				@custom_messages ||= {}
-			end
+      private
 
-			def message type
-				custom_messages[type] || DEFAULT_MESSAGES.fetch(type)
-			end
-		end
+      def message(type)
+        @messages[type] || DEFAULT_MESSAGES[type] || DEFAULT_MESSAGES[:default]
+      end
+    end
 
-		attr_reader :message
+    attr_reader :message
 
-		def initialize
-			@message = Message.new
-		end
-	end
+    def initialize
+      @message = Message.new
+    end
+  end
 end

data/lib/veto/errors.rb

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

@@ -1,5 +1,15 @@
 module Veto
-	class VetoError < StandardError; end
-	class InvalidEntity < VetoError; end
-	class ValidatorNotAssigned < VetoError; end
+  class VetoError < StandardError; end
+  
+  class CheckNotAssigned < VetoError; end
+
+  class InvalidEntity < VetoError
+    def initialize(errors)
+      @errors = errors
+    end
+
+    def message
+      @errors.full_messages
+    end
+  end
 end

data/lib/veto/model.rb

@@ -1,37 +1,35 @@
-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
+  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?(self)
+    end
+
+    def validate!
+      validator.validate!(self)
+    end
+
+    def errors
+      validator.errors
+    end
+
+    private
+
+    def validator
+      self.class.validator
+    end
+  end
 end

data/lib/veto/validator.rb

@@ -1,171 +1,70 @@
-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? *args
-				new(*args).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! *args
-				new(*args).validate!
-			end
-
-			private
-
-			def builder
-				@builder ||= ::Veto::Builder.new(self)
-			end
-
-			# Ensures that when a Validator class is subclassed, the 
-			# validation rules will be carried into the subclass as well,
-			# where they may be added upon.
-			# 
-			# @example
-			# 	class PersonValidator
-			# 		include Veto.validator
-			# 		validates :name, :presence => true
-			# 	end
-			#
-			# 	class EmployeeValidator < PersonValidator
-			# 		validates :employee_id, :presence => true
-			# 	end
-			#
-			# 	employee = Employee.new
-			# 	EmployeeValidator.validate!(employee) # => ["name is not present", "employee_id is not present"]
-						
-			def inherited(descendant)
-				descendant.validate_with validators
-			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
+  module Validator
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def with_options(*args, &block)
+        checker.with_options(*args, &block)
+      end
+
+      def validates(*args)
+        checker.validates(*args)
+      end
+
+      def validate(*args)
+        checker.validate(*args)
+      end
+
+      def check_with(val)
+        @checker = val
+      end
+
+      def checker
+        @checker ||= build_checker
+      end
+
+      private
+
+      def build_checker(children=[])
+        Checker.from_children(children)
+      end
+
+      def inherited(descendant)
+        descendant.check_with(build_checker(checker.children.dup))
+      end
+    end
+
+    def errors
+      @errors ||= ::Veto::Errors.new
+    end
+
+    def valid?(entity)
+      validate(entity)
+      errors.empty?
+    end
+
+    def validate!(entity)
+      raise(::Veto::InvalidEntity, errors) unless valid?(entity)
+    end
+
+    private
+
+    def clear_errors
+      @errors = nil
+    end
+
+    def validate(entity)
+      clear_errors
+      self.class.checker.call(CheckContextObject.new(entity, self, errors))
+      populate_entity_errors(entity)
+    end
+
+    def populate_entity_errors(entity)
+      if entity.respond_to?(:errors=)
+        entity.errors = errors
+      end
+    end
+  end
 end

data/lib/veto/version.rb

@@ -1,3 +1,3 @@
 module Veto
-  	VERSION = "0.1.3"
+  	VERSION = "1.0.0"
 end

data/lib/veto.rb

@@ -1,53 +1,94 @@
+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 ||= Configuration.new
+  end
+end
+
+# base
 require 'veto/version'
-require 'veto/model'
-require 'veto/validator'
+require 'veto/exceptions'
+require 'veto/errors'
 require 'veto/configuration'
+require 'veto/check_context_object'
 
-module Veto
+# conditions
+require 'veto/conditions/condition'
+require 'veto/conditions/entity_eval_condition'
+require 'veto/conditions/context_method_condition'
+require 'veto/conditions/proc_condition'
+require 'veto/conditions/primative_condition'
+require 'veto/conditions/conditions'
+require 'veto/conditions/if_conditions'
+require 'veto/conditions/unless_conditions'
+require 'veto/conditions/if_unless_conditions'
+require 'veto/conditions/condition_factory'
+
+# checks
+require 'veto/checks/check'
+require 'veto/checks/method_check'
+require 'veto/checks/attribute_check'
+require 'veto/checks/exact_length_check'
+require 'veto/checks/format_check'
+require 'veto/checks/greater_than_or_equal_to_check'
+require 'veto/checks/greater_than_check'
+require 'veto/checks/inclusion_check'
+require 'veto/checks/integer_check'
+require 'veto/checks/length_range_check'
+require 'veto/checks/less_than_or_equal_to_check'
+require 'veto/checks/less_than_check'
+require 'veto/checks/max_length_check'
+require 'veto/checks/min_length_check'
+require 'veto/checks/not_null_check'
+require 'veto/checks/numeric_check'
+require 'veto/checks/presence_check'
+require 'veto/checks/check_factory'
 
-	# 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
+# validates
+require 'veto/blocks/block'
+require 'veto/blocks/conditional_block'
+require 'veto/blocks/validate_block'
+require 'veto/blocks/validates_block'
+require 'veto/blocks/with_options_block'
+require 'veto/blocks/checker'
+
+# modules
+require 'veto/validator'
+require 'veto/model'