thoughtbot-clearance 0.3.4 → 0.3.7

data/test/rails_root/vendor/gems/thoughtbot-shoulda-2.0.4/lib/shoulda/active_record.rb

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

data/test/rails_root/vendor/gems/thoughtbot-shoulda-2.0.4/lib/shoulda/assertions.rb

@@ -1,45 +0,0 @@
-module ThoughtBot # :nodoc:
-  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
-    end
-  end
-end

data/test/rails_root/vendor/gems/thoughtbot-shoulda-2.0.4/lib/shoulda/context.rb

@@ -1,306 +0,0 @@
-module Thoughtbot # :nodoc:
-  module Shoulda
-    VERSION = '2.0.4'
-
-    class << self
-      attr_accessor :contexts
-      def contexts # :nodoc:
-        @contexts ||= []
-      end
-
-      def current_context # :nodoc:
-        self.contexts.last
-      end
-
-      def add_context(context) # :nodoc:
-        self.contexts.push(context)
-      end
-
-      def remove_context # :nodoc:
-        self.contexts.pop
-      end
-    end
-
-    # == Should statements
-    #
-    # Should statements are just syntactic sugar over normal Test::Unit test methods.  A should block
-    # contains all the normal code and assertions you're used to seeing, with the added benefit that
-    # they can be wrapped inside context blocks (see below).
-    #
-    # === Example:
-    #
-    #  class UserTest << Test::Unit::TestCase
-    #
-    #    def setup
-    #      @user = User.new("John", "Doe")
-    #    end
-    #
-    #    should "return its full name"
-    #      assert_equal 'John Doe', @user.full_name
-    #    end
-    #
-    #  end
-    #
-    # ...will produce the following test:
-    # * <tt>"test: User should return its full name. "</tt>
-    #
-    # Note: The part before <tt>should</tt> in the test name is gleamed from the name of the Test::Unit class.
-    #
-    # Should statements can also take a Proc as a <tt>:before </tt>option.  This proc runs after any
-    # parent context's setups but before the current context's setup.
-    #
-    # === Example:
-    #
-    #  context "Some context" do
-    #    setup { puts("I run after the :before proc") }
-    #
-    #    should "run a :before proc", :before => lambda { puts("I run before the setup") }  do
-    #      assert true
-    #    end
-    #  end
-
-    def should(name, options = {}, &blk)
-      if Shoulda.current_context
-        block_given? ? Shoulda.current_context.should(name, options, &blk) : Should.current_context.should_eventually(name)
-      else
-        context_name = self.name.gsub(/Test/, "")
-        context = Thoughtbot::Shoulda::Context.new(context_name, self) do
-          block_given? ? should(name, options, &blk) : should_eventually(name)
-        end
-        context.build
-      end
-    end
-
-    # == Before statements
-    #
-    # Before statements are should statements that run before the current
-    # context's setup. These are especially useful when setting expectations.
-    #
-    # === Example:
-    #
-    #  class UserControllerTest < Test::Unit::TestCase
-    #    context "the index action" do
-    #      setup do
-    #        @users = [Factory(:user)]
-    #        User.stubs(:find).returns(@users)
-    #      end
-    #
-    #      context "on GET" do
-    #        setup { get :index }
-    #
-    #        should_respond_with :success
-    #
-    #        # runs before "get :index"
-    #        before_should "find all users" do
-    #          User.expects(:find).with(:all).returns(@users)
-    #        end
-    #      end
-    #    end
-    #  end
-    def before_should(name, &blk)
-      should(name, :before => blk) { assert true }
-    end
-
-    # Just like should, but never runs, and instead prints an 'X' in the Test::Unit output.
-    def should_eventually(name, options = {}, &blk)
-      context_name = self.name.gsub(/Test/, "")
-      context = Thoughtbot::Shoulda::Context.new(context_name, self) do
-        should_eventually(name, &blk)
-      end
-      context.build
-    end
-
-    # == Contexts
-    #
-    # A context block groups should statements under a common set of setup/teardown methods.
-    # Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
-    # and readability of your test code.
-    #
-    # A context block can contain setup, should, should_eventually, and teardown blocks.
-    #
-    #  class UserTest << Test::Unit::TestCase
-    #    context "A User instance" do
-    #      setup do
-    #        @user = User.find(:first)
-    #      end
-    #
-    #      should "return its full name"
-    #        assert_equal 'John Doe', @user.full_name
-    #      end
-    #    end
-    #  end
-    #
-    # This code will produce the method <tt>"test: A User instance should return its full name. "</tt>.
-    #
-    # Contexts may be nested.  Nested contexts run their setup blocks from out to in before each
-    # should statement.  They then run their teardown blocks from in to out after each should statement.
-    #
-    #  class UserTest << Test::Unit::TestCase
-    #    context "A User instance" do
-    #      setup do
-    #        @user = User.find(:first)
-    #      end
-    #
-    #      should "return its full name"
-    #        assert_equal 'John Doe', @user.full_name
-    #      end
-    #
-    #      context "with a profile" do
-    #        setup do
-    #          @user.profile = Profile.find(:first)
-    #        end
-    #
-    #        should "return true when sent :has_profile?"
-    #          assert @user.has_profile?
-    #        end
-    #      end
-    #    end
-    #  end
-    #
-    # This code will produce the following methods
-    # * <tt>"test: A User instance should return its full name. "</tt>
-    # * <tt>"test: A User instance with a profile should return true when sent :has_profile?. "</tt>
-    #
-    # <b>Just like should statements, a context block can exist next to normal <tt>def test_the_old_way; end</tt>
-    # tests</b>.  This means you do not have to fully commit to the context/should syntax in a test file.
-
-    def context(name, &blk)
-      if Shoulda.current_context
-        Shoulda.current_context.context(name, &blk)
-      else
-        context = Thoughtbot::Shoulda::Context.new(name, self, &blk)
-        context.build
-      end
-    end
-
-    class Context # :nodoc:
-
-      attr_accessor :name               # my name
-      attr_accessor :parent             # may be another context, or the original test::unit class.
-      attr_accessor :subcontexts        # array of contexts nested under myself
-      attr_accessor :setup_blocks       # blocks given via setup methods
-      attr_accessor :teardown_blocks    # blocks given via teardown methods
-      attr_accessor :shoulds            # array of hashes representing the should statements
-      attr_accessor :should_eventuallys # array of hashes representing the should eventually statements
-
-      def initialize(name, parent, &blk)
-        Shoulda.add_context(self)
-        self.name               = name
-        self.parent             = parent
-        self.setup_blocks       = []
-        self.teardown_blocks    = []
-        self.shoulds            = []
-        self.should_eventuallys = []
-        self.subcontexts        = []
-
-        merge_block(&blk)
-        Shoulda.remove_context
-      end
-
-      def merge_block(&blk)
-        blk.bind(self).call
-      end
-
-      def context(name, &blk)
-        self.subcontexts << Context.new(name, self, &blk)
-      end
-
-      def setup(&blk)
-        self.setup_blocks << blk
-      end
-
-      def teardown(&blk)
-        self.teardown_blocks << blk
-      end
-
-      def should(name, options = {}, &blk)
-        if block_given?
-          self.shoulds << { :name => name, :before => options[:before], :block => blk }
-        else
-         self.should_eventuallys << { :name => name }
-       end
-      end
-
-      def should_eventually(name, &blk)
-        self.should_eventuallys << { :name => name, :block => blk }
-      end
-
-      def full_name
-        parent_name = parent.full_name if am_subcontext?
-        return [parent_name, name].join(" ").strip
-      end
-
-      def am_subcontext?
-        parent.is_a?(self.class) # my parent is the same class as myself.
-      end
-
-      def test_unit_class
-        am_subcontext? ? parent.test_unit_class : parent
-      end
-
-      def create_test_from_should_hash(should)
-        test_name = ["test:", full_name, "should", "#{should[:name]}. "].flatten.join(' ').to_sym
-
-        if test_unit_class.instance_methods.include?(test_name.to_s)
-          warn "  * WARNING: '#{test_name}' is already defined"
-        end
-
-        context = self
-        test_unit_class.send(:define_method, test_name) do
-          begin
-            context.run_parent_setup_blocks(self)
-            should[:before].bind(self).call if should[:before]
-            context.run_current_setup_blocks(self)
-            should[:block].bind(self).call
-          ensure
-            context.run_all_teardown_blocks(self)
-          end
-        end
-      end
-
-      def run_all_setup_blocks(binding)
-        run_parent_setup_blocks(binding)
-        run_current_setup_blocks(binding)
-      end
-
-      def run_parent_setup_blocks(binding)
-        self.parent.run_all_setup_blocks(binding) if am_subcontext?
-      end
-
-      def run_current_setup_blocks(binding)
-        setup_blocks.each do |setup_block|
-          setup_block.bind(binding).call
-        end
-      end
-
-      def run_all_teardown_blocks(binding)
-        teardown_blocks.reverse.each do |teardown_block|
-          teardown_block.bind(binding).call
-        end
-        self.parent.run_all_teardown_blocks(binding) if am_subcontext?
-      end
-
-      def print_should_eventuallys
-        should_eventuallys.each do |should|
-          test_name = [full_name, "should", "#{should[:name]}. "].flatten.join(' ')
-          puts "  * DEFERRED: " + test_name
-        end
-      end
-
-      def build
-        shoulds.each do |should|
-          create_test_from_should_hash(should)
-        end
-
-        subcontexts.each { |context| context.build }
-
-        print_should_eventuallys
-      end
-
-      def method_missing(method, *args, &blk)
-        test_unit_class.send(method, *args, &blk)
-      end
-
-    end
-  end
-end

