much-stub 0.1.6 → 0.1.10

data/test/unit/much-stub_tests.rb

@@ -16,15 +16,21 @@ module MuchStub
       @orig_value = Factory.string
       @stub_value = Factory.string
 
-      @myclass = Class.new do
-        def initialize(value); @value = value; end
-        def mymeth; @value; end
-      end
+      @myclass =
+        Class.new do
+          def initialize(value)
+            @value = value
+          end
+
+          def mymeth
+            @value
+          end
+        end
       @myobj = @myclass.new(@orig_value)
     end
 
     should "build a stub" do
-      stub1 = MuchStub.(@myobj, :mymeth)
+      stub1 = MuchStub.call(@myobj, :mymeth)
       assert_kind_of MuchStub::Stub, stub1
 
       stub2 = MuchStub.stub(@myobj, :mymeth)
@@ -34,9 +40,9 @@ module MuchStub
     should "build a stub with an on_call block" do
       my_meth_called_with = nil
       stub1 =
-        MuchStub.on_call(@myobj, :mymeth) { |call|
+        MuchStub.on_call(@myobj, :mymeth) do |call|
           my_meth_called_with = call
-        }
+        end
 
       @myobj.mymeth
       assert_kind_of MuchStub::Stub, stub1
@@ -44,9 +50,9 @@ module MuchStub
 
       my_meth_called_with = nil
       stub2 =
-        MuchStub.stub_on_call(@myobj, :mymeth) { |call|
+        MuchStub.stub_on_call(@myobj, :mymeth) do |call|
           my_meth_called_with = call
-        }
+        end
 
       @myobj.mymeth
       assert_kind_of MuchStub::Stub, stub2
@@ -54,15 +60,15 @@ module MuchStub
     end
 
     should "lookup stubs that have been called before" do
-      stub1 = MuchStub.(@myobj, :mymeth)
-      stub2 = MuchStub.(@myobj, :mymeth)
+      stub1 = MuchStub.call(@myobj, :mymeth)
+      stub2 = MuchStub.call(@myobj, :mymeth)
       assert_same stub1, stub2
     end
 
     should "set the stub's do block if given a block" do
-      MuchStub.(@myobj, :mymeth)
+      MuchStub.call(@myobj, :mymeth)
       assert_raises(MuchStub::NotStubbedError){ @myobj.mymeth }
-      MuchStub.(@myobj, :mymeth){ @stub_value }
+      MuchStub.call(@myobj, :mymeth){ @stub_value }
       assert_equal @stub_value, @myobj.mymeth
     end
 
@@ -72,7 +78,7 @@ module MuchStub
       assert_equal @orig_value, @myobj.mymeth
 
       assert_equal @orig_value, @myobj.mymeth
-      MuchStub.(@myobj, :mymeth){ @stub_value }
+      MuchStub.call(@myobj, :mymeth){ @stub_value }
       assert_equal @stub_value, @myobj.mymeth
       MuchStub.unstub(@myobj, :mymeth)
       assert_equal @orig_value, @myobj.mymeth
@@ -81,7 +87,7 @@ module MuchStub
     should "know and teardown all stubs" do
       assert_equal @orig_value, @myobj.mymeth
 
-      MuchStub.(@myobj, :mymeth){ @stub_value }
+      MuchStub.call(@myobj, :mymeth){ @stub_value }
       assert_equal @stub_value, @myobj.mymeth
       assert_equal 1, MuchStub.stubs.size
 
@@ -91,11 +97,14 @@ module MuchStub
     end
 
     should "be able to call a stub's original method" do
-      err = assert_raises(NotStubbedError){ MuchStub.stub_send(@myobj, :mymeth) }
+      err =
+        assert_raises(NotStubbedError) do
+          MuchStub.stub_send(@myobj, :mymeth)
+        end
       assert_includes "not stubbed.",                 err.message
       assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
 
-      MuchStub.(@myobj, :mymeth){ @stub_value }
+      MuchStub.call(@myobj, :mymeth){ @stub_value }
 
       assert_equal @stub_value, @myobj.mymeth
       assert_equal @orig_value, MuchStub.stub_send(@myobj, :mymeth)
