interjectable 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc5668f979eb51feb5f750c012299e11afbb3f92
-  data.tar.gz: 6d302846198716cc7723fb930b465b92ead1b350
+  metadata.gz: fe0594cf0a21a6f303ae028952f2922aa4ccc389
+  data.tar.gz: 19c22afac4eb1264b760d94f3a24b774b2b9ab0c
 SHA512:
-  metadata.gz: d06494d8a15447db4b5df5ede8c8cfb17b3676c50f0a8a54222a13e72b1bb6a7bb203ce64719d0338463296b5da0ce412026efc8effc9916cbf168bd93bd6830
-  data.tar.gz: b112f4d0623cccf90df647776a2712738a5cb6d105786b0f2f8ed767a79d24d496b713d0d26dd5d8dea3f028f2a112347b3d7e26a01880e7d2029eea123d0164
+  metadata.gz: 5c433d1585325e8ddd5e40af9cd0b9bc4166eeeccb863b370dbef3da32cba6f604108fbbd6112673324f205034d2e11391c304b0fc9626fe3f926bdd6b949693
+  data.tar.gz: 611df0ea5914b1d94781024d828a2ae5f76b9c27f2127164e6448449028ca78fcbb701ab984acb89f3c52907ecf7473a62547e7223fca351618d96a5f51f2ace

data/CHANGES.md

@@ -1,5 +1,11 @@
 # Change Log
 
+# v1.0.0
+
+- Calling `#inject` or `#inject_static` multiple times is now an error. Use
+  `#test_inject` instead.
+- Add `#test_inject` rspec helper. See the [README.md](README.md) for usage.
+
 # v0.3.0
 
 - Clear previously set class variables an subsequent calls to `#inject_static`

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in interjectable.gemspec
 gemspec
+
+gem "pry"
+gem "rspec", "~> 3.8"
+gem "rake"

data/README.md

@@ -61,25 +61,42 @@ class A
   include Interjectable
 
   inject(:b) { B.new }
+  inject_static(:c) { C.new }
 
   def read
     b.parse
   end
+
+  def foo
+    c.boom
+  end
 end
 
 # a_spec.rb
-require 'a'
+require "a"
+require "interjectable/rspec"
 
 describe A do
   describe "#read" do
     before do
-      a.b = double("FakeB", parse: 'result')
+      instance_double(B, parse: "result").tap do |fake_b|
+        a.test_inject(:b) { fake_b }
+      end
+      instance_double(C, boom: "goat").tap do |fake_c|
+        a.test_inject(:c) { fake_c }
+      end
     end
 
-    it "parses from its b" do
-      expect(subject.read).to eq('result')
+    it "parses from its b, and foos from its c" do
+      expect(subject.read).to eq("result")
+      expect(subject.foo).to eq("goat")
     end
   end
+
+  it "doesn't pollute other tests" do
+    expect(subject.read).to eq(B.new.parse)
+    expect(subject.foo).to eq(C.new.boom)
+  end
 end
 ```
 
@@ -87,4 +104,4 @@ end
 
 Interjectable aims to provide clear defaults for easy debugging.
 
-The other libraries we found used inject/provide setups. That setup is nice because files don't reference each other. However, this can become a headache to debug to actually figure out what is being used where. In our use cases, we use dependency injection for simplified testing, not for hands-free configuration.
+The other libraries we found used inject/provide setups. That setup is nice because files don't reference each other. However, this can become a headache to debug to actually figure out what is being used where. In our use cases, we use dependency injection for simplified testing, not for hands-free configuration.

data/interjectable.gemspec

@@ -1,4 +1,6 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'interjectable/version'
@@ -17,8 +19,4 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", ">= 3.0.0"
 end

data/lib/interjectable.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require "interjectable/version"
 
 module Interjectable
+  MethodAlreadyDefined = Class.new(StandardError)
+
   def self.included(mod)
     mod.send(:extend, ClassMethods)
   end
@@ -11,6 +15,11 @@ module Interjectable
 
   module ClassMethods
     # Defines a helper methods on instances that memoize values per-instance.
+    #
+    # Calling a second time is an error. Use `#test_inject` for overriding in
+    # RSpec tests. You need to `require "interjectable/rspec"` to use
+    # `#test_inject`. See the README.md.
+    #
     # Similar to writing
     #
     #   attr_writer :dependency
