assert 2.18.3 → 2.18.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff0d6ff9233adc09dda972e165c47c125e158e46b0329b927eb7de201ddebf65
-  data.tar.gz: 8f77b5326cf44e2ed0c7ed72cac390a7147191634354feb2b890f73d572b366f
+  metadata.gz: 7ed950be1bca18deac9277678d40abc99072df13d5e23d21460c7e9b72a1c4ab
+  data.tar.gz: cd7c0eec0a939400f384c6e8d69b7fbb27856f3ed9fdfca25ae1ab48404c822f
 SHA512:
-  metadata.gz: 25b58fd65c099c0c9f8ff16a652e28d5baeae76838b640872224abd7d063759d6fd40b3ec927220260d82321f78cc4b7617d50a081c7ba336b04d45acec8f618
-  data.tar.gz: 669749ff845ae1811802042dd28e27e7a387d9d39a9504d73b8b04667c9597c4da08bd56cc26a7b34838e5afde2970215027a7d3967ad1e7f99175c62c49a08e
+  metadata.gz: 9a0334a2851a5b2742bab2ed51b6583e8ff47c9a89c605dfd10d84f0a20a6f17a16ba59179c53bf89b1dd0ed40673fb3909966c7476410d8ee1a52e580ec5766
+  data.tar.gz: a6f1f6db5d115e7e535ec0305d62970480f7b831eb8026e940011db2fcb3576244084fbf121f1ec499c61853d03dac3a76034dd7bdd3c187b778795ce0a3b5fd

data/lib/assert/context.rb

@@ -165,9 +165,12 @@ module Assert
     end
 
     def subject
-      if subj = self.class.subject
-        instance_eval(&subj)
+      unless instance_variable_defined?("@__assert_subject__")
+        @__assert_subject__ =
+          instance_eval(&self.class.subject) if self.class.subject
       end
+
+      @__assert_subject__
     end
 
     def inspect

data/lib/assert/context/let_dsl.rb

@@ -3,11 +3,11 @@ class Assert::Context; end
 module Assert::Context::LetDSL
   def let(name, &block)
     self.send(:define_method, name, &-> {
-      if instance_variable_get("@#{name}").nil?
-        instance_variable_set("@#{name}", instance_eval(&block))
+      unless instance_variable_defined?("@__assert_let_#{name}__")
+        instance_variable_set("@__assert_let_#{name}__", instance_eval(&block))
       end
 
-      instance_variable_get("@#{name}")
+      instance_variable_get("@__assert_let_#{name}__")
     })
   end
 end

data/lib/assert/context/subject_dsl.rb

@@ -1,33 +1,32 @@
 module Assert; end
-class Assert::Context
-  module SubjectDSL
-    # Add a piece of description text or return the full description for the context
-    def description(text = nil)
-      if text
-        self.descriptions << text.to_s
-      else
-        parent = self.superclass.desc if self.superclass.respond_to?(:desc)
-        own = self.descriptions
-        [parent, *own].compact.reject(&:empty?).join(" ")
-      end
+class Assert::Context; end
+module Assert::Context::SubjectDSL
+  # Add a piece of description text or return the full description for the context
+  def description(text = nil)
+    if text
+      self.descriptions << text.to_s
+    else
+      parent = self.superclass.desc if self.superclass.respond_to?(:desc)
+      own = self.descriptions
+      [parent, *own].compact.reject(&:empty?).join(" ")
     end
-    alias_method :desc, :description
-    alias_method :describe, :description
+  end
+  alias_method :desc, :description
+  alias_method :describe, :description
 
-    def subject(&block)
-      if block_given?
-        @subject = block
-      else
-        @subject || if superclass.respond_to?(:subject)
-          superclass.subject
-        end
+  def subject(&block)
+    if block_given?
+      @subject = block
+    else
+      @subject || if superclass.respond_to?(:subject)
+        superclass.subject
       end
     end
+  end
 
-    protected
+  protected
 
-    def descriptions
-      @descriptions ||= []
-    end
+  def descriptions
+    @descriptions ||= []
   end
 end

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.18.3"
+  VERSION = "2.18.4"
 end

data/test/system/stub_tests.rb

@@ -8,27 +8,25 @@ class Assert::Stub
 
   class InstanceTests < SystemTests
     desc "for instance methods"
-    subject { instance1 }
+    subject { TestClass.new }
 
     setup do
