challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/shoulda-matchers-2.1.0/lib/shoulda/matchers/active_model/allow_value_matcher.rb

@@ -0,0 +1,174 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+
+      # Ensures that the attribute can be set to the given value or values. If
+      # multiple values are given the match succeeds only if all given values
+      # are allowed. Otherwise, the matcher fails at the first bad value in the
+      # argument list (the remaining arguments are not processed then).
+      #
+      # Options:
+      # * <tt>with_message</tt> - value the test expects to find in
+      #   <tt>errors.on(:attribute)</tt>. Regexp or string. If omitted,
+      #   the test looks for any errors in <tt>errors.on(:attribute)</tt>.
+      # * <tt>strict</tt> - expects the model to raise an exception when the
+      #   validation fails rather than adding to the errors collection. Used for
+      #   testing `validates!` and the `:strict => true` validation options.
+      #
+      # Example:
+      #   it { should_not allow_value('bad').for(:isbn) }
+      #   it { should allow_value('isbn 1 2345 6789 0').for(:isbn) }
+      #
+      def allow_value(*values)
+        if values.empty?
+          raise ArgumentError, 'need at least one argument'
+        else
+          AllowValueMatcher.new(*values)
+        end
+      end
+
+      class AllowValueMatcher # :nodoc:
+        include Helpers
+
+        attr_accessor :options
+
+        def initialize(*values)
+          self.values_to_match = values
+          self.message_finder_factory = ValidationMessageFinder
+          self.options = {}
+        end
+
+        def for(attribute)
+          self.attribute = attribute
+          self
+        end
+
+        def on(context)
+          @context = context
+          self
+        end
+
+        def with_message(message)
+          self.options[:expected_message] = message
+          self
+        end
+
+        def strict
+          self.message_finder_factory = ExceptionMessageFinder
+          self
+        end
+
+        def matches?(instance)
+          self.instance = instance
+
+          values_to_match.none? do |value|
+            self.value = value
+            instance.send("#{attribute}=", value)
+            errors_match?
+          end
+        end
+
+        def failure_message_for_should
+          "Did not expect #{expectation}, got error: #{matched_error}"
+        end
+
+        def failure_message_for_should_not
+          "Expected #{expectation}, got #{error_description}"
+        end
+
+        def description
+          message_finder.allow_description(allowed_values)
+        end
+
+        private
+
+        attr_accessor :values_to_match, :message_finder_factory,
+          :instance, :attribute, :context, :value, :matched_error
+
+        def errors_match?
+          has_messages? && errors_for_attribute_match?
+        end
+
+        def has_messages?
+          message_finder.has_messages?
+        end
+
+        def errors_for_attribute_match?
+          if expected_message
+            self.matched_error = errors_match_regexp? || errors_match_string?
+          else
+            errors_for_attribute.compact.any?
+          end
+        end
+
+        def errors_for_attribute
+          message_finder.messages
+        end
+
+        def errors_match_regexp?
+          if Regexp === expected_message
+            errors_for_attribute.detect { |e| e =~ expected_message }
+          end
+        end
+
+        def errors_match_string?
+          if errors_for_attribute.include?(expected_message)
+            expected_message
+          end
+        end
+
+        def expectation
+          includes_expected_message = expected_message ? "to include #{expected_message.inspect}" : ''
+          [error_source, includes_expected_message, "when #{attribute} is set to #{value.inspect}"].join(' ')
+        end
+
+        def error_source
+          message_finder.source_description
+        end
+
+        def error_description
+          message_finder.messages_description
+        end
+
+        def allowed_values
+          if values_to_match.length > 1
+            "any of [#{values_to_match.map(&:inspect).join(', ')}]"
+          else
+            values_to_match.first.inspect
+          end
+        end
+
+        def expected_message
+          if options.key?(:expected_message)
+            if Symbol === options[:expected_message]
+              default_expected_message
+            else
+              options[:expected_message]
+            end
+          end
+        end
+
+        def default_expected_message
+          message_finder.expected_message_from(default_attribute_message)
+        end
+
+        def default_attribute_message
+          default_error_message(
+            options[:expected_message],
+            :model_name => model_name,
+            :instance => instance,
+            :attribute => attribute
+          )
+        end
+
+        def model_name
+          instance.class.to_s.underscore
+        end
+
+        def message_finder
+          message_finder_factory.new(instance, attribute, context)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/lib/shoulda/matchers/active_model/disallow_value_matcher.rb

