lockbox_middleware 1.2.1 → 1.2.2

data/vendor/gems/shoulda-2.10.2/lib/shoulda/active_record/matchers/have_db_index_matcher.rb

@@ -1,112 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that there are DB indices on the given columns or tuples of
-      # columns.
-      #
-      # Options:
-      # * <tt>unique</tt> - whether or not the index has a unique
-      #   constraint. Use <tt>true</tt> to explicitly test for a unique
-      #   constraint.  Use <tt>false</tt> to explicitly test for a non-unique
-      #   constraint. Use <tt>nil</tt> if you don't care whether the index is
-      #   unique or not.  Default = <tt>nil</tt>
-      #
-      # Examples:
-      #
-      #   it { should have_db_index(:age) }
-      #   it { should have_db_index([:commentable_type, :commentable_id]) }
-      #   it { should have_db_index(:ssn).unique(true) }
-      #
-      def have_db_index(columns)
-        HaveDbIndexMatcher.new(:have_index, columns)
-      end
-
-      class HaveDbIndexMatcher # :nodoc:
-        def initialize(macro, columns)
-          @macro = macro
-          @columns = normalize_columns_to_array(columns)
-        end
-        
-        def unique(unique)
-          @unique = unique
-          self
-        end
-
-        def matches?(subject)
-          @subject = subject
-          index_exists? && correct_unique?
-        end
-
-        def failure_message
-          "Expected #{expectation} (#{@missing})"
-        end
-
-        def negative_failure_message
-          "Did not expect #{expectation}"
-        end
-
-        def description
-          "have a #{index_type} index on columns #{@columns.join(' and ')}"
-        end
-
-        protected
-        
-        def index_exists?
-          ! matched_index.nil?
-        end
-        
-        def correct_unique?
-          return true if @unique.nil?
-          if matched_index.unique == @unique
-            true
-          else
-            @missing = "#{table_name} has an index named #{matched_index.name} " <<
-                       "of unique #{matched_index.unique}, not #{@unique}."
-            false
-          end
-        end
-        
-        def matched_index
-          indexes.detect { |each| each.columns == @columns }
-        end
-
-        def model_class
-          @subject.class
-        end
-        
-        def table_name
-          model_class.table_name
-        end
-        
-        def indexes
-          ::ActiveRecord::Base.connection.indexes(table_name)
-        end
-
-        def expectation
-          expected = "#{model_class.name} to #{description}"
-        end
-        
-        def index_type
-          case @unique
-          when nil
-            ''
-          when false
-            'non-unique'
-          else
-            'unique'
-          end
-        end
-        
-        def normalize_columns_to_array(columns)
-          if columns.class == Array
-            columns.collect { |each| each.to_s }
-          else
-            [columns.to_s]
-          end
-        end
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/active_record/matchers/have_named_scope_matcher.rb

