scorpion-ioc 0.3.1 → 0.4.0

data/spec/lib/scorpion/king_spec.rb

@@ -1,198 +0,0 @@
-require 'spec_helper'
-
-module Test
-  module King
-    class UserService; end
-    class Logger; end
-    class BackLogger; end
-    class ColorLogger; end
-
-    class Mamal
-      include Scorpion::King
-
-      def initialize( family, parent = nil, options={}, &block )
-        @family    = family
-        @parent    = parent
-        @options   = feast_on! options
-
-
-        yield if block_given?
-      end
-
-      feed_on do
-        user_service Test::King::UserService
-        logger       Test::King::Logger
-        manager      Test::King::Logger, public: true
-        executive_manager Test::King::Logger, private: true
-      end
-
-      attr_accessor :family
-      attr_accessor :parent
-      attr_accessor :options
-    end
-
-    class Mouse < Mamal
-
-      feed_on do
-        cheese  Test::King::Logger
-        logger  Test::King::BackLogger
-      end
-      def initialize( options = {} )
-        super 'mouse', nil, options
-      end
-    end
-
-    class Bear < Mamal
-      feed_on do
-        logger Test::King::ColorLogger
-      end
-    end
-
-  end
-end
-
-describe Scorpion::King do
-
-  let( :scorpion ){ double Scorpion }
-
-  before( :each ) do
-    allow( scorpion ).to receive( :feed )
-  end
-
-  describe ".spawn" do
-
-    it "can spawn" do
-      mamal = Test::King::Mamal.spawn scorpion, 'mouse', 'rodent', name: 'name'
-      expect( mamal ).to be_a Test::King::Mamal
-    end
-
-    it "calls feed" do
-      expect( scorpion ).to receive( :feed )
-      Test::King::Mouse.spawn scorpion
-    end
-
-    it "can inherit" do
-      mouse = Test::King::Mouse.spawn scorpion, name: 'name'
-      expect( mouse.family ).to eq 'mouse'
-      expect( mouse.options ).to include name: 'name'
-    end
-
-    it "yields to constructor" do
-      expect do |b|
-        Test::King::Mouse.spawn scorpion, name: 'name', &b
-      end.to yield_control
-    end
-
-    it "invokes on_fed" do
-      expect_any_instance_of( Test::King::Mouse ).to receive( :on_fed )
-      Test::King::Mouse.spawn scorpion
-    end
-  end
-
-  describe "accessors" do
-    let( :king ) do
-      Test::King::Mamal.spawn scorpion, 'harry', 'jim', name: 'name', manager: double
-    end
-
-    subject{ king }
-
-    it "defines accessors" do
-      expect( king ).to     respond_to :user_service
-      expect( king ).not_to respond_to :user_service=
-    end
-
-    it "supports private reader" do
-      expect( king.respond_to? :executive_manager, false ).to be_falsy
-      expect( king.respond_to? :executive_manager, true ).to be_truthy
-    end
-
-    it "supports public writer" do
-      expect( king.respond_to? :manager=, false ).to be_truthy
-    end
-
-    describe  "inheritance" do
-      let( :king ) do
-        Test::King::Mouse.spawn scorpion
-      end
-
-      it "inherits attributes" do
-        expect( king.injected_attributes[:user_service].contract ).to be Test::King::UserService
-      end
-
-      it "overrides attributes" do
-        expect( king.injected_attributes[:logger].contract ).to be Test::King::BackLogger
-      end
-
-      it "doesn't effect other classes" do
-        expect( Test::King::Bear.spawn( scorpion, 'Yogi' ).injected_attributes[:logger].contract ).to be Test::King::ColorLogger
-      end
-
-    end
-
-  end
-
-  describe "feasting" do
-    let( :logger )  { Test::King::Logger.new }
-    let( :options ) { { manager: logger, color: :red } }
-    let( :king )    { Test::King::Mouse.new name: 'mighty' }
-
-
-    describe "#feast_on" do
-      it "assigns attributes" do
-        king.send :feast_on, options
-        expect( king.manager ).to be logger
-      end
-
-      it "doesn't overwrite" do
-        king.manager = Test::King::Logger.new
-        king.send :feast_on, options
-        expect( king.manager ).not_to be logger
-      end
-
-      it "overwrites when asked" do
-        king.manager = Test::King::Logger.new
-        king.send :feast_on, options, true
-        expect( king.manager ).to be logger
-      end
-    end
-
-    describe "feast_on!" do
-      it "assigns attributes" do
-        king.send :feast_on!, options
-        expect( king.manager ).to be logger
-      end
-
-      it "doesn't overwrite" do
-        king.manager = Test::King::Logger.new
-        king.send :feast_on!, options
-        expect( king.manager ).not_to be logger
-      end
-
-      it "overwrites when asked" do
-        king.manager = Test::King::Logger.new
-        king.send :feast_on!, options, true
-        expect( king.manager ).to be logger
-      end
-
-      it "removes injected attributes" do
-        expect( options ).to have_key :manager
-        king.send :feast_on!, options
-        expect( options ).not_to have_key :manager
-      end
-
-      it "removes injected attribute even if already set" do
-        expect( options ).to have_key :manager
-        king.manager = Test::King::Logger.new
-        king.send :feast_on!, options
-        expect( options ).not_to have_key :manager
-      end
-
-      it "doesn't remove other options" do
-        king.send :feast_on!, options
-        expect( options ).to have_key :color
-      end
-
-    end
-  end
-
-end

