injection 2.0.0

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+doc
+spec/dummy/log/*.log

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,116 @@
+== DESCRIPTION:
+
+Injection is a simple dependency injection plugin for rails3. It allows you to inject objects into your controllers and observers which have been described in a yaml file (config/objects.yml).
+
+* https://github.com/atomicobject/injection
+
+(for the rails2 plugin install from the rails_2_plugin tag of this repository)
+
+== FEATURES/PROBLEMS:
+  
+* Declarative dependency injection that automatically instantiates ivars via the objects.yml file
+
+== SYNOPSIS:
+ To specify objects to be injected from the DIY context into your controller or observer
+ use the inject class method:
+
+   inject :one_component, :another
+
+=== Example
+
+ This example defines a context with two objects, _foo_ and _bar_, which 
+ are injected into every instance of the WidgetController or WidgetObserver.  The objects 
+ are available as instance variables within the controller and observer.
+ 
+ config/objects.yml:
+   ---
+   foo:
+   bar:
+ 
+ lib/foo.rb:
+   class Foo
+     ...
+   end
+ 
+ lib/bar.rb:
+   class Bar
+     ...
+   end
+ 
+ app/controllers/widget_controller.rb:
+   class WidgetController < ApplicationController
+     inject :foo, :bar
+ 
+     def index
+       render :text => "{@foo.inspect} {@bar.inspect}"
+     end
+   end
+  
+ app/models/widget_observer.rb:
+   class WidgetObserver < ActiveRecord::Observer
+     inject :foo, :bar
+     
+     before :save do |widget|
+      @foo.bar(widget)
+      @bar.foo(widget)
+     end
+   end 
+ 
+=== Declarative Observations
+ 
+ Observations on an active record object can be specified in a declarative way using
+ the before and after class methods. The methods are invoked with a
+ symbol which specifies what kind of event the observer is interested in, and a block 
+ that defines what actions it will perform.
+ 
+   class WidgetObserver < ActiveRecord::Observer
+     before :update do |record|
+       ...
+     end
+ 
+     after :create do |record|
+       ...
+     end
+ 
+     after :validation do |record|
+       ...
+     end
+ 
+     before :validation do |record|
+       ...
+     end
+   end
+ 
+== REQUIREMENTS:
+
+* constructor
+* diy
+
+== INSTALL:
+
+* gem install injection
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007-2010 Atomic Object
+
+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,21 @@
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/rdoctask'
+
+desc 'Default: run unit specs'
+task :default => :spec
+
+desc 'Generate documentation for the injection plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'injection'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)

data/injection.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "injection/version"
+
+Gem::Specification.new do |s|
+  s.name        = "injection"
+  s.version     = Injection::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Atomic Object"]
+  s.email       = ["github@atomicobject.com"]
+  s.homepage    = "https://github.com/atomicobject/injection"
+  s.summary     = %q{Dependency injection for Rails controllers and observers}
+  s.description = %q{Injection is a simple dependency injection gem for rails3. It allows you to inject objects into your controllers and observers which have been described in a yaml file (config/objects.yml).}
+
+  s.rubyforge_project = "injection"
+
+  s.files         = `git ls-files`.split("\n").reject {|f| f =~ /homepage/}
+  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_dependency "rails", ["~> 3"]
+  s.add_dependency "diy", ["~> 1"]
+  s.add_dependency "constructor", ["~> 2"]
+  
+  s.add_development_dependency "rspec-rails", "~> 2"
+  s.add_development_dependency "sqlite3-ruby"
+end

data/lib/injection.rb

@@ -0,0 +1,45 @@
+require 'diy'
+require 'constructor'
+require 'injection/railtie'
+require 'injection/class_inject'
+require 'injection/observer_inject'
+
+# === Accessing Objects in the Context
+#
+# Provides access to the context loaded from <tt>config/objects.yml</tt> which 
+# can be used to look up individual components.
+#
+# config/objects.yml:
+#   ---
+#   foo:
+#   bar:
+# 
+# lib/foo.rb:
+#   class Foo
+#     ...
+#   end
+#
+#   Inject.context[:foo]   #=> #<Foo:0x81eb0>
+#
+module Injection
+  @@context = {}
+  @@extra_inputs = {}
+
+  # Accessor for the context loaded from <tt>config/objects.yml</tt>
+  def self.context
+    @@context
+  end
+  
+  def self.context_file=(path)
+    @@context_file = path
+  end
+  
+  def self.extra_inputs=(hash)
+    @@extra_inputs = hash
+  end
+
+  def self.reset_context
+    @@context = DIY::Context.from_file(@@context_file, @@extra_inputs) if File.exists?(@@context_file)
+  end
+end
+

data/lib/injection/class_inject.rb

@@ -0,0 +1,38 @@
+module Injection
+  module ClassInject
+    extend ActiveSupport::Concern
+  
+    module Initialize #:nodoc:
+      extend ActiveSupport::Concern
+    
+      def initialize(*args)
+        if args.empty?
+          raise 'No context file loaded' if Injection.context.is_a?(Hash)
+          constructor_args = self.class.constructor_keys.inject({}) do |memo, key|
+            memo[key] = Injection.context[key]
+            memo
+          end
+          super(constructor_args)
+        else
+          super
+        end
+      end
+    end
+  
+    module ClassMethods
+      #
+      # Specify which components should be injected into this observer as the 
+      # list of <tt>keys</tt> to look them up from the DI context.
+      #
+      def inject(*keys)
+        constructor_args = if keys.last.is_a?(Hash)
+          keys[0..-2] + [{:super => []}.merge(keys.last)]
+        else
+          keys + [:super => []]
+        end
+        constructor *constructor_args
+        include Initialize
+      end
+    end
+  end
+end

data/lib/injection/observer_inject.rb

@@ -0,0 +1,44 @@
+module Injection
+  module ObserverExtension
+    extend ActiveSupport::Concern
+      
+    module ClassMethods
+      #
+      # Specify what events the observer is interested in after an activerecord object has
+      # performed an operation by passing in a <tt>symbol</tt> and a <tt>block</tt>.
+      def after(observation, &block)
+        build_methods(:after, observation, &block)
+      end
+      
+      #
+      # Specify what events the observer is interested in before an activerecord object has
+      # performed an operation by passing in a <tt>symbol</tt> and a <tt>block</tt>.
+      def before(observation, &block)
+        build_methods(:before, observation, &block)
+      end
+      
+      #
+      # Specify what events the observer is interested in before and after an activerecord object has
+      # performed an operation by passing in a <tt>symbol</tt> and a <tt>block</tt> that yields.
+      def around(observation, &block)
+        build_methods(:around, observation, &block)
+      end
+      
+      private
+      
+      def build_methods(before_after, observation, &block)
+        mname = build_method_name(before_after, observation)
+        validate_observation! mname
+        define_method(mname, &block)
+      end
+      
+      def build_method_name(before_after, observation)
+        "#{before_after}_#{observation}"
+      end
+      
+      def validate_observation!(observation)
+        raise "#{observation} is not an observable action" unless ActiveRecord::Callbacks::CALLBACKS.include? observation.to_sym
+      end
+    end
+  end
+end

data/lib/injection/railtie.rb

@@ -0,0 +1,41 @@
+require 'rails'
+
+module Injection
+  class Railtie < ::Rails::Railtie
+    config.before_configuration do
+      Injection.context_file = ::Rails.root.to_s + '/config/objects.yml'
+    end
+    
+    config.after_initialize do
+      # Let Rails do the auto loading
+      DIY::Context.auto_require = false
+      
+      # Reload the context from the file
+      Injection.reset_context
+    end
+    
+    # Reload the context after each request in development
+    initializer "injection.clear_context", :before => :set_clear_dependencies_hook do |app|
+      unless app.config.cache_classes
+        ::ActionDispatch::Callbacks.after do
+          Injection.reset_context
+        end
+      end
+    end
+    
+    initializer "injection.initialize_action_controller" do |app|
+      ::ActiveSupport.on_load(:action_controller) do
+        include ClassInject
+      end
+    end
+
+    initializer "injection.initialize_observers" do |app|
+      ::ActiveSupport.on_load(:active_record) do
+        ::ActiveRecord::Observer.class_eval do
+          include ClassInject
+          include ObserverExtension
+        end
+      end
+    end
+  end
+end

data/lib/injection/version.rb

@@ -0,0 +1,3 @@
+module Injection
+  VERSION = "2.0.0"
+end

data/spec/class_inject_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+class NormalController < ActionController::Base
+end
+
+class InjectedController < ActionController::Base
+  inject :foo, :bar
+  attr_reader :foo, :bar
+end
+
+class PoorlyInjectedController < ActionController::Base
+  inject :foo, :bar, :qux
+  attr_reader :foo, :bar, :qux
+end
+
+class GalaxyController < ActionController::Base
+  inject :foo
+  attr_accessor :foo
+end
+
+class SpiralGalaxyController < GalaxyController
+  inject :bar
+  attr_accessor :bar
+end
+
+class MilkyWayGalaxyController < SpiralGalaxyController
+  inject :foo_piece_two
+  attr_accessor :foo_piece_two
+end
+
+class FutureMilkyWayGalaxyController < MilkyWayGalaxyController; 
+  constructor
+end
+
+class CommercialController < ActionController::Base
+  inject :old, :readers => true
+end
+
+describe 'class inject' do
+  before do
+    # Instantiate a controller to kick start Rails into loading Injection
+    InjectedController.new 
+  end
+  
+  it "does not mess up construction of a normal controller" do
+    controller = NormalController.new
+    controller.should_not be_nil
+  end
+  
+  it 'injects objects from context' do
+    controller = InjectedController.new
+    controller.should_not be_nil
+    controller.foo.should equal(injection_context[:foo])
+    controller.bar.should equal(injection_context[:bar])
+  end
+  
+  it 'uses the params in injected object' do
+    foo, bar = 'foo', 'bar'
+    controller = InjectedController.new :foo => foo, :bar => bar
+    controller.should_not be_nil
+    controller.foo.should equal(foo)
+    controller.bar.should equal(bar)
+  end
+  
+  it "raises an error for a poorly injected object when a component is not found" do
+    lambda { PoorlyInjectedController.new }.should raise_error(DIY::ConstructionError, /qux/i)
+  end
+  
+  it "constructs poorly injected object given params" do
+    foo, bar, qux = 'foo', 'bar', 'qux'
+    controller = PoorlyInjectedController.new :foo => foo, :bar => bar, :qux => qux
+    controller.foo.should equal(foo)
+    controller.bar.should equal(bar)
+    controller.qux.should equal(qux)
+  end
+  
+  
+  it "raises for an injected object given only partial params" do
+    lambda { InjectedController.new(:foo => 'foo') }.should raise_error(Constructor::ArgumentError, /bar/i)
+    err = assert_raise Constructor::ArgumentError do
+      InjectedController.new :foo => 'foo'
+    end
+    assert_match(/bar/i, err.message) 
+  end
+  
+  context 'with an invalid context file' do
+    before do
+      set_context 'not a file path'  
+    end
+    
+    after do
+      set_context "#{::Rails.root}/config/objects.yml"
+    end
+  
+    it "allows an injected object that is given params to have a non-existent context file" do
+      foo, bar = 'foo', 'bar'
+      controller = InjectedController.new :foo => foo, :bar => bar
+      controller.should_not be_nil
+      controller.foo.should equal(foo)
+      controller.bar.should equal(bar)
+    end
+  
+    it "does not affect a normal object when set to a non-existent context file" do
+      foo, bar = 'foo', 'bar'
+      NormalController.new.should_not be_nil
+    end
+  end
+  
+  it "supports object inheritance" do
+    GalaxyController.new.foo.should be_a_kind_of(TheFooClass)
+    
+    controller = SpiralGalaxyController.new
+    injected_controller = SpiralGalaxyController.new(:foo => "foo", :bar => "bar")
+    SpiralGalaxyController.superclass.should == GalaxyController
+  
+    controller.foo.should be_a_kind_of(TheFooClass)
+    controller.bar.should be_a_kind_of(Bar)
+    injected_controller.foo.should == "foo"
+    injected_controller.bar.should == "bar"
+    
+    controller = MilkyWayGalaxyController.new
+    injected_controller = MilkyWayGalaxyController.new(:foo => "foo", :bar => "bar", :foo_piece_two => "foo2")
+    MilkyWayGalaxyController.superclass.should == SpiralGalaxyController
+    controller.foo.should be_a_kind_of(TheFooClass)
+    assert_kind_of(TheFooClass, controller.foo)
+    controller.bar.should be_a_kind_of(Bar)
+    controller.foo_piece_two.should be_a_kind_of(FooPieceTwo)
+    injected_controller.foo.should == "foo"
+    injected_controller.bar.should == "bar"
+    injected_controller.foo_piece_two.should == "foo2"
+      
+    controller = FutureMilkyWayGalaxyController.new
+    injected_controller = FutureMilkyWayGalaxyController.new(:foo => "foo", :bar => "bar", :foo_piece_two => "foo2")
+    FutureMilkyWayGalaxyController.superclass.should == MilkyWayGalaxyController
+    controller.foo.should be_a_kind_of(TheFooClass)
+    assert_kind_of(TheFooClass, controller.foo)
+    controller.bar.should be_a_kind_of(Bar)
+    controller.foo_piece_two.should be_a_kind_of(FooPieceTwo)
+    injected_controller.foo.should == "foo"
+    injected_controller.bar.should == "bar"
+    injected_controller.foo_piece_two.should == "foo2"
+  end
+
+  it "resets the context to having no built components" do
+    ic = InjectedController.new 
+    ic.foo.should eql(Injection.context['foo'])
+    ic.bar.should eql(Injection.context['bar'])
+  
+    # See that the inject context is being reused, as well as its previously built components:
+    ic2 = InjectedController.new 
+    ic.foo.should eql(Injection.context['foo'])
+    ic.bar.should eql(Injection.context['bar'])
+    ic2.foo.should eql(Injection.context['foo'])
+    ic2.bar.should eql(Injection.context['bar'])
+    ic.foo.foo_piece_one.should eql(Injection.context['foo_piece_one'])
+    ic2.foo.foo_piece_one.should eql(Injection.context['foo_piece_one'])
+       
+    Injection.reset_context
+    Injection.context['foo_piece_one'] = "Mock Foo Piece One"
+       
+    ic3 = InjectedController.new 
+    ic3.foo.should eql(Injection.context['foo'])
+    ic2.foo.should_not eql(Injection.context['foo'])
+    ic.foo.should_not eql(Injection.context['foo'])
+    ic3.foo.foo_piece_one.should == "Mock Foo Piece One"
+  end
+  
+  it 'allows extra inputs to be provided when context is reset' do
+    lambda { injection_context[:old] }.should raise_error(/failed/i)
+    Injection.extra_inputs = {:old => 'spice'}
+    Injection.reset_context
+    injection_context[:old].should == 'spice'
+
+    CommercialController.new.old.should == 'spice'
+  end
+   
+  it "does not reset context after ActionDispatch::Callbacks" do
+    ic = InjectedController.new 
+    ic.foo.should eql(Injection.context['foo'])
+    ic.bar.should eql(Injection.context['bar'])
+  
+    # See that the inject context is being reused, as well as its previously built components:
+    ic2 = InjectedController.new 
+    ic.foo.should eql(Injection.context['foo'])
+    ic.bar.should eql(Injection.context['bar'])
+    ic2.foo.should eql(Injection.context['foo'])
+    ic2.bar.should eql(Injection.context['bar'])
+    ic.foo.foo_piece_one.should eql(Injection.context['foo_piece_one'])
+    ic2.foo.foo_piece_one.should eql(Injection.context['foo_piece_one'])
+  
+    # This will trigger the class reloading
+    ActionDispatch::Callbacks.new(Proc.new {}, false).call({})
+    
+    lambda { Injection.context['foo_piece_one'] = "Mock Foo Piece One" }.should raise_error(/already exists/i)
+  end
+  
+end