activespec 0.1

data/README

@@ -0,0 +1,75 @@
+= ActiveSpec - Ruby Specifications Library
+
+ActiveSpec is a Ruby implementation of the Specification pattern. It was born out of the desire to implement more complicated validations than the built-in Ruby On Rails validations macros allow and can be used with both Rails and non-Rails applications.
+
+== Installation
+
+ActiveSpec can currently be downloaded from Subversion. The repository URL is:
+
+  http://opensource.agileevolved.com/svn/root/activespec/trunk
+
+It will be released as a gem shortly.
+
+== Overview
+
+ActiveSpec is comprised of four main components:
+
+=== 1. A set of low-level Specification classes
+Many of these are designed to work with one or more attributes of a given object and are mostly modelled on the existing set of Ruby On Rails validation macros. There is also a CompositeSpecification class for working with more than one specification at one time. It is also very easy (and actively encouraged) to create your own low-level Specification classes. See ActiveSpec::Specifications for more information.
+
+=== 2. ActiveSpec::Base class
+This can be sub-classed to create specifications in a more declarative manner. Here is a small example:
+
+  class UserSpecification < ActiveSpec::Base
+    requires_presence_of     :username, :password
+    requires_confirmation_of :password
+  end
+
+The main interface for any specification is a <tt>satisfied_by?</tt> method. The low-level specification classes (including CompositeSpecification) define <tt>satisfied_by?</tt> as an instance method and the ActiveSpec::Base specifications define it as a class method (it is not necessary to instantiate ActiveSpec::Base specifications).
+
+=== 3. High-level specification DSL
+ActiveSpec provides a high level DSL for creating specifications, that builds on top of ActiveSpec::Base. An alternative way of creating the above UserSpecification using the specification DSL would be:
+
+  specification :user do 
+    requires_presence_of     :username, :password
+    requires_confirmation_of :password
+  end
+
+This will automatically create a UserSpecification class with the given specifications. See ActiveSpec::Context for more information.
+
+=== 4. ActiveSpec::Satisfies module
+The Satisfies module can be included into your own classes to provide functionality for working with specifications. This will allow you to directly associate specifications with your classes in a style similar to using Rails' validates_* macros.
+
+  class User
+    include ActiveSpec::Satisifies
+
+    must_satisfy :user_specification
+  end
+
+  user = User.new
+  user.satisfies_specs?
+
+For more information, see ActiveSpec::Satisfies.
+  
+Also included with the library is a helper function for pre-loading specification classes in a given directory. See ActiveSpec#preload_specifications.
+
+== Rails integration
+
+You can use ActiveSpec in your Rails app with your ActiveRecord model classes by adding the following lines to your environment.rb file:
+
+  require 'active_spec'
+  ActiveRecord::Base.send(:include, ActiveSpec::Satisfies)
+
+You will currently have to deal with the loading of your specification files yourself and you might find the preload_specifications method handy for this. There are plans to make integration with a Rails app even easier with an ActiveSpec Rails plugin in the near future.
+
+== Future plans
+
+One of the main features that ActiveSpec is missing that Rails' validations module provides is error message functionality. This will eventually be added to ActiveSpec, possibly with integration into the ActiveRecord::Errors class.
+
+== Comments and feedback
+
+Please send any comments to contact [AT] lukeredpath [DOT] co [DOT] uk. Please report any bugs on the Agile Evolved Open Source Trac at http://opensource.agileevolved.com.
+
+== Credits
+
+Copyright (c) Luke Redpath 2006. Released under the MIT license.

data/lib/active_spec.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'active_support'
+
+module ActiveSpec
+  
+  # Globs the given path for files with the name
+  # *_specification.rb and requires any files that it finds.  
+  def self.preload_specifications(path_to_specs)
+    Dir.glob("#{path_to_specs}/*_specification.rb").each do |f|
+      require "#{path_to_specs}/#{File.basename(f, ".rb")}"
+    end
+  end
+  
+end
+
+require File.dirname(__FILE__) + '/active_spec/specifications'
+require File.dirname(__FILE__) + '/active_spec/base'
+require File.dirname(__FILE__) + '/active_spec/satisfies'
+require File.dirname(__FILE__) + '/active_spec/context'
+
+include ActiveSpec::Context

data/lib/active_spec/base.rb

@@ -0,0 +1,141 @@
+# The ActiveSpec::Base class provides a more declarative way of
+# creating specifications than using the low-level Specification
+# classes. It essentially acts as a composite specification (it
+# actually delegates to ActiveSpec::Specifications::CompositeSpecification 
+# when calling <tt>satisfied_by?</tt>) and allows you to create new specifications 
+# by sub-classing ActiveSpec::Base and calling the built-in macros to add 
+# individual specifications.
+#
+# This declarative way of creating specifications will be more familiar
+# to those who are used to using Rails' built-in validates_* macros.
+#
+# Example specification:
+#
+#   class UserSpecification < ActiveSpec::Base
+#     require_presence_of     :username, :email
+#     require_confirmation_of :password
+#     require_inclusion_in    18..30, :age
+#   end
+#
+# You can execute an ActiveSpec against an object by calling
+# the class method <tt>satisfied_by?</tt>. There is no need to
+# instantiate an ActiveSpec class.
+#
+#   user = User.new
+#   UserSpecification.satisfied_by?(user)
+class ActiveSpec::Base
+  
+  class << self
+    
+    # Adds a ActiveSpec::Specifications::PresenceSpecification for the given attributes.
+    def requires_presence_of(*attributes)
+      add_specification ActiveSpec::Specifications::PresenceSpecification.new(*attributes) 
+    end
+
+    # Adds a ActiveSpec::Specifications::CollectionSpecification for the given collection and attributes.
+    def requires_inclusion_in(collection, *attributes)
+      add_specification ActiveSpec::Specifications::CollectionSpecification.new(collection, *attributes)
+    end
+
+    # Adds a ActiveSpec::Specifications::CollectionSpecification wrapped in a
+    # ActiveSpec::Specifications::NotSpecification decorator
+    # for the given collection and attributes.
+    def requires_exclusion_from(collection, *attributes)
+      add_specification ActiveSpec::Specifications::NotSpecification.new(
+        ActiveSpec::Specifications::CollectionSpecification.new(collection, *attributes)
+      )
+    end
+
+    # Adds a ActiveSpec::Specifications::ConfirmationSpecification for the given attributes.
+    def requires_confirmation_of(*attributes)
+      add_specification ActiveSpec::Specifications::ConfirmationSpecification.new(*attributes)
+    end
+
+    # Adds a ActiveSpec::Specifications::SizeSpecification for the given attributes.
+    def requires_size(size, *attributes)
+      add_specification ActiveSpec::Specifications::SizeSpecification.new(size, *attributes)
+    end
+
+    # Adds a ActiveSpec::Specifications::MatchSpecification for the given regexp and attributes.
+    def requires_match(regexp, *attributes)
+      # TODO add_specification MatchSpecification.new(regexp, *attributes)
+    end
+    
+    # A generic method that lets you add arbitrary specifications in several
+    # formats. <tt>specification</tt> can be a specification class (that
+    # responds to <tt>satisfied_by?</tt>), a Symbol (which is used to find a specification
+    # class) or a Proc object. As an alternative to passing a Proc, you can 
+    # simply call <tt>satisfy</tt> with a block. The Proc/block will
+    # be passed the object that is sent to <tt>satisfied_by?</tt> when <tt>satisfied_by?</tt>
+    # is called.
+    #
+    #   # Using a class
+    #   must_satisfy UserSpecification
+    #
+    #   # Using a symbol
+    #   must_satisfy :user_specification
+    #
+    #   # Using a Proc
+    #   must_satisfy proc{ |object| # do something with object }
+    #
+    #   # Passing in a block
+    #   must_satisfy { |object| # do something with object }
+    #
+    # This method gives you the power to create very complicated specifications.
+    # Because you can pass in anything that responds to <tt>satisfied_by?</tt>, you can
+    # pass in your own low-level specification classes, ActiveSpec::Specifications::CompositeSpecification
+    # classes, or even other ActiveSpec classes, e.g.
+    #
+    #   class UserSpecification < ActiveSpec::Base
+    #     require_presence_of :email
+    #   end
+    #
+    #   class AdvancedUserSpecification < ActiveSpec::Base
+    #     must_satisfy :user_specification
+    #     require_presence_of :something_else
+    #   end
+    def must_satisfy(specification=nil, &block)
+      case specification
+      when Symbol
+        add_specification Object.const_get(Inflector::classify(specification))
+      when Proc
+        add_specification ActiveSpec::Specifications::ProcSpecification.new(specification)
+      when Class
+        add_specification specification
+      else
+        if block_given?
+          add_specification ActiveSpec::Specifications::ProcSpecification.new(block)
+        else
+          raise "satisfy must be passed a symbol, proc, class or block"
+        end
+      end
+    end
+    
+    # Calls <tt>satisfied_by?</tt> on each specification with
+    # the given object. Returns <tt>true</tt> if all of the specifications
+    # pass, otherwise it returns <tt>false</tt>.
+    def satisfied_by?(object)
+      composite_spec.satisfied_by?(object)
+    end
+    
+    protected
+      def write_inheritable_set(key, spec)
+        existing_specs = read_inheritable_attribute(key) || []
+        specs_to_write = existing_specs << spec
+        write_inheritable_attribute(key, specs_to_write)
+      end
+      
+      def add_specification(spec)
+        write_inheritable_set(:specifications, spec)
+      end
+      
+      # Returns a ActiveSpec::Specifications::CompositeSpecification with all of the
+      # declared specifications.
+      def composite_spec
+        composite_spec = ActiveSpec::Specifications::CompositeSpecification.new
+        read_inheritable_attribute(:specifications).each { |spec| composite_spec.add_specification(spec) }
+        composite_spec
+      end
+  end
+  
+end

