jeeves 0.1.0 → 0.2.0

data/lib/jeeves/{import_callable.rb → resolve_callable.rb}

@@ -1,9 +1,10 @@
 module Jeeves
-  class ImportCallable
-    def self.call(name, scope)
+  class ResolveCallable
+    def self.call(scope, name)
       class_name = camelize(name)
       if scope.const_defined?(class_name)
-        scope.const_get(class_name).new
+        callable = scope.const_get(class_name)
+        callable.respond_to?(:call) ? callable : callable.new
       end
     end
 

data/lib/jeeves/{import_constant.rb → resolve_constant.rb}

@@ -1,6 +1,6 @@
 module Jeeves
-  class ImportConstant
-    def self.call(name, scope)
+  class ResolveConstant
+    def self.call(scope, name)
       const_name = name.upcase
       if scope.const_defined?(const_name)
         const_value = scope.const_get(const_name)

data/lib/jeeves/resolve_dependency.rb

@@ -0,0 +1,14 @@
+module Jeeves
+  class ResolveDependency
+    RESOLVERS = [ResolveMethod, ResolveCallable, ResolveConstant, ResolveMock]
+
+    def self.call(scope, name)
+      delegator = nil
+      RESOLVERS.each do |resolver|
+        break if delegator = resolver.call(scope, name)
+      end
+      delegator or raise ArgumentError, "Dependency '#{name}' was not found in #{scope}"
+    end
+  end
+end
+

data/lib/jeeves/{import_method.rb → resolve_method.rb}

@@ -1,6 +1,6 @@
 module Jeeves
-  class ImportMethod
-    def self.call(name, scope)
+  class ResolveMethod
+    def self.call(scope, name)
       if scope.respond_to?(name)
         scope.method(name)
       end

data/lib/jeeves/resolve_mock.rb

@@ -0,0 +1,22 @@
+module Jeeves
+  class ResolveMock
+    def self.call(scope, name)
+      if in_test_framework?
+        lambda do |*args, &block|
+          if Jeeves.respond_to?(name)
+            Jeeves.public_send(name, *args, &block)
+          else
+            raise ArgumentError, "Dependency '#{name}' was not found in #{scope}"
+          end
+        end
+      end
+    end
+
+  private
+
+    def self.in_test_framework?
+      defined?(RSpec) || defined?(Test::Unit)
+    end
+  end
+end
+

data/lib/jeeves/version.rb

@@ -1,4 +1,4 @@
 module Jeeves
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end
 

data/lib/jeeves.rb

@@ -1,18 +1,32 @@
 module Jeeves
-  autoload :FindDependencies, "jeeves/find_dependencies"
-  autoload :ImportMethod,     "jeeves/import_method"
-  autoload :ImportCallable,   "jeeves/import_callable"
-  autoload :ImportConstant,   "jeeves/import_constant"
+  autoload :ResolveDependency, "jeeves/resolve_dependency"
+  autoload :ResolveMethod,     "jeeves/resolve_method"
+  autoload :ResolveCallable,   "jeeves/resolve_callable"
+  autoload :ResolveConstant,   "jeeves/resolve_constant"
+  autoload :ResolveMock,       "jeeves/resolve_mock"
 
   def import(*args)
-    options = args.last.respond_to?(:fetch) ? args.pop : {}
+    options = args.last.is_a?(Hash) ? args.pop : {}
     scope = options.fetch(:from) do
       module_names = ancestors.first.to_s.split('::')[0..-2]
       module_names.inject(Object) { |m, c| m.const_get(c) }
     end
-    FindDependencies.call(scope, *args).each do |name, delegator|
-      define_method(name) do |*args, &block|
-        delegator.call(*args, &block)
+    args.each do |name|
+      if name.is_a?(Array)
+        external_name, internal_name = *name
+      else
+        external_name = internal_name = name
+      end
+      if options[:lazy]
+        define_method(internal_name) do |*args, &block|
+          delegator = ResolveDependency.call(scope, external_name)
+          delegator.call(*args, &block)
+        end
+      else
+        delegator = ResolveDependency.call(scope, external_name)
+        define_method(internal_name) do |*args, &block|
+          delegator.call(*args, &block)
+        end
       end
     end
   end

data/spec/{acceptance → integration}/import_spec.rb

@@ -20,10 +20,18 @@ module JeevesTestApp
       :polo
     end
 
