scorpion-ioc 0.4.0 → 0.5.0

data/lib/scorpion/hunter.rb

@@ -32,6 +32,15 @@ module Scorpion
       dependency_map.chart &block
     end
 
+    # Expose dependency injection definitions as top-level methods.
+    [:hunt_for,:capture,:share].each do |delegate|
+      define_method delegate do |*args,&block|
+        prepare do |hunter|
+          hunter.send delegate, *args, &block
+        end
+      end
+    end
+
     # @see Scorpion#replicate
     def replicate
       replica = self.class.new self
@@ -40,16 +49,20 @@ module Scorpion
     end
 
     # @see Scorpion#hunt
-    def execute( hunt )
+    def execute( hunt, explicit_only = false )
       dependency   = dependency_map.find( hunt.contract, hunt.traits )
       dependency ||= parent.dependency_map.find( hunt.contract, hunt.traits ) if parent
-      dependency ||= Dependency.define( hunt.contract ) if hunt.traits.blank?
+      dependency ||= Dependency.define( hunt.contract ) if hunt.traits.blank? && !explicit_only
 
       unsuccessful_hunt( hunt.contract, hunt.traits ) unless dependency
 
       dependency.fetch hunt
     end
 
+    # @see Scorpion#reset
+    def reset
+      dependency_map.reset
+    end
 
   end
 end

data/lib/scorpion/locale/en.yml

@@ -4,6 +4,7 @@ en:
       messages:
         unsuccessful_hunt: "Couldn't find a %{contract} builder with traits '%{traits}'"
         builder_required: A custom builder must be provided to resolve this dependency
+        arity_mismatch: The block must accept %{expected} arguments, but actually expects %{actual}
     warnings:
       messages:
         mixed_scorpions: A scorpion has already been assigned. Mixing scorpions can result in unexpected results.

data/lib/scorpion/method.rb

@@ -0,0 +1,24 @@
+module Scorpion
+  # Adds a #scorpion method to an object.
+  module Method
+    # @overload scorpion
+    #   @return [Scorpion] the object's scorpion used to hunt down dependencies.
+    # @overload scorpion( scope )
+    #   Stings the given `scope` with the current scorpion.
+    #   @param [#with_scorpion] scope an object that responds to #with_scorpion that
+    #     receives the current scorpion.
+    #   @return [scope] stung object.
+    def scorpion( scope = nil )
+      if scope
+        scope.with_scorpion( scorpion )
+      else
+        @scorpion
+      end
+    end
+
+    private def scorpion=( value )
+      @scorpion = value
+    end
+
+  end
+end

data/lib/scorpion/nest.rb

@@ -33,5 +33,10 @@ module Scorpion
       @mother = nil
     end
 
+    # Reset the hunting map and clear all dependencies.
+    def reset
+      mother.reset
+    end
+
   end
 end

data/lib/scorpion/object.rb

@@ -9,10 +9,7 @@ module Scorpion
     # @!group Attributes
     #
 
-    # @!attribute
-    # @return [Scorpion] the scorpion used to hunt down dependencies.
-      attr_accessor :scorpion
-      private :scorpion=
+    include Scorpion::Method
 
     # @!attribute
     # @return [Scorpion::AttributeSet] the set of injected attributes and their
@@ -35,8 +32,8 @@ module Scorpion
       send "#{ attribute.name }=", dependency
     end
 
-    # Crown the object as a object and prepare it to be fed.
-    def self.crown( base )
+    # Infest the object with a scoprion and prepare it to be fed.
+    def self.infest( base )
       base.extend Scorpion::Object::ClassMethods
       if base.is_a? Class
         base.class_exec do
@@ -44,32 +41,38 @@ module Scorpion
           # Create a new instance of this class with all non-lazy dependencies
           # satisfied.
           # @param [Hunt] hunt that this instance will be used to satisfy.
-          def self.spawn( hunt, *args, &block )
-            new( *args, &block ).tap do |object|
-              object.send :scorpion=, hunt.scorpion
-
-              # Go hunt for dependencies that are not lazy and initialize the
-              # references.
-              hunt.inject object
-              object.send :on_injected
-            end
+          def self.spawn( hunt, *args, **dependencies, &block )
+            object =
+              if dependencies.any?
+                new( *args, **dependencies, &block )
+              else
+                new( *args, &block )
+              end
+
+
+            object.send :scorpion=, hunt.scorpion
+
+            # Go hunt for dependencies that are not lazy and initialize the
+            # references.
+            hunt.inject object
+            object
           end
 
         end
 
         base.subclasses.each do |sub|