data/lib/active_spec/context.rb

@@ -0,0 +1,30 @@
+# Provides a high-level DSL-like interface to the ActiveSpec
+# library.
+module ActiveSpec::Context
+  
+  # This method allows you to build ActiveSpec specifications
+  # using a DSL-like syntax. Pass in a name for your specification
+  # (without the _specification suffix which will be added 
+  # automatically) and a block which contains your individual
+  # specifications.
+  #
+  # The ActiveSpec::Context module gets included automatically
+  # when the ActiveSpec library is required, so the <tt>specification</tt>
+  # method is available in the global namespace.
+  #
+  # Example usage:
+  #
+  #   specification :user do
+  #     should_require_presence_of     :username, :password
+  #     should_require_confirmation_of :password
+  #   end
+  #
+  # The above code will create a UserSpecification class (a sub-class
+  # of ActiveSpec::Base) with the given specifications.
+  def specification(name, &block)
+    klass = Inflector::classify("#{name.to_s}_specification")
+    Object.const_set(klass, Class.new(ActiveSpec::Base))
+    Object.const_get(klass).class_eval(&block)
+  end
+  
+end

data/lib/active_spec/satisfies.rb

@@ -0,0 +1,78 @@
+# Provides functionality for working with specifications
+# inside your own classes. Simply include the module
+# inside any class that you want to use with specifications.
+#
+# Example usage:
+#
+#   specification :user do
+#     should_require_presence_of :username
+#   end
+#
+#   specification :authenticated_user do
+#     # some other specs
+#   end
+#
+#   class User
+#     must_satisfy :user_specification
+#     must_satisfy :authenticated_user_specification, :if => { |u| u.has_password? }
+#   end
+#
+#   user = User.new
+#   user.satisfies_specs? # returns false
+#   user.username = 'joebloggs'
+#   user.satisfies_specs? # returns true
+#
+# For information on adding specifications, see the ActiveSpec::Satisfies::ClassMethods module.
+module ActiveSpec::Satisfies
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    
+    # Specifies a specification class (can be anything that responds to <tt>satisfied_by?</tt>)
+    # that any instances of the class should satisfy. Takes one option:
+    #
+    # * <tt>:if</tt> - used to pass in a block that must return true
+    #   for the specification to apply. Can be used to conditionally declare
+    #   specifications.
+    def must_satisfy(spec_name, opts={})
+      satisfies = read_inheritable_attribute(:satisfies) || []
+      satisfies << {:spec => spec_name, :options => opts}
+      write_inheritable_attribute(:satisfies, satisfies)
+    end
+    
+  end
+
+  # Checks that all relevant, assigned specifications pass.
+  # Specifications assigned with the <tt>:if</tt> option will only
+  # be evaluated if the <tt>:if</tt> block returns true.
+  def satisfies_specs?
+    satisfies = self.class.read_inheritable_attribute(:satisfies) || []
+    satisfies.collect do |s|
+      if s[:options][:if]
+        return true unless passes_predicate?(s[:options][:if])
+      end
+      satisfies?(s[:spec]) 
+    end.grep(false).empty?
+  end
+
+  protected
+    def satisfies?(spec)
+      if spec.instance_of?(Symbol)
+        spec = Kernel.const_get(Inflector::classify(spec))
+      end
+      spec.satisfied_by? self
+    end
+
+    def passes_predicate?(predicate)
+      case predicate
+      when Symbol
+        return self.send(predicate)
+      when Proc
+        return predicate.call(self)
+      end
+    end
+    
+end

data/lib/active_spec/specifications.rb

