RubyGems - dirty_history - Versions diffs - 0.5.2 → 0.5.3 - Mend

dirty_history 0.5.2 → 0.5.3

Files changed (1429) hide show

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/set_session_matcher.rb DELETED Viewed

@@ -1,98 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-      # Ensures that a session key was set to the expected value.
-      #
-      # Example:
-      #
-      #   it { should set_session(:message) }
-      #   it { should set_session(:user_id).to(@user.id) }
-      #   it { should_not set_session(:user_id) }
-      def set_session(key)
-        SetSessionMatcher.new(key)
-      end
-      class SetSessionMatcher # :nodoc:
-        def initialize(key)
-          @key = key.to_s
-        end
-        def to(value = nil, &block)
-          @value = value
-          @value_block = block
-          self
-        end
-        def matches?(controller)
-          @controller = controller
-          @value = @context.instance_eval(&@value_block) if @value_block
-          (assigned_value? && assigned_correct_value?) || cleared_value?
-        end
-        def failure_message
-          "Expected #{expectation}, but #{result}"
-        end
-        def negative_failure_message
-          "Didn't expect #{expectation}, but #{result}"
-        end
-        def description
-          description = "set session variable #{@key.inspect}"
-          description << " to #{@value.inspect}" if defined?(@value)
-          description
-        end
-        def in_context(context)
-          @context = context
-          self
-        end
-        private
-        def assigned_value?
-          !assigned_value.nil?
-        end
-        def cleared_value?
-          defined?(@value) && @value.nil? && assigned_value.nil?
-        end
-        def assigned_correct_value?
-          return true if @value.nil?
-          assigned_value == @value
-        end
-        def assigned_value
-          session[@key]
-        end
-        def session
-          if @controller.request.respond_to?(:session)
-            @controller.request.session.to_hash
-          else
-            @controller.response.session.data
-          end
-        end
-        def expectation
-          expectation = "session variable #{@key} to be set"
-          expectation << " to #{@value.inspect}" if @value
-          expectation
-        end
-        def result
-          if session.empty?
-            "no session variables were set"
-          else
-            "the session was #{session.inspect}"
-          end
-        end
-      end
-    end
-  end
-end

@@ -1,100 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-      # Ensures that the flash contains the given value. Can be a String, a
-      # Regexp, or nil (indicating that the flash should not be set).
-      #
-      # Example:
-      #
-      #   it { should set_the_flash }
-      #   it { should set_the_flash.to("Thank you for placing this order.") }
-      #   it { should set_the_flash.to(/created/i) }
-      #   it { should set_the_flash.to(/logged in/i).now }
-      #   it { should_not set_the_flash }
-      def set_the_flash
-        SetTheFlashMatcher.new
-      end
-      class SetTheFlashMatcher # :nodoc:
-        def to(value)
-          @value = value
-          self
-        end
-        def now
-          @now = true
-          self
-        end
-        def matches?(controller)
-          @controller = controller
-          sets_the_flash? && string_value_matches? && regexp_value_matches?
-        end
-        attr_reader :failure_message, :negative_failure_message
-        def description
-          description = "set the flash"
-          description << " to #{@value.inspect}" unless @value.nil?
-          description
-        end
-        def failure_message
-          "Expected #{expectation}"
-        end
-        def negative_failure_message
-          "Did not expect #{expectation}"
-        end
-        private
-        def sets_the_flash?
-          !flash.blank?
-        end
-        def string_value_matches?
-          return true unless String === @value
-          flash.values.any? {|value| value == @value }
-        end
-        def regexp_value_matches?
-          return true unless Regexp === @value
-          flash.values.any? {|value| value =~ @value }
-        end
-        def flash
-          return @flash if @flash
-          flash_and_now = @controller.request.session["flash"].dup if @controller.request.session["flash"]
-          flash         = @controller.send(:flash)
-          @flash = if @now
-            flash.keys.each {|key| flash_and_now.delete(key) }
-            flash_and_now
-          else
-            flash
-          end
-        end
-        def expectation
-          expectation = "the flash#{".now" if @now} to be set"
-          expectation << " to #{@value.inspect}" unless @value.nil?
-          expectation << ", but #{flash_description}"
-          expectation
-        end
-        def flash_description
-          if flash.blank?
-            "no flash was set"
-          else
-            "was #{flash.inspect}"
-          end
-        end
-      end
-    end
-  end
-end

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/shoulda-2.11.3/lib/shoulda/action_mailer.rb DELETED Viewed

