ruse 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed5777f12733b8e7e6ed8fc9711354f77b93db58
-  data.tar.gz: 62796162f3a934ff9668cc39f029b7bb6b58947f
+  metadata.gz: c0271481168d1bc9a40d546611f6d3f142eda19a
+  data.tar.gz: 530a4e863f7820be1970720975f57136332ddc0c
 SHA512:
-  metadata.gz: f5a5251bc60259ea099c2cf2f5402f8dd2b642c8b0ae736305ecfc71e28398ac911b6e68c3e017f9267ab7b1b3da5974f563d3f784ff55496e37fd4ab08fdbd1
-  data.tar.gz: 1a1a86387be403adfa675b87b9d0b91f3ea401939da9bd8937dddec6c4a34d3cca3948e86f4bc228f0d98e92ab9244869dcc04850542140b4cbb9768203ceb06
+  metadata.gz: 885a610f5011e855d770749cfb4582115139b6d1a129dc27dba412ee8c0fb6f467fe8e2141bfd1a2549bdec3966cdb1d46a7126f9b83a1363d5f517f07553528
+  data.tar.gz: 251011507aea85f2d8b2417edc9a0b7527167b9db4356ec8d3101b64ad4bb22cd24114eaa39312e3cad6c1072bd228c232bb3d1afc51544e3fd55a73ca30e0d8

data/Rakefile

@@ -8,3 +8,12 @@ Rake::TestTask.new do |t|
   t.test_files = FileList['specs/*_spec.rb']
   t.verbose = true
 end
+
+# from http://erniemiller.org/2014/02/05/7-lines-every-gems-rakefile-should-have/
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'ruse'
+  ARGV.clear
+  IRB.start
+end

data/lib/ruse.rb

@@ -2,7 +2,9 @@ require "ruse/injector"
 require "ruse/version"
 
 module Ruse
-  def self.create_injector
-    Ruse::Injector.new
+  def self.create_injector(config=nil)
+    Ruse::Injector.new.tap do |i|
+      i.configure(config) if config
+    end
   end
 end

data/lib/ruse/injector.rb

@@ -1,32 +1,136 @@
 module Ruse
   class Injector
     def get(identifier)
-      type = resolve_type identifier
-      args = resolve_dependencies type
-      type.new *args
+      identifier = aliases[identifier] || identifier
+      cache_fetch(identifier) do
+        resolver = find_resolver identifier
+        raise UnknownServiceError.new(identifier) unless resolver
+        resolver.build identifier
+      end
     end
 
-    def resolve_type(identifier)
-      type_name = classify(identifier)
-      unless Object.const_defined?(type_name)
-        raise UnknownServiceError.new(type_name)
-      end
-      Object.const_get type_name
+    def configure(settings)
+      configuration.merge! settings
     end
 