@@ -0,0 +1,13 @@
+module ActiveSpec
+  module Specifications
+  end
+end
+
+require File.dirname(__FILE__) + '/specifications/composite_specification'
+require File.dirname(__FILE__) + '/specifications/attributes_specification'
+require File.dirname(__FILE__) + '/specifications/presence_specification'
+require File.dirname(__FILE__) + '/specifications/confirmation_specification'
+require File.dirname(__FILE__) + '/specifications/size_specification'
+require File.dirname(__FILE__) + '/specifications/collection_specification'
+require File.dirname(__FILE__) + '/specifications/proc_specification'
+require File.dirname(__FILE__) + '/specifications/not_specification'

data/lib/active_spec/specifications/attributes_specification.rb

@@ -0,0 +1,39 @@
+# This is the base class for all specification classes that
+# can act on any number of public object attributes. If you want
+# to write a specification class that can act on many public
+# object attributes, sub-class this class and define your own
+# <tt>satisfied_by?</tt> method.
+class ActiveSpec::Specifications::AttributesSpecification
+  
+  # The default initialize method stores all attributes in
+  # an instance variable called <tt>@attributes</tt>. When
+  # sub-classing, it is important to call <tt>super</tt> 
+  # with the given attributes, for example:
+  #
+  #  class MyOwnSpecification < ActiveSpec::Specifications::AttributesSpecification
+  #    def initialize(custom_var, *attributes)
+  #      # do something with custom_var
+  #      super(*attributes)
+  #    end
+  #  end
+  def initialize(*attributes)
+    @attributes = attributes
+  end
+  
+  # This default implementation always returns <tt>true</tt>.
+  # Override this method in your own specification classes.
+  def satisfied_by?(object)
+    true
+  end
+  
+  protected
+  
+    # Yields each attribute in the <tt>@attributes</tt>
+    # collection to the given block and if all block
+    # calls return <tt>true</tt>, then it returns <tt>true</tt>.
+    # Otherwise it returns <tt>false</tt>.
+    def attributes_satisfy?(&block) #:yields: attribute
+      @attributes.collect { |a| yield a }.grep(false).empty?
+    end
+    
+end

data/lib/active_spec/specifications/collection_specification.rb

@@ -0,0 +1,42 @@
+# Checks the values of one or more attributes for
+# inclusion within a given collection. This is similar to
+# the Rails validation macro <tt>validates_inclusion_of</tt>.
+#
+# Example usage:
+#
+#  include ActiveSpec::Specifications
+#
+#  class ColorPicker
+#    def color
+#      'red'
+#    end
+#  end
+#
+#  spec_one = CollectionSpecification.new(['red', 'yellow'], :color)
+#  spec_two = CollectionSpecification.new(['green', 'yellow'], :color)
+#  spec_one.satisfied_by?(ColorPicker.new) # returns true
+#  spec_two.satisfied_by?(ColorPicker.new) # returns false
+#
+# The equivalent of the Rails <tt>validates_exclusion_of</tt>
+# validation macro can be implemented by wrapping a CollectionSpecification
+# inside a NotSpecification decorator.
+class ActiveSpec::Specifications::CollectionSpecification < ActiveSpec::Specifications::AttributesSpecification  
+  
+  # <tt>collection</tt> can be any object that responds to
+  # <tt>include?</tt>, such as Array and Range objects.
+  def initialize(collection, *attributes)
+    @collection = collection
+    super(*attributes)
+  end
+  
+  # Returns false if the object fails to respond to
+  # to any of the given attributes, or if any of the attribute
+  # values for the object are not in the specified collection.
+  def satisfied_by?(object)
+    attributes_satisfy? do |a|
+      return false unless object.respond_to?(a)
+      return false unless @collection.include?(object.send(a))
+    end
+  end
+  
+end

data/lib/active_spec/specifications/composite_specification.rb

@@ -0,0 +1,24 @@
+# Uses the Composite pattern to allow an object to be
+# run against any number of specifications in one operation.
+# A specification can be any object that responds to <tt>satisfied_by?</tt>.
+# Because the composite specification also responds to <tt>satisfied_by?</tt>, you can
+# add composite specifications to other composite specifications.
+class ActiveSpec::Specifications::CompositeSpecification
+  
+  def initialize
+    @specs = []
+  end
+  
+  # Adds a new specification to the composite
+  def add_specification(spec)
+    @specs << spec
+  end
+  
+  # Calls <tt>satisfied_by?</tt> on each specification with
+  # the given object. Returns <tt>true</tt> if all of the specifications
+  # pass, otherwise it returns <tt>false</tt>.
+  def satisfied_by?(object)
+    @specs.collect { |s| s.satisfied_by?(object) }.grep(false).empty?
+  end
+  
+end

