veto 0.1.3 → 1.0.0

data/lib/veto/conditions_evaluator.rb

@@ -1,30 +0,0 @@
-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/validators/abstract_validator.rb

@@ -1,15 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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/spec/attribute_validator_factory_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'veto/attribute_validator_factory'
-require 'veto'
-
-describe Veto::AttributeValidatorFactory do
-	let(:factory) { Veto::AttributeValidatorFactory }
-	let(:type) { :format }
-
-	describe '::new_validator' do
-		let(:attribute){ :first_name }
-		let(:options) { {} }
-		let(:result) { factory.new_validator(type, attribute, options) }
-	
-		context 'when type is exact_length' do
-			let(:type) { :exact_length }
-			it { result.must_be_instance_of Veto::ExactLengthValidator }
-		end
-
-		context 'when type is format' do
-			let(:type) { :format }
-			it { result.must_be_instance_of Veto::FormatValidator }
-		end
-
-		context 'when type is inclusion' do
-			let(:type) { :inclusion }
-			it { result.must_be_instance_of Veto::InclusionValidator }
-		end
-
-		context 'when type is integer' do
-			let(:type) { :integer }
-			it { result.must_be_instance_of Veto::IntegerValidator }
-		end
-
-		context 'when type is length_range' do
-			let(:type) { :length_range }
-			it { result.must_be_instance_of Veto::LengthRangeValidator }
-		end
-
-		context 'when type is max_length' do
-			let(:type) { :max_length }
-			it { result.must_be_instance_of Veto::MaxLengthValidator }
-		end
-
-		context 'when type is min_length' do
-			let(:type) { :min_length }
-			it { result.must_be_instance_of Veto::MinLengthValidator }
-		end
-
-		context 'when type is not_null' do
-			let(:type) { :not_null }
-			it { result.must_be_instance_of Veto::NotNullValidator }
-		end
-
-		context 'when type is numeric' do
-			let(:type) { :numeric }
-			it { result.must_be_instance_of Veto::NumericValidator }
-		end
-
-		context 'when type is presence' do
-			let(:type) { :presence }
-			it { result.must_be_instance_of Veto::PresenceValidator }
-		end
-
-		context 'when type not recognized' do
-			let(:type) { :blah }
-			it 'raises error' do
-				e = proc{ result }.must_raise(ArgumentError)
-				e.message.must_equal 'Validator not found: ::Veto::BlahValidator'
-			end
-		end
-	end
-end

data/spec/builder_spec.rb

@@ -1,38 +0,0 @@
-# require 'spec_helper'
-# require 'veto/builder'
-
-# describe Veto::Builder do
-# 	let(:context) {stub}
-# 	let(:context_conditions){ {:if => :is_good?} }
-# 	let(:builder) { Veto::Builder.new(context, context_conditions) }
-
-# 	describe '#with_options' do
-# 		it 'returns new builder instance' do
-# 			result = builder.with_options(:if => :is_tasty?, :unless => :rotten?)
-# 			result.must_be_instance_of Veto::Builder
-# 		end
-
-# 		it 'passes conditions to instance as new conditions context' do
-# 			result = builder.with_options(:if => :is_tasty?, :unless => :rotten?)
-# 			result.conditions_context.must_equal({:if=>[:is_good?, :is_tasty?], :unless=>[:rotten?]})
-# 		end
-# 	end
-
-# 	describe '#validates' do
-# 		it 'passes list of validators to validates_with' do
-# 			validators = stub
-# 			Veto::Builder::ValidatesBuilder.expects(:validators).returns(validators)
-# 			builder.expects(:validate_with).with(validators)
-# 			builder.validates(:first_name, :presence => true, :if => 'high5')
-# 		end
-# 	end
-
-# 	describe '#validate' do
-# 		it 'passes list of validators to validates_with' do
-# 			validators = stub
-# 			builder.expects(:validate_with)
-# 			Veto::Builder::ValidateBuilder.expects(:validators).returns(validators)
-# 			builder.validate(:meth1, :meth2, :if => :cond1)
-# 		end
-# 	end
-# end

