assert 2.19.2 → 2.19.3

data/lib/assert/view_helpers.rb

@@ -16,7 +16,7 @@ module Assert
       def option(name, *default_vals)
         default = default_vals.size > 1 ? default_vals : default_vals.first
         define_method(name) do |*args|
-          if !(value = args.size > 1 ? args : args.first).nil?
+          unless (value = args.size > 1 ? args : args.first).nil?
             instance_variable_set("@#{name}", value)
           end
           (val = instance_variable_get("@#{name}")).nil? ? default : val
@@ -38,11 +38,11 @@ module Assert
       end
 
       def tests_to_run_count_statement
-        "#{self.tests_to_run_count} test#{"s" if self.tests_to_run_count != 1}"
+        "#{tests_to_run_count} test#{"s" if tests_to_run_count != 1}"
       end
 
       def result_count_statement
-        "#{self.result_count} result#{"s" if self.result_count != 1}"
+        "#{result_count} result#{"s" if result_count != 1}"
       end
 
       # generate a comma-seperated sentence fragment given a list of items
@@ -56,9 +56,9 @@ module Assert
 
       # generate an appropriate result summary msg for all tests passing
       def all_pass_result_summary_msg
-        if self.result_count < 1
+        if result_count < 1
           "uhh..."
-        elsif self.result_count == 1
+        elsif result_count == 1
           "pass"
         else
           "all pass"
@@ -67,112 +67,120 @@ module Assert
 
       # print a result summary message for a given result type
       def result_summary_msg(result_type)
-        if result_type == :pass && self.all_pass?
-          self.all_pass_result_summary_msg
+        if result_type == :pass && all_pass?
+          all_pass_result_summary_msg
         else
-          "#{self.send("#{result_type}_result_count")} #{result_type}"
+          "#{send("#{result_type}_result_count")} #{result_type}"
         end
       end
 
       # generate a sentence fragment describing the breakdown of test results
-      # if a block is given, yield each msg in the breakdown for custom formatting
+      # if a block is given, yield each msg in the breakdown for custom
+      # formatting.
       def results_summary_sentence
-        summaries = self.ocurring_result_types.map do |result_type|
-          summary_msg = self.result_summary_msg(result_type)
+        summaries = ocurring_result_types.map do |result_type|
+          summary_msg = result_summary_msg(result_type)
           block_given? ? yield(summary_msg, result_type) : summary_msg
         end
-        self.to_sentence(summaries)
+        to_sentence(summaries)
       end
     end
 
     module Ansi