-    def resolve_dependencies(type)
-      type.instance_method(:initialize).parameters.map{|_, identifier|
-        get identifier
+    private
+
+    def cache_fetch(identifier, &block)
+      return cache[identifier] if cache.key?(identifier)
+      cache[identifier] = block.call
+    end
+
+    def cache
+      @cache ||= {}
+    end
+
+    def configuration
+      @configuration ||= {
+       aliases:{},
+       values: {},
+      }
+    end
+
+    def aliases
+      configuration[:aliases]
+    end
+
+    def values
+      configuration[:values]
+    end
+
+    def find_resolver(identifier)
+      resolvers.detect {|h|
+        h.can_build?(identifier)
       }
     end
 
-    def classify(term)
+    def resolvers
+      @resolvers ||= [
+        ValueResolver.new(values),
+        TypeResolver.new(self),
+      ]
+    end
+  end
+
+  class UnknownServiceError < StandardError; end
+
+  class ValueResolver
+    attr_reader :values
+
+    def initialize(values)
+      @values = values
+    end
+
+    def can_build?(identifier)
+      values.key? identifier
+    end
+
+    def build(identifier)
+      values.fetch(identifier)
+    end
+  end
+
+  class TypeResolver
+    def initialize(injector)
+      @injector = injector
+    end
+
+    def can_build?(identifier)
+      type_name = self.class.classify(identifier)
+      load_type type_name
+    end
+
+    def build(identifier)
+      type = resolve_type identifier
+      object_factory.build(type)
+    end
+
+    def self.classify(term)
       # lifted from active_support gem: lib/active_support/inflector/methods.rb
       string = term.to_s
       string = string.sub(/^[a-z\d]*/) { $&.capitalize }
       string.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{ $2.capitalize}" }.gsub('/', '::')
     end
+
+    private
+
+    def load_type(type_name)
+      type_name.split('::').reduce(Object){|ns, name|
+        if ns.const_defined? name
+          ns.const_get name
+        end
+      }
+    end
+
+    def object_factory
+      @object_factory ||= ObjectFactory.new(@injector)
+    end
+
+    def resolve_type(identifier)
+      type_name = self.class.classify(identifier)
+      load_type type_name
+    end
   end
 
-  class UnknownServiceError < StandardError; end
+  class ObjectFactory
+    attr_reader :injector
+
+    def initialize(injector)
+      @injector = injector
+    end
+
+    def build(type)
+      args = resolve_dependencies type
+      type.new *args
+    end
+
+    private
+
+    def resolve_dependencies(type)
+      type.instance_method(:initialize).parameters.map{|_, identifier|
+        @injector.get identifier
+      }
+    end
+  end
 end

data/lib/ruse/version.rb

@@ -1,3 +1,3 @@
 module Ruse
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/specs/injector_spec.rb

@@ -3,42 +3,107 @@ require 'minitest/autorun'
 require 'ruse/injector'
 
 describe Ruse::Injector do
-  it "retrieves an instance it can infer from an identifier" do
-    injector = Ruse::Injector.new
-    injector.get("SomeService").must_be_instance_of(SomeService)
+  def injector
+    @injector ||= Ruse::Injector.new
+  end
+
+  it "retrieves instance when identifier is a class name" do
+    injector.get("ServiceA").must_be_instance_of(ServiceA)
+  end
+
+  it "retrieves instance when identifier can be converted to a class name" do
+    injector.get(:service_a).must_be_instance_of(ServiceA)
+  end
+
+  it "retrieves instance when identifier is namespaced class name" do
+    injector.get("Deep::Namespaced::Service").
+      must_be_instance_of(Deep::Namespaced::Service)
   end
 
   it "raises UnknownServiceError for an identifier it cannot resolve" do
-    injector = Ruse::Injector.new
     ->{
       injector.get("cannot_be_resolved")
     }.must_raise(Ruse::UnknownServiceError)
   end
 
   it "populates dependencies for the instance it retrieves" do
-    injector = Ruse::Injector.new
-    instance = injector.get("ServiceConsumer")
-    instance.must_be_instance_of(ServiceConsumer)
-    instance.service1.must_be_instance_of(SomeService)
-    instance.service2.must_be_instance_of(OtherService)
+    instance = injector.get("ConsumerA")
+    instance.must_be_instance_of(ConsumerA)
+    instance.a.must_be_instance_of(ServiceA)
+    instance.b.must_be_instance_of(ServiceB)
+  end
+
+  it "retrieves an instance based on a configured alias" do
+    injector.configure aliases: {special_service: "ServiceA"}
+    injector.get(:special_service).must_be_instance_of(ServiceA)
+  end
+
+  it "returns same instance of a given service within a single request" do
+    instance = injector.get("ConsumerC")
+    instance.ca.a.must_be_same_as(instance.cb.a)
+  end
+
+  it "returns same instance of a given service for life of injector" do
+    instance1 = injector.get("ConsumerC")
+    instance2 = injector.get("ConsumerC")
+    instance1.must_be_same_as(instance2)
+  end
+
+  it "returns different instance of given service for different injectors" do
+    instance1 = Ruse::Injector.new.get("ConsumerC")
+    instance2 = Ruse::Injector.new.get("ConsumerC")
+    instance1.wont_be_same_as(instance2)
   end
 
-  class SomeService; end
-  class OtherService; end
+  it "can retrieve a registered value object" do
+    value_object = Object.new
+    injector.configure values: { example: value_object }
+    injector.get(:example).must_be_same_as(value_object)
+  end
+
+  class ServiceA; end
+  class ServiceB; end
+
+  class ConsumerA
+    attr_reader :a, :b
+    def initialize(service_a, service_b)
+      @a = service_a
+      @b = service_b
+    end
+  end
+
+  class ConsumerB
+    attr_reader :a
+    def initialize(service_a)
+      @a = service_a
+    end
+  end
+
+  class ConsumerC
+    attr_reader :ca, :cb
+    def initialize(consumer_a, consumer_b)
+      @ca = consumer_a
+      @cb = consumer_b
+    end
+  end
 
-  class ServiceConsumer
-    attr_reader :service1, :service2
-    def initialize(some_service, other_service)
-      @service1 = some_service
-      @service2 = other_service
+  module Deep
+    module Namespaced
+      class Service
+      end
     end
   end
+
 end
 
-# classify will be moved
 describe "classify" do
   it "converts an underscored_term to PascalCase" do
-    resolver = Ruse::Injector.new
+    resolver = Ruse::TypeResolver
     resolver.classify("camel_case").must_equal("CamelCase")
   end
+
+  it "echoes back a PascalCase term" do
+    resolver = Ruse::TypeResolver
+    resolver.classify("PascalCase").must_equal("PascalCase")
+  end
 end

data/specs/ruse_spec.rb

@@ -6,4 +6,9 @@ describe Ruse do
   it "can create an injector" do
     Ruse.create_injector.must_be_kind_of Ruse::Injector
   end
+
+  it "passes configuration to the injector" do
+    injector = Ruse.create_injector({values: {answer: 42}})
+    injector.get(:answer).must_equal 42
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruse
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Joshua Flanagan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-04 00:00:00.000000000 Z
+date: 2014-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler