dim 1.2.7 → 1.2.8

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ODMwNTEzMjE5MTNkYTFkMzA2MDkxZDQ3NDcxYWUyZTVhMjkzZGU3Yg==
-  data.tar.gz: !binary |-
-    NmNkYmZiYzZjYzU1OTU0ZDk3ZmQ5OTZmOTE4MGQzNGFlZjk3NzA2ZQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MzQ4ZmU3ZGY0NDFkZGU3YTI4MGJlNGQ2MDBjZDIxOGIxNzZmNDBjOWE3MmE0
-    MmJlNjZiNTRjNmI5ZGVmODQ2ZGQ0ZDBlZmJiNGM5ODViMGJjOGJjM2U2MmNl
-    YTJlYWYyOWY0ZGRjOTQ0Zjg3YThhNDhkYzZhODgwMDA3NTJmYWY=
-  data.tar.gz: !binary |-
-    NTUzMWJhNmJlYzczNTAwNDQzZjhhMmI5MmJmMDI3MjAxMjEzODhmMmZiMjJm
-    MmQyNGI0ZTdiYWFlZDM4ZjI5YzJhMWQ5ZDkxODU1NTQzZmQ5OTc4Yzk5ZjM0
-    OTY5MTFlNjc5OTY0Y2MxZmYxYWUwYzg4MjEyNTA4MGY0MzY3M2E=
+SHA1:
+  metadata.gz: c4782eddd2362acb00039030ff666c5adf30e3fa
+  data.tar.gz: 11cc13c319a4de4aede04ee05baadabee3c8021b
+SHA512:
+  metadata.gz: ba10c081a2d720b3a076cf6ff8e89f2d16e888cff4857fc74ef90ed8b920593a8265bc9940fb87e848b737e143060473b19e5471fd0a4bcf3e30bcca041d5409
+  data.tar.gz: 8357f2778456f69a4d357a736eeff7072719543ad759803ad6d87623ca1e00f95304f382c727e8fe5d7a820e9eaa9080186c70636f82805e8d3c1f28a3664600

data/Gemfile

@@ -2,4 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in ..gemspec
 gemspec
-gem "rspec-given", "< 3"

data/README.markdown

@@ -13,6 +13,7 @@ When testing your code, you can either stub out services on the container, or yo
 
 The following could be in a "lib.init.rb" file or in a Rails app, "config/initializers/container.rb":
 
+```ruby
     require "dim"
     require "logger"
     require 'game'
@@ -57,19 +58,26 @@ The following could be in a "lib.init.rb" file or in a Rails app, "config/initia
     # attempts to read ENV["API_PASSWORD"], otherwise makes sure that the parent container has
     # a service named api_password registered
     ServerContainer.register_env(:api_password)
-
+```
+  
 Using the above code elsewhere in the app, when you want a reference to the app's logger object:
 
+```ruby
     ServerContainer.logger.info("I didn't have to setup my own logger")
+```
 
 Or if you wanted access to the game instance created during setup (which already is configured with everything it needs):
 
+```ruby
     current_game = ServerContainer.game
+```
 
 If you don't like creating even the one dependency on the global constant ServerContainer, you could
 inject ServerContainer itself into your objects like so:
 
+```ruby
     World.new(GameContainer)
+```
 
 ## More Background
 

data/Rakefile

@@ -9,3 +9,6 @@ task :default => :spec
 task :spec do
   sh "rspec spec"
 end
+
+desc "Build the gem, create a git tag, and push to git. If the build passes, CircleCI will publish to packagecloud"
+task :release, [:remote] => %w(build release:guard_clean release:source_control_push)

data/dim.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
   s.summary = %q{Minimalistic dependency injection framework}
   s.description = %q{Minimalistic dependency injection framework keeps all of your object setup code in one place.}
   s.test_files = `git ls-files spec`.split("\n")
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'rspec-given'
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
   s.license = "MIT"
 end

data/lib/dim.rb

