scorpion-ioc 0.6.2 → 1.0.0

data/lib/scorpion/attribute.rb

@@ -18,56 +18,36 @@ module Scorpion
         @contract
       end
 
-    # @!attribute
-    # @return [Array<Symbol>] traits that must match on instances of the {#contract}
-      attr_reader :traits
-
     # @!attribute
     # @return [Boolean] true if the attribute is not immediately required and
     #   will be hunted down on first use.
-      def lazy?; @lazy end
+      def lazy?
+        @lazy
+      end
 
     # @!attribute
     # @return [Boolean] true if the attribute should have a public writer.
-      def public?; @public end
+      def public?
+        @public
+      end
 
     # @!attribute
     # @return [Boolean] true if the attribute should have a public writer.
-      def private?; @private end
+      def private?
+        @private
+      end
 
     #
     # @!endgroup Attributes
 
 
-    def initialize( name, contract, traits = nil, options = {} )
+    def initialize( name, contract, lazy: false, public: false, private: false )
       @name      = name.to_sym
       @contract  = contract
-      @traits    = Array( traits ).flatten.freeze
-      @trait_set = Set.new( @traits.map{ |t| :"#{t}?" } )
-      @lazy      = options.fetch( :lazy, false )
-      @public    = options.fetch( :public, false )
-      @private   = options.fetch( :private, false )
+      @lazy      = lazy
+      @public    = public
+      @private   = private
     end
 
-    def respond_to?( name, include_all = false )
-      super || trait_set.include?( name )
-    end
-
-    private
-      # @return [Set] the set of traits associated with the attribute pre-processed
-      #   to include the trait names with a '?' suffix.
-        attr_reader :trait_set
-
-      def method_missing( name, *args )
-        if is_trait_method?( name )
-          trait_set.include? name
-        else
-          super
-        end
-      end
-
-      def is_trait_method?( name )
-        name[-1] == '?'
-      end
   end
-end
+end

data/lib/scorpion/attribute_set.rb

@@ -1,4 +1,4 @@
-require 'scorpion/attribute'
+require "scorpion/attribute"
 
 module Scorpion
   class AttributeSet
@@ -13,7 +13,7 @@ module Scorpion
     end
 
     def each( &block )
-      attributes.each do |k,v|
+      attributes.each_value do |v|
         yield v
       end
     end
@@ -36,9 +36,8 @@ module Scorpion
     end
 
     # Defines the food that {Scorpion::Object} will feed on. A food is defined by
-    # invoking a method with the desired name passing the contract and traits
-    # desired. AttributeSet uses method_missing to dynamically define
-    # attributes.
+    # invoking a method with the desired name passing the contract desired.
+    # AttributeSet uses method_missing to dynamically define attributes.
     #
     # If the block takes an argument, AttributeSet will yield to the block
     # passing itself. If no argument is provided, yield will use the
@@ -71,16 +70,13 @@ module Scorpion
     end
 
     # Define a single attribute with the given name that expects food that will
-    # satisfy the contract and traits.
+    # satisfy the contract.
     # @param [String] name of the attribute.
     # @param [Class,Module,Symbol] contract that describes the desired behavior
     #   of the injected object.
-    # @param [Array<Symbol>] traits that must match on instances of the {#contract}
     # @return [Attribute] the attribute that was created.
-    def define_attribute( name, contract, *traits )
-      options = traits.pop if traits.last.is_a? Hash
-      options ||= {}
-      attributes[name.to_sym] = Attribute.new name, contract, traits, options
+    def define_attribute( name, contract, **options )
+      attributes[name.to_sym] = Attribute.new name, contract, options
     end
 
 
@@ -90,7 +86,7 @@ module Scorpion
 
     private
 
-      def method_missing( name, *args )
+      def method_missing( name, *args ) # rubocop:disable Style/MethodMissing
         return super unless @defining_attributes
 
         if args.length >= 1
@@ -100,5 +96,7 @@ module Scorpion
         end
       end
 
+
+
   end
-end
+end

data/lib/scorpion/chain_hunter.rb

