scorpion-ioc 0.3.1 → 0.4.0

data/lib/scorpion/rails.rb

@@ -1,5 +1,9 @@
 module Scorpion
   module Rails
+    require 'scorpion/rails/nest'
+    require 'scorpion/rails/job'
+    require 'scorpion/rails/active_record'
     require 'scorpion/rails/controller'
+    require 'scorpion/rails/railtie'
   end
 end

data/lib/scorpion/rspec/helper.rb

@@ -0,0 +1,25 @@
+module Scorpion
+  module Rspec
+    module Helper
+
+      def self.included( base )
+        base.let( :scorpion ){ Scorpion::Rspec.scorpion_nest.conceive }
+        base.send :extend, Scorpion::Rspec::Helper::Methods
+
+        super
+      end
+
+
+      module Methods
+
+        def scorpion( &block )
+          before( :each ) do
+            scorpion.prepare &block
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/scorpion/rspec.rb

@@ -0,0 +1,17 @@
+require 'scorpion'
+
+module Scorpion
+  module Rspec
+    require 'scorpion/rspec/helper'
+
+    def self.scorpion_nest
+      @scorpion ||= Scorpion::Nest.new
+    end
+
+    # Prepare a root scorpion for testing.
+    def self.prepare( &block )
+      scorpion_nest.prepare &block
+    end
+
+  end
+end

data/lib/scorpion/stinger.rb

@@ -0,0 +1,69 @@
+module Scorpion
+  # Utility methods for propagating a Scorpion to returned objects.
+  module Stinger
+    @wrappers ||= {}
+
+    def self.wrap( instance, stinger )
+      return instance unless instance
+
+      klass = @wrappers[instance.class] ||=
+        Class.new( instance.class ) do
+          def initialize( instance, stinger )
+            @__instance__ = instance
+            @__stinger__  = stinger
+          end
+
+          def respond_to?( *args )
+            @__instance__.respond_to?( *args )
+          end
+
+          private
+            def method_missing( *args, &block )
+              binding.pry
+              @__stinger__.sting! @__instance__.__send__( *args, &block )
+            end
+        end
+
+      klass.new instance, stinger
+    end
+
+    # Sting an object so that it will be injected with the scorpion and use it
+    # to resolve all dependencies.
+    # @param [#scorpion] object to sting.
+    # @return [object] the object that was stung.
+    def sting!( object )
+      return object unless scorpion
+
+      if object
+        assign_scorpion object
+        assign_scorpion_to_enumerable object
+      end
+
+      object
+    end
+
+    private
+
+      def assign_scorpion( object )
+        return unless object.respond_to?( :scorpion=, true )
+
+        # Only set scorpion if it hasn't been set yet.
+        current_scorpion = object.send :scorpion
+        if current_scorpion
+          scorpion.logger.warn I18n.translate :mixed_scorpions, scope: [:scorpion,:warnings,:messages] if current_scorpion != scorpion
+        else
+          object.send :scorpion=, scorpion
+        end
+      end
+
+      def assign_scorpion_to_enumerable( objects )
+        return unless objects.respond_to? :each
+
+        # Don't eager load relations that haven't been loaded yet.
+        return if objects.respond_to?( :loaded? ) && ! objects.loaded?
+
+        objects.each{ |v| sting! v }
+      end
+
+  end
+end

data/lib/scorpion/version.rb

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

data/lib/scorpion.rb

@@ -3,77 +3,65 @@ require 'i18n'
 I18n.load_path += Dir[ File.expand_path( '../scorpion/locale/*.yml', __FILE__ ) ]
 
 module Scorpion
+
   require 'scorpion/version'
   require 'scorpion/error'
-  require 'scorpion/king'
+  require 'scorpion/object'
+  require 'scorpion/object_constructor'
   require 'scorpion/attribute_set'
   require 'scorpion/hunter'
-  require 'scorpion/hunting_map'
-  require 'scorpion/prey'
+  require 'scorpion/dependency_map'
+  require 'scorpion/hunt'
+  require 'scorpion/dependency'
   require 'scorpion/nest'
+  require 'scorpion/stinger'
   require 'scorpion/rails'
 