@@ -0,0 +1,42 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      class DisallowValueMatcher # :nodoc:
+        def initialize(value)
+          @allow_matcher = AllowValueMatcher.new(value)
+        end
+
+        def matches?(subject)
+          !@allow_matcher.matches?(subject)
+        end
+
+        def for(attribute)
+          @allow_matcher.for(attribute)
+          self
+        end
+
+        def with_message(message)
+          @allow_matcher.with_message(message)
+          self
+        end
+
+        def failure_message_for_should
+          @allow_matcher.failure_message_for_should_not
+        end
+
+        def failure_message_for_should_not
+          @allow_matcher.failure_message_for_should
+        end
+
+        def allowed_types
+          ''
+        end
+
+        def strict
+          @allow_matcher.strict
+          self
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/lib/shoulda/matchers/active_model/ensure_exclusion_of_matcher.rb

@@ -0,0 +1,94 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+
+      # Ensure that the attribute's value is not in the range specified
+      #
+      # Options:
+      # * <tt>in_array</tt> - the array of not allowed values for this attribute
+      # * <tt>in_range</tt> - the range of not allowed values for this attribute
+      # * <tt>with_message</tt> - value the test expects to find in
+      #   <tt>errors.on(:attribute)</tt>. Regexp or string. Defaults to the
+      #   translation for :exclusion.
+      #
+      # Example:
+      #   it { should ensure_exclusion_of(:age).in_range(30..60) }
+      #
+      def ensure_exclusion_of(attr)
+        EnsureExclusionOfMatcher.new(attr)
+      end
+
+      class EnsureExclusionOfMatcher < ValidationMatcher # :nodoc:
+        def in_array(array)
+          @array = array
+          self
+        end
+
+        def in_range(range)
+          @range = range
+          @minimum = range.first
+          @maximum = range.max
+          self
+        end
+
+        def with_message(message)
+          @expected_message = message if message
+          self
+        end
+
+        def description
+          "ensure exclusion of #{@attribute} in #{inspect_message}"
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          if @range
+            allows_lower_value &&
+              disallows_minimum_value &&
+              allows_higher_value &&
+              disallows_maximum_value
+          elsif @array
+            disallows_all_values_in_array?
+          end
+        end
+
+        private
+
+        def disallows_all_values_in_array?
+          @array.all? do |value|
+            disallows_value_of(value, expected_message)
+          end
+        end
+
+        def allows_lower_value
+          @minimum == 0 || allows_value_of(@minimum - 1, expected_message)
+        end
+
+        def allows_higher_value
+          allows_value_of(@maximum + 1, expected_message)
+        end
+
+        def disallows_minimum_value
+          disallows_value_of(@minimum, expected_message)
+        end
+
+        def disallows_maximum_value
+          disallows_value_of(@maximum, expected_message)
+        end
+
+        def expected_message
+          @expected_message || :exclusion
+        end
+
+        def inspect_message
+          if @range
+            @range.inspect
+          else
+            @array.inspect
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/lib/shoulda/matchers/active_model/ensure_inclusion_of_matcher.rb