@@ -19,10 +28,14 @@ module Interjectable
     #     @dependency ||= instance_eval(&default_block)
     #   end
     def inject(dependency, &default_block)
+      if instance_methods(false).include?(dependency)
+        raise MethodAlreadyDefined, "#{dependency} is already defined"
+      end
+
       attr_writer dependency
 
       define_method(dependency) do
-        ivar_name = "@#{dependency}"
+        ivar_name = :"@#{dependency}"
         if instance_variable_defined?(ivar_name)
           instance_variable_get(ivar_name)
         else
@@ -32,10 +45,12 @@ module Interjectable
     end
 
     # Defines helper methods on instances that memoize values per-class.
-    # (shared across all instances of a class, including instances of subclasses).
+    # (shared across all instances of a class, including instances of
+    # subclasses).
     #
-    # Calling a second time clears the value (if set) from previous times. This should
-    # probably only be called a second time in tests.
+    # Calling a second time is an error. Use `#test_inject` for overriding in
+    # RSpec tests. You need to `require "interjectable/rspec"` to use
+    # `#test_inject`. See the README.md.
     #
     # Similar to writing
     #
@@ -45,18 +60,30 @@ module Interjectable
     #     @@dependency ||= instance_eval(&default_block)
     #   end
     def inject_static(dependency, &default_block)
-      cvar_name = "@@#{dependency}"
-      remove_class_variable(cvar_name) if class_variable_defined?(cvar_name)
+      if instance_methods(false).include?(dependency) || methods(false).include?(dependency)
+        raise MethodAlreadyDefined, "#{dependency} is already defined"
+      end
+
+      cvar_name = :"@@#{dependency}"
+      setter = :"#{dependency}="
+
+      define_method(setter) do |value|
+        self.class.send(setter, value)
+      end
 
-      define_method("#{dependency}=") do |value|
-        self.class.class_variable_set(cvar_name, value)
+      define_singleton_method(setter) do |value|
+        class_variable_set(cvar_name, value)
       end
 
       define_method(dependency) do
-        if self.class.class_variable_defined?(cvar_name)
-          self.class.class_variable_get(cvar_name)
+        self.class.send(dependency)
+      end
+
+      define_singleton_method(dependency) do
+        if class_variable_defined?(cvar_name)
+          class_variable_get(cvar_name)
         else
-          self.class.class_variable_set(cvar_name, instance_eval(&default_block))
+          class_variable_set(cvar_name, instance_eval(&default_block))
         end
       end
     end