-  # @return [Scorpion] main scorpion for the app.
-  def self.instance
-    @instance
-  end
-  @instance = Scorpion::Hunter.new
-
-  # Prepare the {#instance} for hunting.
-  def self.prepare( &block )
-    instance.prepare &block
-  end
-
   # Hunts for an object that satisfies the requested `contract` and `traits`.
-  # @param [Class,Module,Symbol] contract describing the desired behavior of the prey.
-  # @param [Array<Symbol>] traits required of the prey
-  # @return [Object] an object that matches the requirements defined in `attribute`.
+  # @param [Class,Module,Symbol] contract describing the desired behavior of the dependency.
+  # @param [Array<Symbol>] traits required of the dependency
+  # @return [Object] an object that satisfies the contract and traits.
   # @raise [UnsuccessfulHunt] if a matching object cannot be found.
-  def hunt_by_traits( contract, traits, *args, &block )
-    fail "Not implemented"
+  def fetch_by_traits( contract, traits, *args, &block )
+    hunt = Hunt.new( self, contract, traits, *args, &block )
+    execute hunt
   end
-  alias_method :fetch_by_traits, :hunt_by_traits
 
   # Hunts for an object that satisfies the requested `contract` regardless of
   # traits.
-  # @see #hunt_by_traits
-  def hunt( contract, *args, &block )
-    hunt_by_traits( contract, nil, *args, &block )
-  end
-  alias_method :fetch, :hunt
-
-  # Populate given `king` with its expected attributes.
-  # @param [Scorpion::King] king to be fed.
-  # @return [Scorpion::King] the populated king.
-  def feed( king )
-    king.injected_attributes.each do |attr|
-      next if king.send "#{ attr.name }?"
-
-      king.send :feed, attr, hunt_by_traits( attr.contract, attr.traits )
-    end
+  # @see #fetch_by_traits
+  def fetch( contract, *args, &block )
+    fetch_by_traits( contract, nil, *args, &block )
   end
 
-  # Creates a new king and feeds it it's dependencies.
-  # @param [Class] king_class a class that includes {Scorpion::King}.
+  # Creates a new object and feeds it it's dependencies.
+  # @param [Class] object_class a class that includes {Scorpion::Object}.
   # @param [Array<Object>] args to pass to the constructor.
   # @param [#call] block to pass to the constructor.
-  # @return [Scorpion::King] the spawned king.
-  def spawn( king_class, *args, &block )
-    if king_class < Scorpion::King
-      king_class.spawn self, *args, &block
+  # @return [Scorpion::Object] the spawned object.
+  def spawn( hunt, object_class, *args, &block )
+    if object_class < Scorpion::Object
+      object_class.spawn hunt, *args, &block
     else
-      king_class.new *args, &block
+      object_class.new *args, &block
     end
   end
 
+  # Execute the `hunt` returning the desired dependency.
+  # @param [Hunt] hunt to execute.
+  # @return [Object] an object that satisfies the hunt contract and traits.
+  def execute( hunt )
+    fail "Not implemented"
+  end
+
   # Creates a new {Scorpion} copying the current configuration any any currently
-  # captured prey.
+  # captured dependency.
   # @return [Scorpion] the replicated scorpion.
   def replicate( &block )
     fail "Not implemented"
   end
 
-  # Free up any captured prey and release any long-held resources.
+  # Free up any captured dependency and release any long-held resources.
   def destroy
   end
 
@@ -82,6 +70,65 @@ module Scorpion
     Scorpion::Nest.new( self )
   end
 
