objectify 0.0.7 → 0.1.0

data/README.md

@@ -86,7 +86,7 @@ Objectify has two primary components:
         end
       ```
 
-  2. A dependency injection framework. Objectify automatically injects dependencies into objects it manages based on parameter names. So, if you have a service method signature like  `PictureCreationService#call(params)`, objectify will automatically inject the request's params when it calls that method. It's very simple to create custom injections by implementing Resolver classes. More on that below.
+  2. A dependency injection framework. Objectify automatically injects dependencies into objects it manages based on parameter names. So, if you have a service method signature like  `PictureCreationService#call(params)`, objectify will automatically inject the request's params when it calls that method. It's very simple to create custom injections. More on that below.
 
 
 ## What if I have a bunch of existing rails code?
@@ -140,7 +140,47 @@ end
 
 ## Custom Injections
 
-Several of the above methods have parameters named `current_user`. By default, objectify won't know how to inject a parameter by that name, so it'll raise an error when it encounters one. Here's how to create a custom resolver for it that'll automatically get found by name.
+There are a few ways to customize what gets injected when. By default, when objectify sees a parameter called `something`, it'll first look to see if something is specifically configured for that name, then it'll attempt to satisfy it by calling `Something.new`. If that doesn't exist, it'll try `SomethingResolver.new`, which it'll then call `#call` on. If that doesn't exist, it'll raise an error.
+
+You can configure the injector in 3 ways. The first is used to specify an implemenation.
+
+Let's say you had a PictureCreationService whose constructor took a parameter called `storage`.
+
+```ruby
+class PictureCreationService
+  def initialize(storage)
+    @storage = storage
+  end
+
+  # ... more code ...
+end
+```
+
+You can tell the injector what to supply for that parameter like this:
+
+```ruby
+objectify.implementations :storage => :s3_storage
+```
+
+Another option is to specify a value. For example, you might have a service class with a page_size parameter.
+
+```ruby
+class PicturesIndexService
+  def initialize(page_size)
+    @page_size = page_size
+  end
+
+  # ... more code ...
+end
+```
+
+You can tell the injector what size to make the pages like this:
+
+```ruby
+objectify.values :page_size => 20
+```
+
+Finally, you can tell objectify about `resolvers`. Resolvers are objects that know how to fulfill parameters. For example, several of the above methods have parameters named `current_user`. Here's how to create a custom resolver for it that'll automatically get found by name.
 
 ```ruby
 # app/resolvers/current_user_resolver.rb
@@ -156,6 +196,18 @@ class CurrentUserResolver
 end
 ```
 
+If you wanted to explicitly configure that resolver, you'd do it like this:
+
+```ruby
+objectify.resolvers :current_user => :current_user
+```
+
+If that resolver was in the namespace ObjectifyAuth, you'd configure it like this:
+
+```ruby
+objectify.resolvers :current_user => "objectify_auth/current_user"
+```
+
 ### Why did you constructor-inject the User constant in to the CurrentUserResolver?
   
 Because that makes it possible to test in isolation.

data/lib/objectify.rb

@@ -2,6 +2,3 @@ module Objectify
   module Rails
   end
 end
-
-require "objectify/rails/railtie"
-

data/lib/objectify/config/context.rb

@@ -1,35 +1,36 @@
 require "objectify/config/action"
+require "objectify/config/injectables"
 require "objectify/config/policies"
 require "objectify/injector"
 require "objectify/instantiator"
-require "objectify/resolver"
-require "objectify/resolver_locator"
 require "objectify/executor"
 
 module Objectify
   module Config
     class Context
-      DONT_RELOAD = [:@objectify_controller].freeze
+      DONT_RELOAD = [:@objectify_controller,
+                     :@policies_factory,
+                     :@action_factory].freeze
 
       attr_reader :policy_responders, :defaults, :actions, :policies
-      attr_writer :injector, :resolver_locator, :instantiator, :executor,
-                  :locator, :objectify_controller
+      attr_writer :injector, :instantiator, :executor,
+                  :injectables, :objectify_controller
 
       def initialize(policies_factory = Policies, action_factory = Action)
         @policies_factory = policies_factory
         @action_factory   = action_factory
+      end
 
