scorpion-ioc 0.4.0 → 0.5.0

data/lib/scorpion/rails/nest.rb

@@ -5,17 +5,16 @@ module Scorpion
   module Rails
     # Handles building a scorpion to handle a single request and populating
     # all the dependencies automatically.
+    #
+    # The host class must respond to #scorpion, #assign_scorpion(scorpion) and
+    # #free_scorpion.
     module Nest
+      include Scorpion::Object
 
       # ============================================================================
       # @!group Attributes
       #
 
-      # @!attribute
-      # @return [Scorpion] the scorpion used to fetch dependencies.
-        attr_reader :scorpion
-        private :scorpion
-
       # @!attribute
       # @return [Scorpion::Nest] the nest used to conceive scorpions.
         def nest
@@ -23,12 +22,17 @@ module Scorpion
         end
         private :nest
 
+        def scorpion( scope = nil )
+          # Make sure a scorpion is always available. Will be freed on the next
+          # call to #with_scorpion
+          ensure_scorpion( super ) unless scope
+          super
+        end
+
       #
       # @!endgroup Attributes
 
       def self.included( base )
-        # Setup dependency injection
-        base.send :include, Scorpion::Object
 
         # @!attribute [rw]
         # @return [Scorpion::Nest] the singleton nest used by controllers.
@@ -60,27 +64,26 @@ module Scorpion
       # Fetch a scorpion and feed the controller it's dependencies, then yield
       # to perform the action within the context of that scorpion.
       def with_scorpion( &block )
-        assign_scorpion( nest.conceive )
-
-        prepare_scorpion( @scorpion ) if respond_to?( :prepare_scorpion, true )
-
-        hunt = Scorpion::Hunt.new @scorpion, nil, nil
-        hunt.inject self
+        ensure_scorpion( scorpion )
+        scorpion.inject self
 
         yield
       ensure
         free_scorpion
       end
 
-      private
+      def conceive_scorpion
+        nest.conceive
+      end
 
-        def assign_scorpion( scorpion )
-          @scorpion = scorpion
-        end
+      def ensure_scorpion( existing )
+        scorpion = existing
+        scorpion = assign_scorpion( conceive_scorpion ) unless existing
+
+        prepare_scorpion( scorpion ) if respond_to?( :prepare_scorpion, true )
+        scorpion
+      end
 
-        def free_scorpion
-          @scorpion = nil
-        end
     end
   end
 end

data/lib/scorpion/rails/railtie.rb

@@ -7,6 +7,7 @@ module Scorpion
       initializer "scorpion.configure" do |app|
         ::ActionController::Base.send :include, Scorpion::Rails::Controller
         ::ActiveJob::Base.send :include, Scorpion::Rails::Job
+        ::ActionMailer::Base.send :include, Scorpion::Rails::Mailer
 
         ::Scorpion::Rails::ActiveRecord.install!
       end

data/lib/scorpion/rspec/helper.rb

@@ -6,18 +6,65 @@ module Scorpion
         base.let( :scorpion ){ Scorpion::Rspec.scorpion_nest.conceive }
         base.send :extend, Scorpion::Rspec::Helper::Methods
 
+        [ ActionController::Base, ActiveJob::Base, ActionMailer::Base ].each do |intercept|
+          base.infest_nest intercept
+        end
+
         super
       end
 
 
       module Methods
 
+        # Intercept calls to conceive_scorpion in classes that include
+        # {Scorpion::Rails::Nest}
+        # @param [Class] klass that includes {Scorpion::Rails::Nest}
+        # @return [void]
+        def infest_nest( klass )
+          return unless klass < Scorpion::Rails::Nest
+
+          before( :each ) do
+            allow_any_instance_of( klass ).to receive( :conceive_scorpion )
+              .and_wrap_original do |m|
+                # When hunting for dependencies in controllers, jobs, etc. first
+                # consider the dependencies defined in the specs.
+                Scorpion::ChainHunter.new( scorpion, m.call )
+              end
+          end
+        end
+
+        # Set up scorpion hunting rules for the spec.
         def scorpion( &block )
           before( :each ) do
             scorpion.prepare &block
           end
         end
 
+        # Specify a specific hunting contract and prepare a `let` block of the
+        # same name.
+        def hunt( name, contract, value = :unspecified, &block )
+          block ||= ->{ value == :unspecified ? instance_double( contract ) : value }
+
+          let( name, &block )
+
+          before( :each ) do
+            scorpion.prepare do |hunter|
+              if value == :unspecified
+                hunter.hunt_for contract do
+                  send( name )
+                end
+              else
+                hunter.hunt_for contract, return: value
+              end
+            end
+          end
+        end
+
+        def hunt!( name, contract, value = :unspecified, &block )
+          hunt name, contract, value, &block
+          before(:each){ send name }
+        end
+
       end
 
     end