@@ -58,9 +58,14 @@ module Dim
     # create the service on demand.  It is recommended that symbols be
     # used as the name of a service.
     def register(name,raise_error_on_duplicate = true,&block)
-      if @services[name] && raise_error_on_duplicate
-        fail DuplicateServiceError, "Duplicate Service Name '#{name}'"
+      if @services[name]
+        if raise_error_on_duplicate
+          fail DuplicateServiceError, "Duplicate Service Name '#{name}'"
+        else # delete the service from the cache
+          @cache.delete(name)
+        end
       end
+
       @services[name] = block
 
       self.class.send(:define_method, name) do
@@ -72,15 +77,6 @@ module Dim
       register(name,false,&block)
     end
 
-    # Given a list of services, check to see if they are available, returning true or false.
-    def verify_dependencies(*names)
-      names.all? do |name|
-        respond_to?(name) || service_block(name)
-      end
-    rescue Dim::MissingServiceError
-      false
-    end
-
     # Lookup a service from ENV variables, or use a default if given; fall back to searching the container and its parents for a default value
     def register_env(name,default = nil)
       if value = ENV[name.to_s.upcase]
@@ -128,5 +124,26 @@ module Dim
     def self.service_block(name)
       fail(MissingServiceError, "Unknown Service '#{name}'")
     end
+
+    # Check to see if a custom method or service has been registered, returning true or false.
+    def service_exists?(name)
+      respond_to?(name) || service_block(name)
+    rescue Dim::MissingServiceError
+      false
+    end
+
+    # Given a list of services, check to see if they are available, returning true or false.
+    def verify_dependencies(*names)
+      names.all? { |name| service_exists?(name) }
+    end
+
+    # Given a list of services, check to see if they are available or raise an exception.
+    def verify_dependencies!(*names)
+      missing_dependencies = names.reject { |name| service_exists?(name) }
+
+      unless missing_dependencies.empty?
+        fail Dim::MissingServiceError, "Missing dependencies #{missing_dependencies.join(", ")}"
+      end
+    end
   end
 end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Dim
-  VERSION = "1.2.7"
+  VERSION = "1.2.8".freeze
 end

data/spec/dim_spec.rb

@@ -1,5 +1,4 @@
-require 'dim'
-require 'rspec/given'
+require "dim"
 
 class ConsoleAppender
 end
@@ -28,192 +27,233 @@ end
 describe Dim::Container do
   let(:container) { Dim::Container.new }
 
-  Scenario "creating objects" do
-    Given { container.register(:app) { App.new } }
-    Then  { container.app.should be_a(App) }
+  context "creating objects" do
+    before { container.register(:app) { App.new } }
+    specify { expect(container.app).to be_a(App) }
   end
 
-  Scenario "returning the same object every time" do
-    Given { container.register(:app) { App.new } }
-    Given(:app)  { container.app }
-    Then { container.app.should be(app) }
+  context "returning the same object every time" do
+    let(:app) { container.app }
+    before { container.register(:app) { App.new } }
+    specify { expect(container.app).to be(app) }
   end
 
-  Scenario "overriding previously-registered objects" do
-    Given { container.register(:some_value) { "A" } }
-    Given { container.override(:some_value) { "B" } }
-    Then { container.some_value.should == "B" }
+  context "overriding previously-registered objects" do
+    before do
+      container.register(:some_value) { "A" }
+      container.override(:some_value) { "B" }
+    end
+
+    specify { expect(container.some_value).to eq("B") }
   end
 
-  it "clears cache explicitly" do
-    container.register(:app) { App.new }
-    app_before = container.app
-    container.clear_cache!
-    app_after = container.app
-    app_before.should_not == app_after
+  context "explicitly clearing cache" do
+    before do 
+      container.register(:app) { App.new } 
+    end
+
+    specify "returns new object" do
+      expect { 
+        container.clear_cache! }.
+        to change { container.app }
+    end
   end
 