data/lib/interjectable/rspec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Interjectable
+  module ClassMethods
+    class SuperclassInjectStatic < Struct.new(:klass, :dependency)
+      def override(setter)
+        cvar = "@@#{dependency}"
+        klass.remove_class_variable(cvar) if klass.class_variable_defined?(cvar)
+        klass.define_singleton_method(dependency) do
+          if class_variable_defined?(cvar)
+            class_variable_get(cvar)
+          else
+            class_variable_set(cvar, instance_eval(&setter))
+          end
+        end
+      end
+
+      def restore
+        cvar = "@@#{dependency}"
+        klass.remove_class_variable(cvar) if klass.class_variable_defined?(cvar)
+        klass.singleton_class.remove_method(dependency)
+      end
+    end
+
+    class InjectStatic < SuperclassInjectStatic
+      def override(*)
+        @meth = klass.singleton_method(dependency)
+        super
+      end
+
+      def restore
+        cvar = "@@#{dependency}"
+        klass.remove_class_variable(cvar) if klass.class_variable_defined?(cvar)
+        klass.define_singleton_method(dependency, @meth)
+      end
+    end
+
+    class SuperclassInject < Struct.new(:klass, :dependency)
+      def override(setter)
+        ivar = "@#{dependency}"
+        klass.define_method(dependency) do
+          if instance_variable_defined?(ivar)
+            instance_variable_get(ivar)
+          else
+            instance_variable_set(ivar, instance_eval(&setter))
+          end
+        end
+      end
+
+      def restore
+        klass.remove_method(dependency)
+      end
+    end
+
+    class Inject < SuperclassInject
+      def override(*)
+        @meth = klass.instance_method(dependency)
+        super
+      end
+
+      def restore
+        klass.define_method(dependency, @meth)
+      end
+    end
+
+    RESTORE_HOOKS = Hash.new { |h, k| h[k] = [] }
+    private_constant :Inject, :SuperclassInject, :InjectStatic, :SuperclassInjectStatic, :RESTORE_HOOKS
+
+    def test_inject(dependency, &setter)
+      unless setter
+        raise ArgumentError, "missing setter #{dependency.inspect}, correct usage: #test_inject(#{dependency.inspect}) { FakeDependency.new }"
+      end
+      rspec_example_group = setter.binding.receiver.class
+
+      unless rspec_example_group < RSpec::Core::ExampleGroup
+        raise "#test_inject can only be called from an RSpec ExampleGroup (e.g.: it, before, after)"
+      end
+
+      injector = if singleton_methods(false).include?(dependency) # inject_static(dependency) on this class
+        InjectStatic.new(self, dependency)
+      elsif singleton_methods.include?(dependency) # inject_static(dependency) on a superclass of this class
+        SuperclassInjectStatic.new(self, dependency)
+      elsif instance_methods(false).include?(dependency) # inject(dependency) on this class
+        Inject.new(self, dependency)
+      elsif instance_methods.include?(dependency) # inject(dependency) on a superclass of this class
+        SuperclassInject.new(self, dependency)
+      else
+        raise ArgumentError, "tried to override a non-existent dependency: #{dependency.inspect}"
+      end
+
+      injector.override(setter)
+
+      scope = rspec_example_group.currently_executing_a_context_hook? ? :context : :each
+
+      key = [self, dependency, scope]
+      # if dependency == :dependency && scope == :each
+      #   puts "override: #{key.inspect} #{rspec_example_group}"
+      # end
+
+      # If we already have a restore after(:each) hook for this class +
+      # dependency + scope, don't add another. To check if we already have an
+      # after(:each) hook, we look at all previous after(:each) hooks we've
+      # registered and see if we are currently in a subclass (i.e. we are
+      # nested within) of any of them.
+      #
+      # We don't need to guard against multiple after(:context / :all) hooks
+      # for the same #test_inject call since those before hooks only run once,
+      # and therefore only setup a single after hook.
+      return if scope == :each && RESTORE_HOOKS[key].any? { |group| rspec_example_group <= group }
+      # if dependency == :dependency && scope == :each
+      #   puts "adding new after=#{key.inspect} hooks=#{RESTORE_HOOKS[key]} group=#{rspec_example_group}"
+      # end
+      RESTORE_HOOKS[key] << rspec_example_group
+
+      # if dependency == :dependency && scope == :each
+      #   puts RESTORE_HOOKS.select { |(_, d, s)| d == :dependency && s == :each }
+      # end
+
+      rspec_example_group.after(scope) do
+        # if dependency == :dependency && scope == :each
+        #   puts "restore:  #{key.inspect} #{rspec_example_group}"
+        # end
+        injector.restore
+      end
+    end
+  end
+end

data/lib/interjectable/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Interjectable
-  VERSION = "0.3.0"
+  VERSION = "1.0.0"
 end