-        @policy_responders = {}
-        @defaults = {}
-        @actions = {}
+      def policy_responders
+        @policy_responders ||= {}
       end
 
       def append_policy_responders(responders)
-        @policy_responders.merge!(responders)
+        policy_responders.merge!(responders)
       end
 
       def policy_responder(policy)
-        @policy_responders[policy] ||
+        policy_responders[policy] ||
           raise(ArgumentError, "Can't find a responder for #{policy}.")
       end
 
@@ -41,38 +42,52 @@ module Objectify
         @policies = @policies_factory.new(defaults)
       end
 
+      def actions
+        @actions ||= {}
+      end
+
       def append_action(action)
-        @actions[action.route] = action
+        actions[action.route] = action
       end
 
       def action(route)
-        @actions[route] ||
+        actions[route] ||
           raise(ArgumentError, "No action matching #{route} was found.")
       end
 
       def legacy_action(route)
-        @actions[route] ||
+        actions[route] ||
           @action_factory.new(route.resource, route.action, {}, policies)
       end
 
       def injector
-        @injector ||= Injector.new(resolver_locator)
+        @injector ||= Injector.new(injectables)
       end
 
-      def append_resolutions(opts)
+      def injectables
+        @injectables ||= Injectables.new
+      end
+
+      def append_values(opts)
         opts.each do |k,v|
-          locator.add(k, v)
+          injectables.add_value(k, v)
         end
       end
 
-      def locator
-        @locator ||= NamedValueResolverLocator.new(NameTranslationResolver)
+      def append_implementations(opts)
+        opts.each do |k,v|
+          injectables.add_implementation(k, v)
+        end
+      end
+
+      def append_resolvers(opts)
+        opts.each do |k,v|
+          injectables.add_resolver(k, v)
+        end
       end
 
-      def resolver_locator
-        @resolver_locator ||= MultiResolverLocator.new(
-                                [locator, ConstResolverLocator.new]
-                              )
+      def resolvers
+        @resolvers ||= NamedValueResolverLocator.new(NameTranslationResolver)
       end
 
       def instantiator

data/lib/objectify/config/injectables.rb

@@ -0,0 +1,36 @@
+module Objectify
+  module Config
+    class Injectables
+      attr_reader :config
+      attr_writer :context
+
+      def initialize(config = {})
+        @config = config
+      end
+
+      def add_resolver(name, value)
+        @config[name] = [:resolver, value]
+      end
+
+      def add_value(name, value)
+        @config[name] = [:value, value]
+      end
+
+      def add_implementation(name, value)
+        @config[name] = [:implementation, value]
+      end
+
+      def get(name)
+        @config[name] || context[name] || [:unknown, name]
+      end
+
+      def context
+        @context && @context.config || {}
+      end
+
+      def merge(other)
+        self.class.new @config.merge(other.config)
+      end
+    end
+  end
+end

data/lib/objectify/injector.rb

@@ -4,24 +4,40 @@ module Objectify
   class Injector
     include Instrumentation
 
-    def initialize(resolver_locator)
-      @resolver_locator = resolver_locator
+    attr_writer :config
+
+    def initialize(config)
+      @config = config
     end
 
     def call(object, method)
       payload = {:object => object, :method => method}
       instrument("inject.objectify", payload) do |payload|
         method_obj           = method_object(object, method)
-        resolvers            = method_obj.parameters.map do |reqd, name|
-          @resolver_locator.call(name) if reqd == :req
+        injectables          = method_obj.parameters.map do |reqd, name|
+          @config.get(name) if reqd == :req
         end.compact
-        arguments            = resolvers.map do |resolver|
-          call(resolver, :call)
+        arguments            = injectables.map do |type, value|
+          if type == :unknown
+            type, value = unknown_value_to_injectable(value)
+          end
+
+          if type == :resolver
+            resolver_klass = [value, :resolver].join("_").classify.constantize
+            call(call(resolver_klass, :new), :call)
+          elsif type == :implementation
+            implementation_klass = value.to_s.classify.constantize
+            call(implementation_klass, :new)
+          elsif type == :value
+            value
+          else
+            raise ArgumentError, "Unknown injectable type: #{type}."
+          end
         end
 