data/lib/active_spec/specifications/confirmation_specification.rb

@@ -0,0 +1,50 @@
+# Looks for a confirmation attribute for each given attribute.
+# It looks for a confirmation attribtue named attributename_confirmation 
+# and checks that the value of the attribute and its confirmation attribute match.
+# This could be used to validate password confirmations.
+#
+# Example usage:
+#
+#  include ActiveSpec::Specifications
+#
+#  class User
+#    attr_accessor :password, :password_confirmation
+#  end
+#
+#  spec = ConfirmationSpecification.new(:password)
+#
+#  # passing spec
+#  user_one = User.new
+#  user_one.password = 'foo'
+#  user_one.password_confirmation = 'foo'
+#  spec.satisfied_by?(user_one) # returns true
+#
+#  # failing spec
+#  user_two = User.new
+#  user_two.password = 'foo'
+#  user_two.password_confirmation = 'bar'
+#  spec.satisfied_by?(user_two) # returns false
+#
+# This works in the same way as the Rails validation macro
+# <tt>validates_confirmation_of</tt>.
+class ActiveSpec::Specifications::ConfirmationSpecification < ActiveSpec::Specifications::AttributesSpecification
+  
+  # Returns false if the given object fails to respond to
+  # any of the attributes, or the attributes' confirmation
+  # methods. If both attribute and attribute confirmation methods
+  # respond, then it checks that the values of both match.
+  def satisfied_by?(object)
+    attributes_satisfy? do |a|
+      return false unless object.respond_to?(a)
+      return false unless object.respond_to?(confirmation_attribute(a))
+      return false unless object.send(a) == object.send(confirmation_attribute(a))
+    end
+  end
+  
+  protected
+  
+    def confirmation_attribute(attribute)
+      "#{attribute.to_s}_confirmation"
+    end
+    
+end

data/lib/active_spec/specifications/not_specification.rb

@@ -0,0 +1,19 @@
+# A simple decorator class that negates the
+# specification that it wraps, e.g.:
+#
+#   include ActiveSpec::Specifications
+# 
+#   spec = AlwaysPassSpec.new(:foo)
+#   spec.satisfied_by? # returns true
+#   NotSpecification.new(spec).satisfied_by? # returns false
+class ActiveSpec::Specifications::NotSpecification
+  
+  def initialize(decorated_spec)
+    @decorated_spec = decorated_spec
+  end
+  
+  def satisfied_by?(object)
+    not @decorated_spec.satisfied_by?(object)
+  end
+  
+end

data/lib/active_spec/specifications/presence_specification.rb

@@ -0,0 +1,35 @@
+# This specification will check that the values for
+# each attribute are neither nil, or empty.
+#
+# Example usage:
+#
+#  include ActiveSpec::Specifications
+#
+#  class Foo
+#    attr_accessor :bar
+#  end
+#
+#  spec = PresenceSpecification.new(:bar)
+#  foo = Foo.new
+#  spec.satisfied_by?(foo) # returns false
+#  foo.bar = ''
+#  spec.satisfied_by?(foo) # returns false
+#  foo.bar = 'baz'
+#  spec.satisfied_by?(foo) # returns true
+#
+# This works in the same way as the Rails validation
+# macro <tt>validates_presence_of</tt>.
+class ActiveSpec::Specifications::PresenceSpecification < ActiveSpec::Specifications::AttributesSpecification 
+  
+  # Checks that the value for each attribute on the given object
+  # is neither nil or empty. It will also return false if
+  # the object fails to respond to any attribute.
+  def satisfied_by?(object)
+    attributes_satisfy? do |a|
+      return false unless object.respond_to?(a)
+      return false if object.send(a).nil?
+      return false if object.send(a).empty?
+    end
+  end
+  
+end

data/lib/active_spec/specifications/proc_specification.rb

@@ -0,0 +1,22 @@
+# A ProcSpecification is a simple wrapper around a Proc
+# object, that makes it conform to the Specification
+# interface (with a <tt>satisfied_by?</tt> method). If the given
+# Proc returns true, the specification passes, otherwise
+# it does not pass.
+class ActiveSpec::Specifications::ProcSpecification
+  
+  def initialize(proc)
+    @proc = proc
+  end
+  
+  # Calls the wrapped Proc object, passing the given object 
+  # to the proc. Returns the result of the Proc (either <tt>true</tt>
+  # or <tt>false</tt>). If the Proc raises an exception of any
+  # kind, then <tt>satisfied_by?</tt> will return <tt>false</tt>.
+  def satisfied_by?(object)
+    @proc.call(object)
+  rescue
+    false
+  end
+  
+end