data/spec/conditions_evaluator_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-require 'veto/conditions_evaluator'
-
-describe Veto::ConditionsEvaluator do
-	let(:conditions){}
-	let(:entity){Object.new}
-	let(:context){Object.new}
-	let(:evaluator) { Veto::ConditionsEvaluator.new(conditions) }
-	
-	describe '::truthy?' do
-		let(:condition){}
-		let(:result) { Veto::ConditionsEvaluator.truthy?(condition, context, entity) }
-
-		context 'when condition is true' do
-			let(:condition) { true }
-			it { result.must_equal true }
-		end
-
-		context 'when condition is false' do
-			let(:condition) { false }
-			it { result.must_equal false }
-		end
-
-		context 'when condition is nil' do
-			let(:condition) { nil }
-			it { result.must_equal false }
-		end
-
-		context 'when condition is 0' do
-			let(:condition) { 0 }
-			it { result.must_equal true }
-		end
-
-		context 'when condition is string' do
-			let(:entity) { stub(:is_alive => true) }
-			let(:condition) { 'is_alive' }
-			it { result.must_equal true }
-		end
-
-		context 'when condition is empty string' do
-			let(:condition) { '' }
-			it { result.must_equal false }
-		end
-
-		context 'when condition is empty hash' do
-			let(:condition) { {} }
-			it { result.must_equal true }
-		end
-
-		context 'when condition is method_name symbol' do
-			let(:context) { stub(:active? => true) }
-			let(:condition) { :active? }
-			it { result.must_equal true }
-		end
-
-		context 'when condition is proc' do
-			let(:entity) { stub(:is_alive => true) }
-			let(:condition) { Proc.new{|e| e.is_alive } }
-			it { result.must_equal true }
-		end
-	end
-
-	describe '::truthy_conditions?' do
-		let(:conditions){}
-		let(:result) { Veto::ConditionsEvaluator.truthy_conditions?(conditions, context, entity) }
-
-		context 'when no conditions are assigned' do
-			let(:conditions){{}}
-			it { result.must_equal true }	
-		end
-
-		context 'when if conditions return true' do
-			context 'when unless conditions return false' do
-				let(:conditions){{:if => [true, true], :unless => [false, false]}}
-				it { result.must_equal true }
-			end
-
-			context 'when one unless conditions returns true' do
-				let(:conditions){{:if => [true, true], :unless => [true, false]}}
-				it { result.must_equal false }
-			end
-		end
-
-		context 'when one if condition returns false' do
-			let(:conditions){{:if => [false, true], :unless => [false, false]}}
-			it { result.must_equal false }
-		end
-	end
-
-end

data/spec/conditions_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'veto/conditions'
-
-describe Veto::Conditions do
-	let(:params){{:if => :condition1, :unless => :condition2}}
-	let(:conditions){ Veto::Conditions.new(params) }
-
-	describe '::merge' do
-		it 'extracts and merges condition values' do
-			cond1 = {:if => [:is_good?, :is_tasty?]}
-			cond2 = {:if => "shaking", :unless => :is_bad?, :anotherkey => 'value'}
-			result = Veto::Conditions.merge(cond1, cond2)
-			result.must_equal({:if => [:is_good?, :is_tasty?, "shaking"], :unless => [:is_bad?]})
-		end
-	end
-end

data/spec/configuration_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'veto/configuration'
-
-describe Veto::Configuration do
-	let(:configuration){ Veto::Configuration.new }
-end

data/spec/errors_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'veto/errors'
-require 'veto'
-
-describe Veto::Errors do
-	let(:errors){ Veto::Errors.new }
-	describe '#add' do
-		context 'when message is string' do
-			it 'adds message to errors' do
-				errors.add(:name, 'is too long')
-				errors[:name].must_equal ['is too long']
-			end
-		end
-
-		context 'when message contains message dictionary key' do
-			it 'adds dictionary message to errors' do
-				errors.add(:name, :presence)
-				errors[:name].must_equal ["is not present"]
-			end
-		end
-	end
-end

data/spec/model_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-require 'veto/model'
-
-describe Veto::Model do
-	let(:validator){stub}
-	let(:validator_class){stub(:new => validator)}
-	let(:entity_class) {  
-		klass = Class.new{
-			include Veto::Model
-			attr_accessor :first_name, :last_name
-		}
-		klass.validates_with validator_class
-		klass
-	}
-	let(:entity){ entity_class.new }
-
-	describe '::validates_with' do
-		it 'assigns validator' do
-			obj = Object.new
-			entity_class.validates_with obj
-			entity_class.validator.must_equal obj
-		end
-	end
-
-	describe '::validator' do
-		context 'when validator is assigned' do
-			it 'returns validator' do
-				entity_class.validator.must_equal validator_class
-			end
-		end
-
-		context 'when validator is not assigned' do
-			before { entity_class.validates_with nil }
-
-			it 'raises error' do
-				proc{ entity_class.validator }.must_raise ::Veto::ValidatorNotAssigned
-			end
-		end
-	end
-
-	describe '#validator' do
-		it 'initializes, memoizes, and returns validator instance' do
-			entity.send(:validator).must_equal validator
-		end
-	end
-
-	describe '#errors' do
-		it 'delegates method to validator' do
-			validator.expects(:errors)
-			entity.errors
-		end
-	end
-
-	describe '#valid?' do
-		it 'delegates method to validator' do
-			validator.expects(:valid?)
-			entity.valid?
-		end
-	end
-
-	describe '#validate!' do
-		it 'delegates method to validator' do
-			validator.expects(:validate!)
-			entity.validate!
-		end
-	end
-end