-        payload[:parameters] = method_obj.parameters
-        payload[:resolvers]  = resolvers
-        payload[:arguments]  = arguments
+        payload[:parameters]  = method_obj.parameters
+        payload[:injectables] = injectables
+        payload[:arguments]   = arguments
 
         object.send(method, *arguments)
       end
@@ -35,5 +51,17 @@ module Objectify
           object.method(method)
         end
       end
+
+      def unknown_value_to_injectable(value)
+        [nil, :resolver].each do |suffix|
+          begin
+            [value, suffix].compact.join("_").classify.constantize
+            return [suffix.nil? ? :implementation : suffix, value]
+          rescue NameError => e
+          end
+        end
+
+        raise ArgumentError, "Can't figure out how to inject #{value}."
+      end
   end
 end

data/lib/objectify/rails/controller.rb

@@ -1,4 +1,4 @@
-require "objectify/resolver_locator"
+require "objectify/config/policies"
 require "objectify/executor"
 require "objectify/policy_chain_executor"
 require "objectify/instrumentation"
@@ -20,17 +20,17 @@ module Objectify
           objectify.injector
         end
 
-        def request_resolver
-          klass = Objectify::NamedValueResolverLocator
-          @request_resolver ||= klass.new.tap do |resolver|
-            resolver.add(:controller, self)
-            resolver.add(:params, params)
-            resolver.add(:session, session)
-            resolver.add(:cookies, cookies)
-            resolver.add(:request, request)
-            resolver.add(:response, response)
-            resolver.add(:flash, flash)
-            resolver.add(:renderer, Renderer.new(self))
+        def request_injectables_context
+          klass = Objectify::Config::Injectables
+          @request_injectables_context ||= klass.new.tap do |injectables_context|
+            injectables_context.add_value(:controller, self)
+            injectables_context.add_value(:params, params)
+            injectables_context.add_value(:session, session)
+            injectables_context.add_value(:cookies, cookies)
+            injectables_context.add_value(:request, request)
+            injectables_context.add_value(:response, response)
+            injectables_context.add_value(:flash, flash)
+            injectables_context.add_value(:renderer, Renderer.new(self))
           end
         end
         
@@ -65,14 +65,14 @@ module Objectify
         end
 
         def objectify_around_filter
-          objectify.resolver_locator.context(request_resolver)
+          objectify.injectables.context = request_injectables_context
           yield
-          objectify.resolver_locator.clear_context
+          objectify.injectables.context = nil
         end
 
         def execute_objectify_action
           service_result = objectify_executor.call(action.service, :service)
-          request_resolver.add(:service_result, service_result)
+          request_injectables_context.add_value(:service_result, service_result)
 
           objectify_executor.call(action.responder, :responder)
         end

data/lib/objectify/rails/routing.rb

@@ -38,8 +38,16 @@ module Objectify
           @application.objectify.append_policy_responders(options)
         end
 
-        def resolutions(options)
-          @application.objectify.append_resolutions(options)
+        def implementations(options)
+          @application.objectify.append_implementations(options)
+        end
+
+        def resolvers(options)
+          @application.objectify.append_resolvers(options)
+        end
+
+        def values(options)
+          @application.objectify.append_values(options)
         end
 
         def legacy_action(controller, actions, options)

data/lib/objectify/version.rb

@@ -1,3 +1,3 @@
 module Objectify
-  VERSION = "0.0.7"
+  VERSION = "0.1.0"
 end

data/spec/config/context_spec.rb

@@ -70,19 +70,6 @@ describe "Objectify::Config::Context" do
     end
   end
 
-  context "appending resolutions" do
-    before do
-      @locator = stub("ResolverLocator", :add => nil)
-      @context = Objectify::Config::Context.new(nil)
-      @context.locator = @locator
-      @context.append_resolutions :something => String.new
-    end
-
-    it "adds them to a locator it has" do
-      @locator.should have_received(:add).with(:something, String.new)
-    end
-  end
-
   context "the legacy_action" do
     before do
       @action = stub("Action")