data/test/rails_root/vendor/gems/thoughtbot-shoulda-2.0.4/lib/shoulda/controller/formats/html.rb

@@ -1,201 +0,0 @@
-module ThoughtBot # :nodoc: 
-  module Shoulda # :nodoc: 
-    module Controller # :nodoc:
-      module HTML # :nodoc: all
-        def self.included(other)
-          other.class_eval do
-            extend ThoughtBot::Shoulda::Controller::HTML::ClassMethods
-          end
-        end
-  
-        module ClassMethods 
-          def controller_name_from_class
-            self.name.gsub(/Test/, '')
-          end
-
-          def make_show_html_tests(res)
-            context "on GET to #{controller_name_from_class}#show" do
-              setup do
-                record = get_existing_record(res)
-                parent_params = make_parent_params(res, record)
-                get :show, parent_params.merge({ res.identifier => record.to_param })          
-              end
-
-              if res.denied.actions.include?(:show)
-                should_not_assign_to res.object
-                should_redirect_to res.denied.redirect
-                should_set_the_flash_to res.denied.flash
-              else
-                should_assign_to res.object          
-                should_respond_with :success
-                should_render_template :show
-                should_not_set_the_flash
-              end
-            end
-          end
-
-          def make_edit_html_tests(res)
-            context "on GET to #{controller_name_from_class}#edit" do
-              setup do
-                @record = get_existing_record(res)
-                parent_params = make_parent_params(res, @record)
-                get :edit, parent_params.merge({ res.identifier => @record.to_param })          
-              end
-        
-              if res.denied.actions.include?(:edit)
-                should_not_assign_to res.object
-                should_redirect_to res.denied.redirect
-                should_set_the_flash_to res.denied.flash
-              else
-                should_assign_to res.object                    
-                should_respond_with :success
-                should_render_template :edit
-                should_not_set_the_flash
-                should_render_a_form
-                should "set @#{res.object} to requested instance" do
-                  assert_equal @record, assigns(res.object)
-                end
-              end
-            end
-          end
-
-          def make_index_html_tests(res)
-            context "on GET to #{controller_name_from_class}#index" do
-              setup do
-                record = get_existing_record(res) rescue nil
-                parent_params = make_parent_params(res, record)
-                get(:index, parent_params)          
-              end
-
-              if res.denied.actions.include?(:index)
-                should_not_assign_to res.object.to_s.pluralize
-                should_redirect_to res.denied.redirect
-                should_set_the_flash_to res.denied.flash          
-              else
-                should_respond_with :success
-                should_assign_to res.object.to_s.pluralize
-                should_render_template :index
-                should_not_set_the_flash
-              end
-            end
-          end
-
-          def make_new_html_tests(res)
-            context "on GET to #{controller_name_from_class}#new" do
-              setup do
-                record = get_existing_record(res) rescue nil
-                parent_params = make_parent_params(res, record)
-                get(:new, parent_params)          
-              end
-
-              if res.denied.actions.include?(:new)
-                should_not_assign_to res.object
-                should_redirect_to res.denied.redirect
-                should_set_the_flash_to res.denied.flash
-              else
-                should_respond_with :success
-                should_assign_to res.object
-                should_not_set_the_flash
-                should_render_template :new
-                should_render_a_form
-              end
-            end
-          end
-
-          def make_destroy_html_tests(res)
-            context "on DELETE to #{controller_name_from_class}#destroy" do
-              setup do
-                @record = get_existing_record(res)
-                parent_params = make_parent_params(res, @record)
-                delete :destroy, parent_params.merge({ res.identifier => @record.to_param })
-              end
-        
-              if res.denied.actions.include?(:destroy)
-                should_redirect_to res.denied.redirect
-                should_set_the_flash_to res.denied.flash
-          
-                should "not destroy record" do
-                  assert_nothing_raised { assert @record.reload }
-                end
-              else
-                should_set_the_flash_to res.destroy.flash
-                if res.destroy.redirect.is_a? Symbol
-                  should_respond_with res.destroy.redirect
-                else
-                  should_redirect_to res.destroy.redirect
-                end
-
-                should "destroy record" do
-                  assert_raises(::ActiveRecord::RecordNotFound, "@#{res.object} was not destroyed.") do
-                    @record.reload
-                  end
-                end
-              end
-            end
-          end
-
-          def make_create_html_tests(res)
-            context "on POST to #{controller_name_from_class}#create with #{res.create.params.inspect}" do
-              setup do
-                record = get_existing_record(res) rescue nil
-                parent_params = make_parent_params(res, record)
-                @count = res.klass.count
-                post :create, parent_params.merge(res.object => res.create.params)
-              end
-        
-              if res.denied.actions.include?(:create)
-                should_redirect_to res.denied.redirect
-                should_set_the_flash_to res.denied.flash
-                should_not_assign_to res.object
-          
-                should "not create new record" do
-                  assert_equal @count, res.klass.count
-                end          
-              else
-                should_assign_to res.object
-                should_set_the_flash_to res.create.flash
-                if res.create.redirect.is_a? Symbol
-                  should_respond_with res.create.redirect
-                else
-                  should_redirect_to res.create.redirect
-                end
-
-                should "not have errors on @#{res.object}" do
-                  assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"            
-                end
-              end      
-            end
-          end
-
-          def make_update_html_tests(res)
-            context "on PUT to #{controller_name_from_class}#update with #{res.create.params.inspect}" do
-              setup do
-                @record = get_existing_record(res)
-                parent_params = make_parent_params(res, @record)
-                put :update, parent_params.merge(res.identifier => @record.to_param, res.object => res.update.params)
-              end
-
-              if res.denied.actions.include?(:update)
-                should_not_assign_to res.object
-                should_redirect_to res.denied.redirect
-                should_set_the_flash_to res.denied.flash
-              else
-                should_assign_to res.object
-                should_set_the_flash_to(res.update.flash)
-                if res.update.redirect.is_a? Symbol
-                  should_respond_with res.update.redirect
-                else
-                  should_redirect_to res.update.redirect
-                end
-                
-                should "not have errors on @#{res.object}" do
-                  assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end