@@ -1,13 +0,0 @@
-require 'shoulda'
-require 'shoulda/action_mailer/assertions'
-require 'shoulda/action_mailer/matchers'
-module Test # :nodoc: all
-  module Unit
-    class TestCase
-      include Shoulda::ActionMailer::Assertions
-      include Shoulda::ActionMailer::Matchers
-      extend Shoulda::ActionMailer::Matchers
-    end
-  end
-end

@@ -1,42 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionMailer # :nodoc:
-    module Assertions
-      # Asserts that an email was delivered.  Can take a block that can further
-      # narrow down the types of emails you're expecting.
-      #
-      #  assert_sent_email
-      #
-      # Passes if ActionMailer::Base.deliveries has an email
-      #
-      #  assert_sent_email do |email|
-      #    email.subject =~ /hi there/ && email.to.include?('none@none.com')
-      #  end
-      #
-      # Passes if there is an email with subject containing 'hi there' and
-      # 'none@none.com' as one of the recipients.
-      #
-      def assert_sent_email
-      ::ActiveSupport::Deprecation.warn("use: should have_sent_email")
-        emails = ::ActionMailer::Base.deliveries
-        assert !emails.empty?, "No emails were sent"
-        if block_given?
-          matching_emails = emails.select {|email| yield email }
-          assert !matching_emails.empty?, "None of the emails matched."
-        end
-      end
-      # should have_sent_email.with_subject(/hi there/).to('none@none.com').from('noreply@example.com').with_body(/reach out/)
-      # Asserts that no ActionMailer mails were delivered
-      #
-      #  assert_did_not_send_email
-      def assert_did_not_send_email
-        ::ActiveSupport::Deprecation.warn("use: should_not have_sent_email")
-        msg = "Sent #{::ActionMailer::Base.deliveries.size} emails.\n"
-        ::ActionMailer::Base.deliveries.each { |m| msg << "  '#{m.subject}' sent to #{m.to.to_sentence}\n" }
-        assert ::ActionMailer::Base.deliveries.empty?, msg
-      end
-    end
-  end
-end

@@ -1,22 +0,0 @@
-require 'shoulda/action_mailer/matchers/have_sent_email'
-module Shoulda # :nodoc:
-  module ActionMailer # :nodoc:
-    # = Matchers for your mailers
-    #
-    # This matcher will test that email is sent properly
-    #
-    #   describe User do
-    #     it { should have_sent_email.with_subject(/is spam$/) }
-    #     it { should have_sent_email.from('do-not-reply@example.com') }
-    #     it { should have_sent_email.with_body(/is spam\./) }
-    #     it { should have_sent_email.to('myself@me.com') }
-    #     it { should have_sent_email.with_subject(/spam/).
-    #                                 from('do-not-reply@example.com').
-    #                                 with_body(/spam/).
-    #                                 to('myself@me.com') }
-    #   end
-    module Matchers
-    end
-  end
-end