-  Scenario "contructing dependent objects" do
-    Given { container.register(:app) { |c| App.new(c.logger) } }
-    Given { container.register(:logger) { Logger.new } }
-    Given(:app) { container.app }
-    Then { app.logger.should be(container.logger) }
+  context "contructing dependent objects" do
+    let(:app) { container.app }
+
+    before do
+      container.register(:app) { |c| App.new(c.logger) }
+      container.register(:logger) { Logger.new }
+    end
+
+    specify { expect(app.logger).to be(container.logger) }
   end
 
-  Scenario "constructing dependent objects with setters" do
-    Given {
-      container.register(:app) { |c|
-        App.new.tap { |obj|
-          obj.db = c.database
-        }
-      }
-    }
-    Given { container.register(:database) { MockDB.new } }
-    Given(:app) { container.app }
+  context "constructing dependent objects with setters" do
+    let(:app) { container.app }
+
+    before do
+      container.register(:app) do |c|
+        App.new.tap { |obj| obj.db = c.database }
+      end
+      container.register(:database) { MockDB.new }
+    end
 
-    Then { app.db.should be(container.database) }
+    specify { expect(app.db).to be(container.database) }
   end
 
-  Scenario "constructing multiple dependent objects" do
-    Given {
-      container.register(:app) { |c|
-        App.new(c.logger).tap { |obj|
-          obj.db = c.database
-        }
-      }
-    }
-    Given { container.register(:logger) { Logger.new } }
-    Given { container.register(:database) { MockDB.new } }
-    Given(:app) { container.app }
-    Then { app.logger.should be(container.logger) }
-    Then { app.db.should be(container.database) }
+  context "constructing multiple dependent objects" do
+    let(:app) { container.app }
+
+    before do
+      container.register(:app) do |c|
+        App.new(c.logger).tap { |obj| obj.db = c.database }
+      end
+      container.register(:logger) { Logger.new }
+      container.register(:database) { MockDB.new }
+    end
+
+    specify { expect(app.logger).to be(container.logger) }
+    specify { expect(app.db).to be(container.database) }
   end
 
-  Scenario "constructing chains of dependencies" do
-    Given { container.register(:app) { |c| App.new(c.logger) } }
-    Given {
-      container.register(:logger) { |c|
-        Logger.new.tap { |obj|
-          obj.appender = c.logger_appender
-        }
-      }
-    }
-    Given { container.register(:logger_appender) { ConsoleAppender.new } }
-    Given { container.register(:database) { MockDB.new } }
-    Given(:logger) { container.app.logger }
+  context "constructing chains of dependencies" do
+    let(:logger) { container.app.logger }
 
-    Then { logger.appender.should be(container.logger_appender) }
+    before do
+      container.register(:app) { |c| App.new(c.logger) }
+      container.register(:logger) do |c|
+        Logger.new.tap { |obj| obj.appender = c.logger_appender }
+      end
+      container.register(:logger_appender) { ConsoleAppender.new }
+      container.register(:database) { MockDB.new }
+    end
+
+    specify { expect(logger.appender).to be(container.logger_appender) }
   end
 
-  Scenario "constructing literals" do
-    Given { container.register(:database) { |c| RealDB.new(c.username, c.userpassword) } }
-    Given { container.register(:username) { "user_name_value" } }
-    Given { container.register(:userpassword) { "password_value" } }
-    Given(:db) { container.database }
+  context "constructing literals" do
+    let(:db) { container.database }
+
+    before do
+      container.register(:database) { |c| RealDB.new(c.username, c.userpassword) }
+      container.register(:username) { "user_name_value" }
+      container.register(:userpassword) { "password_value" }
+    end
 
-    Then { db.username.should == "user_name_value" }
-    Then { db.password.should == "password_value" }
+    specify { expect(db.username).to eq("user_name_value") }
+    specify { expect(db.password).to eq("password_value") }
   end
 
   describe "Errors" do
-    Scenario "missing services" do
-      Then {
-        lambda {
-          container.undefined_service_name
-        }.should raise_error(Dim::MissingServiceError, /undefined_service_name/)
-      }
-    end
-
-    Scenario "duplicate service names" do
-      Given { container.register(:duplicate_name) { 0 } }
-      Then {
-        lambda {
+    specify "raise missing service error" do
+      expect {
+        container.undefined_service_name
+      }.to raise_error(Dim::MissingServiceError, /undefined_service_name/)
+    end
+
+    context "duplicate service names" do
+      before { container.register(:duplicate_name) { 0 } }
+
+      specify do
+        expect {
           container.register(:duplicate_name) { 0 }
-        }.should raise_error(Dim::DuplicateServiceError, /duplicate_name/)
-      }
+        }.to raise_error(Dim::DuplicateServiceError, /duplicate_name/)
+      end
     end
   end
 
   describe "Parent/Child Container Interaction" do
-    Given(:parent) { container }
-    Given(:child) { Dim::Container.new(parent) }
+    let(:parent) { container }
+    let(:child) { Dim::Container.new(parent) }
 
-    Given { parent.register(:cell) { :parent_cell } }
-    Given { parent.register(:gene) { :parent_gene } }
-    Given { child.register(:gene) { :child_gene } }
+    before do
+      parent.register(:cell) { :parent_cell }
+      parent.register(:gene) { :parent_gene }
+      child.register(:gene) { :child_gene }
+    end
 
-    Scenario "reusing a service from the parent" do
-      Then { child.cell.should == :parent_cell }
+    context "reusing a service from the parent" do
+      specify { expect(child.cell).to eq(:parent_cell) }
     end
 
-    Scenario "overiding a service from the parent" do
-      Then "the child service overrides the parent" do
-        child.gene.should == :child_gene
+    context "overiding a service from the parent" do
+      specify "the child service overrides the parent" do
+        expect(child.gene).to eq(:child_gene)
       end
     end
 
-    Scenario "wrapping a service from a parent" do
-      Given { child.register(:cell) { |c| [c.parent.cell] } }
-      Then { child.cell.should == [:parent_cell] }
+    context "wrapping a service from a parent" do
+      before { child.register(:cell) { |c| [c.parent.cell] } }
+      specify { expect(child.cell).to eq([:parent_cell]) }
     end
 
-    Scenario "overriding an indirect dependency" do
-      Given { parent.register(:wrapped_cell) { |c| [c.cell] } }
-      Given { child.register(:cell) { :child_cell } }
-      Then { child.wrapped_cell.should == [:child_cell] }
+    context "overriding an indirect dependency" do
+      before do
+        parent.register(:wrapped_cell) { |c| [c.cell] }
+        child.register(:cell) { :child_cell }
+      end
+
+      specify { expect(child.wrapped_cell).to eq([:child_cell]) }
     end
 
-    Scenario "parent / child service conflicts from parents view" do
-      Then { parent.gene.should == :parent_gene }
+    context "parent / child service conflicts from parents view" do
+      specify { expect(parent.gene).to eq(:parent_gene) }
     end
 
-    Scenario "child / child service name conflicts" do
-      Given(:other_child) { Dim::Container.new(parent) }
-      Given { other_child.register(:gene) { :other_child_gene } }
+    context "child / child service name conflicts" do
+      let(:other_child) { Dim::Container.new(parent) }
+
+      before { other_child.register(:gene) { :other_child_gene } }
 
-      Then { child.gene.should == :child_gene }
-      Then { other_child.gene.should == :other_child_gene }
+      specify { expect(child.gene).to eq(:child_gene) }
+      specify { expect(other_child.gene).to eq(:other_child_gene) }
     end
   end
 
   describe "Registering env variables" do