@@ -103,9 +112,9 @@ module MuchStub
 
     should "be able to add a stub tap" do
       my_meth_called_with = nil
-      MuchStub.tap(@myobj, :mymeth){ |value, *args, &block|
+      MuchStub.tap(@myobj, :mymeth) do |_value, *args|
         my_meth_called_with = args
-      }
+      end
 
       assert_equal @orig_value, @myobj.mymeth
       assert_equal [], my_meth_called_with
@@ -113,21 +122,33 @@ module MuchStub
 
     should "be able to add a stub tap with an on_call block" do
       my_meth_called_with = nil
-      MuchStub.tap_on_call(@myobj, :mymeth){ |value, call|
+      MuchStub.tap_on_call(@myobj, :mymeth) do |_value, call|
         my_meth_called_with = call
-      }
+      end
 
       assert_equal @orig_value, @myobj.mymeth
       assert_equal [], my_meth_called_with.args
     end
 
     should "be able to add a stubbed spy" do
-      myclass = Class.new do
-        def one; self; end
-        def two(val); self; end
-        def three; self; end
-        def ready?; false; end
-      end
+      myclass =
+        Class.new do
+          def one
+            self
+          end
+
+          def two(_val)
+            self
+          end
+
+          def three
+            self
+          end
+
+          def ready?
+            false
+          end
+        end
       myobj = myclass.new
 
       spy =
@@ -137,7 +158,8 @@ module MuchStub
           :two,
           :three,
           :to_s,
-          ready?: true)
+          ready?: true,
+        )
 
       assert_equal spy, myobj.one
       assert_equal spy, myobj.two("a")
@@ -160,13 +182,32 @@ module MuchStub
   class StubTests < UnitTests
     desc "Stub"
     setup do
-      @myclass = Class.new do
-        def mymeth; "meth"; end
-        def myval(val); val; end
-        def myargs(*args); args; end
-        def myvalargs(val1, val2, *args); [val1, val2, args]; end
-        def myblk(&block); block.call; end
-      end
+      @myclass =
+        Class.new do
+          def mymeth
+            "meth"
+          end
+
+          def myval(val)
+            val
+          end
+
+          def myargs(*args)
+            args
+          end
+
+          def myvalargs(val1, val2, *args)
+            [val1, val2, args]
+          end
+
+          def mykargs(val1:, **kargs)
+            [val1, kargs]
+          end
+
+          def myblk(&block)
+            block.call
+          end
+        end
       @myobj = @myclass.new
 
       @stub = MuchStub::Stub.new(@myobj, :mymeth)
@@ -181,7 +222,10 @@ module MuchStub
     should "generate a key given an object and method name" do
       obj = @myobj
       meth = :mymeth
-      assert_equal "--#{obj.object_id}--#{meth}--", MuchStub::Stub.key(obj, meth)
+      assert_equal(
+        "--#{obj.object_id}--#{meth}--",
+        MuchStub::Stub.key(obj, meth),
+      )
     end
 
     should "know its names" do
@@ -218,67 +262,72 @@ module MuchStub
     end
 
     should "complain if stubbing a method that the object doesn't respond to" do
-      err = assert_raises(MuchStub::StubError){ MuchStub::Stub.new(@myobj, :some_other_meth) }
-      assert_includes "does not respond to",     err.message
+      err =
+        assert_raises(MuchStub::StubError) do
+          MuchStub::Stub.new(@myobj, :some_other_meth)
+        end
+      assert_includes "does not respond to", err.message
       assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
     end
 
     should "complain if stubbed and called with mismatched arity" do
       MuchStub::Stub.new(@myobj, :myval){ "myval" }
       err = assert_raises(MuchStub::StubArityError){ @myobj.myval }
-      assert_includes "arity mismatch on",       err.message
+      assert_includes "arity mismatch on", err.message
       assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
 
-      assert_nothing_raised { @myobj.myval(1) }
-      assert_raises(MuchStub::StubArityError){ @myobj.myval(1,2) }
+      assert_nothing_raised{ @myobj.myval(1) }
+      assert_raises(MuchStub::StubArityError){ @myobj.myval(1, 2) }
 
       MuchStub::Stub.new(@myobj, :myargs){ "myargs" }
-      assert_nothing_raised { @myobj.myargs }
-      assert_nothing_raised { @myobj.myargs(1) }
-      assert_nothing_raised { @myobj.myargs(1,2) }
+      assert_nothing_raised{ @myobj.myargs }
+      assert_nothing_raised{ @myobj.myargs(1) }
+      assert_nothing_raised{ @myobj.myargs(1, 2) }
 
       MuchStub::Stub.new(@myobj, :myvalargs){ "myvalargs" }
       assert_raises(MuchStub::StubArityError){ @myobj.myvalargs }
       assert_raises(MuchStub::StubArityError){ @myobj.myvalargs(1) }
-      assert_nothing_raised { @myobj.myvalargs(1,2) }
-      assert_nothing_raised { @myobj.myvalargs(1,2,3) }
+      assert_nothing_raised{ @myobj.myvalargs(1, 2) }
+      assert_nothing_raised{ @myobj.myvalargs(1, nil) }
+      assert_nothing_raised{ @myobj.myvalargs(1, 2, 3) }
     end
 
     should "complain if stubbed with mismatched arity" do
-      err = assert_raises(MuchStub::StubArityError) do
-        MuchStub::Stub.new(@myobj, :myval).with(){ "myval" }
-      end
-      assert_includes "arity mismatch on",       err.message
+      err =
+        assert_raises(MuchStub::StubArityError) do
+          MuchStub::Stub.new(@myobj, :myval).with{ "myval" }
+        end
+      assert_includes "arity mismatch on", err.message
       assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
 
       assert_raises(MuchStub::StubArityError) do
-        MuchStub::Stub.new(@myobj, :myval).with(1,2){ "myval" }
+        MuchStub::Stub.new(@myobj, :myval).with(1, 2){ "myval" }
       end
       assert_nothing_raised do
         MuchStub::Stub.new(@myobj, :myval).with(1){ "myval" }
       end
 
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :myargs).with(){ "myargs" }
+        MuchStub::Stub.new(@myobj, :myargs).with{ "myargs" }
       end
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :myargs).with(1,2){ "myargs" }
+        MuchStub::Stub.new(@myobj, :myargs).with(1, 2){ "myargs" }
       end
       assert_nothing_raised do
         MuchStub::Stub.new(@myobj, :myargs).with(1){ "myargs" }
       end
 
       assert_raises(MuchStub::StubArityError) do
-        MuchStub::Stub.new(@myobj, :myvalargs).with(){ "myvalargs" }
+        MuchStub::Stub.new(@myobj, :myvalargs).with{ "myvalargs" }
       end
       assert_raises(MuchStub::StubArityError) do
         MuchStub::Stub.new(@myobj, :myvalargs).with(1){ "myvalargs" }
       end
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :myvalargs).with(1,2){ "myvalargs" }
+        MuchStub::Stub.new(@myobj, :myvalargs).with(1, 2){ "myvalargs" }
       end
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :myvalargs).with(1,2,3){ "myvalargs" }
+        MuchStub::Stub.new(@myobj, :myvalargs).with(1, 2, 3){ "myvalargs" }
       end
     end
 
@@ -292,7 +341,7 @@ module MuchStub
 
     should "stub methods with required arg" do
       assert_equal 1, @myobj.myval(1)
-      stub = MuchStub::Stub.new(@myobj, :myval){ |val| val.to_s }
+      stub = MuchStub::Stub.new(@myobj, :myval, &:to_s)
       assert_equal "1", @myobj.myval(1)
       assert_equal "2", @myobj.myval(2)
       stub.with(2){ "two" }
@@ -300,30 +349,36 @@ module MuchStub
     end
 
     should "stub methods with variable args" do
-      assert_equal [1,2], @myobj.myargs(1,2)
+      assert_equal [1, 2], @myobj.myargs(1, 2)
 
       stub = MuchStub::Stub.new(@myobj, :myargs){ |*args| args.join(",") }
-      assert_equal "1,2,3", @myobj.myargs(1,2,3)
-      stub.with(3,4,5){ |*args| args.join(":") }
-      assert_equal "3:4:5", @myobj.myargs(3,4,5)
+      assert_equal "1,2,3", @myobj.myargs(1, 2, 3)
+      stub.with(3, 4, 5){ |*args| args.join(":") }
+      assert_equal "3:4:5", @myobj.myargs(3, 4, 5)
 