-          crown( sub ) unless sub < Scorpion::Object
+          infest( sub ) unless sub < Scorpion::Object
         end
       end
     end
 
     def self.included( base )
-      crown( base )
+      infest( base )
       super
     end
 
     def self.prepended( base )
-      crown( base )
+      infest( base )
       super
     end
 
@@ -117,14 +120,15 @@ module Scorpion
       # Define an initializer that accepts injections.
       # @param [Hash] arguments to accept in the initializer.
       # @yield to initialize itself.
-      def initialize( arguments, &block )
+      def initialize( arguments = {}, &block )
         Scorpion::ObjectConstructor.new( self, arguments, &block ).define
       end
 
       # Tells a {Scorpion} what to inject into the class when it is constructed
       # @return [nil]
       # @see AttributeSet#define
-      def depend_on( &block )
+      def depend_on( arguments = nil, &block )
+        Scorpion::ObjectConstructor.new( self, arguments ).define if arguments.present?
         injected_attributes.define &block
         build_injected_attributes
       end
@@ -155,8 +159,11 @@ module Scorpion
       # @return [Scorpion::AttributeSet] the set of injected attriutes.
       def initializer_injections
         @initializer_injections ||= begin
-          attrs = AttributeSet.new
-          attrs
+          if superclass.respond_to?( :initializer_injections )
+            superclass.initializer_injections
+          else
+            AttributeSet.new
+          end
         end
       end
 