data/lib/scorpion/stinger.rb

@@ -19,7 +19,6 @@ module Scorpion
 
           private
             def method_missing( *args, &block )
-              binding.pry
               @__stinger__.sting! @__instance__.__send__( *args, &block )
             end
         end

data/lib/scorpion/version.rb

@@ -1,5 +1,5 @@
 module Scorpion
-  VERSION_NUMBER  = "0.4.0"
+  VERSION_NUMBER  = "0.5.0"
   VERSION_SUFFIX  = ""
   VERSION         = "#{VERSION_NUMBER}#{VERSION_SUFFIX}"
 end

data/scorpion.gemspec

@@ -26,4 +26,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", '~> 3.00'
   spec.add_development_dependency "rspec-rails", '~> 3.00'
   spec.add_development_dependency 'combustion', '~> 0.5.3'
+  spec.add_development_dependency 'sqlite3'
 end

data/spec/lib/scorpion/attribute_spec.rb

@@ -1,8 +1,18 @@
 require 'spec_helper'
 
+module Test
+  class Attr; end
+end
+
+
 describe Scorpion::Attribute do
   it "responds to trait? methods" do
     attr = Scorpion::Attribute.new :name, :contract, :formatted
     expect( attr ).to be_formatted
   end
+
+  it "resolves contract strings to constants" do
+    attr = Scorpion::Attribute.new :name, 'Test::Attr'
+    expect( attr.contract ).to be Test::Attr
+  end
 end

data/spec/lib/scorpion/hunt_spec.rb

@@ -39,14 +39,14 @@ describe Scorpion::Hunt do
     end
 
     it "finds matching argument in parent" do
-      hunt.arguments << "Hello"
+      hunt.dependencies[:label] = "Hello"
 
       expect( hunt.fetch String ).to eq "Hello"
     end
 
     it "finds matching argument in grandparent" do
-      hunt = Scorpion::Hunt.new scorpion, String, nil, "Hello"
-      hunt.send :push, Regexp, nil, [], nil
+      hunt = Scorpion::Hunt.new scorpion, String, nil, label: "Hello"
+      hunt.send :push, Regexp, nil, [], {}, nil
 
       expect( scorpion ).to receive( :execute ) do |hunt|
         next if hunt.contract == String
@@ -88,6 +88,12 @@ describe Scorpion::Hunt do
       hunt.inject target
       expect( target.sailor? ).to be_falsy
     end
+
+    it "invokes on_injected" do
+      expect( target ).to receive( :on_injected )
+      hunt.inject target
+    end
+
   end
 
 end

data/spec/lib/scorpion/hunter_spec.rb

@@ -94,17 +94,28 @@ describe Scorpion::Hunter do
     expect( hunter.fetch_by_traits Test::Hunter::Implicit, [] ).to be_a Test::Hunter::Implicit
   end
 
+  it "initialize explicit contracts" do
+    zoo = hunter.new Test::Hunter::Zoo
+    expect( zoo ).to be_a Test::Hunter::Zoo
+    expect( zoo.scorpion ).to eq hunter
+  end
+
+  it "delegates hunting definitions" do
+    hunter.hunt_for Test::Hunter::Zoo, return: :nyc
+    expect( hunter.fetch Test::Hunter::Zoo ).to eq :nyc
+  end
+
   context "child dependencies" do
     it "passes initializer args to child dependencies" do
       zoo  = Test::Hunter::Zoo.new
-      city = hunter.fetch Test::Hunter::City, zoo
+      city = hunter.fetch Test::Hunter::City, zoo: zoo
 
       expect( city.park.zoo ).to be zoo
     end
 
     it "passes self to child dependencies" do
       zoo  = Test::Hunter::Zoo.new
-      city = hunter.fetch Test::Hunter::City, zoo
+      city = hunter.fetch Test::Hunter::City, zoo: zoo
 
       expect( city.park.city ).to be city
     end

data/spec/lib/scorpion/object_constructor_spec.rb

@@ -1,14 +1,15 @@
 require 'spec_helper'
 
 describe Scorpion::ObjectConstructor do
-   it 'defined an initializer' do
+
+   it 'defines an initializer' do
       klass = Class.new do
         include Scorpion::Object
 
         initialize logger: String
       end
 
-      expect( klass.instance_method(:initialize).arity ).to eq 1
+      expect( klass.instance_method(:initialize).arity ).to eq -1
     end
 
     it "executes initializer code" do
@@ -19,7 +20,7 @@ describe Scorpion::ObjectConstructor do
           initialize label: String, &b
         end
 
-        klass.new "home"
+        klass.new label: "home"
       end.to yield_control
     end
 
@@ -27,13 +28,13 @@ describe Scorpion::ObjectConstructor do
       klass = Class.new do
         include Scorpion::Object
 
