boof-not-naughty 0.6.2

data/lib/not_naughty/validations/numericality_validation.rb

@@ -0,0 +1,43 @@
+NotNaughty::Validation.load :format
+
+module NotNaughty
+
+  # == Validates numericality of obj's attribute via an regular expression.
+  #
+  # Unless the validation succeeds an error hash (:attribute => :message)
+  # is added to the obj's instance of Errors.
+  #
+  # <b>Options:</b>
+  # <tt>:only_integer</tt>:: validates with <tt>/^[+-]?\d+$/</tt> (false)
+  # <tt>:message</tt>:: see NotNaughty::Errors for details
+  # <tt>:if</tt>:: see NotNaughty::Validation::Condition for details
+  # <tt>:unless</tt>:: see NotNaughty::Validation::Condition for details
+  #
+  # <b>Example:</b>
+  #
+  #   obj = '-12.2' #
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  #   NumericalityValidation.new({}, :to_s).call obj, :to_s, '-12.2'
+  #   obj.errors.on(:to_s).any? # => false
+  #
+  #   NumericalityValidation.new({:only_integer => true}, :to_s).
+  #     call obj, :to_s, '-12.2'
+  #
+  #   obj.errors.on(:to_s).any? # => true
+  class NumericalityValidation < FormatValidation
+
+    def initialize(valid, attributes) #:nodoc:
+      valid[:with] = if valid[:only_integer]
+        valid[:message] ||= '%s is not an integer.'
+        /^[+-]?\d+$/
+      else
+        valid[:message] ||= '%s is not a number.'
+        /^[+-]?\d*\.?\d+$/
+      end
+
+      super valid, attributes
+    end
+
+  end
+end

data/lib/not_naughty/validations/presence_validation.rb

@@ -0,0 +1,32 @@
+module NotNaughty
+
+  # == Validates presence of obj's attribute via the <tt>:blank?</tt> method.
+  #
+  # Unless the validation succeeds an error hash (:attribute => :message)
+  # is added to the obj's instance of Errors.
+  #
+  # <b>Options:</b>
+  # <tt>:message</tt>:: see NotNaughty::Errors for details
+  # <tt>:if</tt>:: see NotNaughty::Validation::Condition for details
+  # <tt>:unless</tt>:: see NotNaughty::Validation::Condition for details
+  #
+  # <b>Example:</b>
+  #
+  #   obj = '' # blank? => true
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  #   PresenceValidation.new({}, :to_s).call obj, :to_s, ''
+  #   obj.errors.on(:to_s) # => ["To s is not present."]
+  class PresenceValidation < Validation
+
+    def initialize(valid, attributes) #:nodoc:
+      valid[:message] ||= '%s is not present.'
+
+      super valid, attributes do |obj, attr, value|
+        value.blank? and
+        obj.errors.add attr, valid[:message]
+      end
+    end
+
+  end
+end

data/lib/not_naughty/validator.rb