-      stub = MuchStub::Stub.new(@myobj, :myargs).on_call{ |call| call.args.join(",") }
-      assert_equal "1,2,3", @myobj.myargs(1,2,3)
-      stub.with(3,4,5).on_call{ |call| call.args.join(":") }
-      assert_equal "3:4:5", @myobj.myargs(3,4,5)
+      stub =
+        MuchStub::Stub.new(@myobj, :myargs).on_call do |call|
+          call.args.join(",")
+        end
+      assert_equal "1,2,3", @myobj.myargs(1, 2, 3)
+      stub.with(3, 4, 5).on_call{ |call| call.args.join(":") }
+      assert_equal "3:4:5", @myobj.myargs(3, 4, 5)
     end
 
     should "stub methods with required args and variable args" do
-      assert_equal [1,2, [3]], @myobj.myvalargs(1,2,3)
+      assert_equal [1, 2, [3]], @myobj.myvalargs(1, 2, 3)
       stub = MuchStub::Stub.new(@myobj, :myvalargs){ |*args| args.join(",") }
-      assert_equal "1,2,3", @myobj.myvalargs(1,2,3)
-      stub.with(3,4,5){ |*args| args.join(":") }
-      assert_equal "3:4:5", @myobj.myvalargs(3,4,5)
+      assert_equal "1,2,3", @myobj.myvalargs(1, 2, 3)
+      stub.with(3, 4, 5){ |*args| args.join(":") }
+      assert_equal "3:4:5", @myobj.myvalargs(3, 4, 5)
 
-      stub = MuchStub::Stub.new(@myobj, :myvalargs).on_call{ |call| call.args.join(",") }
-      assert_equal "1,2,3", @myobj.myvalargs(1,2,3)
-      stub.with(3,4,5).on_call{ |call| call.args.join(":") }
-      assert_equal "3:4:5", @myobj.myvalargs(3,4,5)
+      stub =
+        MuchStub::Stub.new(@myobj, :myvalargs).on_call do |call|
+          call.args.join(",")
+        end
+      assert_equal "1,2,3", @myobj.myvalargs(1, 2, 3)
+      stub.with(3, 4, 5).on_call{ |call| call.args.join(":") }
+      assert_equal "3:4:5", @myobj.myvalargs(3, 4, 5)
     end
 
     should "stub methods that yield blocks" do
@@ -339,25 +394,32 @@ module MuchStub
     end
 
     should "stub methods even if they are not local to the object" do
-      mydelegatorclass = Class.new do
-        def initialize(delegateclass)
-          @delegate = delegateclass.new
-        end
-        def respond_to?(meth)
-          @delegate.respond_to?(meth) || super
+      mydelegatorclass =
+        Class.new do
+          def initialize(delegateclass)
+            @delegate = delegateclass.new
+          end
+
+          def respond_to?(meth)
+            @delegate.respond_to?(meth) || super
+          end
+
+          def method_missing(meth, *args, &block)
+            respond_to?(meth) ? @delegate.send(meth, *args, &block) : super
+          end
+
+          def respond_to_missing?(meth, _)
+            respond_to?(meth) || super
+          end
         end
-        def method_missing(meth, *args, &block)
-          respond_to?(meth) ? @delegate.send(meth, *args, &block) : super
-        end
-      end
       mydelegator = mydelegatorclass.new(@myclass)
 
-      assert_equal [1,2,[3]], mydelegator.myvalargs(1,2,3)
+      assert_equal [1, 2, [3]], mydelegator.myvalargs(1, 2, 3)
       stub = MuchStub::Stub.new(mydelegator, :myvalargs){ |*args| args.inspect }
