poolparty 1.3.15 → 1.4.0

data/vendor/gems/shoulda/lib/shoulda/active_record/matchers/validate_uniqueness_of_matcher.rb

@@ -1,148 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that the model is invalid if the given attribute is not unique.
-      #
-      # Internally, this uses values from existing records to test validations,
-      # so this will always fail if you have not saved at least one record for
-      # the model being tested, like so:
-      #
-      #   describe User do
-      #     before(:each) { User.create!(:email => 'address@example.com') }
-      #     it { should validate_uniqueness_of(:email) }
-      #   end
-      #
-      # Options:
-      #
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. <tt>Regexp</tt> or <tt>String</tt>.
-      #   Defaults to the translation for <tt>:taken</tt>.
-      # * <tt>scoped_to</tt> - field(s) to scope the uniqueness to.
-      # * <tt>case_insensitive</tt> - ensures that the validation does not
-      #   check case. Off by default. Ignored by non-text attributes.
-      #
-      # Examples:
-      #   it { should validate_uniqueness_of(:keyword) }
-      #   it { should validate_uniqueness_of(:keyword).with_message(/dup/) }
-      #   it { should validate_uniqueness_of(:email).scoped_to(:name) }
-      #   it { should validate_uniqueness_of(:email).
-      #                 scoped_to(:first_name, :last_name) }
-      #   it { should validate_uniqueness_of(:keyword).case_insensitive }
-      #
-      def validate_uniqueness_of(attr)
-        ValidateUniquenessOfMatcher.new(attr)
-      end
-
-      class ValidateUniquenessOfMatcher < ValidationMatcher # :nodoc:
-        include Helpers
-
-        def initialize(attribute)
-          @attribute = attribute
-        end
-
-        def scoped_to(*scopes)
-          @scopes = [*scopes].flatten
-          self
-        end
-
-        def with_message(message)
-          @expected_message = message
-          self
-        end
-
-        def case_insensitive
-          @case_insensitive = true
-          self
-        end
-
-        def description
-          result = "require "
-          result << "case sensitive " unless @case_insensitive
-          result << "unique value for #{@attribute}"
-          result << " scoped to #{@scopes.join(', ')}" unless @scopes.blank?
-          result
-        end
-
-        def matches?(subject)
-          @subject = subject.class.new
-          @expected_message ||= :taken
-          find_existing && 
-            set_scoped_attributes && 
-            validate_attribute &&
-            validate_after_scope_change
-        end
-
-        private
-
-        def find_existing
-          if @existing = @subject.class.find(:first)
-            true
-          else
-            @failure_message = "Can't find first #{class_name}"
-            false
-          end
-        end
-
-        def set_scoped_attributes
-          unless @scopes.blank?
-            @scopes.each do |scope|
-              setter = :"#{scope}="
-              unless @subject.respond_to?(setter)
-                @failure_message =
-                  "#{class_name} doesn't seem to have a #{scope} attribute."
-                return false
-              end
-              @subject.send("#{scope}=", @existing.send(scope))
-            end
-          end
-          true
-        end
-
-        def validate_attribute
-          disallows_value_of(existing_value, @expected_message)
-        end
-
-        # TODO:  There is a chance that we could change the scoped field
-        # to a value that's already taken.  An alternative implementation
-        # could actually find all values for scope and create a unique
-        def validate_after_scope_change
-          if @scopes.blank?
-            true
-          else
-            @scopes.all? do |scope|
-              previous_value = @existing.send(scope)
-
-              # Assume the scope is a foreign key if the field is nil
-              previous_value ||= 0
-
-              next_value = previous_value.next
-
-              @subject.send("#{scope}=", next_value)
-
-              if allows_value_of(existing_value, @expected_message)
-                @negative_failure_message << 
-                  " (with different value of #{scope})"
-                true
-              else
-                @failure_message << " (with different value of #{scope})"
-                false
-              end
-            end
-          end
-        end
-
-        def class_name
-          @subject.class.name
-        end
-
-        def existing_value
-          value = @existing.send(@attribute)
-          value.swapcase! if @case_insensitive && value.respond_to?(:swapcase!)
-          value
-        end
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda/lib/shoulda/active_record/matchers/validation_matcher.rb