-      # Table of supported styles/codes (http://en.wikipedia.org/wiki/ANSI_escape_code)
+      # Table of supported styles/codes
+      # (http://en.wikipedia.org/wiki/ANSI_escape_code).
       CODES = {
-        :clear            => 0,
-        :reset            => 0,
-        :bright           => 1,
-        :bold             => 1,
-        :faint            => 2,
-        :dark             => 2,
-        :italic           => 3,
-        :underline        => 4,
-        :underscore       => 4,
-        :blink            => 5,
-        :slow_blink       => 5,
-        :rapid            => 6,
-        :rapid_blink      => 6,
-        :invert           => 7,
-        :inverse          => 7,
-        :reverse          => 7,
-        :negative         => 7,
-        :swap             => 7,
-        :conceal          => 8,
-        :concealed        => 8,
-        :hide             => 9,
-        :strike           => 9,
-
-        :default_font     => 10,
-        :font_default     => 10,
-        :font0            => 10,
-        :font1            => 11,
-        :font2            => 12,
-        :font3            => 13,
-        :font4            => 14,
-        :font5            => 15,
-        :font6            => 16,
-        :font7            => 17,
-        :font8            => 18,
-        :font9            => 19,
-        :fraktur          => 20,
-        :bright_off       => 21,
-        :bold_off         => 21,
-        :double_underline => 21,
-        :clean            => 22,
-        :italic_off       => 23,
-        :fraktur_off      => 23,
-        :underline_off    => 24,
-        :blink_off        => 25,
-        :inverse_off      => 26,
-        :positive         => 26,
-        :conceal_off      => 27,
-        :show             => 27,
-        :reveal           => 27,
-        :crossed_off      => 29,
-        :crossed_out_off  => 29,
-
-        :black            => 30,
-        :red              => 31,
-        :green            => 32,
-        :yellow           => 33,
-        :blue             => 34,
-        :magenta          => 35,
-        :cyan             => 36,
-        :white            => 37,
-
-        :on_black         => 40,
-        :on_red           => 41,
-        :on_green         => 42,
-        :on_yellow        => 43,
-        :on_blue          => 44,
-        :on_magenta       => 45,
-        :on_cyan          => 46,
-        :on_white         => 47,
-
-        :frame            => 51,
-        :encircle         => 52,
-        :overline         => 53,
-        :frame_off        => 54,
-        :encircle_off     => 54,
-        :overline_off     => 55,
+        clear: 0,
+        reset: 0,
+        bright: 1,
+        bold: 1,
+        faint: 2,
+        dark: 2,
+        italic: 3,
+        underline: 4,
+        underscore: 4,
+        blink: 5,
+        slow_blink: 5,
+        rapid: 6,
+        rapid_blink: 6,
+        invert: 7,
+        inverse: 7,
+        reverse: 7,
+        negative: 7,
+        swap: 7,
+        conceal: 8,
+        concealed: 8,
+        hide: 9,
+        strike: 9,
+
+        default_font: 10,
+        font_default: 10,
+        font0: 10,
+        font1: 11,
+        font2: 12,
+        font3: 13,
+        font4: 14,
+        font5: 15,
+        font6: 16,
+        font7: 17,
+        font8: 18,
+        font9: 19,
+        fraktur: 20,
+        bright_off: 21,
+        bold_off: 21,
+        double_underline: 21,
+        clean: 22,
+        italic_off: 23,
+        fraktur_off: 23,
+        underline_off: 24,
+        blink_off: 25,
+        inverse_off: 26,
+        positive: 26,
+        conceal_off: 27,
+        show: 27,
+        reveal: 27,
+        crossed_off: 29,
+        crossed_out_off: 29,
+
+        black: 30,
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
+        magenta: 35,
+        cyan: 36,
+        white: 37,
+
+        on_black: 40,
+        on_red: 41,
+        on_green: 42,
+        on_yellow: 43,
+        on_blue: 44,
+        on_magenta: 45,
+        on_cyan: 46,
+        on_white: 47,
+
+        frame: 51,
+        encircle: 52,
+        overline: 53,
+        frame_off: 54,
+        encircle_off: 54,
+        overline_off: 55,
       }
 
       def self.code_for(*style_names)
-        style_names.map{ |n| "\e[#{CODES[n]}m" if CODES.key?(n) }.compact.join("")
+        style_names
+          .map{ |n| "\e[#{CODES[n]}m" if CODES.key?(n) }
+          .compact
+          .join("")
       end
 
       def ansi_styled_msg(msg, result_type)
-        return msg if !self.is_tty? || !self.styled
-        code = Assert::ViewHelpers::Ansi.code_for(*self.send("#{result_type}_styles"))
+        return msg if !is_tty? || !styled
+        code =
+          Assert::ViewHelpers::Ansi.code_for(
+            *send("#{result_type}_styles"),
+          )
         return msg if code.empty?
         code + msg + Assert::ViewHelpers::Ansi.code_for(:reset)
       end

data/test/helper.rb

@@ -16,12 +16,13 @@ module Assert::Test::TestHelpers
     receiver.class_eval do
       setup do
         @test_run_results = []
-        @run_callback = proc { |result| @test_run_results << result }
+        @run_callback = proc{ |result| @test_run_results << result }
       end
     end
 
     private
 
+    # rubocop:disable Lint/NestedMethodDefinition
     def test_run_callback
       @run_callback
     end
@@ -42,5 +43,6 @@ module Assert::Test::TestHelpers
     def last_test_run_result
       @test_run_results.last
     end
+    # rubocop:enable Lint/NestedMethodDefinition
   end
 end

data/test/support/factory.rb

@@ -10,11 +10,17 @@ module Factory
   extend Assert::Factory
 
   def self.context_info_called_from
-    File.expand_path("#{Factory.path}_tests.rb:#{Factory.integer}", Dir.pwd)
+    File.expand_path(
+      "#{Factory.path}_tests.rb:#{Factory.integer}",
+      Dir.pwd,
+    )
   end
 
   def self.context_info(context_klass = nil)
-    Assert::ContextInfo.new(context_klass || self.context_class, context_info_called_from)
+    Assert::ContextInfo.new(
+      context_klass || context_class,
+      context_info_called_from,
+    )
   end
 
   # Generate an anonymous `Context` inherited from `Assert::Context` by default.
@@ -24,9 +30,8 @@ module Factory
     klass = Class.new(inherit_from || Assert::Context, &block)
     default = const_name = "FactoryAssertContext"
 