@@ -0,0 +1,125 @@
+module NotNaughty
+
+  # == Superclass for all Adapters.
+  #
+  # See new and get_state for more information.
+  class Validator
+
+    attr_reader :states, :error_handler
+
+    # By default it comes with the :default State unless other states are
+    # provided.
+    #
+    # <b>Example:</b>
+    #   NotNaughty::Validator.new
+    #     # has the :default state
+    #   NotNaughty::Validator.new :create, :update
+    #     # has the :create and :update states
+    #
+    # <em>Adapters should overwrite this method.</em>
+    def initialize(*states)
+      states << :default if states.empty?
+
+      @states         = states.inject({}) {|m, s| m.update s => State.new(s)}
+      @initial_state  = @states[states.first]
+
+      @error_handler  = NotNaughty::ErrorHandler.new
+    end
+
+    def clone #:nodoc:
+      states = [@initial_state.name] | @states.keys
+      error_handler = @error_handler.clone
+
+      clone = self.class.new(*states)
+      @states.each do |n, s|
+        s.validations.each { |a, v| clone.states[n].validations[a] = v.clone }
+      end
+      clone.instance_eval do
+        @initial_state = @states[states.first]
+        @error_handler = error_handler
+      end
+
+      clone
+    end
+
+    # Returns the state for the given object. By default it does return the
+    # initial state.
+    #
+    # <em>Adapters that provide multiple states should eventually overwrite
+    # this method</em>.
+    def get_state(obj = nil) @initial_state end
+
+    # Adds a validation to all/specified states.
+    #
+    # <b>Example:</b>
+    #   add_validation(:firstname, :lastname, :on => :default) {|o, a, v|}
+    #     # adds validation to :default state
+    #   add_validation(:firstname, :lastname) {|o, a, v|}
+    #     # adds validation to all states
+    #   add_validation(:first, :last, :on => [:create, :update]) {|o, a, v|}
+    #     # adds validation to :create and :update states
+    def add_validation(*p, &b)
+      options = (p.last.is_a? Hash) ? p.last : {}
+
+      if states = options.delete(:on)
+        @states.values_at(*states).each do |state|
+          state.add_validation(*p, &b) unless state.nil?
+        end
+      else
+        @states.each { |name, state| state.add_validation(*p, &b) }
+      end
+    end
+
+    # Returns true if given object has validations in its current state. If
+    # no object was given it returns true if any state has validations. It
+    # otherwise returns false.
+    def has_validations?(obj = nil)
+      if obj.nil? then @states.any? { |name, state| state.has_validations? }
+      else get_state(obj).has_validations? end
+    end
+
+    # Runs all validations on object for the object's state.
+    def invoke(obj)
+      get_state(obj).validations.each do |attr, validations|
+        val = obj.send attr
+        validations.each { |validation| validation.call obj, attr, val }
+      end
+    end
+
+    # == Container for attribute specific validations
+    #
+    # See Validator for details.
+    class State
+
+      attr_reader :validations, :name
+
+      # Initializes the state with given name.
+      def initialize(name = :default)
+        @name, @validations = name, Hash.new {|h, k| h[k] = []}
+      end
+
+      # Adds the validation that results from <tt>params</tt> and
+      # <tt>block</tt> to validated attributes (see Validation#new for
+      # details).
+      def add_validation(*params, &block)
+        validation = Validation.new(*params, &block)
+
+        validation.attributes.each do |attribute|
+          @validations[attribute] << validation if attribute.is_a? Symbol
+        end
+      end
+
+      # Returns validations for given attribute.
+      def [](attribute)
+        @validations[attribute]
+      end
+
+      # Returns true if a attributes has validations assigned, false
+      # otherwise.
+      def has_validations?
+        @validations.any? { |attribute, validations| validations.any? }
+      end
+
+    end
+  end
+end

data/lib/not_naughty/violation.rb

@@ -0,0 +1,36 @@
+module NotNaughty
+
+  # == Container for failed validations.
+  #
+  # ...
+  class Violation < RuntimeError
+    extend Forwardable
+
+    def_delegators :@errors, :empty?, :clear, :[], :each
+
+    include Enumerable
+
+    def initialize() #:nodoc:
+      @errors = Hash.new {|h, k| h[k] = []}
+    end
+    # Adds an error for the given attribute.
+    def add(k, msg)  @errors[k] << msg end
+
+    # Returns an array of fully-formatted error messages.
+    def full_messages
+      @errors.inject([]) do |messages, k_errors| k, errors = *k_errors
+        errors.each {|e| messages << eval(e.inspect.delete('\\') % k) }
+        messages
+      end
+    end
+
+    # Returns an array of evaluated error messages for given attribute.
+    def on(attribute)
+      @errors[attribute].map do |message|
+        eval(message.inspect.delete('\\') % attribute)
+      end
+    end
+
+  end
+
+end

data/spec/error_handler_spec.rb