+    class StaticCallable
+      def self.call(*args, &block)
+        block.call(args.map(&:to_s).join("*"))
+      end
+    end
+
     class TestSubject
       extend Jeeves
       import :my_method, :my_callable, :my_constant, from: OtherScope
-      import :marco
+      import :marco, :static_callable
+      import :lazy_method, lazy: true
+      import [:marco, :say_polo]
     end
   end
 end
@@ -36,6 +44,11 @@ describe "import" do
     result.should == "FOO-BAR-BAZ"
   end
 
+  it "imports a static callable" do
+    result = subject.static_callable(:foo, :bar, :baz) { |s| s.capitalize }
+    result.should == "Foo*bar*baz"
+  end
+
   it "imports a callable" do
     result = subject.my_callable(:foo, :bar, :baz) { |s| s.reverse }
     result.should == "zab+rab+oof"
@@ -49,7 +62,22 @@ describe "import" do
     subject.marco.should == :polo
   end
 
+  it "resolves lazy dependencies at call time" do
+    JeevesTestApp::InnerScope.stub(:lazy_method) { :snooze }
+    subject.lazy_method.should == :snooze
+  end
+
+  it "resolves non-lazy dependencies at import time" do
+    JeevesTestApp::InnerScope.stub(:marco) { :not_polo }
+    subject.marco.should == :polo
+  end
+
+  it "imports under an alias" do
+    subject.say_polo.should == :polo
+  end
+
   it "raises an error if no importers can find the dependency" do
+    Jeeves::ResolveMock.stub(:call) # to avoid RSpec integration
     expect { subject.class.import :unknown, from: JeevesTestApp::OtherScope }.
       to raise_error(ArgumentError,
            "Dependency 'unknown' was not found in JeevesTestApp::OtherScope")

data/spec/integration/rspec_spec.rb

@@ -0,0 +1,29 @@
+require "jeeves"
+
+module JeevesTestApp
+  module InnerScope
+    class TestSubject
+      extend Jeeves
+      import :my_mock
+
+      def call
+        my_mock(42)
+      end
+    end
+  end
+end
+
+describe "rspec integration" do
+  subject { JeevesTestApp::InnerScope::TestSubject.new }
+
+  it "wires dependencies directly to Jeeves for easy stubbing" do
+    Jeeves.stub(:my_mock).with(42) { "The answer?" }
+    subject.call.should == "The answer?"
+  end
+
+  it "raises an error if the dependency is not mocked" do
+    expect { subject.call }.to raise_error(ArgumentError,
+      "Dependency 'my_mock' was not found in JeevesTestApp::InnerScope")
+  end
+end
+

data/spec/unit/resolve_callable_spec.rb

@@ -0,0 +1,41 @@
+require "jeeves/resolve_callable"
+
+module JeevesTestApp
+  module CallableTest
+    class StaticCallable
+      def self.call(*args, &block)
+        block.call(args.map(&:to_s).join("*"))
+      end
+    end
+
+    class MyCallable
+      def call(*args, &block)
+        block.call(args.map(&:to_s).join("-"))
+      end
+    end
+  end
+end
+
+module Jeeves
+  describe ResolveCallable do
+
+    it "returns an anonymous function which delegates to the static call method of the callable" do
+      delegator = ResolveCallable.call(JeevesTestApp::CallableTest, :static_callable)
+      result = delegator.call(:foo, :bar, :baz) { |s| s.capitalize }
+      result.should == "Foo*bar*baz"
+    end
+
+    it "returns an anonymous function which delegates to a new instance of the callable" do
+      delegator = ResolveCallable.call(JeevesTestApp::CallableTest, :my_callable)
+      result = delegator.call(:foo, :bar, :baz) { |s| s.upcase }
+      result.should == "FOO-BAR-BAZ"
+    end
+
+    it "returns nil if the the callable class is not defined" do
+      delegator = ResolveCallable.call(JeevesTestApp::CallableTest, :undefined_callable)
+      delegator.should be(nil)
+    end
+
+  end
+end
+

data/spec/unit/{import_constant_spec.rb → resolve_constant_spec.rb}

@@ -1,4 +1,4 @@
-require "jeeves/import_constant"
+require "jeeves/resolve_constant"
 
 module JeevesTestApp
   module ConstantTest
@@ -7,15 +7,15 @@ module JeevesTestApp
 end
 
 module Jeeves
-  describe ImportConstant do
+  describe ResolveConstant do
 
     it "returns an anonymous function which returns the constant" do