data/spec/interjectable/rspec_spec.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "RSpec test helper #test_inject" do
+  class Klass
+    extend Interjectable
+    inject(:dependency) { :dependency }
+    inject_static(:static_dependency) { :static_dependency }
+
+    define_method(:foo) { :foo }
+  end
+  SubKlass = Class.new(Klass)
+
+  let(:instance) { Klass.new }
+  let(:subklass_instance) { SubKlass.new }
+
+  after(:all) do
+    # Sanity check after running the tests, verify #test_inject cleans up after itself
+    instance = Klass.new
+    expect(instance.dependency).to eq(:dependency)
+    expect(instance.static_dependency).to eq(:static_dependency)
+    expect(Klass.static_dependency).to eq(:static_dependency)
+    subklass_instance = SubKlass.new
+    expect(subklass_instance.dependency).to eq(:dependency)
+    expect(subklass_instance.static_dependency).to eq(:static_dependency)
+    expect(SubKlass.static_dependency).to eq(:static_dependency)
+
+    # Don't leak our test classes
+    Object.instance_eval do
+      remove_const(:SubKlass)
+      remove_const(:Klass)
+    end
+  end
+
+  context "isoloated context" do
+    before(:all) do
+      # Sanity check before running the tests
+      instance = Klass.new
+      expect(instance.dependency).to eq(:dependency)
+      expect(instance.static_dependency).to eq(:static_dependency)
+      expect(Klass.static_dependency).to eq(:static_dependency)
+      subklass_instance = SubKlass.new
+      expect(subklass_instance.dependency).to eq(:dependency)
+      expect(subklass_instance.static_dependency).to eq(:static_dependency)
+      expect(SubKlass.static_dependency).to eq(:static_dependency)
+
+      Klass.test_inject(:dependency) { :unused_dependency }
+      Klass.test_inject(:static_dependency) { :unused_overriden_static_dependency }
+    end
+
+    before do
+      Klass.test_inject(:dependency) { :another_unused_dependency }
+      Klass.test_inject(:dependency) { foo }
+      Klass.test_inject(:static_dependency) { :overriden_static_dependency }
+    end
+
+    it "sets the dependency" do
+      expect(instance.dependency).to eq(:foo)
+      expect(instance.static_dependency).to eq(:overriden_static_dependency)
+      expect(Klass.static_dependency).to eq(:overriden_static_dependency)
+    end
+
+    it "still respects instance setters" do
+      instance.dependency = :bar
+      expect(instance.dependency).to eq(:bar)
+    end
+
+    it "errors if you inject a non static default into a static injection" do
+      Klass.test_inject(:static_dependency) { foo }
+      expect { instance.bad_dependency }.to raise_error(NameError)
+      expect { Klass.bad_dependency }.to raise_error(NameError)
+    end
+
+    context "override dependency" do
+      before(:all) do
+        Klass.test_inject(:dependency) { :yet_another_unused_dependency }
+        Klass.test_inject(:static_dependency) { :unused_static_dependency }
+      end
+
+      before do
+        Klass.test_inject(:dependency) { :override }
+        Klass.test_inject(:static_dependency) { :double_overriden_static_dependency }
+      end
+
+      it "sets the dependency" do
+        expect(instance.dependency).to eq(:override)
+        expect(instance.static_dependency).to eq(:double_overriden_static_dependency)
+        expect(Klass.static_dependency).to eq(:double_overriden_static_dependency)
+      end
+
+      it "sets the dependency again" do
+        expect(instance.dependency).to eq(:override)
+        expect(instance.static_dependency).to eq(:double_overriden_static_dependency)
+        expect(Klass.static_dependency).to eq(:double_overriden_static_dependency)
+      end
+
+      context "in a subclass" do
+        before do
+          SubKlass.test_inject(:dependency) { :subklass_override }
+          SubKlass.test_inject(:static_dependency) { :subklass_double_overriden_static_dependency }
+        end
+
+        it "sets the dependency" do
+          expect(subklass_instance.dependency).to eq(:subklass_override)
+          expect(subklass_instance.static_dependency).to eq(:subklass_double_overriden_static_dependency)
+          expect(Klass.static_dependency).to eq(:double_overriden_static_dependency)
+        end
+      end
+
+      context "in a context" do
+        it "sets the dependency" do
+          expect(instance.dependency).to eq(:override)
+          expect(instance.static_dependency).to eq(:double_overriden_static_dependency)
+          expect(Klass.static_dependency).to eq(:double_overriden_static_dependency)
+        end
+
+        it "sets the dependency again" do
+          expect(instance.dependency).to eq(:override)
+          expect(instance.static_dependency).to eq(:double_overriden_static_dependency)
+          expect(Klass.static_dependency).to eq(:double_overriden_static_dependency)
+        end
+      end
+    end
+  end
+
+  context "isoloated context: subclass inject" do
+    before do
+      SubKlass.test_inject(:dependency) { foo }
+    end
+
+    it "sets the dependency" do
+      expect(subklass_instance.dependency).to eq(:foo)
+    end
+
+    context "subcontext" do
+      it "sets the dependency" do
+        expect(subklass_instance.dependency).to eq(:foo)
+      end
+    end
+  end
+
+  context "isoloated context: subclass before :all" do
+    before(:all) do
+      SubKlass.test_inject(:static_dependency) { :bar }
+      SubKlass.test_inject(:static_dependency) { :baz }
+    end
+
+    it "sets the static_dependency" do
+      expect(SubKlass.static_dependency).to eq(:baz)
+    end
+
+    context "subcontext" do
+      before(:all) do
+        SubKlass.test_inject(:static_dependency) { :goat }
+      end
+
+      it "sets the static_dependency" do
+        expect(SubKlass.static_dependency).to eq(:goat)
+      end
+    end
+
+    context "another subcontext" do
+      it "sets the static_dependency" do
+        expect(SubKlass.static_dependency).to eq(:baz)
+      end
+    end
+  end
+
+  context "rspec receive mocks" do
+    before do
+      instance_double(Object).tap do |fake_dependency|
+        Klass.test_inject(:dependency) { fake_dependency }
+      end
+      instance_double(Object).tap do |fake_static_dependency|
+        Klass.test_inject(:static_dependency) { fake_static_dependency }
+      end
+    end
+
+    it "supports rspec mocks" do
+      expect(instance.dependency).to receive(:to_s).and_return("house")
+      expect(instance.dependency.to_s).to eq("house")
+      expect(SubKlass.static_dependency).to receive(:to_s).and_return("boom")
+      expect(SubKlass.static_dependency.to_s).to eq("boom")
+      expect(subklass_instance.static_dependency).to receive(:to_s).and_return("not boom")
+      expect(subklass_instance.static_dependency.to_s).to eq("not boom")
+    end
+  end
+
+  describe "invalid arguments" do
+    it "raises ArgumentError" do
+      expect { Klass.test_inject(:dependency) }.to raise_error(ArgumentError)
+      expect { Klass.test_inject { instance_double(Object) } }.to raise_error(ArgumentError)
+      expect { Klass.test_inject(:bad_dependency) { 1 } }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/interjectable_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Interjectable do
@@ -39,6 +41,27 @@ describe Interjectable do
         expect(count).to eq(1)
       end
 
+      it "errors when injecting the same dependency multiple times" do
+        expect { klass.inject(:some_dependency) { :some_other_value } }
+          .to raise_error(Interjectable::MethodAlreadyDefined)
+      end
+
+      it "errors when there is an instance method with the same name already defined" do
+        klass.class_eval do
+          define_method(:duplicate_dependency) { :the_method }
+        end
+        expect(instance.duplicate_dependency).to eq(:the_method)
+        expect { klass.inject(:duplicate_dependency) { :some_other_value } }
+          .to raise_error(Interjectable::MethodAlreadyDefined)
+      end
+
+      it "allows you to inject a non static default" do
+        klass.module_eval { attr_accessor :foo }
+        klass.inject(:good_dependency) { foo }
+        instance.foo = 2
+        expect(instance.good_dependency).to eq(2)
+      end
+
       context "with a dependency on another class" do
         before do
           expect(defined?(SomeOtherClass)).to be_falsey
@@ -52,6 +75,16 @@ describe Interjectable do
           expect(instance.some_other_class).to eq(:fake_other_class)
         end
       end
+
+      context "with a subclass" do
+        let(:subclass) { Class.new(klass) }
+        let(:subclass_instance) { subclass.new }
+
+        it "does not error if the method exists on the superclass" do
+          subclass.inject(:dependency) { :some_other_value }
+          expect(subclass_instance.dependency).to eq(:some_other_value)
+        end
+      end
     end
 
     describe "#inject_static" do
@@ -70,9 +103,15 @@ describe Interjectable do
         expect(instance.static_dependency).to eq('aaa')
       end
 