+  # @!attribute
+  # @return [Logger] logger for the scorpion to use.
+  def logger
+    @logger || Scorpion.logger
+  end
+  def logger=( value )
+    @logger = value
+  end
+
+  # ============================================================================
+  # @!group Convenience Methods
+  #
+  # Module methods to make it easier to work with scorpion configurations. These
+  # _should not_ be used by library level classes. Instead only application
+  # level code (controllers, scripts, etc.) should explicitly access these
+  # methods.
+
+  # @return [Scorpion] main scorpion for the app.
+  def self.instance
+    @instance
+  end
+  @instance = Scorpion::Hunter.new
+
+  # Prepare the {#instance} for hunting.
+  # @param [Boolean] reset true to free all existing resource and initialize a
+  #   new scorpion.
+  def self.prepare( reset = false, &block )
+    if reset
+      @instance.destroy
+      @instance = Scorpion::Hunter.new
+    end
+    instance.prepare &block
+  end
+
+  # Hunt for dependency from the primary Scorpion {#instance}.
+  # @see #fetch
+  def self.fetch( *args, &block )
+    instance.fetch *args, &block
+  end
+
+  # Hunt for dependency from the primary Scorpion {#instance}.
+  # @see #fetch_by_traits
+  def self.fetch_by_traits( *args, &block )
+    instance.fetch_by_traits *args, &block
+  end
+
+  # @!attribute logger
+  # @return [Logger] logger for the Scorpion framework to use.
+  def self.logger
+    @logger ||= defined?( ::Rails ) ? ::Rails.logger : Logger.new( STDOUT )
+  end
+  def self.logger=( value )
+    @logger = value
+  end
+
+  #
+  # @!endgroup Convenience Methods
+
+
   private
 
     # Used by concrete scorpions to notify the caller that the hunt was

data/scorpion.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency 'rails', '~> 4.0'
-  spec.required_ruby_version = '>= 1.9.2'
+  spec.required_ruby_version = '>= 2.0.0'
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", '~> 10'

data/spec/internal/app/models/author.rb

@@ -0,0 +1,17 @@
+class Author < ActiveRecord::Base
+
+  # @!attribute name
+  # @return [String]
+
+
+  # @!attribute
+  # @return [ActiveRecord::Relation<Todo>]
+    has_many :todos, inverse_of: :author
+
+  scope :named, ->( name ) { where( name: name ) } do
+    def alphabetical
+      order( :name )
+    end
+  end
+
+end

data/spec/internal/app/models/todo.rb

@@ -0,0 +1,14 @@
+class Todo < ActiveRecord::Base
+
+  # @!attribute name
+  # @return [String]
+
+
+  # @!attribute
+  # @return [Author] name
+    belongs_to :author, inverse_of: :todos
+
+
+
+
+end

data/spec/internal/db/schema.rb

@@ -1,3 +1,14 @@
 ActiveRecord::Schema.define do
-  #
+  #ActiveRecord::Schema.define do
+  create_table( :todos, :force => true ) do |t|
+    t.string :name
+    t.references :author
+    t.timestamps null: false
+  end
+
+  create_table( :authors, :force => true ) do |t|
+    t.string :name
+    t.timestamps null: false
+  end
+
 end

data/spec/lib/scorpion/dependency/argument_dependency_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Scorpion::Dependency::ArgumentDependency do
+  let( :dependency ) { Scorpion::Dependency::ArgumentDependency.new( arg ) }
+  let( :arg )  { "Hello" }
+
+  it "matches the same type" do
+    expect( dependency.satisfies?( String ) ).to be_truthy
+  end
+
+  it "doesn't match different types" do
+    expect( dependency.satisfies?( Regexp ) ).to be_falsy
+  end
+
+  it "doesn't match traits" do
+    expect( dependency.satisfies?( String, :password ) ).to be_falsy
+  end
+end

data/spec/lib/scorpion/dependency/builder_dependency_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Test
+  module BuilderDependency
+    class ClassDelegate
+      def call( hunt, *args, &block )
+        Test
+      end
+    end
+
+    module ModDelegate
+      module_function
+
+      def call( hunt, *args, &block )
+        Test
+      end
+    end
+  end
+end
+
+describe Scorpion::Dependency::BuilderDependency do
+  let( :scorpion ){ double }
+  let( :hunt ){ Scorpion::Hunt.new( scorpion, String, nil ) }
+
+  it "supports class hunting delegates" do
+    dependency = Scorpion::Dependency::BuilderDependency.new( String, nil, Test::BuilderDependency::ClassDelegate.new )
+    expect( dependency.fetch( hunt ) ).to be Test
+  end
+
+  it "supports module hunting delegates" do
+    dependency = Scorpion::Dependency::BuilderDependency.new( String, nil, Test::BuilderDependency::ModDelegate )
+    expect( dependency.fetch( hunt ) ).to be Test
+  end
+
+  it "supports block hunting delegates" do
+    dependency = Scorpion::Dependency::BuilderDependency.new( String, nil ) do
+      Test
+    end
+    expect( dependency.fetch( hunt ) ).to be Test
+  end
+end