@@ -174,7 +181,7 @@ module Scorpion
             def #{ attr.name }
               @#{ attr.name } ||= begin
                 attr = injected_attributes[ :#{ attr.name } ]
-                scorpion.fetch( attr.contract, attr.traits )
+                scorpion.fetch_by_traits( attr.contract, attr.traits )
               end
             end
 

data/lib/scorpion/object_constructor.rb

@@ -9,10 +9,11 @@ module Scorpion
     end
 
     def define
-      @signature = []
-      @body      = ""
+      @signature       = []
+      @block_signature = []
+      @body            = []
 
-      build_signature
+      define_dependencies
       build_body
 
       add_initialize_block
@@ -20,35 +21,43 @@ module Scorpion
     end
 
     private
-      attr_reader :base, :arguments, :block, :body, :signature
+      attr_reader :base, :arguments, :block, :body
 
-      def build_signature
-        arguments.each do |key,expectation|
-          signature << key
+      def define_dependencies
+        # Override the inherited injections cause we're about to define a new
+        # initializer.
+        base.instance_variable_set :@initializer_injections, AttributeSet.new
 
+        arguments.each do |key,expectation|
           base.initializer_injections.define_attribute key, *Array( expectation )
           base.attr_dependency key, *Array( expectation )
         end
       end
 
       def build_body
-        arguments.each do |key,expectation|
-          body << "@#{ key } = #{ key };"
+        if arguments.present?
+          body << "injections = dependencies.slice( :#{ arguments.keys.join(', :') } )"
+          body << "inject_from( dependencies )"
         end
+        body << "super" if base.superclass < Scorpion::Object
       end
 
       def add_initialize_block
         if block
-          body << "__initialize_with_block( &block )"
-          base.send :define_method, :__initialize_with_block, &block
+          name = "__initialize_with_block_#{ base.name || base.object_id }"
+          body << "#{ name }( *args, **injections, &block )"
+          base.send :define_method, :"#{ name }", &block
         end
       end
 
       def assemble
+        source = %Q|def initialize( *args, **dependencies, &block )\n\t#{ body.join( "\n\t" ) }\nend|
+
+        # puts base.name
+        # puts source
+
         base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def initialize( #{ signature.join( ', ' ) }, &block )
-            #{ body }
-          end
+#{ source }
         RUBY
       end
   end

data/lib/scorpion/rails.rb

@@ -2,6 +2,7 @@ module Scorpion
   module Rails
     require 'scorpion/rails/nest'
     require 'scorpion/rails/job'
+    require 'scorpion/rails/mailer'
     require 'scorpion/rails/active_record'
     require 'scorpion/rails/controller'
     require 'scorpion/rails/railtie'

data/lib/scorpion/rails/active_record/association.rb

@@ -10,12 +10,11 @@ module Scorpion
         # @!group Attributes
         #
 
-        # @!attribute
-        # @return [Scorpion] the scorpion serving the association.
-          attr_accessor :scorpion
-          def scorpion
-            @scorpion || owner.scorpion
-          end
+        include Scorpion::Method
+
+        def scorpion( scope = nil )
+          super || owner.scorpion( scope )
+        end
 
         #
         # @!endgroup Attributes

data/lib/scorpion/rails/active_record/model.rb

@@ -9,12 +9,11 @@ module Scorpion
         def self.prepended( base )
           # Setup dependency injection
           base.send :include, Scorpion::Object
-          base.send :extend, ClassMethods
-          super
-        end
+          base.singleton_class.class_exec do
+            delegate :with_scorpion, to: :all
+          end
 
-        module ClassMethods
-          delegate :with_scorpion, to: :all
+          super
         end
 
         def association( *args, &block )

data/lib/scorpion/rails/active_record/relation.rb

@@ -11,9 +11,7 @@ module Scorpion
         # @!group Attributes
         #
 
-        # @!attribute
-        # @return [Scorpion] the scorpion serving the relation.
-          attr_accessor :scorpion
+        include Scorpion::Method
 
         #
         # @!endgroup Attributes
@@ -27,7 +25,7 @@ module Scorpion
         #   User.with_scorpion( scorpion ).where( ... )
         def with_scorpion( scorpion )
           spawn.tap do |other|
-            other.scorpion = scorpion
+            other.send :scorpion=, scorpion
           end
         end
 

data/lib/scorpion/rails/controller.rb

@@ -8,14 +8,41 @@ module Scorpion
 
       ENV_KEY = 'scorpion.instance'.freeze
 
-      def scorpion
-        env[ENV_KEY]
+
+      # Fetch an object from the controller's {#scorpion}.
+      # @see Scorpion#fetch
+      def fetch( *args, &block )
+        scorpion.fetch *args, &block
       end
+      private :fetch
+
+
+      # @overload scorpion
+      #   @return [Scorpion] the current scorpion
+      # @overload scorpion( scope )
+      #   Stings the given `scope` with the current scorpion.
+      #   @param [ActiveRecord::Relation,#with_scorpion] an ActiveRecord relation,
+      #     scope or model class.
+      #   @return [ActiveRecord::Relation] scorpion scoped relation.
 
       def self.included( base )
         # Setup dependency injection
+        base.send :include, Scorpion::Object
         base.send :include, Scorpion::Rails::Nest
+
         base.around_filter :with_scorpion
+
+        base.class_eval do
+          # Defined here to override the #scorpion method provided by Scorpion::Object.
+          def scorpion( scope = nil )
+            if scope
+              super
+            else
+              ensure_scorpion( env[ENV_KEY] )
+            end
+          end
+        end
+
         super
       end
 
@@ -42,6 +69,8 @@ module Scorpion
         end
 
         def free_scorpion
+          scorpion.try( :destroy )
+          env.delete ENV_KEY
         end
 
     end

data/lib/scorpion/rails/job.rb

@@ -6,8 +6,10 @@ module Scorpion
     # Adds a scorpion nest to support injection into rails background worker jobs.
     module Job
 
+
       def self.included( base )
         # Setup dependency injection
+        base.send :include, Scorpion::Object
         base.send :include, Scorpion::Rails::Nest
         base.send :around_perform do |job, block|
           job.with_scorpion &block
@@ -25,6 +27,16 @@ module Scorpion
             end
           end
         end
+
+        attr_reader :scorpion
+        def assign_scorpion( scorpion )
+          @scorpion = scorpion
+        end
+
+        def free_scorpion
+          @scorpion.try( :destroy )
+          @scorpion = nil
+        end
     end
   end
 end

data/lib/scorpion/rails/mailer.rb

@@ -0,0 +1,42 @@
+require 'scorpion/nest'
+
+module Scorpion
+  module Rails
+
+    # Adds a scorpion nest to support injection into rails mailers.
+    module Mailer
+
+
+      def self.included( base )
+        # Setup dependency injection
+        base.send :include, Scorpion::Object
+        base.send :include, Scorpion::Rails::Nest
+        base.send :around_filter do |mailer, block|
+          mailer.with_scorpion &block
+        end
+
+        super
+      end
+
+      private
+
+        def prepare_scorpion( scorpion )
+          scorpion.prepare do |hunter|
+            hunter.hunt_for ActionMailer::Base do
+              self
+            end
+          end
+        end
+
+        attr_reader :scorpion
+        def assign_scorpion( scorpion )
+          @scorpion = scorpion
+        end
+
+        def free_scorpion
+          @scorpion.try( :destroy )
+          @scorpion = nil
+        end
+    end
+  end
+end