-    while(Object.const_defined?(const_name)) do
-      const_name = "#{default}#{rand(Time.now.to_i)}"
-    end
+    const_name =
+      "#{default}#{rand(Time.now.to_i)}" while Object.const_defined?(const_name)
     Object.const_set(const_name, klass)
     klass
   end
@@ -35,9 +40,9 @@ module Factory
 
   def self.test(*args, &block)
     config, context_info, name = [
-      args.last.kind_of?(Assert::Config) ? args.pop : self.modes_off_config,
-      args.last.kind_of?(Assert::ContextInfo) ? args.pop : self.context_info,
-      args.last.kind_of?(::String) ? args.pop : "a test"
+      args.last.is_a?(Assert::Config) ? args.pop : modes_off_config,
+      args.last.is_a?(Assert::ContextInfo) ? args.pop : self.context_info,
+      args.last.is_a?(::String) ? args.pop : "a test",
     ]
     Assert::Test.for_block(name, context_info, config, &block)
   end
@@ -45,15 +50,27 @@ module Factory
   # Generate results for use in testing.
 
   def self.pass_result(msg = nil)
-    Assert::Result::Pass.for_test(Factory.test(Factory.string), msg || Factory.string, [])
+    Assert::Result::Pass.for_test(
+      Factory.test(Factory.string),
+      msg || Factory.string,
+      [],
+    )
   end
 
   def self.ignore_result(msg = nil)
-    Assert::Result::Ignore.for_test(Factory.test(Factory.string), msg || Factory.string, [])
+    Assert::Result::Ignore.for_test(
+      Factory.test(Factory.string),
+      msg || Factory.string,
+      [],
+    )
   end
 
   def self.fail_result(msg = nil)
-    Assert::Result::Fail.for_test(Factory.test(Factory.string), msg || Factory.string, [])
+    Assert::Result::Fail.for_test(
+      Factory.test(Factory.string),
+      msg || Factory.string,
+      [],
+    )
   end
 
   def self.skip_result(exception = nil)
@@ -68,23 +85,23 @@ module Factory
 
   def self.modes_off_config
     Assert::Config.new({
-      :capture_output => false,
-      :halt_on_fail   => false,
-      :changed_only   => false,
-      :pp_objects     => false,
-      :debug          => false
+      capture_output: false,
+      halt_on_fail: false,
+      changed_only: false,
+      pp_objects: false,
+      debug: false,
     })
   end
 
   def self.modes_off_suite
-    Assert::DefaultSuite.new(self.modes_off_config)
+    Assert::DefaultSuite.new(modes_off_config)
   end
 
   def self.modes_off_context_class(*args, &block)
-    suite_obj = self.modes_off_suite
-    self.context_class(*args) do
+    suite_obj = modes_off_suite
+    context_class(*args) do
       suite(suite_obj)
-      instance_eval(&block) if !block.nil?
+      instance_eval(&block) unless block.nil?
     end
   end
 
@@ -93,7 +110,7 @@ module Factory
     Factory.modes_off_context_class.new(
       test,
       test.config,
-      result_block || proc { |r| }
+      result_block || proc{ |r| },
     )
   end
 

data/test/system/stub_tests.rb

@@ -10,7 +10,7 @@ class Assert::Stub
 
   class InstanceTests < SystemTests
     desc "for instance methods"
-    subject { TestClass.new }
+    subject{ TestClass.new }
 
     setup do
       Assert.stub(subject, :noargs){ "default" }
@@ -56,33 +56,33 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that { subject.noargs(1) }.raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that { subject.withargs }.raises
-      assert_that { subject.withargs(1, 2) }.raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that { subject.minargs }.raises
-      assert_that { subject.minargs(1) }.raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that { subject.withblock(1) }.raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class ClassTests < SystemTests
     desc "for singleton methods on a class"
-    subject { TestClass }
+    subject{ TestClass }
 
     setup do
       Assert.stub(subject, :noargs){ "default" }
@@ -129,33 +129,33 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that { subject.noargs(1) }.raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that { subject.withargs }.raises
-      assert_that { subject.withargs(1, 2) }.raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that { subject.minargs }.raises
-      assert_that { subject.minargs(1) }.raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that { subject.withblock(1) }.raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class ModuleTests < SystemTests
     desc "for singleton methods on a module"
-    subject { TestModule }
+    subject{ TestModule }
 
     setup do
       Assert.stub(subject, :noargs){ "default" }