data/spec/lib/scorpion/dependency/module_dependency_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Test
+  module ModuleDependency
+    module Example; end
+  end
+end
+describe Scorpion::Dependency::ModuleDependency do
+  let( :scorpion ){ double }
+  let( :dependency )    { Scorpion::Dependency::ModuleDependency.new( Test::ModuleDependency::Example ) }
+
+  it "returns the module itself" do
+    expect( dependency.fetch( scorpion ) ).to be Test::ModuleDependency::Example
+  end
+
+end

data/spec/lib/scorpion/dependency_map_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+module Test
+  module DependencyMap
+    class Weapon; end
+    class Armor; end
+  end
+end
+
+describe Scorpion::DependencyMap do
+  let( :scorpion ){ double Scorpion }
+  let( :map ){ Scorpion::DependencyMap.new scorpion }
+
+  describe "#chart" do
+    it "yields itself when arg expected" do
+      map.chart do |itself|
+        expect( map ).to be itself
+      end
+    end
+  end
+
+  describe "#find" do
+    it "returns a match" do
+      map.chart do
+        hunt_for Test::DependencyMap::Weapon
+        hunt_for Test::DependencyMap::Armor
+      end
+
+      expect( map.find( Test::DependencyMap::Armor ).contract ).to eq Test::DependencyMap::Armor
+    end
+
+    it "returns nil when no match" do
+      map.chart do
+        hunt_for Test::DependencyMap::Weapon
+      end
+
+      expect( map.find( Test::DependencyMap::Armor ) ).to be_nil
+    end
+
+    it "returns nil when no match" do
+      map.chart do
+        hunt_for Test::DependencyMap::Weapon
+      end
+
+      expect( map.find( Test::DependencyMap::Armor ) ).to be_nil
+    end
+
+
+    context "multiple possible matches" do
+      before( :each ) do
+        map.chart do
+          hunt_for Test::DependencyMap::Weapon, [ :sharp, :one_handed ]
+          hunt_for Test::DependencyMap::Weapon, [ :blunt, :one_handed ]
+        end
+      end
+
+      it "returns the last dependency that matches one trait" do
+        expect( map.find( Test::DependencyMap::Weapon, :one_handed ).traits ).to include :blunt
+      end
+
+      it "returns the last dependency that matches all of the traits" do
+        expect( map.find( Test::DependencyMap::Weapon, [ :one_handed, :blunt ] ).traits ).to include :blunt
+      end
+
+      it "returns the last dependency that matches a unique trait" do
+        expect( map.find( Test::DependencyMap::Weapon, :blunt ).traits ).to include :blunt
+      end
+    end
+  end
+
+  describe "#hunt_for" do
+    it "adds a Dependency" do
+      expect( map ).to be_empty
+
+      map.chart do
+        hunt_for Test::DependencyMap::Weapon
+      end
+
+      expect( map.first ).to be_a Scorpion::Dependency
+    end
+  end
+
+  describe "#replicate_from" do
+    it "does not dup shared dependency" do
+      map.chart do
+        share do
+          capture Test::DependencyMap::Weapon
+        end
+      end
+
+      replica = Scorpion::DependencyMap.new scorpion
+      replica.replicate_from( map )
+
+      expect( replica ).to be_empty
+    end
+
+    it "dups captured dependency" do
+      map.chart do
+        capture Test::DependencyMap::Weapon
+      end
+
+      replica = Scorpion::DependencyMap.new scorpion
+      replica.replicate_from( map )
+
+      expect( replica ).not_to be_empty
+    end
+  end
+end