@@ -39,7 +39,7 @@ module Scorpion
       scorpions.each do |hunter|
         begin
           return hunter.execute( hunt, true )
-        rescue UnsuccessfulHunt
+        rescue UnsuccessfulHunt # rubocop:disable Lint/HandleExceptions
         end
       end
 
@@ -47,12 +47,12 @@ module Scorpion
       scorpions.each do |hunter|
         begin
           return hunter.execute( hunt )
-        rescue UnsuccessfulHunt
+        rescue UnsuccessfulHunt # rubocop:disable Lint/HandleExceptions
         end
       end
 
-      unsuccessful_hunt hunt.contract, hunt.traits
+      unsuccessful_hunt hunt.contract
     end
 
   end
-end
+end

data/lib/scorpion/dependency.rb

@@ -2,11 +2,11 @@ module Scorpion
   # Dependency that can be injected into a {Scorpion::Object} by a {Scorpion}.
   class Dependency
 
-    require 'scorpion/dependency/captured_dependency'
-    require 'scorpion/dependency/class_dependency'
-    require 'scorpion/dependency/module_dependency'
-    require 'scorpion/dependency/builder_dependency'
-    require 'scorpion/dependency/argument_dependency'
+    require "scorpion/dependency/captured_dependency"
+    require "scorpion/dependency/class_dependency"
+    require "scorpion/dependency/module_dependency"
+    require "scorpion/dependency/builder_dependency"
+    require "scorpion/dependency/argument_dependency"
 
     # ============================================================================
     # @!group Attributes
@@ -14,23 +14,18 @@ module Scorpion
 
     # @!attribute
     # @return [Class,Module,Symbol] contract describing the desired behavior of the dependency.
-      attr_reader :contract
-
-    # @!attribute
-    # @return [Array<Symbol>] the traits available on the dependency.
-      attr_reader :traits
+    attr_reader :contract
 
     #
     # @!endgroup Attributes
 
-    def initialize( contract, traits = nil )
+    def initialize( contract )
       @contract = contract
-      @traits   = Set.new( Array( traits ) )
     end
 
-    # @return [Boolean] if the dependency satisfies the required contract and traits.
-    def satisfies?( contract, traits = nil )
-      satisfies_contract?( contract ) && satisfies_traits?( traits )
+    # @return [Boolean] if the dependency satisfies the required contract.
+    def satisfies?( contract )
+      satisfies_contract?( contract )
     end
 
     # Fetch an instance of the dependency.
@@ -52,21 +47,16 @@ module Scorpion
 
     def ==( other )
       return unless other
-      self.class == other.class &&
-      contract   == other.contract &&
-      traits     == other.traits
+      self.class == other.class && contract == other.contract
     end
     alias_method :eql?, :==
 
     def hash
-      self.class.hash ^
-      contract.hash ^
-      traits.hash
+      self.class.hash ^ contract.hash
     end
 
     def inspect
       result = "<#{ contract.inspect }"
-      result << " traits=#{ traits.to_a.inspect }" if traits.present?
       result << ">"
       result
     end
@@ -82,60 +72,34 @@ module Scorpion
         end
       end
 
-      # @return [Boolean] true if the pray satisfies the given contract.
-      def satisfies_traits?( traits )
-        return true if traits.blank?
-
-        Array( traits ).all? do |trait|
-          case trait
-          when Symbol then self.traits.include? trait
-          when Module then self.contract <= trait
-          else fail ArgumentError, "Unsupported trait"
-          end
-        end
-      end
-
     class << self
 
-      # Define dependency based on the desired contract and traits.
+      # Define dependency based on the desired contract.
       # @return [Dependency] the defined dependency.
-      def define( contract, traits = nil, &builder )
-        options, traits = extract_options!( traits )
-
+      def define( contract, options = {}, &builder )
         if options.key?( :return )
-          Scorpion::Dependency::BuilderDependency.new( contract, traits ) do
+          Scorpion::Dependency::BuilderDependency.new( contract ) do
             options[:return]
           end