+      it "adds a class method and setter" do
+        klass.static_dependency = 'aaa'
+        expect(klass.static_dependency).to eq('aaa')
+      end
+
       it "shares a value across all instances of a class" do
         instance.static_dependency = 'bbb'
         expect(other_instance.static_dependency).to eq('bbb')
+        expect(klass.static_dependency).to eq('bbb')
       end
 
       it "calls its dependency block once across all instances" do
@@ -81,24 +120,55 @@ describe Interjectable do
 
         expect(instance.falsy_static_dependency).to be_nil
         expect(other_instance.falsy_static_dependency).to be_nil
+        expect(klass.falsy_static_dependency).to be_nil
 
         expect(count).to eq(1)
       end
 
-      it "clears class variable on subsequent calls to inject_static" do
-        expect(instance.static_dependency).to eq(:some_value)
-        klass.inject_static(:static_dependency) { :another_value }
-        expect(instance.static_dependency).to eq(:another_value)
-        expect(other_instance.static_dependency).to eq(:another_value)
+      it "errors when inject_static-ing a dependency multiple times" do
+        expect { klass.inject_static(:static_dependency) { :some_other_value } }
+          .to raise_error(Interjectable::MethodAlreadyDefined)
       end
 
-      context "with a subclas" do
+      it "errors when there is an instance method with the same name already defined" do
+        klass.class_eval do
+          define_method(:duplicate_static_dependency) { :the_method }
+        end
+        expect(instance.duplicate_static_dependency).to eq(:the_method)
+        expect { klass.inject_static(:duplicate_static_dependency) { :some_other_value } }
+          .to raise_error(Interjectable::MethodAlreadyDefined)
+      end
+
+      it "errors when there is a class method with the same name already defined" do
+        klass.class_eval do
+          define_singleton_method(:duplicate_static_dependency) { :the_method }
+        end
+        expect(klass.duplicate_static_dependency).to eq(:the_method)
+        expect { klass.inject_static(:duplicate_static_dependency) { :some_other_value } }
+          .to raise_error(Interjectable::MethodAlreadyDefined)
+      end
+
+      it "errors if you inject a non static default" do
+        klass.module_eval { attr_accessor :foo }
+        klass.inject_static(:bad_dependency) { foo }
+        expect { instance.bad_dependency }.to raise_error(NameError)
+        expect { klass.bad_dependency }.to raise_error(NameError)
+      end
+
+      context "with a subclass" do
         let(:subclass) { Class.new(klass) }
         let(:subclass_instance) { subclass.new }
 
         it "shares its values with its superclass" do
           instance.static_dependency = 'ccc'
           expect(subclass_instance.static_dependency).to eq('ccc')
+          expect(subclass.static_dependency).to eq('ccc')
+        end
+
+        it "does not error if the method exists on the super klass" do
+          subclass.inject_static(:static_dependency) { :some_other_value }
+          expect(subclass_instance.static_dependency).to eq(:some_other_value)
+          expect(subclass.static_dependency).to eq(:some_other_value)
         end
       end
     end

data/spec/spec_helper.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'rspec'
 
 $LOAD_PATH.unshift(
   File.join(File.dirname(__FILE__), '..', 'lib', 'interjectable')
 )
 
-require 'interjectable'
+require 'interjectable'
+require 'interjectable/rspec'

metadata

@@ -1,57 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: interjectable
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Zach Margolis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-13 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.0.0
+date: 2018-10-16 00:00:00.000000000 Z
+dependencies: []
 description: A simple dependency injection library for unit testing
 email:
 - zbmargolis@gmail.com
@@ -67,7 +25,9 @@ files:
 - Rakefile
 - interjectable.gemspec
 - lib/interjectable.rb
+- lib/interjectable/rspec.rb
 - lib/interjectable/version.rb
+- spec/interjectable/rspec_spec.rb
 - spec/interjectable_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/zachmargolis/interjectable
@@ -95,5 +55,6 @@ signing_key:
 specification_version: 4
 summary: A simple dependency injection library for unit testing
 test_files:
+- spec/interjectable/rspec_spec.rb
 - spec/interjectable_spec.rb
 - spec/spec_helper.rb