@@ -1,110 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionMailer # :nodoc:
-    module Matchers
-      # The right email is sent.
-      #
-      #   it { should have_sent_email.with_subject(/is spam$/) }
-      #   it { should have_sent_email.from('do-not-reply@example.com') }
-      #   it { should have_sent_email.with_body(/is spam\./) }
-      #   it { should have_sent_email.to('myself@me.com') }
-      #   it { should have_sent_email.with_subject(/spam/).
-      #                               from('do-not-reply@example.com').
-      #                               with_body(/spam/).
-      #                               to('myself@me.com') }
-      def have_sent_email
-        HaveSentEmailMatcher.new
-      end
-      class HaveSentEmailMatcher # :nodoc:
-        def initialize
-        end
-        def with_subject(email_subject)
-          @email_subject = email_subject
-          self
-        end
-        def from(sender)
-          @sender = sender
-          self
-        end
-        def with_body(body)
-          @body = body
-          self
-        end
-        def to(recipient)
-          @recipient = recipient
-          self
-        end
-        def matches?(subject)
-          ::ActionMailer::Base.deliveries.each do |mail|
-            @subject_failed = !regexp_or_string_match(mail.subject, @email_subject) if @email_subject
-            @body_failed = !regexp_or_string_match(mail.body, @body) if @body
-            @sender_failed = !regexp_or_string_match_in_array(mail.from, @sender) if @sender
-            @recipient_failed = !regexp_or_string_match_in_array(mail.to, @recipient) if @recipient
-            return true unless anything_failed?
-          end
-          false
-        end
-        def failure_message
-          "Expected #{expectation}"
-        end
-        def negative_failure_message
-          "Did not expect #{expectation}"
-        end
-        def description
-          "send an email"
-        end
-        private
-        def expectation
-          expectation = "sent email"
-          expectation << " with subject #{@email_subject.inspect}" if @subject_failed
-          expectation << " with body #{@body.inspect}" if @body_failed
-          expectation << " from #{@sender.inspect}" if @sender_failed
-          expectation << " to #{@recipient.inspect}" if @recipient_failed
-          expectation << "\nDeliveries:\n#{inspect_deliveries}"
-        end
-        def inspect_deliveries
-          ::ActionMailer::Base.deliveries.map do |delivery|
-            "#{delivery.subject.inspect} to #{delivery.to.inspect}"
-          end.join("\n")
-        end
-        def anything_failed?
-          @subject_failed || @body_failed || @sender_failed || @recipient_failed
-        end
-        def regexp_or_string_match(a_string, a_regexp_or_string)
-          case a_regexp_or_string
-          when Regexp
-            a_string =~ a_regexp_or_string
-          when String
-            a_string == a_regexp_or_string
-          end
-        end
-        def regexp_or_string_match_in_array(an_array, a_regexp_or_string)
-          case a_regexp_or_string
-          when Regexp
-            an_array.detect{|e| e =~ a_regexp_or_string}.any?
-          when String
-            an_array.include?(a_regexp_or_string)
-          end
-        end
-      end
-    end
-  end
-end

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/shoulda-2.11.3/lib/shoulda/active_record.rb DELETED Viewed

@@ -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

@@ -1,69 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Assertions
-      # Asserts that the given object can be saved
-      #
-      #  assert_save User.new(params)
-      def assert_save(obj)
-        assert obj.save, "Errors: #{pretty_error_messages obj}"
-        obj.reload
-      end
-      # Asserts that the given object is valid
-      #
-      #  assert_valid User.new(params)
-      def assert_valid(obj)
-        assert obj.valid?, "Errors: #{pretty_error_messages obj}"
-      end
-      # Asserts that an Active Record model validates with the passed
-      # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
-      # contained within the list of errors for that attribute.
-      #
-      #   assert_good_value(User.new, :email, "user@example.com")
-      #   assert_good_value(User.new, :ssn, "123456789", /length/)
-      #
-      # If a class is passed as the first argument, a new object will be
-      # instantiated before the assertion.  If an instance variable exists with
-      # the same name as the class (underscored), that object will be used
-      # instead.
-      #
-      #   assert_good_value(User, :email, "user@example.com")
-      #
-      #   product = Product.new(:tangible => false)
-      #   assert_good_value(product, :price, "0")
-      def assert_good_value(object_or_klass, attribute, value, error_message_to_avoid = nil)
-        object = get_instance_of(object_or_klass)
-        matcher = allow_value(value).
-                    for(attribute).
-                    with_message(error_message_to_avoid)
-        assert_accepts(matcher, object)
-      end
-      # Asserts that an Active Record model invalidates the passed
-      # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
-      # contained within the list of errors for that attribute.
-      #
-      #   assert_bad_value(User.new, :email, "invalid")
-      #   assert_bad_value(User.new, :ssn, "123", /length/)
-      #
-      # If a class is passed as the first argument, a new object will be
-      # instantiated before the assertion.  If an instance variable exists with
-      # the same name as the class (underscored), that object will be used
-      # instead.
-      #
-      #   assert_bad_value(User, :email, "invalid")
-      #
-      #   product = Product.new(:tangible => true)
-      #   assert_bad_value(product, :price, "0")
-      def assert_bad_value(object_or_klass, attribute, value,
-                           error_message_to_expect = nil)
-        object = get_instance_of(object_or_klass)
-        matcher = allow_value(value).
-                    for(attribute).
-                    with_message(error_message_to_expect)
-        assert_rejects(matcher, object)
-      end
-    end
-  end
-end