-      delegator = ImportConstant.call(:my_constant, JeevesTestApp::ConstantTest)
+      delegator = ResolveConstant.call(JeevesTestApp::ConstantTest, :my_constant)
       delegator.call.should == "MY VALUE"
     end
 
     it "returns nil if the constant is not defined" do
-      delegator = ImportConstant.call(:undefined_constant, JeevesTestApp::ConstantTest)
+      delegator = ResolveConstant.call(JeevesTestApp::ConstantTest, :undefined_constant)
       delegator.should be(nil)
     end
 

data/spec/unit/resolve_dependency_spec.rb

@@ -0,0 +1,48 @@
+module Jeeves
+  class ResolveMethod; end
+  class ResolveCallable; end
+  class ResolveConstant; end
+  class ResolveMock; end
+end
+require "jeeves/resolve_dependency"
+
+module Jeeves
+  describe ResolveDependency do
+    let(:scope) { stub("scope", to_s: "ScopeStub") }
+    let(:delegator) { stub("delegator") }
+
+    before do
+      ResolveMethod.stub(:call)
+      ResolveCallable.stub(:call)
+      ResolveConstant.stub(:call)
+    end
+
+    it "maps dependency names to anonymous delegator functions" do
+      ResolveMethod.stub(:call).with(scope, :my_dependency) { delegator }
+      ResolveDependency.call(scope, :my_dependency).should be(delegator)
+    end
+
+    it "uses ResolveCallable if ResolveMethod fails" do
+      ResolveCallable.stub(:call).with(scope, :my_dependency) { delegator }
+      ResolveDependency.call(scope, :my_dependency).should be(delegator)
+    end
+
+    it "uses ResolveConstant if ResolveMethod and ResolveCallable fail" do
+      ResolveConstant.stub(:call).with(scope, :my_dependency) { delegator }
+      ResolveDependency.call(scope, :my_dependency).should be(delegator)
+    end
+
+    it "uses ResolveMock as a last resort" do
+      ResolveMock.stub(:call).with(scope, :my_dependency) { delegator }
+      ResolveDependency.call(scope, :my_dependency).should be(delegator)
+    end
+
+    it "raises an error if all importers fail" do
+      Jeeves::ResolveMock.stub(:call) # to avoid RSpec integration
+      expect { ResolveDependency.call(scope, :my_dependency) }.
+        to raise_error(ArgumentError,
+          "Dependency 'my_dependency' was not found in ScopeStub")
+    end
+  end
+end
+

data/spec/unit/{import_method_spec.rb → resolve_method_spec.rb}

@@ -1,4 +1,4 @@
-require "jeeves/import_method"
+require "jeeves/resolve_method"
 
 module JeevesTestApp
   module MethodTest
@@ -9,16 +9,16 @@ module JeevesTestApp
 end
 
 module Jeeves
-  describe ImportMethod do
+  describe ResolveMethod do
 
     it "returns an anonymous function which delegates to the method" do
-      delegator = ImportMethod.call(:my_method, JeevesTestApp::MethodTest)
+      delegator = ResolveMethod.call(JeevesTestApp::MethodTest, :my_method)
       result = delegator.call(:foo, :bar, :baz) { |s| s.upcase }
       result.should == "FOO-BAR-BAZ"
     end
 
     it "returns nil if the scope does not respond to the method" do
-      delegator = ImportMethod.call(:undefined_method, JeevesTestApp::MethodTest)
+      delegator = ResolveMethod.call(JeevesTestApp::MethodTest, :undefined_method)
       delegator.should be(nil)
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jeeves
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -35,16 +35,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/jeeves.rb
-- lib/jeeves/import_callable.rb
-- lib/jeeves/import_constant.rb
-- lib/jeeves/find_dependencies.rb
-- lib/jeeves/import_method.rb
+- lib/jeeves/resolve_dependency.rb
 - lib/jeeves/version.rb
-- spec/acceptance/import_spec.rb
-- spec/unit/import_callable_spec.rb
-- spec/unit/import_method_spec.rb
-- spec/unit/find_dependencies_spec.rb
-- spec/unit/import_constant_spec.rb
+- lib/jeeves/resolve_constant.rb
+- lib/jeeves/resolve_method.rb
+- lib/jeeves/resolve_mock.rb
+- lib/jeeves/resolve_callable.rb
+- spec/integration/rspec_spec.rb
+- spec/integration/import_spec.rb
+- spec/unit/resolve_method_spec.rb
+- spec/unit/resolve_callable_spec.rb
+- spec/unit/resolve_constant_spec.rb
+- spec/unit/resolve_dependency_spec.rb
 homepage: http://github.com/ronhopper/jeeves
 licenses: []
 post_install_message: 