-        elsif with = options[:with]
-          Scorpion::Dependency::BuilderDependency.new( contract, traits, with )
+        elsif with = options[ :with ]
+          Scorpion::Dependency::BuilderDependency.new( contract, with )
         elsif block_given?
-          Scorpion::Dependency::BuilderDependency.new( contract, traits, builder )
+          Scorpion::Dependency::BuilderDependency.new( contract, builder )
 
         # Allow a Class/Module to define a #create method that will resolve
         # and return an instance of itself. Do not automatically inherit the
         # #create method so only consider it if the owner of the method is the
         # contract itself.
         elsif contract.respond_to?( :create ) && contract.singleton_methods( false ).include?( :create )
-          Scorpion::Dependency::BuilderDependency.new( contract, traits ) do |hunt,*args,**dependencies,&block|
-            contract.create hunt, *args, **dependencies, &block
+          Scorpion::Dependency::BuilderDependency.new( contract ) do |hunt, *args, &block|
+            contract.create hunt, *args, &block
           end
         else
-          dependency_class( contract ).new( contract, traits, &builder )
+          dependency_class( contract ).new( contract, &builder )
         end
       end
 
       private
-        def extract_options!( traits )
-          case traits
-          when Hash then return [ traits, nil ]
-          when Array then
-            if traits.last.is_a? Hash
-              return [ traits.pop, traits ]
-            end
-          end
-
-          [ {}, traits]
-        end
 
         def dependency_class( contract, &builder )
           return Scorpion::Dependency::ClassDependency   if contract.is_a? Class
@@ -146,4 +110,4 @@ module Scorpion
     end
 
   end
-end
+end

data/lib/scorpion/dependency/argument_dependency.rb

@@ -1,4 +1,4 @@
-require 'scorpion/dependency'
+require "scorpion/dependency"
 
 module Scorpion
   class Dependency
@@ -16,10 +16,10 @@ module Scorpion
         argument
       end
 
-      def satisfies?( contract, traits = nil )
-        contract === argument && traits.blank?
+      def satisfies?( contract )
+        contract === argument
       end
 
     end
   end
-end
+end

data/lib/scorpion/dependency/builder_dependency.rb

@@ -1,4 +1,4 @@
-require 'scorpion/dependency'
+require "scorpion/dependency"
 
 module Scorpion
   class Dependency
@@ -17,16 +17,16 @@ module Scorpion
       #
       # @!endgroup Attributes
 
-      def initialize( contract, traits = nil, builder = nil, &block )
+      def initialize( contract, builder = nil, &block )
         @builder = block_given? ? block : builder
-        super contract, traits
+        super contract
       end
 
       # @see Scorpion::Dependency#fetch
       def fetch( hunt )
-        builder.call( hunt, *hunt.arguments, **hunt.dependencies, &hunt.block )
+        builder.call( hunt, *hunt.arguments, &hunt.block )
       end
 
     end
   end
-end
+end

data/lib/scorpion/dependency/captured_dependency.rb

@@ -1,4 +1,4 @@
-require 'scorpion/dependency'
+require "scorpion/dependency"
 
 module Scorpion
   class Dependency
@@ -20,7 +20,7 @@ module Scorpion
         private :specific_dependency
 
 
-      delegate [:contract,:traits,:satisfies?] => :specific_dependency
+      delegate [ :contract, :satisfies? ] => :specific_dependency
 
       #
       # @!endgroup Attributes
@@ -41,11 +41,9 @@ module Scorpion
 
       # @see Dependency#replicate
       def replicate
-        dup.tap do |replica|
-          replica.release
-        end
+        dup.tap(&:release)
       end
 
     end
   end
-end
+end

data/lib/scorpion/dependency/class_dependency.rb

@@ -1,4 +1,4 @@
-require 'scorpion/dependency'
+require "scorpion/dependency"
 
 module Scorpion
   class Dependency
@@ -6,23 +6,9 @@ module Scorpion
     class ClassDependency < Scorpion::Dependency
 
       def fetch( hunt )
