codeine 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2011 Tim Ariyeh
+
+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/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/codeine.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "codeine/version"
+
+Gem::Specification.new do |s|
+  s.name        = "codeine"
+  s.version     = Codeine::VERSION
+  s.authors     = ["Tim Ariyeh"]
+  s.email       = ["tim.ariyeh@gmail.com"]
+  s.homepage    = "https://github.com/timariyeh/codeine"
+  s.summary     = %q{A simple Ruby dependency injector}
+  s.description = %q{A really simple, partitionable, ruby-flavored dependency injector}
+
+  s.rubyforge_project = "codeine"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end

data/examples/flexible.rb

@@ -0,0 +1,32 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'codeine'
+
+
+module FooModule
+  class A
+    codeine_inject :logger
+    def initialize
+      puts logger.inspect
+    end
+  end
+end
+
+module BarModule
+  class A
+    codeine_inject :logger
+    def initialize
+      puts logger.inspect
+    end
+  end
+end
+
+
+container_foo = Codeine.container_for(FooModule)
+container_foo.register(:logger){"the fancy logger for FooModule"}
+
+container_bar = Codeine.container_for(BarModule)
+container_bar.register(:logger){"the simple logger for BarModule"}
+
+
+FooModule::A.new 
+BarModule::A.new

data/examples/simple.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'codeine'
+
+Codeine.activate
+Codeine.register(:logger){"some logger"}
+
+module FooModule
+  class A
+    codeine_inject :logger
+    def initialize
+      puts logger.inspect
+    end
+  end
+end
+
+module BarModule
+  class A
+    codeine_inject :logger
+    def initialize
+      puts logger.inspect
+    end
+  end
+end
+
+FooModule::A.new
+BarModule::A.new

data/lib/codeine.rb

@@ -0,0 +1,59 @@
+require "codeine/version"
+require "codeine/container"
+require "codeine/injectable"
+require "codeine/containable"
+
+module Codeine
+  class << self
+   
+    #automatically called later in this file
+    def activate()
+      Module.send(:include, Codeine::Containable)
+      Class.send(:include, Codeine::Injectable)
+    end
+
+    def container_for(mod)
+      mod.codeine_container ||= Container.new
+    end
+
+    def default_container
+      @default_container ||= Container.new
+    end
+
+    def register(service, &block)
+      default_container.register(service, &block)
+    end
+
+    def get(service)
+      default_container.get(service)
+    end
+    alias :[] :get
+
+  end
+
+  module Utility
+    class << self
+      def constant_path(constant)
+        constants = []
+        parts = constant.to_s.split("::")
+        parts.count.times do |i|
+          constants <<  parts[0..i].inject(Kernel) do |memo, obj|
+            memo.const_get(obj)
+          end
+        end
+        constants
+      end
+
+      def nearest_container(constant)
+        container = nil
+        constant_path(constant).reverse.each do |c|
+          next unless c.respond_to? :codeine_container
+          break if container = c.codeine_container
+        end
+        container || ::Codeine.default_container
+      end
+    end
+  end
+end
+
+Codeine.activate

data/lib/codeine/containable.rb

@@ -0,0 +1,8 @@
+
+module Codeine
+  module Containable
+
+    attr_accessor :codeine_container
+
+  end
+end

data/lib/codeine/container.rb

@@ -0,0 +1,33 @@
+
+module Codeine
+  class Container
+    
+    def services
+      @services ||= {}
+    end
+
+    def filters
+      @filters ||= []
+    end
+
+    def register(key, &block)
+      services[key.to_sym] = block
+    end
+
+    def get(key)
+      key = key.to_sym
+      service = services[key].call
+      filters.each do |f|
+        if key.to_s =~ f[:pattern]
+          f[:block].call(key, service)
+        end
+      end
+      service
+    end
+    alias :[] :get
+
+    def filter(pattern, &block)
+      filters.push :pattern => pattern, :block => block
+    end
+  end
+end

data/lib/codeine/injectable.rb