@@ -70,8 +72,9 @@ signing_key:
 specification_version: 3
 summary: Jeeves is a dependency management library for Ruby.
 test_files:
-- spec/acceptance/import_spec.rb
-- spec/unit/import_callable_spec.rb
-- spec/unit/import_method_spec.rb
-- spec/unit/find_dependencies_spec.rb
-- spec/unit/import_constant_spec.rb
+- spec/integration/rspec_spec.rb
+- spec/integration/import_spec.rb
+- spec/unit/resolve_method_spec.rb
+- spec/unit/resolve_callable_spec.rb
+- spec/unit/resolve_constant_spec.rb
+- spec/unit/resolve_dependency_spec.rb

data/lib/jeeves/find_dependencies.rb

@@ -1,22 +0,0 @@
-module Jeeves
-  class FindDependencies
-    def self.call(scope, *names)
-      names.inject({}) do |dependencies, name|
-        dependencies.update(name => delegator_for(name, scope))
-      end
-    end
-
-  private
-
-    IMPORTERS = [ImportMethod, ImportCallable, ImportConstant]
-
-    def self.delegator_for(name, scope)
-      delegator = nil
-      IMPORTERS.each do |importer|
-        break if delegator = importer.call(name, scope)
-      end
-      delegator or raise ArgumentError, "Dependency '#{name}' was not found in #{scope}"
-    end
-  end
-end
-

data/spec/unit/find_dependencies_spec.rb

@@ -1,57 +0,0 @@
-module Jeeves
-  class ImportMethod; end
-  class ImportCallable; end
-  class ImportConstant; end
-end
-require "jeeves/find_dependencies"
-
-module Jeeves
-  describe FindDependencies do
-    let(:scope) { stub("scope", to_s: "ScopeStub") }
-    let(:delegator) { stub("delegator") }
-
-    before do
-      ImportMethod.stub(:call)
-      ImportCallable.stub(:call)
-      ImportConstant.stub(:call)
-    end
-
-    it "maps dependency names to anonymous delegator functions" do
-      ImportMethod.stub(:call).with(:my_dependency, scope) { delegator }
-      FindDependencies.call(scope, :my_dependency).should == {
-        my_dependency: delegator
-      }
-    end
-
-    it "maps multiple dependencies" do
-      delegator2 = stub("delegator 2")
-      ImportMethod.stub(:call).with(:my_dep_1, scope) { delegator }
-      ImportMethod.stub(:call).with(:my_dep_2, scope) { delegator2 }
-      FindDependencies.call(scope, :my_dep_1, :my_dep_2).should == {
-        my_dep_1: delegator,
-        my_dep_2: delegator2
-      }
-    end
-
-    it "uses ImportCallable if ImportMethod fails" do
-      ImportCallable.stub(:call).with(:my_dependency, scope) { delegator }
-      FindDependencies.call(scope, :my_dependency).should == {
-        my_dependency: delegator
-      }
-    end
-
-    it "uses ImportConstant if ImportMethod and ImportCallable fail" do
-      ImportConstant.stub(:call).with(:my_dependency, scope) { delegator }
-      FindDependencies.call(scope, :my_dependency).should == {
-        my_dependency: delegator
-      }
-    end
-
-    it "raises an error if all importers fail" do
-      expect { FindDependencies.call(scope, :my_dependency) }.
-        to raise_error(ArgumentError,
-          "Dependency 'my_dependency' was not found in ScopeStub")
-    end
-  end
-end
-

data/spec/unit/import_callable_spec.rb

@@ -1,29 +0,0 @@
-require "jeeves/import_callable"
-
-module JeevesTestApp
-  module CallableTest
-    class MyCallable
-      def call(*args, &block)
-        block.call(args.map(&:to_s).join("-"))
-      end
-    end
-  end
-end
-
-module Jeeves
-  describe ImportCallable do
-
-    it "returns an anonymous function which delegates to a new instance of the callable" do
-      delegator = ImportCallable.call(:my_callable, JeevesTestApp::CallableTest)
-      result = delegator.call(:foo, :bar, :baz) { |s| s.upcase }
-      result.should == "FOO-BAR-BAZ"
-    end
-
-    it "returns nil if the the callable class is not defined" do
-      delegator = ImportCallable.call(:undefined_callable, JeevesTestApp::CallableTest)
-      delegator.should be(nil)
-    end
-
-  end
-end
-