-      Assert.stub(instance1, :noargs){ "default" }
-      Assert.stub(instance1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(instance1, :withargs){ "default" }
-      Assert.stub(instance1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(instance1, :anyargs){ "default" }
-      Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(instance1, :minargs){ "default" }
-      Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(instance1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:instance1) { TestClass.new }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -82,27 +80,25 @@ class Assert::Stub
 
   class ClassTests < SystemTests
     desc "for singleton methods on a class"
-    subject { class1 }
+    subject { TestClass }
 
     setup do
-      Assert.stub(class1, :noargs){ "default" }
-      Assert.stub(class1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(class1, :withargs){ "default" }
-      Assert.stub(class1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(class1, :anyargs){ "default" }
-      Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(class1, :minargs){ "default" }
-      Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(class1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:class1) { TestClass }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -157,27 +153,25 @@ class Assert::Stub
 
   class ModuleTests < SystemTests
     desc "for singleton methods on a module"
-    subject { module1 }
+    subject { TestModule }
 
     setup do
-      Assert.stub(module1, :noargs){ "default" }
-      Assert.stub(module1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(module1, :withargs){ "default" }
-      Assert.stub(module1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(module1, :anyargs){ "default" }
-      Assert.stub(module1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(module1, :minargs){ "default" }
-      Assert.stub(module1, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(module1, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(module1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:module1) { TestModule }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -232,27 +226,25 @@ class Assert::Stub
 
   class ExtendedTests < SystemTests
     desc "for extended methods"
-    subject { class1 }
+    subject { Class.new{ extend TestMixin } }
 
     setup do
-      Assert.stub(class1, :noargs){ "default" }
-      Assert.stub(class1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(class1, :withargs){ "default" }
-      Assert.stub(class1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(class1, :anyargs){ "default" }
-      Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(class1, :minargs){ "default" }
-      Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(class1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:class1) { Class.new{ extend TestMixin } }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -307,27 +299,27 @@ class Assert::Stub
 
   class IncludedTests < SystemTests
     desc "for an included method"
-    subject { instance1 }
+    subject {
+      Class.new { include TestMixin }.new
+    }
 
     setup do
-      Assert.stub(instance1, :noargs){ "default" }
-      Assert.stub(instance1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(instance1, :withargs){ "default" }
-      Assert.stub(instance1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(instance1, :anyargs){ "default" }
-      Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(instance1, :minargs){ "default" }
-      Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(instance1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:instance1) { Class.new { include TestMixin }.new }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -382,27 +374,25 @@ class Assert::Stub
 
   class InheritedClassTests < SystemTests
     desc "for an inherited class method"
-    subject { class1 }
+    subject { Class.new(TestClass) }
 
     setup do
-      Assert.stub(class1, :noargs){ "default" }
-      Assert.stub(class1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(class1, :withargs){ "default" }
-      Assert.stub(class1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(class1, :anyargs){ "default" }
-      Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(class1, :minargs){ "default" }
-      Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(class1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:class1) { Class.new(TestClass) }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -457,27 +447,25 @@ class Assert::Stub
 
   class InheritedInstanceTests < SystemTests
     desc "for an inherited instance method"
-    subject { instance1 }
+    subject { Class.new(TestClass).new }
 
     setup do
-      Assert.stub(instance1, :noargs){ "default" }
-      Assert.stub(instance1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(instance1, :withargs){ "default" }
-      Assert.stub(instance1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(instance1, :anyargs){ "default" }
-      Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(instance1, :minargs){ "default" }
-      Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(instance1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:instance1) { Class.new(TestClass).new }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -532,27 +520,25 @@ class Assert::Stub
 
   class DelegateClassTests < SystemTests
     desc "a class that delegates another object"
-    subject { class1 }
+    subject { DelegateClass }
 
     setup do
-      Assert.stub(class1, :noargs){ "default" }
-      Assert.stub(class1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(class1, :withargs){ "default" }
-      Assert.stub(class1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(class1, :anyargs){ "default" }
-      Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(class1, :minargs){ "default" }
-      Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(class1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:class1) { DelegateClass }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -607,27 +593,25 @@ class Assert::Stub
 
   class DelegateInstanceTests < SystemTests
     desc "an instance that delegates another object"
-    subject { instance1 }
+    subject { DelegateClass.new }
 
     setup do
-      Assert.stub(instance1, :noargs){ "default" }
-      Assert.stub(instance1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(instance1, :withargs){ "default" }
-      Assert.stub(instance1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(instance1, :anyargs){ "default" }
-      Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(instance1, :minargs){ "default" }
-      Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(instance1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:instance1) { DelegateClass.new }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end