@@ -202,33 +202,33 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that { subject.noargs(1) }.raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that { subject.withargs }.raises
-      assert_that { subject.withargs(1, 2) }.raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that { subject.minargs }.raises
-      assert_that { subject.minargs(1) }.raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that { subject.withblock(1) }.raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class ExtendedTests < SystemTests
     desc "for extended methods"
-    subject { Class.new{ extend TestMixin } }
+    subject{ Class.new{ extend TestMixin } }
 
     setup do
       Assert.stub(subject, :noargs){ "default" }
@@ -275,35 +275,35 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that { subject.noargs(1) }.raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that { subject.withargs }.raises
-      assert_that { subject.withargs(1, 2) }.raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that { subject.minargs }.raises
-      assert_that { subject.minargs(1) }.raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that { subject.withblock(1) }.raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class IncludedTests < SystemTests
     desc "for an included method"
-    subject {
-      Class.new { include TestMixin }.new
-    }
+    subject do
+      Class.new{ include TestMixin }.new
+    end
 
     setup do
       Assert.stub(subject, :noargs){ "default" }
@@ -350,33 +350,33 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that { subject.noargs(1) }.raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that { subject.withargs }.raises
-      assert_that { subject.withargs(1, 2) }.raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that { subject.minargs }.raises
-      assert_that { subject.minargs(1) }.raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that { subject.withblock(1) }.raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class InheritedClassTests < SystemTests
     desc "for an inherited class method"
-    subject { Class.new(TestClass) }
+    subject{ Class.new(TestClass) }
 
     setup do
       Assert.stub(subject, :noargs){ "default" }
@@ -423,33 +423,33 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that { subject.noargs(1) }.raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that { subject.withargs }.raises
-      assert_that { subject.withargs(1, 2) }.raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that { subject.minargs }.raises
-      assert_that { subject.minargs(1) }.raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that { subject.withblock(1) }.raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class InheritedInstanceTests < SystemTests
     desc "for an inherited instance method"
-    subject { Class.new(TestClass).new }
+    subject{ Class.new(TestClass).new }
 
     setup do
       Assert.stub(subject, :noargs){ "default" }
@@ -496,33 +496,33 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
-      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that { subject.noargs(1) }.raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that { subject.withargs }.raises
-      assert_that { subject.withargs(1, 2) }.raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that { subject.minargs }.raises
-      assert_that { subject.minargs(1) }.raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that { subject.withblock(1) }.raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class DelegateClassTests < SystemTests
     desc "a class that delegates another object"
-    subject { DelegateClass }
+    subject{ DelegateClass }
 
     setup do
       Assert.stub(subject, :noargs){ "default" }
@@ -569,33 +569,33 @@ class Assert::Stub
     end
 
     should "allow stubbing methods with invalid arity" do
-      assert_that { Assert.stub(subject, :noargs).with(1){ } }.does_not_raise
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.does_not_raise
 
-      assert_that { Assert.stub(subject, :withargs).with{ } }.does_not_raise
-      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.does_not_raise
+      assert_that{ Assert.stub(subject, :withargs).with{} }.does_not_raise
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.does_not_raise
 
-      assert_that { Assert.stub(subject, :minargs).with{ } }.does_not_raise
-      assert_that { Assert.stub(subject, :minargs).with(1){ } }.does_not_raise
+      assert_that{ Assert.stub(subject, :minargs).with{} }.does_not_raise
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.does_not_raise
 
-      assert_that { Assert.stub(subject, :withblock).with(1){ } }.does_not_raise
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.does_not_raise
     end
 
     should "allow calling methods with invalid arity" do
-      assert_that { subject.noargs(1) }.does_not_raise
+      assert_that{ subject.noargs(1) }.does_not_raise
 
-      assert_that { subject.withargs }.does_not_raise
-      assert_that { subject.withargs(1, 2) }.does_not_raise
+      assert_that{ subject.withargs }.does_not_raise
+      assert_that{ subject.withargs(1, 2) }.does_not_raise
 
-      assert_that { subject.minargs }.does_not_raise
-      assert_that { subject.minargs(1) }.does_not_raise
+      assert_that{ subject.minargs }.does_not_raise
+      assert_that{ subject.minargs(1) }.does_not_raise
 
-      assert_that { subject.withblock(1) }.does_not_raise
+      assert_that{ subject.withblock(1) }.does_not_raise
     end
   end
 
   class DelegateInstanceTests < SystemTests
     desc "an instance that delegates another object"