@@ -0,0 +1,22 @@
+
+module Codeine
+  module Injectable
+
+    def nearest_codeine_container
+      Codeine::Utility.nearest_container(self)
+    end
+
+    def codeine_inject(service, method_name = nil)
+      method_name = method_name || service
+      define_method(method_name.to_sym) do
+        cache = instance_variable_get("@codeine_#{service}")
+        unless cache
+          cache = self.class.nearest_codeine_container[service.to_sym]
+          instance_variable_set("@codeine_#{service}", cache)
+        end
+        cache
+      end
+    end
+
+  end
+end

data/lib/codeine/version.rb

@@ -0,0 +1,3 @@
+module Codeine
+  VERSION = "0.0.1"
+end

data/readme.markdown

@@ -0,0 +1,46 @@
+Codeine
+=======
+
+A simple dependency injector for ruby projects.
+
+Despite how flexible ruby is, and despite the insistence of a large part of the community, I frequently run into the need on larger projects to centrally manage my dependencies.  I end up building something like Codeine for each one, so I decided to build it one more time and re-use it.
+
+Usage
+-----
+
+Codeine can operate as either a global or module-local dependency container.  Using it globally is the least flexible, but presents the simplest syntax.
+
+    require 'codeine'
+    Codeine.register(:logger){Logger.new}
+
+    class Foo
+      codeine_inject :logger
+      
+      def initialize
+        logger.log "Initialized..."
+      end
+    end
+
+
+For library code, and for larger projects, it's probably a better idea to segregate the containers.
+
+    require 'codeine'
+
+
+    module ProjectA
+      class Foo
+        codeine_inject :logger
+
+        def initialize
+          logger.log "Initialized..."
+        end
+      end
+    end
+
+    container = Codeine.container_for(ProjectA)
+    container.register(:logger){Logger.new}
+
+    foo = ProjectA::Foo.new
+
+
+The the container bound to the ProjectA module will only service injection requests from classes/modules that reside within it

data/spec/.rspec

@@ -0,0 +1,2 @@
+--color
+

data/spec/containable_spec.rb

@@ -0,0 +1,31 @@
+require_relative "spec_helper"
+require 'codeine'
+
+
+describe Codeine::Containable do
+  before(:each) do
+    module Foo
+      class Bar
+      end
+    end
+  end
+
+  it "should create getter/setter" do
+    Foo.send(:extend, Codeine::Containable)
+    Foo.should respond_to :codeine_container
+    Foo.should respond_to :codeine_container=
+  end
+
+  it "should store container at the instance level" do
+    Foo.send(:extend, Codeine::Containable)
+    Foo::Bar.send(:extend, Codeine::Containable)
+  
+    Foo.codeine_container = "foo_container"
+    Foo::Bar.codeine_container = "bar_container"
+
+    Foo.codeine_container.should == "foo_container"
+    Foo::Bar.codeine_container.should == "bar_container"
+  end
+
+
+end

data/spec/container_spec.rb

@@ -0,0 +1,55 @@
+
+require_relative "spec_helper"
+require 'codeine'
+
+describe Codeine::Container do
+  let(:container){Codeine::Container.new}
+  
+  describe "#register" do
+    it "should accept a block and register it as a service" do
+      hash = Hash.new
+      container.register(:foo){hash}
+
+      container.services[:foo].call.should == hash
+    end
+  end
+
+  describe "#get" do
+    it "should execute the block registered at the given key" do
+      hash = Hash.new
+      container.register(:foo){hash}
+
+      container.get(:foo).should == hash
+    end
+
+    it "should be aliased to []" do
+      hash = Hash.new
+      container.register(:foo){hash}
+
+      container[:foo].should == hash
+    end
+  end
+
+  describe "#filter" do
+    it "should fire the given block when a key matches the given filter" do
+      hash = Hash.new
+      container.register(:foo){hash}
+      container.filter(/^foo/){|key, service|
+        service[:bar] = "baz"
+      }
+      service = container.get(:foo)
+      service[:bar].should == "baz"
+    end
+
+    it "shouldn't fire the given block when a key doesn't match the given filter" do
+      hash = Hash.new
+      container.register(:foo){hash}
+      container.filter(/^bar/){|key, service|
+        service[:bar] = "baz"
+      }
+      service = container.get(:foo)
+      service[:bar].should_not == "baz"
+    end
+  end
+
+end

