collaborator 0.0.1 → 0.0.2

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/collaborator.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "collaborator"
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sebastian Porto"]

data/lib/collaborator.rb

@@ -1,24 +1,36 @@
 module Collaborator
 
-		def self.included(base)
-			base.extend(ClassMethods)
+	# a dependecy might be a class, an instance or a lambda
+	# evaluate the lambda if necessary
+	def evaluate_dependency(dependency)
+		if dependency.is_a?(Proc)
+			return dependency.call
+		else
+			dependency
 		end
+	end
 
-		module ClassMethods
-			def dependency(name, default_dep)
-				define_method(name) do
-					cached = instance_variable_get("@#{name}")
-					return cached if cached
-					instance_variable_set("@#{name}", default_dep)
-					default_dep
-				end
-				define_method("#{name}=") do |injected|
-					instance_variable_set("@#{name}", injected)
-				end
-				define_method("reset_#{name}") do
-					instance_variable_set("@#{name}", default_dep)
-				end
-			end
+	def dependency(name, default_dep)
+
+		define_method(name) do
+			cached = instance_variable_get("@#{name}")
+			return cached if cached
+			self.send "reset_#{name}"
+		end
+
+		define_method("#{name}=") do |injected|
+			self.prepare_collaborator(name, injected) if self.respond_to?(:prepare_collaborator)
+			instance_variable_set("@#{name}", injected)
 		end
 
+		define_method("reset_#{name}") do
+			evaluated = self.class.evaluate_dependency(default_dep)
+			self.prepare_collaborator(name, evaluated) if self.respond_to?(:prepare_collaborator)
+			instance_variable_set("@#{name}", evaluated)
+			evaluated
+		end
+		
+	end
+
+
 end

data/readme.markdown

@@ -1,7 +1,74 @@
 Collaborator
 ==========
 
-A simple gem for injecting dependencies into classes
+A simple gem for injecting dependencies into classes. I got bored of copying the same code again and again so I made this simple gem. 
+
+Usage
+-----
+
+	class BugFinder
+		...
+	end
+
+	class BugKiller
+		# mixing the Collaborator module
+		extend Collaborator
+		
+		# declare a dependency, pass an instance of the collaborator object
+		dependency :bug_finder, BugFinder.new
+	end
+
+The dependecy method just creates a couple of attribute accesors, so you can use the dependecy like this:
+
+	class BugKiller
+		extend Collaborator 
+		dependency :bug_finder, BugFinder.new
+
+		def run
+			bugs = bug_finder.run
+			...
+		end
+
+	end
+
+### Injecting dependencies
+
+	In your test you just inject a new dependency like so:
+
+	bug_killer = BugKiller.new
+	bug_killer.bug_finder = mocked_bug_finder
+
+### Lazy evaluation
+
+You can also pass a lambda as the second argument, this will defer evaluation of the dependecy until it is actually used
+
+	class BugKiller
+		extend Collaborator 
+		dependency :bug_finder, ->{ BugFinder.new }
+
+		def run
+			bugs = bug_finder.run
+			...
+		end
+
+	end
+
+### Preparing collaborators
+
+Sometimes it is useful to prepare the collaborators in some way before actually using them. To do this just create a method in your class called 'prepare_collaborator'.
+
+	class BugKiller
+		extend Collaborator 
+		dependency :bug_finder, ->{ BugFinder.new }
+
+		# this function receives the name of the collaborator e.g. :bug_finder and the collaborator itself
+		def prepare_collaborator(name, collaborator)
+			collaborator.log_enable = true
+		end
+
+	end
+
+When a dependency is injected e.g. bug_killer.bug_finder = mocked_bug_finder this method is also called on the injected dependency
 
 Copyright
 ----------

data/spec/collaborator_spec.rb

@@ -1,17 +1,23 @@
 require 'spec_helper'
 require 'collaborator'
+require 'ostruct'
 
 describe 'Collaborator' do
 
 	let(:injected_collaborator)	{ double.as_null_object }
 	let(:subject) { Subject.new }
 
-	class Service
+	class Collaborator1
+		attr_accessor :foo
+		def run
+			true
+		end
 	end
 
 	class Subject
-		include Collaborator
-		dependency :collaborator, Service.new
+		extend Collaborator
+		dependency :collaborator1, Collaborator1.new
+		dependency :collaborator2, ->{ Collaborator1.new }
 	end
 
 	it "mixes in the module" do
@@ -19,30 +25,89 @@ describe 'Collaborator' do
 	end
 
 	it "creates a getter method" do
-		expect(subject).to respond_to(:collaborator)
+		expect(subject).to respond_to(:collaborator1)
 	end
 
 	it "creates a setter method" do
-		expect(subject).to respond_to(:collaborator=)
+		expect(subject).to respond_to(:collaborator1=)
 	end
 
 	it "creates a reset method" do
-		expect(subject).to respond_to(:reset_collaborator)
+		expect(subject).to respond_to(:reset_collaborator1)
 	end
 
-	it "returns the default collaborator" do
-		expect(subject.collaborator).to be_instance_of(Service)
+	it "reached the collaborator object" do
+		expect(subject.collaborator1.run).to be_true
+	end
+
+	it "returns the default collaborator1" do
+		expect(subject.collaborator1).to be_instance_of(Collaborator1)
 	end
 
 	it "can inject the dependency" do
-		subject.collaborator = injected_collaborator
-		expect(subject.collaborator).to eq(injected_collaborator)
+		subject.collaborator1 = injected_collaborator
+		expect(subject.collaborator1).to eq(injected_collaborator)
 	end
 
 	it "can reset the dependency" do
-		subject.collaborator = injected_collaborator
-		subject.reset_collaborator
-		expect(subject.collaborator).to be_instance_of(Service)
+		subject.collaborator1 = injected_collaborator
+		subject.reset_collaborator1
+		expect(subject.collaborator1).to be_instance_of(Collaborator1)
 	end
 
+	it "accepts a lambda" do
+		expect(subject).to respond_to(:collaborator2)
+		expect(subject.collaborator2.run).to be_true
+	end
+
+	describe "#prepare_collaborator" do
+
+		let(:subject2) { SubjectWithPrepareCollaborator.new }
+
+		class SubjectWithPrepareCollaborator
+			extend Collaborator
+			dependency :collaborator1, Collaborator1.new
+
+			def prepare_collaborator(name, collaborator)
+				collaborator.foo = 9
+			end
+		end
+
+		it 'gets call when using the dependency' do
+			subject2.should_receive(:prepare_collaborator)
+			subject2.collaborator1
+		end
+
+		it 'passes the name of the collaborator' do
+			subject2.stub(:prepare_collaborator) do |name, collaborator|
+				expect(name).to eq(:collaborator1)
+			end
+			subject2.collaborator1
+		end
+
+		it 'passes the reference to the collaborator' do
+			subject2.stub(:prepare_collaborator) do |name, collaborator|
+				expect(collaborator).to be_instance_of(Collaborator1)
+			end
+			subject2.collaborator1
+		end
+
+		it 'gets call when a dependency is injected' do
+			subject2.should_receive(:prepare_collaborator)
+			subject2.collaborator1 = injected_collaborator
+		end
+
+		it "runs the code in the method" do
+			expect(subject2.collaborator1.foo).to eq(9)
+		end
+
+		it "runs the code in the method for an injected collaborator" do
+			injected = OpenStruct.new
+			subject2.collaborator1 = injected
+			expect(injected.foo).to eq(9)
+		end
+
+	end
+
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: collaborator
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -125,7 +125,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3557498814883905141
+      hash: 2528418177998634082
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: