challah 1.0.0.beta2 → 1.0.0.beta3

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

@@ -0,0 +1,45 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      module Helpers
+        def pretty_error_messages(obj) # :nodoc:
+          obj.errors.map do |attribute, model|
+            msg = "#{attribute} #{model}"
+            if attribute.to_sym != :base && obj.respond_to?(attribute)
+              msg << " (#{obj.send(attribute).inspect})"
+            end
+            msg
+          end
+        end
+
+        # Helper method that determines the default error message used by Active
+        # Record.  Works for both existing Rails 2.1 and Rails 2.2 with the newly
+        # introduced I18n module used for localization. Use with Rails 3.0 and
+        # up will delegate to ActiveModel::Errors.generate_error if a model
+        # instance is given.
+        #
+        #   default_error_message(:blank)
+        #   default_error_message(:too_short, :count => 5)
+        #   default_error_message(:too_long, :count => 60)
+        #   default_error_message(:blank, :model_name => 'user', :attribute => 'name')
+        #   default_error_message(:blank, :instance => #<Model>, :attribute => 'name')
+        def default_error_message(key, options = {})
+          model_name = options.delete(:model_name)
+          attribute = options.delete(:attribute)
+          instance = options.delete(:instance)
+
+          if instance && instance.errors.respond_to?(:generate_message)
+            instance.errors.generate_message(attribute.to_sym, key, options)
+          else
+            default_translation = [ :"activerecord.errors.models.#{model_name}.#{key}",
+                                    :"activerecord.errors.messages.#{key}",
+                                    :"errors.attributes.#{attribute}.#{key}",
+                                    :"errors.messages.#{key}" ]
+            I18n.translate(:"activerecord.errors.models.#{model_name}.attributes.#{attribute}.#{key}",
+              { :default => default_translation }.merge(options))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      class OddEvenNumberMatcher # :nodoc:
+        NON_EVEN_NUMBER_VALUE = 1
+        NON_ODD_NUMBER_VALUE  = 2
+
+        def initialize(attribute, options = {})
+          @attribute = attribute
+          options[:odd]   ||= true
+          options[:even]  ||= false
+
+          if options[:odd] && !options[:even]
+            @disallow_value_matcher = DisallowValueMatcher.new(NON_ODD_NUMBER_VALUE).
+              for(@attribute).
+              with_message(:odd)
+          else
+            @disallow_value_matcher = DisallowValueMatcher.new(NON_EVEN_NUMBER_VALUE).
+              for(@attribute).
+              with_message(:even)
+          end
+        end
+
+        def matches?(subject)
+          @disallow_value_matcher.matches?(subject)
+        end
+
+        def with_message(message)
+          @disallow_value_matcher.with_message(message)
+          self
+        end
+
+        def allowed_types
+          'integer'
+        end
+
+        def failure_message_for_should
+          @disallow_value_matcher.failure_message_for_should
+        end
+
+        def failure_message_for_should_not
+          @disallow_value_matcher.failure_message_for_should_not
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      class OnlyIntegerMatcher # :nodoc:
+        NON_INTEGER_VALUE = 0.1
+
+        def initialize(attribute)
+          @attribute = attribute
+          @disallow_value_matcher = DisallowValueMatcher.new(NON_INTEGER_VALUE).
+            for(attribute).
+            with_message(:not_an_integer)
+        end
+
+        def matches?(subject)
+          @disallow_value_matcher.matches?(subject)
+        end
+
+        def with_message(message)
+          @disallow_value_matcher.with_message(message)
+          self
+        end
+
+        def allowed_types
+          'integer'
+        end
+
+        def failure_message_for_should
+          @disallow_value_matcher.failure_message_for_should
+        end
+
+        def failure_message_for_should_not
+          @disallow_value_matcher.failure_message_for_should_not
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+
+      # 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)
+          if message
+            @expected_message = message
+          end
+          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/bundle/gems/shoulda-matchers-2.1.0/lib/shoulda/matchers/active_model/validate_confirmation_of_matcher.rb