-        resolved = resolve_dependencies( hunt )
-        hunt.scorpion.spawn hunt, hunt.contract, *hunt.arguments, **resolved, &hunt.block
+        hunt.scorpion.spawn hunt, hunt.contract, *hunt.arguments, &hunt.block
       end
 
-      private
-
-        def resolve_dependencies( hunt )
-          dependencies = hunt.dependencies
-          return dependencies unless hunt.contract.respond_to? :initializer_injections
-
-          hunt.contract.initializer_injections.each_with_object(dependencies.dup) do |attr,deps|
-            next if attr.lazy?
-
-            deps[attr.name] ||= hunt.fetch_by_traits( attr.contract, attr.traits )
-          end
-        end
-
     end
   end
-end
+end

data/lib/scorpion/dependency/module_dependency.rb

@@ -1,4 +1,4 @@
-require 'scorpion/dependency'
+require "scorpion/dependency"
 
 module Scorpion
   class Dependency

data/lib/scorpion/dependency_map.rb

@@ -1,3 +1,5 @@
+require "forwardable"
+
 module Scorpion
   # {#chart} available {Dependency} and {#find} them based on desired
   # {Scorpion::Attribute attributes}.
@@ -33,13 +35,12 @@ module Scorpion
       reset
     end
 
-    # Find {Dependency} that matches the requested `contract` and `traits`.
+    # Find {Dependency} that matches the requested `contract`.
     # @param [Class,Module,Symbol] contract describing the desired behavior of the dependency.
-    # @param [Array<Symbol>] traits found on the {Dependency}.
     # @return [Dependency] the dependency matching the attribute.
-    def find( contract, traits = nil )
-      dependency_set.find{ |p| p.satisfies?( contract, traits ) } ||
-      shared_dependency_set.find{ |p| p.satisfies?( contract, traits ) }
+    def find( contract )
+      dependency_set.find { |p| p.satisfies?( contract ) } ||
+        shared_dependency_set.find { |p| p.satisfies?( contract ) }
     end
 
     # Chart the {Dependency} that this hunting map can {#find}.
@@ -75,24 +76,23 @@ module Scorpion
       self
     end
 
-    # Define {Dependency} that can be found on this map by `contract` and `traits`.
+    # Define {Dependency} that can be found on this map by `contract`.
     #
     # If a block is given, it will be used build the actual instances of the
     # dependency for the {Scorpion}.
     #
     # @param [Class,Module,Symbol] contract describing the desired behavior of the dependency.
-    # @param [Array<Symbol>] traits found on the {Dependency}.
     # @return [Dependency] the dependency to be hunted for.
-    def hunt_for( contract, traits = nil, &builder )
-      active_dependency_set.unshift define_dependency( contract, traits, &builder )
+    def hunt_for( contract, **options, &builder )
+      active_dependency_set.unshift define_dependency( contract, options, &builder )
     end
 
     # Captures a single dependency and returns the same instance fore each request
     # for the resource.
     # @see #hunt_for
     # @return [Dependency] the dependency to be hunted for.
-    def capture( contract, traits = nil, &builder )
-      active_dependency_set.unshift Dependency::CapturedDependency.new( define_dependency( contract, traits, &builder ) )
+    def capture( contract, **options, &builder )
+      active_dependency_set.unshift Dependency::CapturedDependency.new( define_dependency( contract, options, &builder ) ) # rubocop:disable Metrics/LineLength
     end
     alias_method :singleton, :capture
 
@@ -127,8 +127,8 @@ module Scorpion
 
     # Remove all dependency mappings.
     def reset
-      @dependency_set.each &:release        if @dependency_set
-      @shared_dependency_set.each &:release if @shared_dependency_set
+      @dependency_set&.each &:release
+      @shared_dependency_set&.each &:release
 
       @dependency_set        = @active_dependency_set = []
       @shared_dependency_set = []
@@ -136,8 +136,8 @@ module Scorpion
 
     private
 
-      def define_dependency( contract, traits, &builder )
-        Dependency.define contract, traits, &builder
+      def define_dependency( contract, options, &builder )
+        Dependency.define contract, options, &builder
       end
   end
-end
+end