@@ -1,128 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Deprecated.
-      #
-      # Ensures that the model has a method named scope_call that returns a
-      # NamedScope object with the proxy options set to the options you supply.
-      # scope_call can be either a symbol, or a Ruby expression in a String
-      # which will be evaled. The eval'd method call has access to all the same
-      # instance variables that an example would.
-      #
-      # Options:
-      #
-      #  * <tt>in_context</tt> - Any of the options that the named scope would
-      #    pass on to find.
-      #
-      # Example:
-      #
-      #   it { should have_named_scope(:visible).
-      #                 finding(:conditions => {:visible => true}) }
-      #
-      # Passes for
-      #
-      #   named_scope :visible, :conditions => {:visible => true}
-      #
-      # Or for
-      #
-      #   def self.visible
-      #     scoped(:conditions => {:visible => true})
-      #   end
-      #
-      # You can test lambdas or methods that return ActiveRecord#scoped calls:
-      #
-      #   it { should have_named_scope('recent(5)').finding(:limit => 5) }
-      #   it { should have_named_scope('recent(1)').finding(:limit => 1) }
-      #
-      # Passes for
-      #   named_scope :recent, lambda {|c| {:limit => c}}
-      #
-      # Or for
-      #
-      #   def self.recent(c)
-      #     scoped(:limit => c)
-      #   end
-      #
-      def have_named_scope(scope_call)
-        warn "[DEPRECATION] should_have_named_scope is deprecated."
-        HaveNamedScopeMatcher.new(scope_call).in_context(self)
-      end
-
-      class HaveNamedScopeMatcher # :nodoc:
-
-        def initialize(scope_call)
-          @scope_call = scope_call.to_s
-        end
-
-        def finding(finding)
-          @finding = finding
-          self
-        end
-
-        def in_context(context)
-          @context = context
-          self
-        end
-
-        def matches?(subject)
-          @subject = subject
-          call_succeeds? && returns_scope? && finds_correct_scope?
-        end
-
-        def failure_message
-          "Expected #{@missing_expectation}"
-        end
-
-        def negative_failure_message
-          "Didn't expect a named scope for #{@scope_call}"
-        end
-
-        def description
-          result = "have a named scope for #{@scope_call}"
-          result << " finding #{@finding.inspect}" unless @finding.nil?
-          result
-        end
-
-        private
-
-        def call_succeeds?
-          scope
-          true
-        rescue Exception => exception
-          @missing_expectation = "#{@subject.class.name} " <<
-            "to respond to #{@scope_call} " <<
-            "but raised error: #{exception.inspect}"
-          false
-        end
-
-        def scope
-          @scope ||= @context.instance_eval("#{@subject.class.name}.#{@scope_call}")
-        end
-
-        def returns_scope?
-          if ::ActiveRecord::NamedScope::Scope === scope
-            true
-          else
-            @missing_expectation = "#{@scope_call} to return a scope"
-            false
-          end
-        end
-
-        def finds_correct_scope?
-          return true if @finding.nil?
-          if @finding == scope.proxy_options
-            true
-          else
-            @missing_expectation = "#{@scope_call} to return results scoped to "
-            @missing_expectation << "#{@finding.inspect} but was scoped to "
-            @missing_expectation << scope.proxy_options.inspect
-            false
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/active_record/matchers/have_readonly_attribute_matcher.rb

@@ -1,59 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that the attribute cannot be changed once the record has been
-      # created.
-      #
-      #   it { should have_readonly_attributes(:password) }
-      #
-      def have_readonly_attribute(value)
-        HaveReadonlyAttributeMatcher.new(value)
-      end
-
-      class HaveReadonlyAttributeMatcher # :nodoc:
-
-        def initialize(attribute)
-          @attribute = attribute.to_s
-        end
-
-        def matches?(subject)
-          @subject = subject
-          if readonly_attributes.include?(@attribute)
-            @negative_failure_message =
-              "Did not expect #{@attribute} to be read-only"
-            true
-          else
-            if readonly_attributes.empty?
-              @failure_message = "#{class_name} attribute #{@attribute} " <<
-                "is not read-only"
-            else
-              @failure_message = "#{class_name} is making " <<
-                "#{readonly_attributes.to_sentence} " <<
-                "read-only, but not #{@attribute}."
-            end
-            false
-          end
-        end
-
-        attr_reader :failure_message, :negative_failure_message
-
-        def description
-          "make #{@attribute} read-only"
-        end
-
-        private
-
-        def readonly_attributes
-          @readonly_attributes ||= (@subject.class.readonly_attributes || [])
-        end
-
-        def class_name
-          @subject.class.name
-        end
-
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/active_record/matchers/validate_acceptance_of_matcher.rb