data/spec/injectable_spec.rb

@@ -0,0 +1,31 @@
+
+require_relative "spec_helper"
+require 'codeine'
+
+
+describe Codeine::Injectable do
+  before(:each) do
+    module Foo
+      class Bar
+      end
+    end
+  end
+
+  describe "dynamic methods" do
+    it "should create a module-level inject_service method" do
+      Foo::Bar.should_not respond_to(:inject_service)
+      Foo::Bar.send(:extend, Codeine::Injectable)
+      Foo::Bar.should respond_to(:codeine_inject)
+    end
+
+    it "should create a service getter for injected services" do
+      Foo::Bar.send(:extend, Codeine::Injectable)
+      Foo::Bar.send(:extend, Codeine::Containable)
+      Foo::Bar.codeine_container = {:bat => "man"}
+      Foo::Bar.codeine_inject(:bat)
+      bar = Foo::Bar.new
+      bar.bat.should == "man"
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift "../lib"
+
+RSpec.configure do |config|
+  config.after(:each) do
+    Object.send(:remove_const, :Foo) if Object.const_defined?(:Foo)
+  end
+end

data/spec/utility_spec.rb

@@ -0,0 +1,48 @@
+require_relative "spec_helper"
+require 'codeine'
+
+
+describe Codeine::Utility do
+  before(:each) do
+    module Foo
+      module Bar
+        class Baz
+
+        end
+      end
+    end
+  end
+
+  describe "constant_path" do
+    it "should return an array of constant values" do
+      path = Codeine::Utility.constant_path("Foo")
+      path[0].should == Foo
+    end
+
+    it "should return constant path in heirarchial order" do
+      path = Codeine::Utility.constant_path(Foo::Bar::Baz)
+      path.should == [Foo, Foo::Bar, Foo::Bar::Baz]
+    end
+  end
+
+  describe "nearest_container" do
+
+    it "should look up the constant heirarchy for a container" do
+      Foo.send(:extend, Codeine::Injectable)
+      Foo.send(:extend, Codeine::Containable)
+      Foo::Bar.send(:extend, Codeine::Injectable)
+      Foo.codeine_container = "foo_container"
+      Foo::Bar.nearest_codeine_container.should == "foo_container"
+    end
+
+    it "should not look down the constant heirarchy for a container" do
+      Foo.send(:extend, Codeine::Injectable)
+      Foo.send(:extend, Codeine::Containable)
+      Foo::Bar.send(:extend, Codeine::Injectable)
+      Foo::Bar.send(:extend, Codeine::Containable)
+
+      Foo::Bar.codeine_container = "bar_container"
+      Foo.nearest_codeine_container.should_not == "bar_container"
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: codeine
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tim Ariyeh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-08 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &13428680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13428680
+description: A really simple, partitionable, ruby-flavored dependency injector
+email:
+- tim.ariyeh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- Rakefile
+- codeine.gemspec
+- examples/flexible.rb
+- examples/simple.rb
+- lib/codeine.rb
+- lib/codeine/containable.rb
+- lib/codeine/container.rb
+- lib/codeine/injectable.rb
+- lib/codeine/version.rb
+- readme.markdown
+- spec/.rspec
+- spec/containable_spec.rb
+- spec/container_spec.rb
+- spec/injectable_spec.rb
+- spec/spec_helper.rb
+- spec/utility_spec.rb
+homepage: https://github.com/timariyeh/codeine
+licenses: []
+post_install_message: 
+rdoc_options: []
+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: codeine
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A simple Ruby dependency injector
+test_files: []