@@ -0,0 +1,21 @@
+require "#{ File.dirname(__FILE__) }/spec_helper.rb"
+
+describe subject::ErrorHandler do
+  before(:each) { @eh = subject::ErrorHandler.new }
+
+  it "passed all Exceptions to Kernel.raise" do
+    proc { @eh.raise Exception.new }.should raise_error(Exception)
+  end
+
+  it "calls the closest handle" do
+    @eh.handle(ArgumentError) {ArgumentError}
+    @eh.handle(StandardError) {StandardError}
+
+    @eh.raise(ArgumentError.new).should == ArgumentError
+    @eh.raise(StandardError.new).should == StandardError
+    @eh.raise(NoMethodError.new).should == StandardError
+
+    proc { @eh.raise ScriptError.new }.should raise_error(Exception)
+  end
+
+end

data/spec/not_naughty_spec.rb

@@ -0,0 +1,82 @@
+require "#{ File.dirname(__FILE__) }/spec_helper.rb"
+
+module subject::ClassMethods
+  def self.extended(base) end
+end
+module subject::InstanceMethods
+  def self.included(base) end
+end
+
+describe subject do
+
+  it "should load necessary files" do
+    subject::should be_const_defined(:Validation)
+    subject::should be_const_defined(:Validator)
+    subject::should be_const_defined(:ClassMethods)
+    subject::should be_const_defined(:InstanceMethods)
+    subject::should be_const_defined(:Violation)
+  end
+  it "should define a validator" do
+    validated = Class.new(Object).extend subject
+    validated.should respond_to(:validator)
+    validated.validator(:state).should be_an_instance_of(subject::Validator)
+    validated.validator.states.should have_key(:state)
+
+    validator = Class.new(subject::Validator)
+    validated = Class.new(Object).extend subject
+    validated.validator validator, :create, :update
+    validated.validator.should be_an_instance_of(validator)
+    validated.validator.states.keys.should include(:create, :update)
+  end
+  it "should extend the receiver if validator is defined" do
+    validated = Class.new(Object)
+
+    subject::ClassMethods.should_receive(:extended).with(validated)
+    subject::InstanceMethods.should_receive(:included).with(validated)
+
+    validated.extend subject
+  end
+  it "should deep-clone the validator if inherited" do
+    super_validated = Class.new(Object).extend subject
+    super_validated.validator.add_validation(:name) {|o, a, v|}
+    validated = Class.new(super_validated)
+
+    validated.validator.should_not == super_validated.validator
+    validated.validator.should have_validations
+    validated.validator.add_validation(:name) {|o, a, v|}
+
+    super_validated.validator.get_state.validations[:name].length.
+    should < validated.validator.get_state.validations[:name].length
+  end
+  it "should prepend a validation before any method" do
+    validated = Class.new(Object).extend subject
+
+    validated.validated_before :clone
+    instance = validated.new
+    instance.should_receive(:valid?).once.and_return(true)
+    instance.should_receive(:clone_without_validations)
+    instance.clone
+  end
+  it "should raise an exception if invalid and method called" do
+    validated = Class.new(Object).extend subject
+
+    validated.validated_before :clone
+    instance = validated.new
+    instance.should_receive(:valid?).once.and_return(false)
+    lambda { instance.clone }.should raise_error(subject::Violation)
+  end
+  it "should return false if invalid and method called" do
+    validated = Class.new(Object).extend subject
+
+    validated.validated_before :clone
+    validated.validator.error_handler.handle(subject::Violation) {false}
+    instance = validated.new
+    instance.should_receive(:valid?).once.and_return(false)
+    instance.clone.should == false
+  end
+  it "should add ClassMethods to Validation observers" do
+    subject::Validation.instance_variable_get(:@observer_peers).
+    should include(subject::ClassMethods)
+  end
+
+end

data/spec/rcov.opts

@@ -0,0 +1,4 @@
+--exclude
+gems
+--exclude
+spec

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--backtrace
+--format
+specdoc
+--diff

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'spec'
+
+require "#{ File.dirname __FILE__ }/../lib/not_naughty.rb"
+NotNaughty::Validation.load 'format', 'presence'
+
+def subject() ::NotNaughty end
+def h(something)
+  puts '<pre>%s</pre>' %
+  something.inspect.gsub(/[<>]/) {|m| (m == '<')? '&lt;': '&gt;'}
+end

data/spec/validation_spec.rb

@@ -0,0 +1,117 @@
+require "#{ File.dirname __FILE__ }/spec_helper.rb"
+
+describe subject::Validation do
+
+  it "should register validations if inherited" do
+    subject::ClassMethods.
+      should_receive(:update).once.
+      with Class.new(subject::Validation)
+  end
+  it "should build validations with block" do
+    block = proc {|o, a, v|}
+    validation = subject::Validation.new({}, &block)
+
+    validation.instance_variable_get(:@block).should == block
+  end
+  it "should alias call to call_without_conditions" do
+    validation = subject::Validation.new({}) {|o, a, v|}
+
+    validation.method(:call).
+    should == validation.method(:call_without_conditions)
+  end
+  it "should not build conditions" do
+    validation = subject::Validation.
+    new({:if => nil, :unless => nil}) {|o, a, v|}
+
+    validation.instance_variable_get(:@conditions).should be_empty
+  end
+  it "should build conditions" do
+    validation = subject::Validation.new({:if => :nil?}) {|o, a, v|}
+    validation.instance_variable_get(:@conditions).should_not be_empty
+
+    validation.instance_variable_get(:@conditions).
+    first.instance_variable_get(:@condition).
+    should == :nil?
+  end
+  it "should alias call to call_with_conditions" do
+    validation = subject::Validation.new({:if => :nil?}) {|o, a, v|}
+
+    validation.method(:call).
+    should == validation.method(:call_with_conditions)
+  end
+  it "should call" do
+    probe = mock 'Probe'
+    probe.should_receive(:test).exactly(3).times
+
+    validation = subject::Validation.
+      new({}) { |o, a, v| [o, a, v].each { |p| p.test } }
+
+    validation.call probe, probe, probe
+  end
+  it "should call unless a condition passes" do
+    probe = mock 'Probe'
+    probe.stub!(:nil?).and_return(true)
+
+    validation = subject::Validation.
+      new({:unless => :nil?}) { |o, a, v| [o, a, v].each { |p| p.test } }
+
+    validation.call probe, probe, probe
+
+    probe.should_receive(:test).exactly(3).times
+    probe.stub!(:nil?).and_return(false)
+
+    validation.call probe, probe, probe
+  end
+  it "should not call" do
+    probe = mock 'Probe'
+    probe.should_not_receive(:test)
+
+    validation = subject::Validation.
+      new({:if => :nil?}) { |o, a, v| [o, a, v].each { |p| p.test } }
+
+    validation.call probe, probe, probe
+
+  end
+  it "should have validated attributes accessable" do
+    validation = subject::Validation.new(:probe)
+    validation.attributes.should include(:probe)
+  end
+  it "should clone observer peers to descendant" do
+    peers = subject::Validation.instance_variable_get :@observer_peers
+    peers.should_receive(:clone).and_return(true)
+    descendant = Class.new(subject::Validation)
+    descendant.instance_variable_get(:@observer_peers).should be_true
+  end
+
+end
+
+describe subject::Validation::Condition do
+
+  it "should evaluate positive callable" do
+    condition = subject::Validation::Condition.new proc {|o| o.nil?}
+    condition.evaluate(nil).should be_true
+  end
+  it "should evaluate negative callable" do
+    condition = subject::Validation::Condition.new proc {|o| o.nil?}, false
+    condition.evaluate(nil).should be_false
+  end
+  it "should evaluate positive Symbol" do
+    condition = subject::Validation::Condition.new :nil?
+    condition.evaluate(nil).should be_true
+  end
+  it "should evaluate negative Symbol" do
+    condition = subject::Validation::Condition.new :nil?, false
+    condition.evaluate(nil).should be_false
+  end
+  it "should evaluate positive UnboundMethod" do
+    um = NilClass.instance_method :nil?
+    condition = subject::Validation::Condition.new um
+    condition.evaluate(nil).should be_true
+  end
+  it "should evaluate negative UnboundMethod" do
+    um = NilClass.instance_method :nil?
+    condition = subject::Validation::Condition.new um, false
+    condition.evaluate(nil).should be_false
+  end
+
+end