@@ -0,0 +1,65 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      # Ensures that the model's attribute matches confirmation
+      #
+      # Example:
+      #   it { should validate_confirmation_of(:password) }
+      #
+      def validate_confirmation_of(attr)
+        ValidateConfirmationOfMatcher.new(attr)
+      end
+
+      class ValidateConfirmationOfMatcher < ValidationMatcher # :nodoc:
+        include Helpers
+
+        def initialize(attribute)
+          @attribute = attribute
+          @confirmation = "#{attribute}_confirmation"
+        end
+
+        def with_message(message)
+          @message = message if message
+          self
+        end
+
+        def description
+          "require #{@confirmation} to match #{@attribute}"
+        end
+
+        def matches?(subject)
+          super(subject)
+          @message ||= :confirmation
+
+          disallows_different_value &&
+            allows_same_value &&
+            allows_missing_confirmation
+        end
+
+        private
+
+        def disallows_different_value
+          set_confirmation('some value')
+          disallows_value_of('different value', @message)
+        end
+
+        def allows_same_value
+          set_confirmation('same value')
+          allows_value_of('same value', @message)
+        end
+
+        def allows_missing_confirmation
+          set_confirmation(nil)
+          allows_value_of('any value', @message)
+        end
+
+        def set_confirmation(val)
+          setter = :"#{@confirmation}="
+          if @subject.respond_to?(setter)
+            @subject.send(setter, val)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      # 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>.
+      # * <tt>only_integer</tt> - allows only integer values
+      # * <tt>odd</tt> - Specifies the value must be an odd number.
+      # * <tt>even</tt> - Specifies the value must be an even number.
+      #
+      # Examples:
+      #   it { should validate_numericality_of(:price) }
+      #   it { should validate_numericality_of(:age).only_integer }
+      #   it { should validate_numericality_of(:frequency).odd }
+      #   it { should validate_numericality_of(:frequency).even }
+      #
+      def validate_numericality_of(attr)
+        ValidateNumericalityOfMatcher.new(attr)
+      end
+
+      class ValidateNumericalityOfMatcher
+        NON_NUMERIC_VALUE = 'abcd'
+
+        def initialize(attribute)
+          @attribute = attribute
+          @submatchers = []
+
+          add_disallow_value_matcher
+        end
+
+        def only_integer
+          only_integer_matcher = OnlyIntegerMatcher.new(@attribute)
+          add_submatcher(only_integer_matcher)
+          self
+        end
+
+        def odd
+          odd_number_matcher = OddEvenNumberMatcher.new(@attribute, :odd => true)
+          add_submatcher(odd_number_matcher)
+          self
+        end
+
+        def even
+          even_number_matcher = OddEvenNumberMatcher.new(@attribute, :even => true)
+          add_submatcher(even_number_matcher)
+          self
+        end
+
+        def with_message(message)
+          @submatchers.each { |matcher| matcher.with_message(message) }
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject
+          submatchers_match?
+        end
+
+        def description
+          "only allow #{allowed_types} values for #{@attribute}"
+        end
+
+        def failure_message_for_should
+          submatcher_failure_messages_for_should.last
+        end
+
+        def failure_message_for_should_not
+          submatcher_failure_messages_for_should_not.last
+        end
+
+        private
+
+        def add_disallow_value_matcher
+          disallow_value_matcher = DisallowValueMatcher.new(NON_NUMERIC_VALUE).
+            for(@attribute).
+            with_message(:not_a_number)
+
+          add_submatcher(disallow_value_matcher)
+        end
+
+        def add_submatcher(submatcher)
+          @submatchers << submatcher
+        end
+
+        def submatchers_match?
+          failing_submatchers.empty?
+        end
+
+        def submatcher_failure_messages_for_should
+          failing_submatchers.map(&:failure_message_for_should)
+        end
+
+        def submatcher_failure_messages_for_should_not
+          failing_submatchers.map(&:failure_message_for_should_not)
+        end
+
+        def failing_submatchers
+          @failing_submatchers ||= @submatchers.select { |matcher| !matcher.matches?(@subject) }
+        end
+
+        def allowed_types
+          allowed = ['numeric'] + submatcher_allowed_types
+          allowed.join(', ')
+        end
+
+        def submatcher_allowed_types
+          @submatchers.map(&:allowed_types).reject(&:empty?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+
+      # 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
+            [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
+          else
+            false
+          end
+        end
+
+        def reflection
+          @subject.class.respond_to?(:reflect_on_association) &&
+            @subject.class.reflect_on_association(@attribute)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,221 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      # Ensures that the model is invalid if the given attribute is not unique.
+      # It uses the first existing record or creates a new one if no record
+      # exists in the database. It simply uses `:validate => false` to get
+      # around validations, so it will probably fail if there are `NOT NULL`
+      # constraints. In that case, you must create a record before calling
+      # `validate_uniqueness_of`.
+      #
+      # Example:
+      #   it { should validate_uniqueness_of(:email) }
+      #
+      # 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)
+          super(attribute)
+          @options = {}
+        end
+
+        def scoped_to(*scopes)
+          @options[:scopes] = [*scopes].flatten
+          self
+        end
+
+        def with_message(message)
+          @expected_message = message
+          self
+        end
+
+        def case_insensitive
+          @options[:case_insensitive] = true
+          self
+        end
+
+        def allow_nil
+          @options[:allow_nil] = true
+          self
+        end
+
+        def description
+          result = "require "
+          result << "case sensitive " unless @options[:case_insensitive]
+          result << "unique value for #{@attribute}"
+          result << " scoped to #{@options[:scopes].join(', ')}" if @options[:scopes].present?
+          result
+        end
+
+        def matches?(subject)
+          @subject = subject.class.new
+          @expected_message ||= :taken
+          set_scoped_attributes &&
+            validate_everything_except_duplicate_nils? &&
+            validate_after_scope_change? &&
+            allows_nil?
+        end
+
+        def description
+          result = 'require '
+          result << 'case sensitive ' unless @options[:case_insensitive]
+          result << "unique value for #{@attribute}"
+          result << " scoped to #{@options[:scopes].join(', ')}" if @options[:scopes].present?
+          result
+        end
+
+        private
+
+        def allows_nil?
+          if @options[:allow_nil]
+            ensure_nil_record_in_database
+            allows_value_of(nil, @expected_message)
+          else
+            true
+          end
+        end
+
+        def existing_record
+          @existing_record ||= first_instance
+        end
+
+        def first_instance
+          @subject.class.first || create_record_in_database
+        end
+
+        def ensure_nil_record_in_database
+          unless existing_record_is_nil?
+            create_record_in_database(nil_value: true)
+          end
+        end
+
+        def existing_record_is_nil?
+          @existing_record.present? && existing_value.nil?
+        end
+
+        def create_record_in_database(options = {})
+          if options[:nil_value]
+            value = nil
+          else
+            value = "arbitrary_string"
+          end
+
+          @subject.class.new.tap do |instance|
+            instance.send("#{@attribute}=", value)
+            instance.save(:validate => false)
+          end
+        end
+
+        def set_scoped_attributes
+          if @options[:scopes].present?
+            @options[:scopes].all? do |scope|
+              setter = :"#{scope}="
+              if @subject.respond_to?(setter)
+                @subject.send(setter, existing_record.send(scope))
+                true
+              else
+                @failure_message_for_should = "#{class_name} doesn't seem to have a #{scope} attribute."
+                false
+              end
+            end
+          else
+            true
+          end
+        end
+
+        def validate_everything_except_duplicate_nils?
+          if @options[:allow_nil] && existing_value.nil?
+            create_record_without_nil
+          end
+
+          disallows_value_of(existing_value, @expected_message)
+        end
+
+        def create_record_without_nil
+          @existing_record = create_record_in_database
+        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 @options[:scopes].blank?
+            true
+          else
+            @options[:scopes].all? do |scope|
+              previous_value = existing_record.send(scope)
+
+              # Assume the scope is a foreign key if the field is nil
+              previous_value ||= correct_type_for_column(@subject.class.columns_hash[scope.to_s])
+
+              next_value =
+                if previous_value.respond_to?(:next)
+                  previous_value.next
+                elsif previous_value.respond_to?(:to_datetime)
+                  previous_value.to_datetime.next
+                else
+                  previous_value.to_s.next
+                end
+
+              @subject.send("#{scope}=", next_value)
+
+              if allows_value_of(existing_value, @expected_message)
+                @subject.send("#{scope}=", previous_value)
+
+                @failure_message_for_should_not <<
+                  " (with different value of #{scope})"
+                true
+              else
+                @failure_message_for_should << " (with different value of #{scope})"
+                false
+              end
+            end
+          end
+        end
+
+        def correct_type_for_column(column)
+          if column.type == :string
+            '0'
+          elsif column.type == :datetime
+            DateTime.now
+          else
+            0
+          end
+        end
+
+        def class_name
+          @subject.class.name
+        end
+
+        def existing_value
+          value = existing_record.send(@attribute)
+          if @options[:case_insensitive] && value.respond_to?(:swapcase!)
+            value.swapcase!
+          end
+          value
+        end
+      end
+    end
+  end
+end