data/lib/active_spec/specifications/size_specification.rb

@@ -0,0 +1,38 @@
+# Checks that the values for the given attributes are
+# of a particular size. The size can be a precise number (Fixnum)
+# or a Range. If a Range is given, the specification will pass
+# if the value's size falls within the Range.
+#
+# Creating a SizeSpecification with a Fixnum is the same as
+# the Rails <tt>validates_size_of</tt> macro with the <tt>:exactly</tt> option. 
+# Using a Range is the equivalent of using <tt>validates_size_of</tt>
+# with the <tt>:in</tt> option.
+class ActiveSpec::Specifications::SizeSpecification < ActiveSpec::Specifications::AttributesSpecification
+  
+  # <tt>size</tt> can be a Fixnum or a Range.
+  def initialize(size, *attributes)
+    @size = size
+    super(*attributes)
+  end
+  
+  # Will return false if the object does not respond
+  # to any of the specified attributes, or if any of the
+  # the values for each attribute does not respond to
+  # <tt>size</tt>. Otherwise it will check that the size of the value
+  # for each attribute equals the given size (if size is
+  # a Fixnum) or within the given Range.
+  def satisfied_by?(object)
+    attributes_satisfy? do |a|
+      return false unless object.respond_to?(a)
+      return false unless object.send(a).respond_to?(:size)
+      case @size
+        when Fixnum
+          return false unless object.send(a).size == @size
+        when Range
+          return false unless @size.include?(object.send(a).size)
+      end
+      true
+    end
+  end
+  
+end

data/spec/collection_specification_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/spec_helper'
+include ActiveSpec::Specifications
+
+context "Collection specification" do
+  setup do
+    @spec = CollectionSpecification.new(['foo', 'bar'], :widget)
+  end
+  
+  specify "should pass if the given object returns a value in the specified collection for the specified attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :widget)
+    object = klass.new
+    object.widget = 'foo'
+    @spec.should_be_satisfied_by object
+    object.widget = 'bar'
+    @spec.should_be_satisfied_by object
+  end
+  
+  specify "should not pass if the given object doesn't respond to the specified attribute" do
+    @spec.should_not_be_satisfied_by Object.new
+  end
+  
+  specify "should not pass if the given object doesn't return a value in the specified collection for the specified attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :widget)
+    object = klass.new
+    object.widget = 'baz'
+    @spec.should_not_be_satisfied_by object
+  end
+end
+
+context "Collection specification with range" do
+  setup do
+    @spec = CollectionSpecification.new(Range.new(10, 30), :age)
+  end
+  
+  specify "should pass if the given object returns a fixnum for the attribute in the given range" do
+    klass = Class.new
+    klass.send(:attr_accessor, :age)
+    object = klass.new
+    object.age = 20
+    @spec.should_be_satisfied_by object
+  end
+  
+  specify "should not pass if the given object does not respond to the specified attribute" do
+    @spec.should_not_be_satisfied_by Object.new
+  end
+  
+  specify "should not pass if the given object returns a fixnum for the attribute that isn't in the given range" do
+    klass = Class.new
+    klass.send(:attr_accessor, :age)
+    object = klass.new
+    object.age = 35
+    @spec.should_not_be_satisfied_by object
+  end
+end

data/spec/composite_specification_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/spec_helper'
+include ActiveSpec::Specifications
+
+context "Empty composite specifcation" do  
+  setup do
+    @spec = CompositeSpecification.new
+  end
+  
+  specify "should pass" do
+    @spec.should_be_satisfied_by Object.new
+  end
+end
+
+context "Composite specifcation with just passing specifications" do  
+  setup do
+    @spec = CompositeSpecification.new
+    @spec.add_specification(PresenceSpecification.new(:foo))
+    @spec.add_specification(PresenceSpecification.new(:bar))
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    klass.send(:attr_accessor, :bar)
+    @object = klass.new
+    @object.foo = 'something'
+    @object.bar = 'something else'
+  end
+  
+  specify "should pass" do
+    @spec.should_be_satisfied_by @object
+  end
+end
+
+context "Composite specifcation with just failing specifications" do 
+  setup do
+    @spec = CompositeSpecification.new
+    @spec.add_specification(PresenceSpecification.new(:foo))
+    @spec.add_specification(PresenceSpecification.new(:bar))
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    klass.send(:attr_accessor, :bar)
+    @object = klass.new
+    @object.foo = ''
+    @object.bar = nil
+  end
+  
+  specify "should not pass" do
+    @spec.should_not_be_satisfied_by @object
+  end
+end
+
+context "Composite specifcation with passing and failing specifications" do
+  setup do
+    @spec = CompositeSpecification.new
+    @spec.add_specification(PresenceSpecification.new(:foo))
+    @spec.add_specification(PresenceSpecification.new(:bar))
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    klass.send(:attr_accessor, :bar)
+    @object = klass.new
+    @object.foo = 'something'
+    @object.bar = nil
+  end
+  
+  specify "should not pass" do
+    @spec.should_not_be_satisfied_by @object
+  end
+end