data/spec/config/injectables_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "objectify/config/injectables"
+
+describe "Objectify::Config::Injectables" do
+  before do
+    @injectables = Objectify::Config::Injectables.new
+  end
+
+  it "accepts new resolvers" do
+    @injectables.add_resolver(:a, :b)
+    @injectables.get(:a).should == [:resolver, :b]
+  end
+
+  it "accepts new implementations" do
+    @injectables.add_implementation(:a, :b)
+    @injectables.get(:a).should == [:implementation, :b]
+  end
+
+  it "accepts new values" do
+    @injectables.add_value(:a, :b)
+    @injectables.get(:a).should == [:value, :b]
+  end
+
+  it "returns unknown if the value is unknown" do
+    @injectables.get(:c).should == [:unknown, :c]
+  end
+
+  it "can merge configs" do
+    @injectables = Objectify::Config::Injectables.new :a => [:implementation, :b]
+    @injectables2 = Objectify::Config::Injectables.new :a => [:implementation, :c]
+    @injectables.merge(@injectables2).get(:a).should == [:implementation, :c]
+  end
+
+  it "accepts a context that it falls back to" do
+    @context = Objectify::Config::Injectables.new
+    @context.add_value :controller, :something
+    @injectables.context = @context
+    @injectables.get(:controller).should == [:value, :something]
+  end
+end

data/spec/injector_spec.rb

@@ -18,6 +18,11 @@ describe "Objectify::Injector" do
     end
 
     def optional_arg(asdf=true)
+      "other value"
+    end
+
+    def no_args
+      "value"
     end
   end
 
@@ -34,55 +39,64 @@ describe "Objectify::Injector" do
     end
   end
 
-  describe "the simple case" do
-    before do
-      @dependency       = stub("Dependency")
-      @resolver         = SimpleResolver.new(@dependency)
-      @resolver_locator = stub("ResolverLocator", :call => @resolver)
-      @injector         = Objectify::Injector.new(@resolver_locator)
-    end
-
-    it "can constructor inject based on method name using a simple resolver" do
-      @injector.call(MyInjectedClass, :new).some_dependency.should == @dependency
-    end
+  before do
+    @config = stub("Config", :get => nil)
+    @injector = Objectify::Injector.new(@config)
+  end
 
-    it "can method inject based on method name using a simple resolver" do
-      object = MyInjectedClass.new(nil)
-      @injector.call(object, :call).should == @dependency
+  context "when there aren't any parameters" do
+    it "can call the method" do
+      obj = MyInjectedClass.new(nil)
+      @injector.call(obj, :no_args).should == "value"
     end
 
-    it "calls the resolver_locator to get the resolver" do
-      @injector.call(MyInjectedClass, :new)
-      @resolver_locator.should have_received(:call).with(:some_dependency)
+    it "can call a method with optional parameters" do
+      obj = MyInjectedClass.new(nil)
+      @injector.call(obj, :optional_arg).should == "other value"
     end
+  end
 
-    it "supports optional arguments" do
-      obj = MyInjectedClass.new("Asdf")
-      lambda { @injector.call(obj, :optional_arg) }.should_not raise_error
+  context "when there is a simple value parameter" do
+    it "injects that value" do
+      @config.stubs(:get).with(:params).returns([:value, 1])
+      obj = MyInjectedClass.new(nil)
+      @injector.call(obj, :requires_params).should == 1
     end
   end
 
-  class ParamsResolver
-    def name
-      :params
+  context "when there is a resolver param" do
+    it "instantiates and calls the resolver" do
+      @config.stubs(:get).with(:params).returns([:resolver, :simple])
+      @config.stubs(:get).with(:something).returns([:value, :SOMETHING])
+      obj = MyInjectedClass.new(nil)
+      @injector.call(obj, :requires_params).should == :SOMETHING
     end
+  end
 
-    def call
-      {:some => "params"}
+  context "when there is an implementation param" do
+    it "instantiates and calls the resolver" do
+      @config.stubs(:get).with(:params).returns([:implementation, :simple_resolver])
+      @config.stubs(:get).with(:something).returns([:value, :SOMETHING])
+      obj = MyInjectedClass.new(nil)
+      @injector.call(obj, :requires_params).call.should == :SOMETHING
     end
   end
 