-    Scenario "which exist in ENV" do
-      Given { ENV["SHAZ"] = "bot" }
-      Given { container.register_env(:shaz) }
-      Then  { container.shaz.should == "bot" }
+    context "which exist in ENV" do
+      before do
+        ENV["SHAZ"] = "bot"
+        container.register_env(:shaz)
+      end
+
+      specify { expect(container.shaz).to eq("bot") }
     end
 
-    Scenario "which only exist in parent" do
-      Given(:parent) { container }
-      Given { parent.register(:foo) { "bar" } }
-      Given(:child) { Dim::Container.new(parent) }
+    context "which only exist in parent" do
+      let(:parent) { container }
+      let(:child) { Dim::Container.new(parent) }
 
-      Given { ENV["FOO"] = nil }
-      Given { child.register_env(:foo) }
-      Then  { container.foo.should == "bar" }
+      before do
+        parent.register(:foo) { "bar" }
+        ENV["FOO"] = nil
+        child.register_env(:foo)
+      end
+
+      specify { expect(container.foo).to eq("bar") }
     end
 
-    Scenario "which don't exist in ENV but have a default" do
-      Given { container.register_env(:abc,"123") }
-      Then  { container.abc.should == "123" }
+    context "which don't exist in ENV but have a default" do
+      before { container.register_env(:abc,"123") }
+      specify { expect(container.abc).to eq("123") }
     end
 
-    Scenario "which don't exist in optional hash" do
-      Then {
-        lambda {
+    context "which don't exist in optional hash" do
+      specify do
+        expect {
           container.register_env(:dont_exist_in_env_or_optional_hash)
-        }.should raise_error(Dim::EnvironmentVariableNotFound)
-      }
+        }.to raise_error(Dim::EnvironmentVariableNotFound)
+      end
     end
   end
 
-  Scenario "verifying dependencies" do
-    Given { container.register(:app) { :app } }
-    Given {
-      def container.custom_method
-      end
-    }
-    Then  { container.verify_dependencies(:app,:custom_method).should == true }
-    Then  { container.verify_dependencies(:app,:custom_method,:frobosh).should == false }
+  context "verifying dependencies" do
+    before { container.register(:app) { :app } }
+
+    specify { expect(container.verify_dependencies(:app)).to be_true }
+    specify { expect(container.verify_dependencies(:app,:frobosh)).to be_false }
+  end
+
+  context "check if service exists" do
+    before do
+      container.register(:app) { :app }
+      def container.custom_method; end
+    end
+
+    specify { expect(container.service_exists?(:app)).to be_true }
+    specify { expect(container.service_exists?(:custom_method)).to be_true }
+    specify { expect(container.service_exists?(:missing_app)).to be_false }
+  end
+
+  context "dangerously verifying dependencies" do
+    before { container.register(:app) { :app } }
+
+    specify { expect(container.verify_dependencies!(:app)).to be_nil }
+
+    specify "raise error with list of missing services" do
+      expect{ container.verify_dependencies!(:app,:missing_app) }.to raise_error(Dim::MissingServiceError,/missing_app/)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dim
 version: !ruby/object:Gem::Version
-  version: 1.2.7
+  version: 1.2.8
 platform: ruby
 authors:
 - Jim Weirich
@@ -9,34 +9,34 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-06 00:00:00.000000000 Z
+date: 2017-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   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-given
+  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'
 description: Minimalistic dependency injection framework keeps all of your object
@@ -47,9 +47,8 @@ extensions: []
 extra_rdoc_files:
 - README.markdown
 files:
-- .gitignore
-- .rspec
-- .ruby-version
+- ".gitignore"
+- ".rspec"
 - Gemfile
 - LICENSE
 - README.markdown
@@ -64,25 +63,24 @@ licenses:
 metadata: {}
 post_install_message: 
 rdoc_options:
-- --charset=UTF-8
+- "--charset=UTF-8"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Minimalistic dependency injection framework
 test_files:
 - spec/dim_spec.rb
-has_rdoc: 

data/.ruby-version

@@ -1 +0,0 @@
-ruby-1.9.3