medicine 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79bc0ab2a504f8fac7530336253908d4d7a79332
-  data.tar.gz: dbd4d812702841a2182eee8506bcd650144190a0
+  metadata.gz: 9bd32dce92b989b0d76ecc791f5a2306df67c890
+  data.tar.gz: 0c75aa02a7c6835a7138323800930a8556d885a6
 SHA512:
-  metadata.gz: 8677b2d572b120218ee4fb4a9812948673d2eff51fc703a973f88029a82b77076fbf6d80fe3e90e00af5964c28c945a8cbdf869422e71703b9d18fd29a1c82b5
-  data.tar.gz: 24a18976d5119c76c0a56f6e115382c87c1786060613bedadaf63ff9a8a3b331b3f54289212e6b593771b3436cbcf3ea559aeaa718196f6f19c87f15377ffa0a
+  metadata.gz: a08a91ebe6927ea99a50659ac099f3be1ff27ab0191438c8b9d489e202438b2b4a96aeac6959b074866cfbe8b5b276f35b367a51cb80da2bdfd2b51eeaac1b49
+  data.tar.gz: 5d55b2ee2e909e30f91210bb3b43980b44d2fbc9b3eb99313a39f60bf4151f53d98b4acc4c2e7f9708b0707333f3812ab9ae6e93d5897ca08606e49eac4c2653

data/.ruby-version

@@ -1 +1 @@
-2.1.5
+2.3

data/.travis.yml

@@ -2,9 +2,5 @@ language: ruby
 bundler_args: --without=extras
 script: rspec spec
 rvm:
-  - '2.1.5'
+  - '2.3'
   - rbx-2
-matrix:
-  include:
-    - rvm: jruby
-      env: JRUBY_OPTS="--2.1"

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## 1.0.0 (01/10/2016)
+
+* rename `inject` to `inject_dependency` to avoid clash with collection-like
+  objects which might have an `inject` method already. [breaking change]
+
 ## 0.0.2 (13th Feb 2015)
 
 * refactoring

data/Gemfile

@@ -8,6 +8,9 @@ gem 'coveralls', require: false
 
 group :extras do
   gem "rake"
+  gem 'guard-rspec'
   gem 'pry-byebug'
   gem 'yard'
+  gem 'redcarpet' # yard
+  gem 'inch'
 end

data/Guardfile