-    subject { DelegateClass.new }
+    subject{ DelegateClass.new }
 
     setup do
       Assert.stub(subject, :noargs){ "default" }
@@ -642,27 +642,27 @@ class Assert::Stub
     end
 
     should "allow stubbing methods with invalid arity" do
-      assert_that { Assert.stub(subject, :noargs).with(1){ } }.does_not_raise
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.does_not_raise
 
-      assert_that { Assert.stub(subject, :withargs).with{ } }.does_not_raise
-      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.does_not_raise
+      assert_that{ Assert.stub(subject, :withargs).with{} }.does_not_raise
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.does_not_raise
 
-      assert_that { Assert.stub(subject, :minargs).with{ } }.does_not_raise
-      assert_that { Assert.stub(subject, :minargs).with(1){ } }.does_not_raise
+      assert_that{ Assert.stub(subject, :minargs).with{} }.does_not_raise
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.does_not_raise
 
-      assert_that { Assert.stub(subject, :withblock).with(1){ } }.does_not_raise
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.does_not_raise
     end
 
     should "allow calling methods with invalid arity" do
-      assert_that { subject.noargs(1) }.does_not_raise
+      assert_that{ subject.noargs(1) }.does_not_raise
 
-      assert_that { subject.withargs }.does_not_raise
-      assert_that { subject.withargs(1, 2) }.does_not_raise
+      assert_that{ subject.withargs }.does_not_raise
+      assert_that{ subject.withargs(1, 2) }.does_not_raise
 
-      assert_that { subject.minargs }.does_not_raise
-      assert_that { subject.minargs(1) }.does_not_raise
+      assert_that{ subject.minargs }.does_not_raise
+      assert_that{ subject.minargs(1) }.does_not_raise
 
-      assert_that { subject.withblock(1) }.does_not_raise
+      assert_that{ subject.withblock(1) }.does_not_raise
     end
   end
 
@@ -673,8 +673,8 @@ class Assert::Stub
       Assert.stub(child_class, :new){ "child" }
     end
 
-    let(:parent_class) { Class.new }
-    let(:child_class) { Class.new(parent_class) }
+    let(:parent_class){ Class.new }
+    let(:child_class){ Class.new(parent_class) }
 
     should "allow stubbing the methods individually" do
       assert_that(parent_class.new).equals("parent")
@@ -683,37 +683,73 @@ class Assert::Stub
   end
 
   class TestClass
-    def self.noargs; end
-    def self.withargs(a); end
-    def self.anyargs(*args); end
-    def self.minargs(a, b, *args); end
-    def self.withblock(&block); end
-
-    def noargs; end
-    def withargs(a); end
-    def anyargs(*args); end
-    def minargs(a, b, *args); end
-    def withblock(&block); end
+    def self.noargs
+    end
+
+    def self.withargs(a)
+    end
+
+    def self.anyargs(*args)
+    end
+
+    def self.minargs(a, b, *args)
+    end
+
+    def self.withblock(&block)
+    end
+
+    def noargs
+    end
+
+    def withargs(a)
+    end
+
+    def anyargs(*args)
+    end
+
+    def minargs(a, b, *args)
+    end
+
+    def withblock(&block)
+    end
   end
 
   module TestModule
-    def self.noargs; end
-    def self.withargs(a); end
-    def self.anyargs(*args); end
-    def self.minargs(a, b, *args); end
-    def self.withblock(&block); end
+    def self.noargs
+    end
+
+    def self.withargs(a)
+    end
+
+    def self.anyargs(*args)
+    end
+
+    def self.minargs(a, b, *args)
+    end
+
+    def self.withblock(&block)
+    end
   end
 
   module TestMixin
-    def noargs; end
-    def withargs(a); end
-    def anyargs(*args); end
-    def minargs(a, b, *args); end
-    def withblock(&block); end
+    def noargs
+    end
+
+    def withargs(a)
+    end
+
+    def anyargs(*args)
+    end
+
+    def minargs(a, b, *args)
+    end
+
+    def withblock(&block)
+    end
   end
 
   class DelegateClass
-    def self.respond_to?(*args)
+    def self.respond_to_missing?(*args)
       TestClass.respond_to?(*args) || super
     end
 
@@ -725,7 +761,7 @@ class Assert::Stub
       @delegate = TestClass.new
     end
 
-    def respond_to?(*args)
+    def respond_to_missing?(*args)
       @delegate.respond_to?(*args) || super
     end