@@ -1,57 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      class ValidationMatcher # :nodoc:
-
-        attr_reader :failure_message
-
-        def initialize(attribute)
-          @attribute = attribute
-        end
-
-        def negative_failure_message
-          @negative_failure_message || @failure_message
-        end
-
-        def matches?(subject)
-          @subject = subject
-          false
-        end
-        
-
-        private
-
-        def allows_value_of(value, message = nil)
-          allow = AllowValueMatcher.
-            new(value).
-            for(@attribute).
-            with_message(message)
-          if allow.matches?(@subject)
-            @negative_failure_message = allow.failure_message
-            true
-          else
-            @failure_message = allow.negative_failure_message
-            false
-          end
-        end
-
-        def disallows_value_of(value, message = nil)
-          disallow = AllowValueMatcher.
-            new(value).
-            for(@attribute).
-            with_message(message)
-          if disallow.matches?(@subject)
-            @failure_message = disallow.negative_failure_message
-            false
-          else
-            @negative_failure_message = disallow.failure_message
-            true
-          end
-        end
-      end
-
-    end
-  end
-end
-

data/vendor/gems/shoulda/lib/shoulda/active_record/matchers.rb

@@ -1,43 +0,0 @@
-require 'shoulda/active_record/helpers'
-require 'shoulda/active_record/matchers/validation_matcher'
-require 'shoulda/active_record/matchers/allow_value_matcher'
-require 'shoulda/active_record/matchers/ensure_length_of_matcher'
-require 'shoulda/active_record/matchers/ensure_inclusion_of_matcher'
-require 'shoulda/active_record/matchers/validate_presence_of_matcher'
-require 'shoulda/active_record/matchers/validate_format_of_matcher'
-require 'shoulda/active_record/matchers/validate_uniqueness_of_matcher'
-require 'shoulda/active_record/matchers/validate_acceptance_of_matcher'
-require 'shoulda/active_record/matchers/validate_numericality_of_matcher'
-require 'shoulda/active_record/matchers/association_matcher'
-require 'shoulda/active_record/matchers/have_db_column_matcher'
-require 'shoulda/active_record/matchers/have_db_index_matcher'
-require 'shoulda/active_record/matchers/have_readonly_attribute_matcher'
-require 'shoulda/active_record/matchers/allow_mass_assignment_of_matcher'
-require 'shoulda/active_record/matchers/have_named_scope_matcher'
-
-
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    # = Matchers for your active record models
-    #
-    # These matchers will test most of the validations and associations for your
-    # ActiveRecord models.
-    #
-    #   describe User do
-    #     it { should validate_presence_of(:name) }
-    #     it { should validate_presence_of(:phone_number) }
-    #     %w(abcd 1234).each do |value|
-    #       it { should_not allow_value(value).for(:phone_number) }
-    #     end
-    #     it { should allow_value("(123) 456-7890").for(:phone_number) }
-    #     it { should_not allow_mass_assignment_of(:password) }
-    #     it { should have_one(:profile) }
-    #     it { should have_many(:dogs) }
-    #     it { should have_many(:messes).through(:dogs) }
-    #     it { should belong_to(:lover) }
-    #   end
-    #
-    module Matchers
-    end
-  end
-end

data/vendor/gems/shoulda/lib/shoulda/active_record.rb

@@ -1,16 +0,0 @@
-require 'shoulda'
-require 'shoulda/active_record/helpers'
-require 'shoulda/active_record/matchers'
-require 'shoulda/active_record/assertions'
-require 'shoulda/active_record/macros'
-
-module Test # :nodoc: all
-  module Unit
-    class TestCase
-      include Shoulda::ActiveRecord::Helpers
-      include Shoulda::ActiveRecord::Matchers
-      include Shoulda::ActiveRecord::Assertions
-      extend Shoulda::ActiveRecord::Macros
-    end
-  end
-end

data/vendor/gems/shoulda/lib/shoulda/assertions.rb

@@ -1,71 +0,0 @@
-module Shoulda # :nodoc:
-  module Assertions
-    # Asserts that two arrays contain the same elements, the same number of times.  Essentially ==, but unordered.
-    #
-    #   assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
-    def assert_same_elements(a1, a2, msg = nil)
-      [:select, :inject, :size].each do |m|
-        [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
-      end
-
-      assert a1h = a1.inject({}) { |h,e| h[e] = a1.select { |i| i == e }.size; h }
-      assert a2h = a2.inject({}) { |h,e| h[e] = a2.select { |i| i == e }.size; h }
-
-      assert_equal(a1h, a2h, msg)
-    end
-
-    # Asserts that the given collection contains item x.  If x is a regular expression, ensure that
-    # at least one element from the collection matches x.  +extra_msg+ is appended to the error message if the assertion fails.
-    #
-    #   assert_contains(['a', '1'], /\d/) => passes
-    #   assert_contains(['a', '1'], 'a') => passes
-    #   assert_contains(['a', '1'], /not there/) => fails
-    def assert_contains(collection, x, extra_msg = "")
-      collection = [collection] unless collection.is_a?(Array)
-      msg = "#{x.inspect} not found in #{collection.to_a.inspect} #{extra_msg}"
-      case x
-      when Regexp
-        assert(collection.detect { |e| e =~ x }, msg)
-      else         
-        assert(collection.include?(x), msg)
-      end
-    end
-
-    # Asserts that the given collection does not contain item x.  If x is a regular expression, ensure that
-    # none of the elements from the collection match x.
-    def assert_does_not_contain(collection, x, extra_msg = "")
-      collection = [collection] unless collection.is_a?(Array)
-      msg = "#{x.inspect} found in #{collection.to_a.inspect} " + extra_msg
-      case x
-      when Regexp
-        assert(!collection.detect { |e| e =~ x }, msg)
-      else         
-        assert(!collection.include?(x), msg)
-      end
-    end
-
-    # Asserts that the given matcher returns true when +target+ is passed to #matches?
-    def assert_accepts(matcher, target, options = {})
-      if matcher.matches?(target)
-        assert_block { true }
-        if options[:message]
-          assert_match options[:message], matcher.negative_failure_message
-        end
-      else
-        assert_block(matcher.failure_message) { false }
-      end
-    end
-
-    # Asserts that the given matcher returns false when +target+ is passed to #matches?
-    def assert_rejects(matcher, target, options = {})
-      unless matcher.matches?(target)
-        assert_block { true }
-        if options[:message]
-          assert_match options[:message], matcher.failure_message
-        end
-      else
-        assert_block(matcher.negative_failure_message) { false }
-      end
-    end
-  end
-end

data/vendor/gems/shoulda/lib/shoulda/autoload_macros.rb

@@ -1,46 +0,0 @@
-module Shoulda # :nodoc:
-  # Call autoload_macros when you want to load test macros automatically in a non-Rails 
-  # project (it's done automatically for Rails projects).
-  # You don't need to specify ROOT/test/shoulda_macros explicitly. Your custom macros
-  # are loaded automatically when you call autoload_macros.
-  #
-  # The first argument is the path to you application's root directory.
-  # All following arguments are directories relative to your root, which contain 
-  # shoulda_macros subdirectories. These directories support the same kinds of globs as the 
-  # Dir class.
-  # 
-  # Basic usage (from a test_helper):
-  # Shoulda.autoload_macros(File.dirname(__FILE__) + '/..')
-  #	will load everything in 
-  #	- your_app/test/shoulda_macros
-  #
-  #	To load vendored macros as well:
-  # Shoulda.autoload_macros(APP_ROOT, 'vendor/*')
-  #	will load everything in 
-  #	- APP_ROOT/vendor/*/shoulda_macros
-  #	- APP_ROOT/test/shoulda_macros
-  #
-  #	To load macros in an app with a vendor directory laid out like Rails':
-  # Shoulda.autoload_macros(APP_ROOT, 'vendor/{plugins,gems}/*')
-  # or
-  # Shoulda.autoload_macros(APP_ROOT, 'vendor/plugins/*', 'vendor/gems/*')
-  #	will load everything in 
-  #	- APP_ROOT/vendor/plugins/*/shoulda_macros
-  #	- APP_ROOT/vendor/gems/*/shoulda_macros
-  #	- APP_ROOT/test/shoulda_macros
-  #
-  #	If you prefer to stick testing dependencies away from your production dependencies:
-  # Shoulda.autoload_macros(APP_ROOT, 'vendor/*', 'test/vendor/*')
-  #	will load everything in 
-  #	- APP_ROOT/vendor/*/shoulda_macros
-  #	- APP_ROOT/test/vendor/*/shoulda_macros
-  #	- APP_ROOT/test/shoulda_macros
-  def self.autoload_macros(root, *dirs)
-    dirs << File.join('test')
-    complete_dirs = dirs.map{|d| File.join(root, d, 'shoulda_macros')}
-    all_files     = complete_dirs.inject([]){ |files, dir| files + Dir[File.join(dir, '*.rb')] }
-    all_files.each do |file|
-      require file
-    end
-  end
-end