@@ -0,0 +1,156 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+
+      # Ensure that the attribute's value is in the range specified
+      #
+      # Options:
+      # * <tt>in_array</tt> - the array of allowed values for this attribute
+      # * <tt>in_range</tt> - the range of allowed values for this attribute
+      # * <tt>with_low_message</tt> - value the test expects to find in
+      #   <tt>errors.on(:attribute)</tt>. Regexp or string. Defaults to the
+      #   translation for :inclusion.
+      # * <tt>with_high_message</tt> - value the test expects to find in
+      #   <tt>errors.on(:attribute)</tt>. Regexp or string. Defaults to the
+      #   translation for :inclusion.
+      #
+      # Example:
+      #   it { should ensure_inclusion_of(:age).in_range(0..100) }
+      #
+      def ensure_inclusion_of(attr)
+        EnsureInclusionOfMatcher.new(attr)
+      end
+
+      class EnsureInclusionOfMatcher < ValidationMatcher # :nodoc:
+        ARBITRARY_OUTSIDE_STRING = 'shouldamatchersteststring'
+
+        def initialize(attribute)
+          super(attribute)
+          @options = {}
+        end
+
+        def in_array(array)
+          @array = array
+          self
+        end
+
+        def in_range(range)
+          @range = range
+          @minimum = range.first
+          @maximum = range.max
+          self
+        end
+
+        def allow_blank(allow_blank = true)
+          @options[:allow_blank] = allow_blank
+          self
+        end
+
+        def allow_nil(allow_nil = true)
+          @options[:allow_nil] = allow_nil
+          self
+        end
+
+        def with_message(message)
+          if message
+            @low_message = message
+            @high_message = message
+          end
+          self
+        end
+
+        def with_low_message(message)
+          @low_message = message if message
+          self
+        end
+
+        def with_high_message(message)
+          @high_message = message if message
+          self
+        end
+
+        def description
+          "ensure inclusion of #{@attribute} in #{inspect_message}"
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          if @range
+            @low_message  ||= :inclusion
+            @high_message ||= :inclusion
+
+            disallows_lower_value &&
+              allows_minimum_value &&
+              disallows_higher_value &&
+              allows_maximum_value
+          elsif @array
+            if allows_all_values_in_array? && allows_blank_value? && allows_nil_value? && disallows_value_outside_of_array?
+              true
+            else
+              @failure_message_for_should = "#{@array} doesn't match array in validation"
+              false
+            end
+          end
+        end
+
+        private
+
+        def allows_blank_value?
+          if @options.key?(:allow_blank)
+            blank_values = ['', ' ', "\n", "\r", "\t", "\f"]
+            @options[:allow_blank] == blank_values.all? { |value| allows_value_of(value) }
+          else
+            true
+          end
+        end
+
+        def allows_nil_value?
+          if @options.key?(:allow_nil)
+            @options[:allow_nil] == allows_value_of(nil)
+          else
+            true
+          end
+        end
+
+        def inspect_message
+          @range.nil? ? @array.inspect : @range.inspect
+        end
+
+        def allows_all_values_in_array?
+          @array.all? do |value|
+            allows_value_of(value, @low_message)
+          end
+        end
+
+        def disallows_lower_value
+          @minimum == 0 || disallows_value_of(@minimum - 1, @low_message)
+        end
+
+        def disallows_higher_value
+          disallows_value_of(@maximum + 1, @high_message)
+        end
+
+        def allows_minimum_value
+          allows_value_of(@minimum, @low_message)
+        end
+
+        def allows_maximum_value
+          allows_value_of(@maximum, @high_message)
+        end
+
+        def disallows_value_outside_of_array?
+          disallows_value_of(value_outside_of_array)
+        end
+
+        def value_outside_of_array
+          if @array.include?(ARBITRARY_OUTSIDE_STRING)
+            raise CouldNotDetermineValueOutsideOfArray
+          else
+            ARBITRARY_OUTSIDE_STRING
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/lib/shoulda/matchers/active_model/ensure_length_of_matcher.rb