@@ -0,0 +1,5 @@
+guard :rspec, cmd: 'bundle exec rspec', all_on_start: true, all_after_pass: true do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -4,11 +4,17 @@
 [![Code Climate](https://codeclimate.com/github/krisleech/medicine.png)](https://codeclimate.com/github/krisleech/medicine)
 [![Build Status](https://travis-ci.org/krisleech/medicine.png?branch=master)](https://travis-ci.org/krisleech/medicine)
 [![Coverage Status](https://coveralls.io/repos/krisleech/medicine/badge.png?branch=master)](https://coveralls.io/r/krisleech/medicine?branch=master)
+[![Inch Pages](http://inch-ci.org/github/krisleech/medicine.png)](http://inch-ci.org/github/krisleech/medicine)
 
 Simple Dependency Injection for Ruby
 
-Find yourself passing dependencies in to the initalizer? Medicine makes this
-declarative.
+Find yourself injecting dependencies via the initalizer or a setter method?
+
+Medicine makes this declarative.
+
+## Usage
+
+Include the Medicine module and declare the dependencies with `dependency`.
 
 ```ruby
 class CastVote
@@ -16,53 +22,96 @@ class CastVote
 
   dependency :votes_repo, default: -> { Vote }
 
-  def call(entry_id)
-    vote_repo.create!(entry_id: entry_id)
+  def call
+    votes_repo # => Vote
   end
 end
+```
+
+For each dependency declared a private method is defined which returns the
+dependency.
 
+### Without injection
 
-cast_vote = CastVote.new
-cast_vote.call(3)
+```ruby
+command = CastVote.new
 ```
 
-In this example Medicine adds a private method called `vote_repo` which returns `Vote`.
+In the above case the `votes_repo` method will return `Vote`.
+
+If no dependency is injected the default will be used.
+
+Specifying a default is optional and if a dependency is not injected and
+there is no default an error will be raised if the dependencies method is
+invoked.
+
+### Injecting via initializer
 
-## Injecting a dependency
 
 ```ruby
-vote_repo = double('VoteRepo')
-cast_vote = CastVote.new(vote_repo: vote_repo)
+command = CastVote.new(votes_repo: double)
 ```
 
-If you want to arguments other than the dependencies in to the constructor
-don't forget to invoke `super`:
+In the above case `votes_repo` will return the double.
+
+If you try and inject a dependency which has not been declared an error is
+raised.
+
+### Injecting via a setter
 
 ```ruby
-def initialize(arg1, arg2, dependencies = {})
-  @arg1 = arg1
-  @arg2 = arg2
-  super(dependencies)
-end
+command = CastVote.new
+command.inject_depdendency(:vote_repo, double)
 ```
 
-## Required dependencies
+In the above case `votes_repo` will return the double.
+
+If you try and inject a dependency which has not been declared an error is
+raised.
+
+### Required dependencies
 
 ```ruby
 dependency :vote_repo
 ```
 
-When no default is specified and is not injected an exception will be raised on
-initialization.
+When no default is specified the dependency must be injected via the
+constructor or setter an otherwise an exception will be raised.
 
-## Default dependencies
+### Default dependencies
 
 ```ruby
+dependency :vote_repo, default: Vote
 dependency :vote_repo, default: :vote
 dependency :vote_repo, default: :Vote
 dependency :vote_repo, default: 'Vote'
 dependency :vote_repo, default: -> { Vote }
 ```
 
-The above examples will expose a method called `vote_repo` which returns the
+All the above examples will expose a method called `vote_repo` which returns the
 `Vote` class as the default dependency.
+
+### Already got an initializer?
+
+If you want to pass arguments other than the dependencies in to the constructor
+don't forget to invoke `super`:
+
+```ruby
+def initialize(arg1, arg2, dependencies = {})
+  @arg1 = arg1
+  @arg2 = arg2
+  super(dependencies)
+end
+```
+
+## Compatibility
+
+Tested with MRI 2.1+ and Rubinius.
+
+See the [build status](https://travis-ci.org/krisleech/medicine) for details.
+
+## Running Specs
+
+```
+rspec spec
+```

data/TODO

@@ -1,9 +1,3 @@
 # TODO
 
-test that zsuper/super is called
-module populates class with many private instance methods
-  * think about namespacing them somehow, module/double underscore...
 refactor tests
-test to make sure state is not shared between objects
-freeze dependency hash passed to initalize
-release 0.0.2

data/lib/medicine.rb

@@ -1,81 +1,126 @@
 require "medicine/version"
-require "inflecto"
+require "medicine/dependencies"
+require "medicine/injections"
 
 module Medicine
+  # returns the {Medicine::DI} module
+  #
+  # @example
+  #   class MyCommand
+  #     include Medicine.di
+  #   end
+  #
+  # @api public
   def self.di
     DI
   end
 
   RequiredDependencyError = Class.new(::ArgumentError)
+  DependencyUnknownError  = Class.new(::StandardError)
+  NoInjectionError        = Class.new(::StandardError)
 
   module DI
-    def self.included(base)
-      base.extend(ClassMethods)
+    # Injects dependencies
+    #
+    # @param [Array<Object>] args - the last argument must be a Hash
+    #
+    # @return [undefined]
+    #
+    # @example
+    #   register_user = RegisterUser.new(user_repo: double('UserRepo'))
+    #
+    # @api public
+    def initialize(injections = {})
+      @injections = Injections.new
+      injects(injections)
+      super()
     end
 
-    def self.prepended(base)
-      base.extend(ClassMethods)
-    end
-
-    def initialize(*args)
-      @dependencies = extract_dependencies(args)
-      assert_all_dependencies_met
-      define_dependency_methods
-
-      super
-    end
-
-    private
-
-    def define_dependency_methods
-      self.class.dependencies.each do |name, options|
-        define_singleton_method name do
-          @dependencies.fetch(name) { resolve_dependency(name) }
-        end
-        self.singleton_class.class_eval { private name }
-      end
+    # Injects a dependency
+    #
+    # @param [Symbol] key
+    # @param [Object] dependency
+    #
+    # @return [self]
+    #
+    # @example
+    #   register_user.inject_dependency(:user_repo, double('UserRepo'))
+    #
+    # @api public
+    def inject_dependency(name, dependency)
+      raise DependencyUnknownError, "#{name} has not been declared as a dependency" unless self.class.dependencies.include?(name)
+      @injections.set(name, dependency)
+      self
     end
 
-    def extract_dependencies(args)
-      args.last.respond_to?(:[]) ? args.pop : {}
+    # Injects dependencies
+    #
+    # @params [Hash] injections
+    #
+    # @return [self]
+    #
+    # @example
+    #   register_user.injects(user_repo: double, user_mailer: double)
+    #
+    # @api public
+    def injects(injections)
+      injections.each { |name, dependency| inject_dependency(name, dependency) }
     end
 
-    def assert_all_dependencies_met
-      raise RequiredDependencyError, "pass all required dependencies (#{unmet_dependencies.join(', ')}) in to initialize" unless unmet_dependencies.empty?
+    # Returns injections
+    #
+    # @example
+    #   register_user.injections
+    #
+    # @return [Injections]
+    #
+    # @api private
+    def injections
+      @injections.dup.freeze
     end
 
-    def unmet_dependencies
-      self.class.dependencies.keys.select do |key|
-        !@dependencies.has_key?(key) && !self.class.dependencies.fetch(key).has_key?(:default)
-      end
-    end
+    private
 
-    def resolve_dependency(name)
-      typecast_dependency(self.class.dependencies.fetch(name).fetch(:default))
+    def self.included(base)
+      base.extend(ClassMethods)
     end
 
-    def typecast_dependency(dependency)
-      case dependency.class.name
-      when 'String' then
-        Inflecto.constantize(Inflecto.camelize(dependency))
-      when 'Symbol' then
-        typecast_dependency(dependency.to_s)
-      when 'Proc' then
-        dependency.call
-      else
-        dependency
-      end
+    def self.prepended(base)
+      base.extend(ClassMethods)
     end
 
     module ClassMethods
       def dependencies
-        @dependencies ||= {}
+        @dependencies ||= Dependencies.new
       end
 
       private
 
+      # Declare a dependency
+      #
+      # @param [Symbol] name
+      # @param [Hash] options
+      #
+      # @example
+      #   class MyThing
+      #     depdendency :user_repo, default: -> { User }
+      #   end
+      #
+      # @api public
       def dependency(name, options = {})
-        dependencies[name] = options
+        dependencies.add(name, options)
+
+        define_method name do
+          @injections.fetch(name) do
+            self.class.dependencies.fetch(name).default do
+              raise NoInjectionError, "Dependency not injected and default not declared for #{name}"
+            end
+          end
+        end
+
+        private name
+
+        self
       end
 
       def inherited(subclass)
@@ -83,5 +128,7 @@ module Medicine
         super
       end
     end
+
+    private_constant :ClassMethods
   end
 end

data/lib/medicine/dependencies.rb

@@ -0,0 +1,60 @@
+require "inflecto"
+require "medicine/dependency"
+
+module Medicine
+  UnknownDependency = Class.new(StandardError)
+
+  # @api private
+
+  class Dependencies
+    include Enumerable
+
+    def initialize
+      @dependencies = []
+    end
+
+    def all
+      @dependencies
+    end
+
+    def each(&block)
+      all.each(&block)
+    end
+
+    def empty?
+      all.empty?
+    end
+
+    def size
+      all.size
+    end
+
+    def [](name)
+      find { |dependency| dependency.name == name }
+    end
+
+    def fetch(name)
+      self[name] || raise(UnknownDependency, "Dependency #{name} is unknown")
+    end
+
+    def include?(name)
+      !!self[name]
+    end
+
+    def <<(dependency)
+      push(dependency)
+    end
+
+    def add(name, options = {})
+      push(Dependency.new(name, options))
+    end
+
+    def push(dependency)
+      all.push(dependency)
+    end
+
+    def without_default
+      reject(&:default?)
+    end
+  end
+end

data/lib/medicine/dependency.rb

@@ -0,0 +1,55 @@
+module Medicine
+  NoDefaultError = Class.new(StandardError)
+  NoDefault      = Class.new.freeze
+
+  class Dependency
+    attr_reader :name
+
+    def initialize(name, options = {})
+      @name    = name
+      @default = options.fetch(:default, NoDefault)
+    end
+
+    def method_name
+      name
+    end
+
+    # returns the default, yields block or raises an error
+    #
+    # FIXME: move block yielding to default_or method.
+    def default
+      if default?
+        typecast(@default)
+      else
+        if block_given?
+          yield
+        else
+          raise NoDefaultError, "No default declared for #{name}"
+        end
+      end
+    end
+
+    def default?
+      !required?
+    end
+
+    def required?
+      @default == NoDefault
+    end
+
+    private
+
+    def typecast(dependency)
+      case dependency.class.name
+      when 'String' then
+        Inflecto.constantize(Inflecto.camelize(dependency))
+      when 'Symbol' then
+        typecast(dependency.to_s)
+      when 'Proc' then
+        dependency.call
+      else
+        dependency
+      end
+    end
+  end
+end

data/lib/medicine/injections.rb

@@ -0,0 +1,33 @@
+module Medicine
+
+  # @api private
+
+  class Injections
+    def initialize
+      @injections = {}
+    end
+
+    def fetch(name, &block)
+      @injections.fetch(name, &block)
+    rescue KeyError
+      raise ArgumentError, "No dependency with name #{name} has been injected."
+    end
+
+    def [](name)
+      @injections[name]
+    end
+
+    def set(name, dependency)
+      warn "#{name} has already been injected" if include?(name)
+      @injections[name] = dependency
+    end
+
+    def include?(name)
+      @injections.has_key?(name)
+    end
+
+    def empty?
+      @injections.empty?
+    end
+  end
+end

data/lib/medicine/version.rb

@@ -1,3 +1,3 @@
 module Medicine
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
 end

data/spec/initialization_injection_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe 'injection via initializer' do
+  let(:medicated_class) { new_medicated_class }
+
+  def new_medicated_class
+    Class.new do
+      include Medicine.di
+
+      # access to otherwise private method
+      def _vote_repo
+        vote_repo
+      end
+    end
+  end
+
+  before { medicated_class.class_eval { dependency :vote_repo } }
+
+  context 'when subject is initalized with a hash' do
+    subject { medicated_class.new(vote_repo: :foo) }
+
+    context 'and hash has key for dependency' do
+      it 'provides a private method' do
+        expect(subject.respond_to?(:vote_repo, true)).to be_truthy
+      end
+
+      it 'does not provide a public method' do
+        expect(subject).not_to respond_to(:vote_repo)
+      end
+
+      it 'provides method which returns injected value' do
+        expect(subject._vote_repo).to eq :foo
+      end
+
+      it 'does not resolve default' do
+        medicated_class.class_eval do
+          dependency :vote_repo, default: -> { DoesNotExist }
+        end
+
+        object = medicated_class.new(vote_repo: 'bar')
+        expect { object._vote_repo.not_to raise_error }
+      end
+    end
+  end
+end

data/spec/medicine/dependencies_spec.rb

@@ -0,0 +1,109 @@
+RSpec.describe Medicine::Dependencies do
+  it 'is a collection' do
+    expect(subject).to be_a(Enumerable)
+    expect(subject).to respond_to(:each)
+  end
+
+  describe '#[]' do
+    context 'when dependency is known' do
+      before { subject.add(:foo) }
+
+      it 'returns a dependency' do
+        expect(subject[:foo]).to an_instance_of(Medicine::Dependency)
+      end
+    end
+
+    context 'when dependency is unknown' do
+      it 'returns nil' do
+        expect(subject[:foo]).to be_nil
+      end
+    end
+  end
+
+  describe '#fetch' do
+    context 'when dependency is known' do
+      before { subject.add(:foo) }
+
+      it 'returns a dependency' do
+        expect(subject.fetch(:foo)).to an_instance_of(Medicine::Dependency)
+      end
+    end
+
+    context 'when when dependency is unknown' do
+      it 'raise an error' do
+        expect { subject.fetch(:foo) }.to raise_error(Medicine::UnknownDependency, "Dependency foo is unknown")
+      end
+    end
+  end
+
+  describe '#include?' do
+    context 'when dependency is known' do
+      before { subject.add(:foo) }
+
+      it 'returns true' do
+        expect(subject.include?(:foo)).to be_truthy
+      end
+    end
+
+    context 'when when dependency is unknown' do
+      it 'returns false' do
+        expect(subject.include?(:foo)).to be_falsey
+      end
+    end
+  end
+
+  describe '#<<' do
+    it 'appends given dependency' do
+      expect { subject << double }.to change { subject.size }.by(1)
+    end
+  end
+
+  describe '#add' do
+    it 'appends dependency' do
+      expect { subject.add('foo') }.to change { subject.size }.by(1)
+    end
+
+    context 'options' do
+      let(:added_dependency) { subject.first }
+
+      context 'default given' do
+        let(:default) { double }
+        let(:options) { { default: default } }
+
+        before { subject.add('foo', options) }
+
+        it 'sets default' do
+          expect(added_dependency).to be_default
+        end
+      end
+
+      context 'default not given' do
+        let(:options) { {} }
+
+        before { subject.add('foo', options) }
+
+        it 'appends dependency without default' do
+          expect(added_dependency).not_to be_default
+        end
+      end
+    end
+  end
+
+  describe '#without_defaults' do
+    let(:dependency_with_default)    { double('Dependency', default?: true) }
+    let(:dependency_without_default) { double('Dependency', default?: false) }
+
+    it 'returns dependencies without a default' do
+      subject << dependency_without_default
+      subject << dependency_with_default
+
+      expect(subject.without_default).to eq [dependency_without_default]
+    end
+  end
+
+  context 'initialize' do
+    it 'is empty' do
+      expect(subject).to be_empty
+    end
+  end
+end

data/spec/medicine/dependency_spec.rb

@@ -0,0 +1,142 @@
+RSpec.describe Medicine::Dependency do
+  subject { described_class }
+
+  TOKEN = Class.new
+
+  describe '#initialize' do
+    it 'sets name' do
+      expect(subject.new(TOKEN, {}).name).to eq TOKEN
+    end
+
+    context 'given default option' do
+      let(:dependency) { subject.new('foo', default: TOKEN) }
+
+      it 'sets default to given value' do
+        expect(dependency.default).to eq TOKEN
+      end
+    end
+
+    context 'without default option' do
+      let(:dependency) { subject.new('foo') }
+
+      it 'raises an error' do
+        expect { dependency.default }.to raise_error(Medicine::NoDefaultError)
+      end
+    end
+  end
+
+  describe '#required?' do
+    context 'when has non-nil default' do
+      let(:dependency) { subject.new('foo', default: TOKEN) }
+
+      it 'returns false' do
+        expect(dependency.required?).to be_falsey
+      end
+    end
+
+    context 'when has nil default' do
+      let(:dependency) { subject.new('foo', default: nil) }
+
+      it 'returns false' do
+        expect(dependency.required?).to be_falsey
+      end
+    end
+
+    context 'when has no default' do
+      let(:dependency) { subject.new('foo') }
+
+      it 'returns true' do
+        expect(dependency.required?).to be_truthy
+      end
+    end
+  end
+
+  describe '#default' do
+    context 'when no default given' do
+      let(:dependency) { subject.new('foo') }
+
+      context 'when block given' do
+        it 'yields the block' do
+          expect { |b| dependency.default(&b) }.to yield_with_no_args
+        end
+      end
+
+      context 'when no block given' do
+        it 'raise an error' do
+          expect { dependency.default }.to raise_error(Medicine::NoDefaultError)
+        end
+      end
+    end
+
+    context 'when default given' do
+      let(:dependency) { subject.new('foo', default: default) }
+
+      Foo  = Class.new
+      Foos = Class.new
+
+      describe 'when initalized with nil' do
+        let(:default) { nil }
+
+        it 'returns a class' do
+          expect(dependency.default).to eq nil
+        end
+      end
+
+      describe 'when initalized with a class' do
+        let(:default) { Foo }
+
+        it 'returns a class' do
+          expect(dependency.default).to eq Foo
+        end
+      end
+
+      describe 'when initialized with a lambda' do
+        let(:default) { -> { Foo } }
+
+        it 'returns a class' do
+          expect(dependency.default).to eq Foo
+        end
+      end
+
+      describe 'when initialized with a Proc' do
+        let(:default) { Proc.new { Foo } }
+
+        it 'returns a class' do
+          expect(dependency.default).to eq Foo
+        end
+      end
+
+      describe 'when initialized with a CamelCase String' do
+        let(:default) { 'Foo' }
+
+        it 'returns a class' do
+          expect(dependency.default).to eq Foo
+        end
+      end
+
+      describe 'when initialized with a plural CamelCase String' do
+        let(:default) { 'Foos' }
+
+        it 'returns a class' do
+          expect(dependency.default).to eq Foos
+        end
+      end
+
+      describe 'when initialized with a CamelCase Symbol' do
+        let(:default) { :Foo }
+
+        it 'returns a class' do
+          expect(dependency.default).to eq Foo
+        end
+      end
+
+      describe 'when initialized with a lowercase Symbol' do
+        let(:default) { :foo }
+
+        it 'returns a class' do
+          expect(dependency.default).to eq Foo
+        end
+      end
+    end
+  end
+end

data/spec/medicine/di_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Medicine::DI do
+  it 'can be included' do
+    klass = Class.new { include Medicine::DI }
+    expect(klass).to respond_to(:dependencies)
+  end
+
+  it 'can be prepended' do
+    klass = Class.new { prepend Medicine::DI }
+    expect(klass).to respond_to(:dependencies)
+  end
+end

data/spec/medicine/injections_spec.rb

@@ -0,0 +1,83 @@
+RSpec.describe Medicine::Injections do
+  subject { described_class.new }
+
+  let(:dependency) { double }
+  let(:name)       { :name }
+
+  describe '#set' do
+    it 'sets a dependency for name' do
+      subject.set(name, dependency)
+      expect(subject.fetch(name)).to eq dependency
+    end
+
+    context 'when dependency has already been set' do
+      it 'issues a warning' do
+        expect(subject).to receive(:warn)
+        subject.set(name, dependency)
+        subject.set(name, dependency)
+      end
+    end
+  end
+
+  describe '#fetch' do
+    context 'given a known name' do
+      it 'gets a dependency by name' do
+        subject.set(name, dependency)
+        expect(subject.fetch(name)).to eq dependency
+      end
+    end
+
+    context 'given an unknown name' do
+      context 'and no block given' do
+        it 'raise an error' do
+          expect { subject.fetch(:made_up_name) }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'and block given' do
+        # FIXME: assert block is called
+        it 'does not raise an error' do
+          expect { subject.fetch(:made_up_name) {  } }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  describe '#[]' do
+    context 'given a known name' do
+      it 'returns dependency' do
+        subject.set(name, dependency)
+        expect(subject[name]).to eq dependency
+      end
+    end
+
+    context 'given an unknown name' do
+      it 'returns nil' do
+        expect(subject[name]).to eq nil
+      end
+    end
+  end
+
+  describe '#empty?' do
+    context 'when no dependencies' do
+      it 'returns true' do
+        expect(subject.empty?).to be_truthy
+      end
+    end
+  end
+
+  describe '#include?' do
+    context 'given known name' do
+      it 'returns true' do
+        subject.set(name, dependency)
+        expect(subject.include?(name)).to be_truthy
+      end
+    end
+
+    context 'given an unknown name' do
+      it 'returns false' do
+        expect(subject.include?(:made_up_name)).to be_falsey
+      end
+    end
+  end
+end

data/spec/medicine_spec.rb

@@ -12,61 +12,35 @@ RSpec.describe 'Medicine' do
     end
   end
 
-  describe 'dependency declarations' do
-    it 'survive inheritence' do
-      medicated_class.class_eval { dependency :foobar }
+  describe 'when dependency declared' do
+    it 'survives inheritence' do
+      medicated_class.class_eval { dependency :vote_repo }
 
       super_medicated_class = Class.new(medicated_class)
       expect(super_medicated_class.dependencies).not_to be_empty
     end
 
-    it 'do not leak between unrelated classes' do
-      medicated_class.class_eval { dependency :foobar }
+    it 'does not leak between unrelated classes' do
+      medicated_class.class_eval { dependency :vote_repo }
 
       expect(medicated_class.dependencies).not_to be_empty
       expect(new_medicated_class.dependencies).to be_empty
     end
   end
 
-  describe 'dependency declared without any options' do
+  describe 'when dependency declared with no default' do
     before { medicated_class.class_eval { dependency :vote_repo } }
 
-    context 'and subject initialized with no arguments' do
+    context 'and dependency not injected' do
       subject { medicated_class.new }
 
-      it 'raises exception' do
-        expect { subject }.to raise_error(Medicine::RequiredDependencyError)
-      end
-    end
-
-    context 'and subject initalized with hash' do
-      subject { medicated_class.new(vote_repo: :foo) }
-
-      context 'and hash has key for dependency' do
-        it 'provides a private method' do
-          expect(subject.respond_to?(:vote_repo, true)).to be_truthy
-        end
-
-        it 'does not provide a public method' do
-          expect(subject).not_to respond_to(:vote_repo)
-        end
-
-        it 'provides method which returns injected value' do
-          expect(subject._vote_repo).to eq :foo
-        end
-      end
-
-      context 'and hash has no key for dependency' do
-        subject { medicated_class.new({}) }
-
-        it 'raises exception' do
-          expect { subject }.to raise_error(Medicine::RequiredDependencyError)
-        end
+      it 'raises an error' do
+        expect { subject._vote_repo }.to raise_error(Medicine::NoInjectionError, /Dependency not injected and default not declared/)
       end
     end
   end
 
-  context 'and subject initialized with no arguments' do
+  describe 'dependency declared with default' do
 
     subject { medicated_class.new }
 
@@ -75,77 +49,62 @@ RSpec.describe 'Medicine' do
       Foos = Class.new unless defined?(Foos)
     end
 
-    describe 'and dependency declared with default option' do
-
-      describe 'as a class' do
-        before { medicated_class.class_eval { dependency :vote_repo, default: Foo } }
+    describe 'as a class' do
+      before { medicated_class.class_eval { dependency :vote_repo, default: Foo } }
 
-        it 'returns a class' do
-          expect(subject._vote_repo).to eq Foo
-        end
+      it 'returns a class' do
+        expect(subject._vote_repo).to eq Foo
       end
+    end
 
-      describe 'as a lambda' do
-        before { medicated_class.class_eval { dependency :vote_repo, default: -> { Foo } } }
+    describe 'as a lambda' do
+      before { medicated_class.class_eval { dependency :vote_repo, default: -> { Foo } } }
 
-        it 'returns a class' do
-          expect(subject._vote_repo).to eq Foo
-        end
+      it 'returns a class' do
+        expect(subject._vote_repo).to eq Foo
       end
+    end
 
-      describe 'as a Proc' do
-        before { medicated_class.class_eval { dependency :vote_repo, default: Proc.new { Foo } } }
+    describe 'as a Proc' do
+      before { medicated_class.class_eval { dependency :vote_repo, default: Proc.new { Foo } } }
 
-        it 'returns a class' do
-          expect(subject._vote_repo).to eq Foo
-        end
+      it 'returns a class' do
+        expect(subject._vote_repo).to eq Foo
       end
+    end
 
-      describe 'as a CamelCase String' do
-        before { medicated_class.class_eval { dependency :vote_repo, default: 'Foo' } }
+    describe 'as a CamelCase String' do
+      before { medicated_class.class_eval { dependency :vote_repo, default: 'Foo' } }
 
-        it 'returns a class' do
-          expect(subject._vote_repo).to eq Foo
-        end
+      it 'returns a class' do
+        expect(subject._vote_repo).to eq Foo
       end
+    end
 
-      describe 'as a plural CamelCase String' do
-        before { medicated_class.class_eval { dependency :vote_repo, default: 'Foos' } }
+    describe 'as a plural CamelCase String' do
+      before { medicated_class.class_eval { dependency :vote_repo, default: 'Foos' } }
 
-        it 'returns a class' do
-          expect(subject._vote_repo).to eq Foos
-        end
+      it 'returns a class' do
+        expect(subject._vote_repo).to eq Foos
       end
+    end
 
-      describe 'as a CamelCase Symbol' do
-        before { medicated_class.class_eval { dependency :vote_repo, default: :Foo} }
+    describe 'as a CamelCase Symbol' do
+      before { medicated_class.class_eval { dependency :vote_repo, default: :Foo} }
 
-        it 'returns a class' do
-          expect(subject._vote_repo).to eq Foo
-        end
+      it 'returns a class' do
+        expect(subject._vote_repo).to eq Foo
       end
+    end
 
-      describe 'as a lowercase Symbol' do
-        before { medicated_class.class_eval { dependency :vote_repo, default: :foo} }
+    describe 'as a lowercase Symbol' do
+      before { medicated_class.class_eval { dependency :vote_repo, default: :foo} }
 
-        it 'returns a class' do
-          expect(subject._vote_repo).to eq Foo
-        end
+      it 'returns a class' do
+        expect(subject._vote_repo).to eq Foo
       end
-    end # with default option
-  end # initialized with no arguments
-
-  describe 'inclusion of module' do
-    it 'can be included' do
-      klass = Class.new { include Medicine.di }
-      expect(klass).to respond_to(:dependencies)
     end
-
-    it 'can be prepended' do
-      klass = Class.new { prepend Medicine.di }
-      expect(klass).to respond_to(:dependencies)
-    end
-  end
+  end # with default option
 
   describe 'object initialization' do
     it 'zsuper is called' do
@@ -162,4 +121,4 @@ RSpec.describe 'Medicine' do
       expect(klass.new.initalize_reached).to be_truthy
     end
   end
-end # rspec
+end

data/spec/setter_injection_spec_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe 'Medicine' do
+    let(:medicated_class) { new_medicated_class }
+
+    def new_medicated_class
+      Class.new do
+        include Medicine.di
+
+        # access to otherwise private method
+        def _vote_repo
+          vote_repo
+        end
+      end
+    end
+
+    subject { medicated_class.new }
+
+  describe '#injections' do
+    it 'starts empty' do
+      expect(subject.injections).to be_empty
+    end
+
+    it 'returns Injections object' do
+      expect(subject.injections).to be_an_instance_of(Medicine::Injections)
+    end
+
+    it 'is frozen' do
+      expect(subject.injections).to be_frozen
+    end
+  end
+
+  describe '#inject_dependency' do
+    it 'is a public method' do
+      expect(subject).to respond_to :inject_dependency
+    end
+
+    it 'injects a dependency' do
+      medicated_class.class_eval { dependency :name }
+      subject.inject_dependency(:name, double)
+      expect(subject.injections).not_to be_empty
+    end
+
+    describe 'when dependency has not been declared' do
+      it 'raises an error' do
+        expect { subject.inject_dependency(:name, double) }.to raise_error(Medicine::DependencyUnknownError)
+      end
+    end
+  end
+
+  describe '#injects' do
+    it 'is a public method' do
+      expect(subject).to respond_to :injects
+    end
+
+    it 'invokes inject for each dependency' do
+      medicated_class.class_eval { dependency :name }
+      expect(subject).to receive(:inject_dependency).twice
+      subject.injects(name: double, other: double)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: medicine
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Kris Leech
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-13 00:00:00.000000000 Z
+date: 2016-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inflecto
@@ -38,14 +38,24 @@ files:
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - TODO
 - lib/medicine.rb
+- lib/medicine/dependencies.rb
+- lib/medicine/dependency.rb
+- lib/medicine/injections.rb
 - lib/medicine/version.rb
 - medicine.gemspec
+- spec/initialization_injection_spec.rb
+- spec/medicine/dependencies_spec.rb
+- spec/medicine/dependency_spec.rb
+- spec/medicine/di_spec.rb
+- spec/medicine/injections_spec.rb
 - spec/medicine_spec.rb
+- spec/setter_injection_spec_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/krisleech/medicine
 licenses:
@@ -67,11 +77,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Simple Dependency Injection for Ruby
 test_files:
+- spec/initialization_injection_spec.rb
+- spec/medicine/dependencies_spec.rb
+- spec/medicine/dependency_spec.rb
+- spec/medicine/di_spec.rb
+- spec/medicine/injections_spec.rb
 - spec/medicine_spec.rb
+- spec/setter_injection_spec_spec.rb
 - spec/spec_helper.rb
 has_rdoc: