scorpion-ioc 0.0.1 → 0.1.0

data/lib/scorpion/version.rb

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

data/scorpion.gemspec

@@ -24,4 +24,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", '~> 10'
   spec.add_development_dependency "rspec", '~> 3.00'
+  spec.add_development_dependency "rspec-rails", '~> 3.00'
+  spec.add_development_dependency 'combustion', '~> 0.5.3'
 end

data/spec/internal/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter:  sqlite3
+  database: db/combustion_test.sqlite

data/spec/internal/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  #
+end

data/spec/internal/db/schema.rb

@@ -0,0 +1,3 @@
+ActiveRecord::Schema.define do
+  #
+end

data/spec/internal/log/.gitignore

@@ -0,0 +1 @@
+*.log

data/spec/lib/scorpion/attribute_set_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Scorpion::AttributeSet do
+  let( :set ){ Scorpion::AttributeSet.new }
+
+  it "yields attributes" do
+    set.define do
+     apples 'apples'
+    end
+    expect( set.first ).to be_a Scorpion::Attribute
+  end
+
+  describe "#define" do
+    it "yields itself when arg expected" do
+      set.define do |itself|
+        expect( set ).to be itself
+      end
+    end
+
+    it "yields self as context when no arg expeted" do
+      expect( set ).to receive( :define_attribute )
+      set.define do
+        whatever Scorpion
+      end
+    end
+  end
+
+  describe "define_attribute" do
+    it "adds an expected attribute" do
+      set.define do
+        logger nil
+      end
+
+      expect( set[:logger] ).not_to be_lazy
+    end
+
+    it "adds an allowed attribute" do
+      set.define do
+        logger nil, lazy: true
+      end
+
+      expect( set[:logger] ).to be_lazy
+    end
+
+    it "parses traits" do
+      set.define do
+        with_traits nil, :color
+      end
+
+      expect( set[:with_traits].traits ).to eq [:color]
+    end
+
+    it "parses traits and options" do
+      set.define do
+        both nil, :formatted, lazy: true
+      end
+
+      expect( set[:both] ).to be_formatted
+      expect( set[:both] ).to be_lazy
+    end
+
+
+    it "parses options" do
+      set.define do
+        options nil, lazy: true
+      end
+
+      expect( set[:options] ).to be_lazy
+    end
+  end
+
+  describe "#merge" do
+    it "merges two sets" do
+      a = Scorpion::AttributeSet.new.define do
+        alpha nil
+      end
+
+      b = Scorpion::AttributeSet.new.define do
+        beta nil
+      end
+
+      c = a | b
+
+      expect( c ).to be_key :alpha
+      expect( c ).to be_key :beta
+    end
+  end
+
+end

data/spec/lib/scorpion/attribute_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Scorpion::Attribute do
+  it "responds to trait? methods" do
+    attr = Scorpion::Attribute.new :name, :contract, :formatted
+    expect( attr ).to be_formatted
+  end
+end

data/spec/lib/scorpion/error_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Scorpion::UnsuccessfulHunt do
+  it "formats the default message" do
+    expect( Scorpion::UnsuccessfulHunt.new( :attr ).message ).to match /builder/
+  end
+
+end

data/spec/lib/scorpion/hunter_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Test
+  module Hunter
+    class Beast; end
+    class Bear < Beast; end
+    class Lion < Beast; end
+    class Grizly < Bear; end
+    class Argumented
+      def initialize( arg )
+        @arg = arg
+      end
+      attr_reader :arg
+    end
+    class Implicit; end
+
+    class Zoo
+      include Scorpion::King
+
+      feed_on do
+        bear Bear
+      end
+    end
+  end
+end
+
+describe Scorpion::Hunter do
+
+  let( :hunter ) do
+    Scorpion::Hunter.new do
+      hunt_for Test::Hunter::Bear
+      hunt_for Test::Hunter::Lion, :male
+      hunt_for Test::Hunter::Grizly, :female
+      hunt_for Test::Hunter::Argumented
+
+      capture Test::Hunter::Lion, :tame
+      hunt_for Test::Hunter::Zoo
+    end
+  end
+
+  it "spawns prey" do
+    expect( hunter.hunt! Test::Hunter::Beast ).to be_a Test::Hunter::Bear
+  end
+
+  it "spawns a new instance for multiple requests" do
+    first = hunter.hunt! Test::Hunter::Beast
+    expect( hunter.hunt! Test::Hunter::Beast ).not_to eq first
+  end
+
+  it "spawns the same instance for captured prey" do
+    first = hunter.hunt_by_traits! Test::Hunter::Beast, :tame
+    expect( hunter.hunt_by_traits! Test::Hunter::Beast, :tame ).to be first
+  end
+
+  it "injects nested kings" do
+    zoo = hunter.hunt! Test::Hunter::Zoo
+    expect( zoo.bear ).to be_a Test::Hunter::Bear
+  end
+
+  it "accepts arguments that are passed to constructor" do
+    obj = hunter.hunt! Test::Hunter::Argumented, :awesome
+    expect( obj.arg ).to eq :awesome
+  end
+
+  it "implicitly spawns Class contracts" do
+    expect( hunter.hunt! Test::Hunter::Implicit ).to be_a Test::Hunter::Implicit
+  end
+
+end

data/spec/lib/scorpion/hunting_map_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module Test
+  module HuntingMap
+    class Weapon; end
+    class Armor; end
+  end
+end
+
+describe Scorpion::HuntingMap do
+  let( :scorpion ){ double Scorpion }
+  let( :map ){ Scorpion::HuntingMap.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::HuntingMap::Weapon
+        hunt_for Test::HuntingMap::Armor
+      end
+
+      expect( map.find( Test::HuntingMap::Armor ).contract ).to eq Test::HuntingMap::Armor
+    end
+
+    it "returns nil when no match" do
+      map.chart do
+        hunt_for Test::HuntingMap::Weapon
+      end
+
+      expect( map.find( Test::HuntingMap::Armor ) ).to be_nil
+    end
+
+    it "returns nil when no match" do
+      map.chart do
+        hunt_for Test::HuntingMap::Weapon
+      end
+
+      expect( map.find( Test::HuntingMap::Armor ) ).to be_nil
+    end
+
+
+    context "multiple possible matches" do
+      before( :each ) do
+        map.chart do
+          hunt_for Test::HuntingMap::Weapon, [ :sharp, :one_handed ]
+          hunt_for Test::HuntingMap::Weapon, [ :blunt, :one_handed ]
+        end
+      end
+
+      it "returns the first prey that matches one trait" do
+        expect( map.find( Test::HuntingMap::Weapon, :one_handed ).traits ).to include :sharp
+      end
+
+      it "returns the first prey that matches all of the traits" do
+        expect( map.find( Test::HuntingMap::Weapon, [ :one_handed, :blunt ] ).traits ).to include :blunt
+      end
+
+      it "returns the first prey that matches a unique trait" do
+        expect( map.find( Test::HuntingMap::Weapon, :blunt ).traits ).to include :blunt
+      end
+    end
+  end
+
+  describe "#hunt_for" do
+    it "adds a Prey" do
+      expect( map ).to be_empty
+
+      map.chart do
+        hunt_for Test::HuntingMap::Weapon
+      end
+
+      expect( map.first ).to be_a Scorpion::Prey
+    end
+
+    it "adds a BuilderPrey for block hunts" do
+      map.chart do
+        hunt_for String do
+          "YASS"
+        end
+      end
+
+      expect( map.first ).to be_a Scorpion::Prey::BuilderPrey
+    end
+  end
+
+  describe "#replicate_from" do
+    it "does not dup shared prey" do
+      map.chart do
+        share do
+          capture Test::HuntingMap::Weapon
+        end
+      end
+
+      replica = Scorpion::HuntingMap.new scorpion
+      replica.replicate_from( map )
+
+      expect( replica ).to be_empty
+    end
+
+    it "dups captured prey" do
+      map.chart do
+        capture Test::HuntingMap::Weapon
+      end
+
+      replica = Scorpion::HuntingMap.new scorpion
+      replica.replicate_from( map )
+
+      expect( replica ).not_to be_empty
+    end
+  end
+end

data/spec/lib/scorpion/king_spec.rb

@@ -0,0 +1,129 @@
+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   = 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 "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
+
+
+end