@@ -0,0 +1,176 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+
+      # Ensures that the length of the attribute is validated. Only works with
+      # string/text columns because it uses a string to check length.
+      #
+      # Options:
+      # * <tt>is_at_least</tt> - minimum length of this attribute
+      # * <tt>is_at_most</tt> - maximum length of this attribute
+      # * <tt>is_equal_to</tt> - exact requred length of this attribute
+      # * <tt>with_short_message</tt> - value the test expects to find in
+      #   <tt>errors.on(:attribute)</tt>. Regexp or string.  Defaults to the
+      #   translation for :too_short.
+      # * <tt>with_long_message</tt> - value the test expects to find in
+      #   <tt>errors.on(:attribute)</tt>. Regexp or string.  Defaults to the
+      #   translation for :too_long.
+      # * <tt>with_message</tt> - value the test expects to find in
+      #   <tt>errors.on(:attribute)</tt>. Regexp or string.  Defaults to the
+      #   translation for :wrong_length. Used in conjunction with
+      #   <tt>is_equal_to</tt>.
+      #
+      # Examples:
+      #   it { should ensure_length_of(:password).
+      #                 is_at_least(6).
+      #                 is_at_most(20) }
+      #   it { should ensure_length_of(:name).
+      #                 is_at_least(3).
+      #                 with_short_message(/not long enough/) }
+      #   it { should ensure_length_of(:ssn).
+      #                 is_equal_to(9).
+      #                 with_message(/is invalid/) }
+      def ensure_length_of(attr)
+        EnsureLengthOfMatcher.new(attr)
+      end
+
+      class EnsureLengthOfMatcher < ValidationMatcher # :nodoc:
+        include Helpers
+
+        def initialize(attribute)
+          super(attribute)
+          @options = {}
+        end
+
+        def is_at_least(length)
+          @options[:minimum] = length
+          @short_message ||= :too_short
+          self
+        end
+
+        def is_at_most(length)
+          @options[:maximum] = length
+          @long_message ||= :too_long
+          self
+        end
+
+        def is_equal_to(length)
+          @options[:minimum] = length
+          @options[:maximum] = length
+          @short_message ||= :wrong_length
+          @long_message ||= :wrong_length
+          self
+        end
+
+        def with_short_message(message)
+          if message
+            @short_message = message
+          end
+          self
+        end
+        alias_method :with_message, :with_short_message
+
+        def with_long_message(message)
+          if message
+            @long_message = message
+          end
+          self
+        end
+
+        def description
+          description =  "ensure #{@attribute} has a length "
+          if @options.key?(:minimum) && @options.key?(:maximum)
+            if @options[:minimum] == @options[:maximum]
+              description << "of exactly #{@options[:minimum]}"
+            else
+              description << "between #{@options[:minimum]} and #{@options[:maximum]}"
+            end
+          else
+            description << "of at least #{@options[:minimum]}" if @options[:minimum]
+            description << "of at most #{@options[:maximum]}" if @options[:maximum]
+          end
+          description
+        end
+
+        def matches?(subject)
+          super(subject)
+          translate_messages!
+          lower_bound_matches? && upper_bound_matches?
+        end
+
+        private
+
+        def translate_messages!
+          if Symbol === @short_message
+            @short_message = default_error_message(@short_message,
+                                                   :model_name => @subject.class.to_s.underscore,
+                                                   :instance => @subject,
+                                                   :attribute => @attribute,
+                                                   :count => @options[:minimum])
+          end
+
+          if Symbol === @long_message
+            @long_message = default_error_message(@long_message,
+                                                  :model_name => @subject.class.to_s.underscore,
+                                                  :instance => @subject,
+                                                  :attribute => @attribute,
+                                                  :count => @options[:maximum])
+          end
+        end
+
+        def lower_bound_matches?
+          disallows_lower_length? && allows_minimum_length?
+        end
+
+        def upper_bound_matches?
+          disallows_higher_length? && allows_maximum_length?
+        end
+
+        def disallows_lower_length?
+          if @options.key?(:minimum)
+            @options[:minimum] == 0 ||
+              disallows_length_of?(@options[:minimum] - 1, @short_message)
+          else
+            true
+          end
+        end
+
+        def disallows_higher_length?
+          if @options.key?(:maximum)
+            disallows_length_of?(@options[:maximum] + 1, @long_message)
+          else
+            true
+          end
+        end
+
+        def allows_minimum_length?
+          if @options.key?(:minimum)
+            allows_length_of?(@options[:minimum], @short_message)
+          else
+            true
+          end
+        end
+
+        def allows_maximum_length?
+          if @options.key?(:maximum)
+            allows_length_of?(@options[:maximum], @long_message)
+          else
+            true
+          end
+        end
+
+        def allows_length_of?(length, message)
+          allows_value_of(string_of_length(length), message)
+        end
+
+        def disallows_length_of?(length, message)
+          disallows_value_of(string_of_length(length), message)
+        end
+
+        def string_of_length(length)
+          'x' * length
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/lib/shoulda/matchers/active_model/errors.rb

@@ -0,0 +1,7 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      class CouldNotDetermineValueOutsideOfArray < RuntimeError; end
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/lib/shoulda/matchers/active_model/exception_message_finder.rb

@@ -0,0 +1,58 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # Finds message information from exceptions thrown by #valid?
+      class ExceptionMessageFinder
+        def initialize(instance, attribute, context=nil)
+          @instance = instance
+          @attribute = attribute
+          @context = context
+        end
+
+        def allow_description(allowed_values)
+          "doesn't raise when #{@attribute} is set to #{allowed_values}"
+        end
+
+        def messages_description
+          if has_messages?
+            messages.join
+          else
+            'no exception'
+          end
+        end
+
+        def has_messages?
+          messages.any?
+        end
+
+        def messages
+          @messages ||= validate_and_rescue
+        end
+
+        def source_description
+          'exception'
+        end
+
+        def expected_message_from(attribute_message)
+          "#{human_attribute_name} #{attribute_message}"
+        end
+
+        private
+
+        def validate_and_rescue
+          @instance.valid?(@context)
+          []
+        rescue ::ActiveModel::StrictValidationFailed => exception
+          [exception.message]
+        end
+
+        def human_attribute_name
+          @instance.class.human_attribute_name(@attribute)
+        end
+      end
+
+    end
+  end
+end
+
+