mindreframer-dim 1.2.5

data/.gitignore

@@ -0,0 +1,3 @@
+.project_env.rc
+.togglerc
+*.gem

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-turbo@dim --create

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ..gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    dim (1.2.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.1)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.0)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-given (2.4.0)
+      rspec (>= 2.11)
+      sorcerer (>= 0.3.7)
+    rspec-mocks (2.13.0)
+    sorcerer (0.3.10)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dim!
+  rspec
+  rspec-given

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Mike Subelsky
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,81 @@
+# DIM: Dependency Injection - Minimal
+
+DIM is [Jim Weirich's](http://onestepback.org) minimalistic dependency injection framework, maintained in
+gem form by [Mike Subelsky](http://subelsky.com).
+
+Dependency injection lets you organize all of your app's object setup code in one place by creating a
+container. Whenver an object in your application needs access to another object or resource, it asks
+the container to provide it (using lazily-evaluated code blocks).
+
+When testing your code, you can either stub out services on the container, or you can provide a substitute container.
+
+## Example
+
+The following could be in a "lib.init.rb" file or in a Rails app, "config/initializers/container.rb":
+
+    require "dim"
+    require "logger"
+    require 'game'
+    require 'event_handler'
+    require 'transmitter'
+
+    ServerContainer = Dim::Container.new
+
+    ServerContainer.register(:transmitter) { |c| Transmitter.new(c.logger) }
+
+    ServerContainer.register(:event_handler) do |c|
+      eh = EventHandler.new
+      eh.transmitter = c.transmitter
+      eh.logger = c.logger
+      eh
+    end
+
+    ServerContainer.register(:listening_host) { "0.0.0.0" }
+    ServerContainer.register(:listening_port) { "8080" }
+
+    ServerContainer.register(:game) do |c|
+      game = Game.new
+      game.logger = c.logger
+      game.event_handler = c.event_handler
+      game.host = c.listening_host
+      game.port = c.listening_port
+      game
+    end
+
+    ServerContainer.register(:root_dir) do |c|
+      Pathname.new(File.expand_path(File.dirname(__FILE__) + "/.."))
+    end
+
+    ServerContainer.register(:log_file_path) do |c|
+      "#{c.root_dir}/log/#{c.environment}.log"
+    end
+
+    ServerContainer.register(:logger) do |c|
+      Logger.new(c.log_file_path)
+    end
+
+    # 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:
+
+    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):
+
+    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:
+
+    World.new(GameContainer)
+
+## More Background
+
+Jim wrote a [nice article](http://onestepback.org/index.cgi/Tech/Ruby/DependencyInjectionInRuby.rdoc) explaining
+the rationale for this code and how it works. Also check out [his slides](http://onestepback.org/articles/depinj/).
+
+# License
+
+Dim is available under the MIT license (see the file LICENSE for details).

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/clean'
+require 'rake/testtask'
+
+task :default => :spec
+
+task :spec do
+  sh "rspec spec"
+end

data/dim.gemspec

@@ -0,0 +1,21 @@
+$:.unshift(File.dirname(__FILE__))
+require 'lib/version'
+
+Gem::Specification.new do |s|
+  s.name = %q{mindreframer-dim}
+  s.version = Dim::VERSION
+  s.authors = ["Jim Weirich", "Mike Subelsky"]
+  s.date = Time.now.utc.strftime("%Y-%m-%d")
+  s.email = %q{mike@subelsky.com}
+  s.extra_rdoc_files = %w(README.markdown)
+  s.files = `git ls-files`.split("\n")
+  s.homepage = %q{http://github.com/subelsky/dim}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  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.license = "MIT"
+end

data/lib/dim.rb

@@ -0,0 +1,134 @@
+#--
+# Copyright 2004, 2005, 2010, 2012 by Jim Weirich (jim.weirich@gmail.com)
+# and Mike Subelsky (mike@subelsky.com)
+#
+# All rights reserved.
+#
+# This software is available under the MIT license.  See the LICENSE file for details.
+#++
+#
+# = Dependency Injection - Minimal (DIM)
+#
+# The DIM module provides a minimal dependency injection framework for
+# Ruby programs.
+#
+# Example:
+#
+#   require 'dim'
+#
+#   container = Dim::Container.new
+#   container.register(:log_file) { "logfile.log" }
+#   container.register(:logger) { |c| FileLogger.new(c.log_file) }
+#   container.register(:application) { |c|
+#     app = Application.new
+#     app.logger = c.logger
+#     app
+#   }
+#
+#   c.application.run
+#
+module Dim
+  # Thrown when a service cannot be located by name.
+  MissingServiceError = Class.new(StandardError)
+
+  # Thrown when a duplicate service is registered.
+  DuplicateServiceError = Class.new(StandardError)
+
+  # Thrown by register_env when a suitable ENV variable can't be found
+  EnvironmentVariableNotFound = Class.new(StandardError)
+
+  # Dim::Container is the central data store for registering services
+  # used for dependency injuction.  Users register services by
+  # providing a name and a block used to create the service.  Services
+  # may be retrieved by asking for them by name (via the [] operator)
+  # or by selector (via the method_missing technique).
+  #
+  class Container
+    attr_reader :parent
+
+    # Create a dependency injection container.  Specify a parent
+    # container to use as a fallback for service lookup.
+    def initialize(parent=nil)
+      @services = {}
+      @cache = {}
+      @parent = parent || Container
+    end
+
+    def to_s
+      info = " services: #{service_list}"
+      "<Dim::Container::#{self.__id__}:#{info}>"
+    end
+
+    # Register a service named +name+.  The +block+ will be used to
+    # create the service on demand.  It is recommended that symbols be
+    # used as the name of a service.
+    def register(name, &block)
+      if @services[name]
+        fail DuplicateServiceError, "Duplicate Service Name '#{name}'"
+      end
+      @services[name] = block
+
+      self.class.send(:define_method, name) do
+        self[name]
+      end
+    end
+
+    # Lookup a service from ENV variables; fall back to searching the container and its parents for a default value
+    def register_env(name)
+      if value = ENV[name.to_s.upcase]
+        register(name) { value }
+      else
+        begin
+          @parent.service_block(name)
+        rescue MissingServiceError
+          raise EnvironmentVariableNotFound, "Could not find an ENV variable named #{name.to_s.upcase} nor could we find a service named #{name} in the parent container"
+        end
+      end
+    end
+
+    # Lookup a service by name.  Throw an exception if no service is
+    # found.
+    def [](name)
+      @cache[name] ||= service_block(name).call(self)
+    end
+
+    ##
+    # a list with services, that this container provides
+    # @return [Array]
+    def service_list
+      (@services.keys + @parent.service_list).flatten.uniq
+    end
+
+    # initial implementation for a clean Container
+    def self.service_list
+      []
+    end
+
+    # Lookup a service by message selector.  A service with the same
+    # name as +sym+ will be returned, or an exception is thrown if no
+    # matching service is found.
+    def method_missing(sym, *args, &block)
+      self[sym]
+    end
+
+    # Return the block that creates the named service.  Throw an
+    # exception if no service creation block of the given name can be
+    # found in the container or its parents.
+    def service_block(name)
+      @services[name] || @parent.service_block(name)
+    end
+
+    # Resets the cached services
+    def clear_cache!
+      @cache = {}
+    end
+
+    # Searching for a service block only reaches the Container class
+    # when all the containers in the hierarchy search chain have no
+    # entry for the service.  In this case, the only thing to do is
+    # signal a failure.
+    def self.service_block(name)
+      fail(MissingServiceError, "Unknown Service '#{name}'")
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Dim
+  VERSION = "1.2.5"
+end

data/spec/dim_spec.rb

@@ -0,0 +1,221 @@
+require 'dim'
+require 'rspec/given'
+
+class ConsoleAppender
+end
+
+class Logger
+  attr_accessor :appender
+end
+
+class MockDB
+end
+
+class RealDB
+  attr_accessor :username, :password
+  def initialize(username, password)
+    @username, @password = username, password
+  end
+end
+
+class App
+  attr_accessor :logger, :db
+  def initialize(logger=nil)
+    @logger = logger
+  end
+end
+
+describe Dim::Container do
+  let(:container) { Dim::Container.new }
+
+  describe "creating objects" do
+    Given { container.register(:app) { App.new } }
+    Then  { container.app.should be_a(App) }
+  end
+
+  describe "returning the same object every time" do
+    Given { container.register(:app) { App.new } }
+    Given(:app)  { container.app }
+    Then { container.app.should be(app) }
+  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
+  end
+
+  describe "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) }
+  end
+
+  describe "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 }
+
+    Then { app.db.should be(container.database) }
+  end
+
+  describe "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) }
+  end
+
+  describe "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 }
+
+    Then { logger.appender.should be(container.logger_appender) }
+  end
+
+  describe "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 }
+
+    Then { db.username.should == "user_name_value" }
+    Then { db.password.should == "password_value" }
+  end
+
+  describe "Errors" do
+    describe "missing services" do
+      Then {
+        lambda {
+          container.undefined_service_name
+        }.should raise_error(Dim::MissingServiceError, /undefined_service_name/)
+      }
+    end
+
+    describe "duplicate service names" do
+      Given { container.register(:duplicate_name) { 0 } }
+      Then {
+        lambda {
+          container.register(:duplicate_name) { 0 }
+        }.should raise_error(Dim::DuplicateServiceError, /duplicate_name/)
+      }
+    end
+  end
+
+  describe "Parent/Child Container Interaction" do
+    Given(:parent) { container }
+    Given(:child) { Dim::Container.new(parent) }
+
+    Given { parent.register(:cell) { :parent_cell } }
+    Given { parent.register(:gene) { :parent_gene } }
+    Given { child.register(:gene) { :child_gene } }
+
+    describe "reusing a service from the parent" do
+      Then { child.cell.should == :parent_cell }
+    end
+
+    describe "overiding a service from the parent" do
+      Then { child.gene.should == :child_gene }
+    end
+
+    describe "wrapping a service from a parent" do
+      Given { child.register(:cell) { |c| [c.parent.cell] } }
+      Then { child.cell.should == [:parent_cell] }
+    end
+
+    describe "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] }
+    end
+
+    describe "parent / child service conflicts from parents view" do
+      Then { parent.gene.should == :parent_gene }
+    end
+
+    describe "child / child service name conflicts" do
+      Given(:other_child) { Dim::Container.new(parent) }
+      Given { other_child.register(:gene) { :other_child_gene } }
+
+      Then { child.gene.should == :child_gene }
+      Then { other_child.gene.should == :other_child_gene }
+    end
+  end
+
+  describe "Registering env variables" do
+    describe "which exist in ENV" do
+      Given { ENV["SHAZ"] = "bot" }
+      Given { container.register_env(:shaz) }
+      Then  { container.shaz.should == "bot" }
+    end
+
+    describe "which exist in optional hash" do
+      Given(:parent) { container }
+      Given { parent.register(:foo) { "bar" } }
+      Given(:child) { Dim::Container.new(parent) }
+
+      Given { ENV["FOO"] = nil }
+      Given { child.register_env(:foo) }
+      Then  { container.foo.should == "bar" }
+    end
+
+    describe "which don't exist in optional hash" do
+      Then {
+        lambda {
+          container.register_env(:dont_exist_in_env_or_optional_hash)
+        }.should raise_error(Dim::EnvironmentVariableNotFound)
+      }
+    end
+  end
+
+
+  describe "output in terminal" do
+    describe "contains a short list of services" do
+      Given(:parent) { container }
+      Given { parent.register(:parent_foo) { "bar" } }
+      Then  { parent.to_s.should include("services: [:parent_foo]") }
+    end
+
+    describe "also from parent" do
+      Given(:parent) { container }
+      Given { parent.register(:parent_foo) { "bar" } }
+      Given(:child) { Dim::Container.new(parent) }
+      Given { child.register(:child_foo) {"bar"} }
+      Then  { child.to_s.should include("services: [:child_foo, :parent_foo]") }
+    end
+
+    describe "also when overridden from parent without duplicates" do
+      Given(:parent) { container }
+      Given { parent.register(:overriden_foo) { "parent" } }
+      Given(:child) { Dim::Container.new(parent) }
+      Given { child.register(:overriden_foo) {"child"} }
+      Then  { child.to_s.should include("services: [:overriden_foo]") }
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: mindreframer-dim
+version: !ruby/object:Gem::Version
+  version: 1.2.5
+  prerelease: 
+platform: ruby
+authors:
+- Jim Weirich
+- Mike Subelsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Minimalistic dependency injection framework keeps all of your object
+  setup code in one place.
+email: mike@subelsky.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.markdown
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.markdown
+- Rakefile
+- dim.gemspec
+- lib/dim.rb
+- lib/version.rb
+- spec/dim_spec.rb
+homepage: http://github.com/subelsky/dim
+licenses:
+- MIT
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Minimalistic dependency injection framework
+test_files:
+- spec/dim_spec.rb