@@ -1,41 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that the model cannot be saved the given attribute is not
-      # accepted.
-      #
-      # Options:
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. Regexp or string.  Defaults to the
-      #   translation for <tt>:accepted</tt>.
-      #
-      # Example:
-      #   it { should validate_acceptance_of(:eula) }
-      #
-      def validate_acceptance_of(attr)
-        ValidateAcceptanceOfMatcher.new(attr)
-      end
-
-      class ValidateAcceptanceOfMatcher < ValidationMatcher # :nodoc:
-
-        def with_message(message)
-          @expected_message = message if message
-          self
-        end
-
-        def matches?(subject)
-          super(subject)
-          @expected_message ||= :accepted
-          disallows_value_of(false, @expected_message)
-        end
-
-        def description
-          "require #{@attribute} to be accepted"
-        end
-
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/active_record/matchers/validate_format_of_matcher.rb

@@ -1,67 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that the model is not valid if the given attribute is not
-      # formatted correctly.
-      #
-      # 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>:blank</tt>.
-      # * <tt>with(string to test against)</tt>
-      # * <tt>not_with(string to test against)</tt>
-      #
-      # Examples:
-      #   it { should validate_format_of(:name).
-      #                 with('12345').
-      #                 with_message(/is not optional/) }
-      #   it { should validate_format_of(:name).
-      #                 not_with('12D45').
-      #                 with_message(/is not optional/) }
-      #
-      def validate_format_of(attr)
-        ValidateFormatOfMatcher.new(attr)
-      end
-
-      class ValidateFormatOfMatcher < ValidationMatcher # :nodoc:
-        
-        def initialize(attribute)
-          super
-        end
-
-        def with_message(message)
-          @expected_message = message if message
-          self
-        end
-        
-        def with(value)
-          raise "You may not call both with and not_with" if @value_to_fail
-          @value_to_pass = value
-          self
-        end
-        
-
-        def not_with(value)
-          raise "You may not call both with and not_with" if @value_to_pass
-          @value_to_fail = value
-          self
-        end
-
-
-        def matches?(subject)
-          super(subject)
-          @expected_message ||= :blank
-          return disallows_value_of(@value_to_fail, @expected_message) if @value_to_fail
-          allows_value_of(@value_to_pass, @expected_message) if @value_to_pass
-        end
-
-        def description
-          "#{@attribute} have a valid format"
-        end
-
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/active_record/matchers/validate_numericality_of_matcher.rb

@@ -1,39 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensure that the attribute is numeric
-      #
-      # Options:
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. Regexp or string.  Defaults to the
-      #   translation for <tt>:not_a_number</tt>.
-      #
-      # Example:
-      #   it { should validate_numericality_of(:age) }
-      #
-      def validate_numericality_of(attr)
-        ValidateNumericalityOfMatcher.new(attr)
-      end
-
-      class ValidateNumericalityOfMatcher < ValidationMatcher # :nodoc:
-
-        def with_message(message)
-          @expected_message = message if message
-          self
-        end
-
-        def matches?(subject)
-          super(subject)
-          @expected_message ||= :not_a_number
-          disallows_value_of('abcd', @expected_message)
-        end
-
-        def description
-          "only allow numeric values for #{@attribute}"
-        end
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/active_record/matchers/validate_presence_of_matcher.rb

@@ -1,60 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that the model is not valid if the given attribute is not
-      # present.
-      #
-      # 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>:blank</tt>.
-      #
-      # Examples:
-      #   it { should validate_presence_of(:name) }
-      #   it { should validate_presence_of(:name).
-      #                 with_message(/is not optional/) }
-      #
-      def validate_presence_of(attr)
-        ValidatePresenceOfMatcher.new(attr)
-      end
-
-      class ValidatePresenceOfMatcher < ValidationMatcher # :nodoc:
-
-        def with_message(message)
-          @expected_message = message if message
-          self
-        end
-
-        def matches?(subject)
-          super(subject)
-          @expected_message ||= :blank
-          disallows_value_of(blank_value, @expected_message)
-        end
-
-        def description
-          "require #{@attribute} to be set"
-        end
-
-        private
-
-        def blank_value
-          if collection?
-            []
-          else
-            nil
-          end
-        end
-
-        def collection?
-          if reflection = @subject.class.reflect_on_association(@attribute)
-            [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
-          else
-            false
-          end
-        end
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/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