-  context "recursive injection in to resolvers" do
-    before do
-      @resolver         = ParamsResolver.new
-      @resolver_locator = stub("ResolverLocator", :call => @resolver)
-      @injector         = Objectify::Injector.new(@resolver_locator)
+  context "when there is an unconfigured resolver param" do
+    it "instantiates and calls the resolver" do
+      @config.stubs(:get).with(:params).returns([:unknown, :simple])
+      @config.stubs(:get).with(:something).returns([:value, :SOMETHING])
+      obj = MyInjectedClass.new(nil)
+      @injector.call(obj, :requires_params).should == :SOMETHING
     end
+  end
 
-    it "can inject into resolvers" do
-      object = MyInjectedClass.new(nil)
-      @injector.call(object, :requires_params).should ==
-        {:some => "params"}
+  context "when there is an unconfigured impl param" do
+    it "instantiates and calls the resolver" do
+      @config.stubs(:get).with(:params).returns([:unknown, :simple_resolver])
+      @config.stubs(:get).with(:something).returns([:value, :SOMETHING])
+      obj = MyInjectedClass.new(nil)
+      @injector.call(obj, :requires_params).call.should == :SOMETHING
     end
   end
 end

data/spec/rails/routing_spec.rb

@@ -8,7 +8,9 @@ describe "Objectify::Rails::Routing::ObjectifyMapper" do
                                           :append_defaults          => nil,
                                           :append_action            => nil,
                                           :policies  => @policies,
-                                          :append_resolutions       => nil,
+                                          :append_implementations   => nil,
+                                          :append_resolvers         => nil,
+                                          :append_values            => nil,
                                           :objectify_controller => "some_controller")
     @rails_mapper   = stub("RailsMapper", :resources => nil,
                                           :match     => nil)
@@ -138,14 +140,25 @@ describe "Objectify::Rails::Routing::ObjectifyMapper" do
     end
   end
 
-  context "adding resolutions" do
-    before do
+  context "adding injector config" do
+    it "hands resolvers to the context" do
       @opts = { :authenticated => :unauthenticated_responder }
-      @mapper.resolutions @opts
+      @mapper.resolvers @opts
+      @objectify.should have_received(:append_resolvers).
+                          with(@opts)
     end
 
-    it "hands them to the context" do
-      @objectify.should have_received(:append_resolutions).
+    it "hands implementations to the context" do
+      @opts = { :authenticated => :unauthenticated_responder }
+      @mapper.implementations @opts
+      @objectify.should have_received(:append_implementations).
+                          with(@opts)
+    end
+
+    it "hands values to the context" do
+      @opts = { :authenticated => :unauthenticated_responder }
+      @mapper.values @opts
+      @objectify.should have_received(:append_values).
                           with(@opts)
     end
   end

data/thoughts/injector.md