data/spec/confirmation_specification_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/spec_helper'
+include ActiveSpec::Specifications
+
+context "Confirmation specification" do
+  setup do
+    @spec = ConfirmationSpecification.new(:password)
+  end
+  
+  specify "should pass if the given object returns the same value for attribute as it does for attribute_confirmation" do
+    klass = Class.new
+    klass.send(:attr_accessor, :password)
+    klass.send(:attr_accessor, :password_confirmation)
+    object = klass.new
+    object.password = 'foobar'
+    object.password_confirmation = 'foobar'
+    @spec.should_be_satisfied_by object
+  end
+  
+  specify "should fail if the given object doesn't respond to the specified attribute" do
+    @spec.should_not_be_satisfied_by Object.new
+  end
+  
+  specify "should fail if the given object doesn't respond to specified_attribute_confirmation" do
+    klass = Class.new
+    klass.send(:attr_accessor, :password)
+    object = klass.new
+    @spec.should_not_be_satisfied_by object
+  end
+  
+  specify "should fail if the given object returns a different value for attribute as it does for attribute_confirmation" do
+    klass = Class.new
+    klass.send(:attr_accessor, :password)
+    klass.send(:attr_accessor, :password_confirmation)
+    object = klass.new
+    object.password = 'foobar'
+    object.password_confirmation = 'foobarbaz'
+    @spec.should_not_be_satisfied_by object
+  end
+end

data/spec/not_specification_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/spec_helper'
+include ActiveSpec::Specifications
+
+context "Not specification" do
+  setup do
+    @original_spec = PresenceSpecification.new(:foo, :bar)
+    @klass = Class.new
+  end
+  
+  specify "should not pass if the decorated spec passes" do
+    @klass.send(:attr_accessor, :foo)
+    @klass.send(:attr_accessor, :bar)
+    object = @klass.new
+    object.foo = 'make me pass'
+    object.bar = 'make me pass'
+    @original_spec.should_be_satisfied_by object
+    NotSpecification.new(@original_spec).should_not_be_satisfied_by(object)
+  end
+  
+  specify "should pass if the decorated spec does not pass" do
+    object = @klass.new
+    @original_spec.should_not_be_satisfied_by object
+    NotSpecification.new(@original_spec).should_be_satisfied_by(object)
+  end
+end

data/spec/presence_specification_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/spec_helper'
+include ActiveSpec::Specifications
+
+context "Presence specification with one attribute" do
+  setup do
+    @spec = PresenceSpecification.new(:foo)
+  end
+  
+  specify "should pass if the given object has a value for the required attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    object = klass.new
+    object.foo = 'anything'
+    @spec.should_be_satisfied_by object
+  end
+  
+  specify "should not pass if the given object doesn't respond to required attribute" do
+    klass = Class.new
+    @spec.should_not_be_satisfied_by klass.new
+  end
+  
+  specify "should not pass if the given object returns nil for required attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    object = klass.new
+    object.foo = nil
+    @spec.should_not_be_satisfied_by object
+  end
+  
+  specify "should not pass if the given object returns an empty string for required attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    object = klass.new
+    object.foo = ''
+    @spec.should_not_be_satisfied_by object
+  end
+end
+
+context "Presence specification with multiple attributes" do
+  setup do
+    @spec = PresenceSpecification.new(:foo, :bar)
+  end
+  
+  specify "should pass if object satisfies spec for all attributes" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    klass.send(:attr_accessor, :bar)
+    object = klass.new
+    object.foo = 'something'
+    object.bar = 'anything'
+    @spec.should_be_satisfied_by object
+  end
+  
+  specify "should not pass if object fails to satisfy spec for at least one attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    klass.send(:attr_accessor, :bar)
+    object = klass.new
+    object.foo = 'something'
+    object.bar = ''
+    @spec.should_not_be_satisfied_by object
+  end
+end

data/spec/proc_specification_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/spec_helper'
+include ActiveSpec::Specifications
+
+context "Proc specification" do
+  setup do
+    @spec = ProcSpecification.new(Proc.new { |o| o.respond_to?(:foo) })
+  end
+  
+  specify "should pass when the proc returns true when called with the given object" do
+    klass = Class.new
+    klass.send(:attr_reader, :foo)
+    @spec.should_be_satisfied_by klass.new
+  end
+  
+  specify "should not pass when the proc returns false when called with the given object" do
+    @spec.should_not_be_satisfied_by Object.new
+  end
+end
+
+context "Proc specification with proc that raises" do
+  setup do
+    @spec = ProcSpecification.new(Proc.new { |o| o.non_existant_method })
+  end
+  
+  specify "should never pass" do
+    @spec.should_not_be_satisfied_by Object.new
+  end
+end

data/spec/size_specification_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/spec_helper'
+include ActiveSpec::Specifications
+
+context "Size specification with a number" do
+  setup do
+    @spec = SizeSpecification.new(5, :foo)
+  end
+  
+  specify "should pass if the given object returns a string of the specified size for the specified attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    object = klass.new
+    object.foo = 'xxxxx'
+    @spec.should_be_satisfied_by object
+  end
+  
+  specify "should not pass if the given object does not respond to the specified attribute" do
+    @spec.should_not_be_satisfied_by Object.new
+  end
+  
+  specify "should not pass if the value of the given object does not respond to size" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    object = klass.new
+    object.foo = nil
+    @spec.should_not_be_satisfied_by object
+  end
+  
+  specify "should not pass if the given object does not return a string of the specified size for the specified attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    object = klass.new
+    object.foo = 'xxxxxxxxx'
+    @spec.should_not_be_satisfied_by object
+  end
+end
+
+context "Size specification with a range" do
+  setup do
+    @spec = SizeSpecification.new(5..10, :foo)
+  end
+  
+  specify "should pass if the given object returns a string of a size within range for the specified attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    object = klass.new
+    object.foo = 'xxxxx'
+    @spec.should_be_satisfied_by object
+    object.foo = 'xxxxxxxx'
+    @spec.should_be_satisfied_by object
+  end
+  
+  specify "should not pass if the given object does not respond to the specified attribute" do
+    @spec.should_not_be_satisfied_by Object.new
+  end
+  
+  specify "should not pass if the given object does not return a string for the specified attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    object = klass.new
+    object.foo = DateTime.new
+    @spec.should_not_be_satisfied_by object
+  end
+  
+  specify "should not pass if the given object does not return a string of a size within range for the specified attribute" do
+    klass = Class.new
+    klass.send(:attr_accessor, :foo)
+    object = klass.new
+    object.foo = 'xxxx'
+    @spec.should_not_be_satisfied_by object
+    object.foo = 'xxxxxxxxxxxxxx'
+    @spec.should_not_be_satisfied_by object
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require_gem 'rspec'
+
+require File.dirname(__FILE__) + '/../lib/active_spec'

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: activespec
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2006-09-22 00:00:00 +01:00
+summary: Ruby Specification Library
+require_paths: 
+- lib
+email: contact @nospam@ lukeredpath.co.uk
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: rubyslim
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Luke Redpath
+files: 
+- lib/active_spec.rb
+- lib/active_spec/base.rb
+- lib/active_spec/context.rb
+- lib/active_spec/satisfies.rb
+- lib/active_spec/specifications.rb
+- lib/active_spec/specifications/attributes_specification.rb
+- lib/active_spec/specifications/collection_specification.rb
+- lib/active_spec/specifications/composite_specification.rb
+- lib/active_spec/specifications/confirmation_specification.rb
+- lib/active_spec/specifications/not_specification.rb
+- lib/active_spec/specifications/presence_specification.rb
+- lib/active_spec/specifications/proc_specification.rb
+- lib/active_spec/specifications/size_specification.rb
+- README
+test_files: 
+- spec/collection_specification_spec.rb
+- spec/composite_specification_spec.rb
+- spec/confirmation_specification_spec.rb
+- spec/not_specification_spec.rb
+- spec/presence_specification_spec.rb
+- spec/proc_specification_spec.rb
+- spec/size_specification_spec.rb
+- spec/spec_helper.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+