data/spec/lib/scorpion/prey/builder_prey_spec.rb

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

data/spec/lib/scorpion/prey/module_prey_spec.rb

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

data/spec/lib/scorpion/prey_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-module Test
-  module Prey
-    module Mod; end
-    class Base; end
-    class Derived < Base
-      include Mod
-    end
-  end
-end
-
-describe Scorpion::Prey do
-  context "inheritance" do
-    let( :prey ){ Scorpion::Prey.new( Test::Prey::Derived ) }
-
-    it "matches more derived class when looking for base class" do
-      expect( prey.satisfies? Test::Prey::Base ).to be_truthy
-    end
-
-    it "matches same class when looking for base class" do
-      expect( prey.satisfies? Test::Prey::Derived ).to be_truthy
-    end
-
-    it "does not inherit symbols" do
-      expect( Scorpion::Prey.new( :a ).satisfies? :b ).to be_falsy
-    end
-
-    it "can satisfy a module with a class" do
-      expect( prey.satisfies? Test::Prey::Mod ).to be_truthy
-    end
-
-  end
-
-  describe "traits" do
-
-    context "symbolic" do
-      let( :prey ){ Scorpion::Prey.new Test::Prey::Base, :apples }
-      it "satisfies matched traits" do
-        expect( prey.satisfies? Test::Prey::Base, :apples ).to be_truthy
-      end
-
-      it "doesn't satisfy mis-matched traits" do
-        expect( prey.satisfies? Test::Prey::Base, :oranges ).to be_falsy
-      end
-    end
-
-    context "module" do
-      let( :prey ){ Scorpion::Prey.new Test::Prey::Derived }
-
-      it "satisfies module traits" do
-        expect( prey.satisfies? Test::Prey::Base, Test::Prey::Derived ).to be_truthy
-      end
-    end
-
-  end
-
-  it "can satisfy symbol contracts" do
-    expect( Scorpion::Prey.new( :symbol ).satisfies? :symbol ).to be_truthy
-  end
-
-  it "satisfies ignores tail hash traits" do
-    expect( Scorpion::Prey.new( Test::Prey::Base ).satisfies?( Test::Prey::Base, ) )
-  end
-
-  describe "equality" do
-    let( :prey )      { Scorpion::Prey.new( Test::Prey::Derived ) }
-    let( :same )      { Scorpion::Prey.new( Test::Prey::Derived ) }
-    let( :different ) { Scorpion::Prey.new( Test::Prey::Base ) }
-
-    specify{ expect( prey ).to eq same }
-    specify{ expect( prey ).not_to eq different }
-    specify{ expect( prey.hash ).to eq same.hash }
-  end
-
-end