@@ -0,0 +1,76 @@
+# Rethinking the injector
+
+Example types of injectables:
+
+  * :current_user => A class that we need to instantiate and call #call on to get the current_user.
+  * :session_min_age_function => A function value that can be injected as-is.
+  * :user_finder => Sometimes a constant, sometimes the name of a class that needs to be instantiated.
+  * :session_creation_service => The name of a class that gets instantiated before it gets injected.
+
+## Decorators
+
+Do we want to make decorators first class? My inclination is to say yes. I'd love to have something that looked like this:
+
+objectify.decorate "objectify_auth/session_creation_service" => ["objectify_auth/session_creation_service/with_email",
+                                                                 "objectify_auth/session_creation_service/with_last_pageview"]
+
+The above would mean that in the following case:
+
+```ruby
+class ObjectifyAuth::SessionCreationService::WithEmail
+  def initialize(session_creation_service)
+    @session_creation_service = session_creation_service
+  end
+
+  def call(user, session)
+    @session_creation_service.call(user, session)
+    session[:e] = user.email
+  end
+end
+
+class ObjectifyAuth::SessionCreationService::WithLastPageview
+  def initialize(session_creation_service, time)
+    @session_creation_service = session_creation_service
+    @time = time
+  end
+
+  def call(user, session)
+    @session_creation_service.call(user, session)
+    session[:l] = @time.now
+  end
+end
+```
+
+...WithEmail's `session_creation_service` parameter would resolve to the base SessionCreationService, and WithLastPageview's `session_creation_service` parameter would resolve to the WithEmail instance.
+
+Also, the ability to override decorations at the resource or action level:
+
+```ruby
+objectify.resources :pictures, :decorate => {:picture_creation_service => :generic_service_instrumentation}
+```
+
+Also, injectables in general:
+
+```ruby
+objectify.resources :pictures, :resolve => {:storage_service => :s3_storage_service}
+objectify.resources :videos, :resolve => {:storage_service => :riak_storage_service}
+```
+
+## Ideas on API
+
+```ruby
+objectify.resolvers :current_user => "objectify_auth/current_user" # this would automatically append "Resolver"
+objectify.injectables :session_min_age_function => lambda { 1.month.ago },
+                      :user_finder => User,
+                      :session_creation_service => :"objectify_auth/session_creation_service"
+```
+
+So basically we'd have resolvers (things that need to be instaniated called to get an injectable from), and injectables which are either class names that need to be instantiated (if they're symbols) or values.
+
+Do we always need to be explicit? If there's a parameter called session_creation_service, should we automatically try to constantize that if we don't have a way to resolve it? If the answer to that question is yes (which I think it is), then should we allow people to import a namespace?
+
+```ruby
+objectify.injectable_namespace "objectify_auth"
+```
+
+If not that, then we probably need *something* or any kind of library is going to require a lot of manual configuration to get going.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: objectify
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-25 00:00:00.000000000 Z
+date: 2012-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70332392343920 !ruby/object:Gem::Requirement
+  requirement: &70137374227200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 2.4.0
   type: :development
   prerelease: false
-  version_requirements: *70332392343920
+  version_requirements: *70137374227200
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70332392343200 !ruby/object:Gem::Requirement
+  requirement: &70137374226220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *70332392343200
+  version_requirements: *70137374226220
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &70332400562900 !ruby/object:Gem::Requirement
+  requirement: &70137374224820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *70332400562900
+  version_requirements: *70137374224820
 - !ruby/object:Gem::Dependency
   name: bourne
-  requirement: &70332400562340 !ruby/object:Gem::Requirement
+  requirement: &70137374222400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -54,10 +54,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *70332400562340
+  version_requirements: *70137374222400
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70332400561620 !ruby/object:Gem::Requirement
+  requirement: &70137374221700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -65,10 +65,10 @@ dependencies:
         version: 0.9.8
   type: :development
   prerelease: false
-  version_requirements: *70332400561620
+  version_requirements: *70137374221700
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70332400560740 !ruby/object:Gem::Requirement
+  requirement: &70137378002540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70332400560740
+  version_requirements: *70137378002540
 - !ruby/object:Gem::Dependency
   name: i18n
-  requirement: &70332400559120 !ruby/object:Gem::Requirement
+  requirement: &70137378000720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,7 +87,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70332400559120
+  version_requirements: *70137378000720
 description: Objects on rails.
 email:
 - jamesgolick@gmail.com
@@ -99,13 +99,13 @@ files:
 - .gitignore
 - .rspec
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/objectify.rb
 - lib/objectify/config/action.rb
 - lib/objectify/config/context.rb
+- lib/objectify/config/injectables.rb
 - lib/objectify/config/policies.rb
 - lib/objectify/executor.rb
 - lib/objectify/injector.rb
@@ -127,6 +127,7 @@ files:
 - objectify.gemspec
 - spec/config/action_spec.rb
 - spec/config/context_spec.rb
+- spec/config/injectables_spec.rb
 - spec/config/policies_spec.rb
 - spec/executor_spec.rb
 - spec/injector_spec.rb
@@ -138,6 +139,7 @@ files:
 - spec/resolver_spec.rb
 - spec/route_spec.rb
 - spec/spec_helper.rb
+- thoughts/injector.md
 homepage: https://github.com/bitlove/objectify
 licenses: []
 post_install_message: 
@@ -165,6 +167,7 @@ summary: Objects on rails.
 test_files:
 - spec/config/action_spec.rb
 - spec/config/context_spec.rb
+- spec/config/injectables_spec.rb
 - spec/config/policies_spec.rb
 - spec/executor_spec.rb
 - spec/injector_spec.rb