-      assert_equal "[1, 2, 3]", mydelegator.myvalargs(1,2,3)
-      assert_equal "[4, 5, 6]", mydelegator.myvalargs(4,5,6)
-      stub.with(4,5,6){ "four-five-six" }
-      assert_equal "four-five-six", mydelegator.myvalargs(4,5,6)
+      assert_equal "[1, 2, 3]", mydelegator.myvalargs(1, 2, 3)
+      assert_equal "[4, 5, 6]", mydelegator.myvalargs(4, 5, 6)
+      stub.with(4, 5, 6){ "four-five-six" }
+      assert_equal "four-five-six", mydelegator.myvalargs(4, 5, 6)
     end
 
     should "call to the original method" do
@@ -365,46 +427,54 @@ module MuchStub
 
       # no args
       stub = MuchStub::Stub.new(@myobj, :mymeth){ "mymeth" }
-      assert_equal "mymeth", stub.call([])
-      assert_equal "meth",   stub.call_method([])
+      assert_equal "mymeth", stub.call
+      assert_equal "meth",   stub.call_method
 
       # static args
-      stub = MuchStub::Stub.new(@myobj, :myval){ |val| val.to_s }
-      assert_equal "1", stub.call([1])
-      assert_equal 1,   stub.call_method([1])
-      assert_equal "2", stub.call([2])
-      assert_equal 2,   stub.call_method([2])
+      stub = MuchStub::Stub.new(@myobj, :myval, &:to_s)
+      assert_equal "1", stub.call(1)
+      assert_equal 1,   stub.call_method(1)
+      assert_equal "2", stub.call(2)
+      assert_equal 2,   stub.call_method(2)
       stub.with(2){ "two" }
-      assert_equal "two", stub.call([2])
-      assert_equal 2,     stub.call_method([2])
+      assert_equal "two", stub.call(2)
+      assert_equal 2,     stub.call_method(2)
 
       # dynamic args
       stub = MuchStub::Stub.new(@myobj, :myargs){ |*args| args.join(",") }
-      assert_equal "1,2",   stub.call([1,2])
-      assert_equal [1,2],   stub.call_method([1,2])
-      assert_equal "3,4,5", stub.call([3,4,5])
-      assert_equal [3,4,5], stub.call_method([3,4,5])
-      stub.with(3,4,5){ "three-four-five" }
-      assert_equal "three-four-five", stub.call([3,4,5])
-      assert_equal [3,4,5],           stub.call_method([3,4,5])
+      assert_equal "1,2", stub.call(1, 2)
+      assert_equal [1, 2], stub.call_method(1, 2)
+      assert_equal "3,4,5", stub.call(3, 4, 5)
+      assert_equal [3, 4, 5], stub.call_method(3, 4, 5)
+      stub.with(3, 4, 5){ "three-four-five" }
+      assert_equal "three-four-five", stub.call(3, 4, 5)
+      assert_equal [3, 4, 5], stub.call_method(3, 4, 5)
 
       # mixed static/dynamic args
       stub = MuchStub::Stub.new(@myobj, :myvalargs){ |*args| args.join(",") }
-      assert_equal "1,2,3",    stub.call([1,2,3])
-      assert_equal [1,2, [3]], stub.call_method([1,2,3])
-      assert_equal "3,4,5",    stub.call([3,4,5])
-      assert_equal [3,4,[5]],  stub.call_method([3,4,5])
-      stub.with(3,4,5){ "three-four-five" }
-      assert_equal "three-four-five", stub.call([3,4,5])
-      assert_equal [3,4,[5]],         stub.call_method([3,4,5])
+      assert_equal "1,2,3", stub.call(1, 2, 3)
+      assert_equal [1, 2, [3]], stub.call_method(1, 2, 3)
+      assert_equal "3,4,5", stub.call(3, 4, 5)
+      assert_equal [3, 4, [5]], stub.call_method(3, 4, 5)
+      stub.with(3, 4, 5){ "three-four-five" }
+      assert_equal "three-four-five", stub.call(3, 4, 5)
+      assert_equal [3, 4, [5]], stub.call_method(3, 4, 5)
+
+      # keyword args
+      stub = MuchStub::Stub.new(@myobj, :mykargs){ |**kargs| kargs.inspect }
+      assert_equal "{:val1=>1, :val2=>2}", stub.call(val1: 1, val2: 2)
+      assert_equal [1, { val2: 2 }], stub.call_method(val1: 1, val2: 2)
+      stub.with(val1: 3, val2: 4){ "three-four" }
+      assert_equal "three-four", stub.call(val1: 3, val2: 4)
+      assert_equal [3, { val2: 4 }], stub.call_method(val1: 3, val2: 4)
 
       # blocks
       blkcalled = false
       blk = proc{ blkcalled = true }
       stub = MuchStub::Stub.new(@myobj, :myblk){ blkcalled = "true" }
-      stub.call([], &blk)
+      stub.call(&blk)
       assert_equal "true", blkcalled
-      stub.call_method([], &blk)
+      stub.call_method(&blk)
       assert_equal true, blkcalled
     end
 
@@ -416,16 +486,17 @@ module MuchStub
 
     should "be removable" do
       assert_equal 1, @myobj.myval(1)
-      stub = MuchStub::Stub.new(@myobj, :myval){ |val| val.to_s }
+      stub = MuchStub::Stub.new(@myobj, :myval, &:to_s)
       assert_equal "1", @myobj.myval(1)
       stub.teardown
       assert_equal 1, @myobj.myval(1)
     end
 
     should "have a readable inspect" do
-      expected = "#<#{subject.class}:#{"0x0%x" % (subject.object_id << 1)}" \
-                 " @method_name=#{subject.method_name.inspect}>"
-      assert_equal expected, subject.inspect
+      exp =
+        "#<#{subject.class}:#{format("0x0%x", (subject.object_id << 1))}" \
+        " @method_name=#{subject.method_name.inspect}>"
+      assert_equal exp, subject.inspect
     end
   end
 
@@ -442,7 +513,7 @@ module MuchStub
     subject{ @stub }
 
     should "not raise a stub error when called" do
-      assert_nothing_raised{ @stub.call([@arg]) }
+      assert_nothing_raised{ @stub.call(@arg) }
     end
   end
 
@@ -465,7 +536,8 @@ module MuchStub
       assert_equal "child", @child_class.new(1, 2)
     end
 
-    should "not raise any errors when tearing down the parent before the child" do
+    should "not raise any errors when tearing down the parent before the "\
+           "child" do
       assert_nothing_raised do
         @parent_stub.teardown
         @child_stub.teardown
@@ -486,9 +558,9 @@ module MuchStub
   class ParameterListTests < UnitTests
     desc "ParameterList"
     setup do
-      many_args = (0..ParameterList::LETTERS.size).map do
+      many_args = (0..ParameterList::LETTERS.size).map{
         Assert::Factory.string
-      end.join(", ")
+      }.join(", ")
       @object = Class.new
       # use `class_eval` with string to easily define methods with many params
       @object.class_eval <<-methods
@@ -505,7 +577,7 @@ module MuchStub
     end
 
     should "build a parameter list for a method that takes any args" do
-      assert_equal "*args, &block", subject.new(@object, "anyargs")
+      assert_equal "*pargs, **kargs, &block", subject.new(@object, "anyargs")
     end
 
     should "build a parameter list for a method that takes many args" do
@@ -513,8 +585,10 @@ module MuchStub
       assert_equal expected, subject.new(@object, "manyargs")
     end
 
-    should "build a parameter list for a method that takes a minimum number of args" do
-      expected = "#{ParameterList::LETTERS.join(", ")}, aa, *args, &block"
+    should "build a parameter list for a method that takes a minimum number "\
+           "of args" do
+      expected =
+        "#{ParameterList::LETTERS.join(", ")}, aa, *pargs, **kargs, &block"
       assert_equal expected, subject.new(@object, "minargs")
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: much-stub
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.10
 platform: ruby
 authors:
 - Kelly Redding
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-04 00:00:00.000000000 Z
+date: 2022-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: assert
@@ -17,14 +17,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.19.0
+        version: 2.19.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.19.0
+        version: 2.19.7
+- !ruby/object:Gem::Dependency
+  name: much-style-guide
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.7
 description: Stubbing API for replacing method calls on objects in test runs.
 email:
 - kelly@kellyredding.com
@@ -34,6 +48,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".l.yml"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".t.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -60,7 +78,7 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
@@ -69,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.5
 signing_key: 
 specification_version: 4
 summary: Stubbing API for replacing method calls on objects in test runs.