-        initialize label: String do |&block|
+        initialize label: String do |label, &block|
           block.call
         end
       end
 
       expect do |b|
-        klass.new "apples", &b
+        klass.new label: "apples", &b
       end.to yield_control
     end
 
@@ -44,6 +45,62 @@ describe Scorpion::ObjectConstructor do
         initialize label: String
       end
 
-      expect( klass.new( "apples" ).label ).to eq "apples"
+      expect( klass.new( label: "apples" ).label ).to eq "apples"
+    end
+
+    it "invokes all initializers" do
+      klass = Class.new do
+        include Scorpion::Object
+
+        initialize label: String do |label:|
+          @label = label.reverse
+        end
+      end
+
+      derived = Class.new( klass ) do
+        initialize logger: Logger do |logger:|
+          @logger = logger.to_s.reverse.to_sym
+        end
+      end
+
+      expect( derived.new( logger: :unset, label: "Super" ).label ).to eq "repuS"
+      expect( derived.new( logger: :unset, label: "Super" ).logger ).to eq :tesnu
     end
+
+
+    context "inheritance" do
+      let( :klass ) do
+        Class.new do
+          include Scorpion::Object
+
+          initialize label: String do |label:|
+            @label = label.reverse
+          end
+        end
+      end
+
+      let( :derived ) do
+        Class.new( klass )
+      end
+
+      it "inherits super initializer block" do
+        expect( derived.new( label: "Super" ).label ).to eq "repuS"
+      end
+
+      it "inherits initializer_injections" do
+        expect( klass.initializer_injections.count ).to eq 1
+        expect( klass.initializer_injections ).to eq derived.initializer_injections
+      end
+
+      it "can override initializer_injections" do
+        more_derived = Class.new( derived ) do
+          initialize do
+          end
+        end
+
+        expect( more_derived.initializer_injections.count ).to eq 0
+      end
+
+    end
+
 end

data/spec/lib/scorpion/object_spec.rb

@@ -63,6 +63,14 @@ describe Scorpion::Object do
     allow( hunt ).to receive( :scorpion ).and_return scorpion
   end
 
+  it "stings scopes" do
+    scope = double
+
+    expect( scope ).to receive( :with_scorpion ).with( scorpion )
+
+    Test::Object::Mouse.spawn( hunt ).scorpion( scope )
+  end
+
   describe ".spawn" do
 
     it "can spawn" do
@@ -76,7 +84,7 @@ describe Scorpion::Object do
     end
 
     it "can inherit" do
-      mouse = Test::Object::Mouse.spawn hunt, name: 'name'
+      mouse = Test::Object::Mouse.spawn hunt, { name: 'name' }, {}
       expect( mouse.family ).to eq 'mouse'
       expect( mouse.options ).to include name: 'name'
     end
@@ -87,10 +95,6 @@ describe Scorpion::Object do
       end.to yield_control
     end
 
-    it "invokes on_injected" do
-      expect_any_instance_of( Test::Object::Mouse ).to receive( :on_injected )
-      Test::Object::Mouse.spawn hunt
-    end
   end
 
   describe "accessors" do

data/spec/lib/scorpion/rails/controller_spec.rb

@@ -10,7 +10,6 @@ end
 
 describe Scorpion::Rails::Controller, type: :controller do
   controller ActionController::Base do
-    include Scorpion::Rails::Controller
 
     depend_on do
       service Test::Nest::Service
@@ -42,6 +41,29 @@ describe Scorpion::Rails::Controller, type: :controller do
       expect( subject ).to respond_to :scorpion
     end
 
+    it "retrieves scorpion from `env`" do
+      expect( subject.env ).to receive( :[] )
+        .with( Scorpion::Rails::Controller::ENV_KEY )
+        .at_least( :once )
+        .and_call_original
+
+      get :index
+    end
+
+    it "stores the scorpion in `env`" do
+      expect( subject.env ).to receive( :[]= )
+        .with( Scorpion::Rails::Controller::ENV_KEY, kind_of( Scorpion ) )
+        .at_least( :once )
+        .and_call_original
+
+      get :index
+    end
+
+    it "prepares a scorpion outside of a request when accessed" do
+      expect( subject.env[Scorpion::Rails::Controller::ENV_KEY] ).to be_nil
+      expect( subject.scorpion ).not_to be_nil
+    end
+
     it "initializes non-lazy dependencies" do
       expect( subject.cache ).to be_present
     end
@@ -107,5 +129,15 @@ describe Scorpion::Rails::Controller, type: :controller do
 
       get :index
     end
+
+
+    it "scopes relations" do
+      allow( subject ).to receive( :index ) do
+        expect( subject.scorpion( Todo ).all.scorpion ).to be subject.scorpion
+        controller.render nothing: true
+      end
+
+      get :index
+    end
   end
 end