data/spec/lib/scorpion/dependency_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+module Test
+  module Dependency
+    module Mod; end
+    class Base; end
+    class Derived < Base
+      include Mod
+    end
+
+    class Footwear
+      def self.create( scorpion, *args, &block )
+        yield
+      end
+    end
+
+  end
+end
+
+describe Scorpion::Dependency do
+  context "inheritance" do
+    let( :dependency ){ Scorpion::Dependency.new( Test::Dependency::Derived ) }
+
+    it "matches more derived class when looking for base class" do
+      expect( dependency.satisfies? Test::Dependency::Base ).to be_truthy
+    end
+
+    it "matches same class when looking for base class" do
+      expect( dependency.satisfies? Test::Dependency::Derived ).to be_truthy
+    end
+
+    it "does not inherit symbols" do
+      expect( Scorpion::Dependency.new( :a ).satisfies? :b ).to be_falsy
+    end
+
+    it "can satisfy a module with a class" do
+      expect( dependency.satisfies? Test::Dependency::Mod ).to be_truthy
+    end
+
+  end
+
+  describe "traits" do
+
+    context "symbolic" do
+      let( :dependency ){ Scorpion::Dependency.new Test::Dependency::Base, :apples }
+      it "satisfies matched traits" do
+        expect( dependency.satisfies? Test::Dependency::Base, :apples ).to be_truthy
+      end
+
+      it "doesn't satisfy mis-matched traits" do
+        expect( dependency.satisfies? Test::Dependency::Base, :oranges ).to be_falsy
+      end
+    end
+
+    context "module" do
+      let( :dependency ){ Scorpion::Dependency.new Test::Dependency::Derived }
+
+      it "satisfies module traits" do
+        expect( dependency.satisfies? Test::Dependency::Base, Test::Dependency::Derived ).to be_truthy
+      end
+    end
+
+  end
+
+  it "can satisfy symbol contracts" do
+    expect( Scorpion::Dependency.new( :symbol ).satisfies? :symbol ).to be_truthy
+  end
+
+  it "satisfies ignores tail hash traits" do
+    expect( Scorpion::Dependency.new( Test::Dependency::Base ).satisfies?( Test::Dependency::Base, ) )
+  end
+
+  describe "equality" do
+    let( :dependency )      { Scorpion::Dependency.new( Test::Dependency::Derived ) }
+    let( :same )      { Scorpion::Dependency.new( Test::Dependency::Derived ) }
+    let( :different ) { Scorpion::Dependency.new( Test::Dependency::Base ) }
+
+    specify{ expect( dependency ).to eq same }
+    specify{ expect( dependency ).not_to eq different }
+    specify{ expect( dependency.hash ).to eq same.hash }
+  end
+
+  describe ".define" do
+    let( :scorpion ){ double Scorpion }
+    let( :hunt )    { Scorpion::Hunt.new scorpion, String, nil }
+
+    it "is a ClassDependency for class hunts" do
+      dependency = Scorpion::Dependency.define String
+      expect( dependency ).to be_a Scorpion::Dependency::ClassDependency
+    end
+
+    it "is a ModuleDependency for module hunts" do
+      dependency = Scorpion::Dependency.define Test::Dependency::Mod
+      expect( dependency ).to be_a Scorpion::Dependency::ModuleDependency
+    end
+
+    it "is a BuilderDependency for return: instances" do
+      dependency = Scorpion::Dependency.define String, return: "AWESEOME"
+
+      expect( dependency ).to be_a Scorpion::Dependency::BuilderDependency
+      expect( dependency.fetch hunt ).to eq "AWESEOME"
+    end
+
+    it "is a BuilderDependency for block hunts" do
+      dependency =  Scorpion::Dependency.define String do
+                "YASS"
+              end
+
+      expect( dependency ).to be_a Scorpion::Dependency::BuilderDependency
+    end
+
+    it "is a BuilderDependency for with: option" do
+      dependency = Scorpion::Dependency.define String, with: ->(scorpion,*args,&block){ "YASSS" }
+
+      expect( dependency ).to be_a Scorpion::Dependency::BuilderDependency
+      expect( dependency.fetch hunt ).to eq "YASSS"
+    end
+
+    it "is a BuilderDependency when hunted class implements #create" do
+      dependency = Scorpion::Dependency.define Test::Dependency::Footwear
+      hunt = Scorpion::Hunt.new scorpion, String, nil do
+        "Nike"
+      end
+
+      expect( dependency ).to be_a Scorpion::Dependency::BuilderDependency
+      expect( dependency.fetch( hunt ) ).to eq "Nike"
+    end
+
+  end
+
+end