mutant 0.5.24 → 0.5.25

data/lib/mutant/config.rb

@@ -1,53 +1,21 @@
 module Mutant
   # The configuration of a mutator run
   class Config
-    include Adamantium::Flat, Anima.new(
+    include Adamantium::Flat, Anima::Update, Anima.new(
       :debug,
       :integration,
-      :matcher,
+      :matcher_config,
+      :includes,
+      :requires,
       :reporter,
+      :isolation,
       :fail_fast,
       :zombie,
       :expected_coverage
     )
 
-    # Enumerate subjects
-    #
-    # @api private
-    #
-    # @return [self]
-    #   if block given
-    #
-    # @return [Enumerator<Subject>]
-    #   otherwise
-    #
-    # @api private
-    #
-    def subjects(&block)
-      return to_enum(__method__) unless block_given?
-      matcher.each(&block)
-      self
-    end
-
-    # Return tests for mutation
-    #
-    # TODO: This logic is now centralized but still fucked.
-    #
-    # @param [Mutation] mutation
-    #
-    # @return [Enumerable<Test>]
-    #
-    # @api private
-    #
-    def tests(subject)
-      subject.match_expressions.each do |match_expression|
-        tests = integration.all_tests.select do |test|
-          match_expression.prefix?(test.expression)
-        end
-        return tests if tests.any?
-      end
-
-      EMPTY_ARRAY
+    [:fail_fast, :zombie, :debug].each do |name|
+      define_method(:"#{name}?") { public_send(name) }
     end
 
   end # Config

data/lib/mutant/delegator.rb

@@ -25,6 +25,7 @@ module Mutant
       # @api private
       #
       def define_delegator(name)
+        fail "method #{name} already defined" if instance_methods.include?(name)
         define_method(name) do
           object.public_send(name)
         end
@@ -43,6 +44,7 @@ module Mutant
     #
     def self.included(host)
       super
+
       host.extend(ClassMethods)
     end
 

data/lib/mutant/env.rb

@@ -1,31 +1,43 @@
 module Mutant
   # Abstract base class for mutant environments
   class Env
-    include AbstractType, Adamantium
+    include Adamantium, Concord::Public.new(:config, :cache), Procto.call(:run)
 
-    # Return config
+    # Return new env
     #
-    # @return [Config]
+    # @param [Config] config
+    #
+    # @return [Env]
     #
     # @api private
     #
-    abstract_method :config
+    def self.new(config, cache = Cache.new)
+      super(config, cache)
+    end
 
-    # Return cache
+    # Initialize env
     #
-    # @return [Cache]
+    # @return [undefined]
     #
     # @api private
     #
-    abstract_method :cache
+    def initialize(*)
+      super
+
+      infect
+      initialize_matchable_scopes
+      initialize_subjects
+    end
 
-    # Return reporter
+    # Run mutant producing a report on configured env
     #
-    # @return [Reporter]
+    # @return [Report]
     #
     # @api private
     #
-    abstract_method :reporter
+    def run
+      Runner.call(self)
+    end
 
     # Print warning message
     #
@@ -36,14 +48,105 @@ module Mutant
     # @api private
     #
     def warn(message)
-      reporter.warn(message)
+      config.reporter.warn(message)
       self
     end
 
-    # Boot environment used for matching
-    class Boot < self
-      include Concord::Public.new(:reporter, :cache)
-    end # Boot
+    # Return subjects
+    #
+    # @return [Array<Subject>]
+    #
+    # @api private
+    #
+    attr_reader :subjects
+
+    # Return all usable match scopes
+    #
+    # @return [Array<Matcher::Scope>]
+    #
+    # @api private
+    #
+    attr_reader :matchable_scopes
+
+  private
+
+    # Return scope name
+    #
+    # @param [Class, Module] scope
+    #
+    # @return [String]
+    #   if scope has a name and does not raise exceptions optaining it
+    #
+    # @return [nil]
+    #   otherwise
+    #
+    # @api private
+    #
+    # rubocop:disable LineLength
+    #
+    def scope_name(scope)
+      scope.name
+    rescue => exception
+      warn("While optaining #{scope.class}#name from: #{scope.inspect} It raised an error: #{exception.inspect} fix your lib!")
+      nil
+    end
+
+    # Try to turn scope into expression
+    #
+    # @param [Class, Module] scope
+    #
+    # @return [Expression]
+    #   if scope can be represented in an expression
+    #
+    # @return [nil]
+    #   otherwise
+    #
+    # @api private
+    #
+    def expression(scope)
+      name = scope_name(scope) or return
+
+      unless name.kind_of?(String)
+        warn("#{scope.class}#name from: #{scope.inspect} did not return a String or nil.  Fix your lib to support normal ruby semantics!")
+        return
+      end
+
+      Expression.try_parse(name)
+    end
+
+    # Initialize subjects
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize_subjects
+      @subjects = Matcher::Compiler.call(self, config.matcher_config).to_a
+    end
+
+    # Infect environment
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def infect
+      config.includes.each(&$LOAD_PATH.method(:<<))
+      config.requires.each(&method(:require))
+    end
+
+    # Initialize matchable scopes
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize_matchable_scopes
+      @matchable_scopes = ObjectSpace.each_object(Module).each_with_object([]) do |scope, aggregate|
+        expression = expression(scope)
+        aggregate << Matcher::Scope.new(self, scope, expression) if expression
+      end.sort_by(&:identification)
+    end
 
-  end # ENV
+  end # Env
 end # Mutant

data/lib/mutant/expression.rb

@@ -17,6 +17,12 @@ module Mutant
 
     REGISTRY = {}
 
+    # Error raised on invalid expressions
+    class InvalidExpressionError < RuntimeError; end
+
+    # Error raised on ambigous expressions
+    class AmbigousExpressionError < RuntimeError; end
+
     # Initialize expression
     #
     # @param [MatchData] match
@@ -88,7 +94,7 @@ module Mutant
     # @api private
     #
     def self.parse(input)
-      try_parse(input) or raise "Expression: #{input.inspect} is not valid"
+      try_parse(input) or fail InvalidExpressionError, "Expression: #{input.inspect} is not valid"
     end
 
     # Parse input into expression
@@ -110,7 +116,7 @@ module Mutant
       when 1
         expressions.first
       else
-        fail "Ambigous expression: #{input.inspect}"
+        fail AmbigousExpressionError, "Ambigous expression: #{input.inspect}"
       end
     end
 

data/lib/mutant/expression/method.rb

@@ -4,10 +4,10 @@ module Mutant
     # Explicit method expression
     class Method < self
 
-      MATCHERS = {
+      MATCHERS = IceNine.deep_freeze(
         '.' => Matcher::Methods::Singleton,
         '#' => Matcher::Methods::Instance
-      }.freeze
+      )
 
       register(
         /\A(?<scope_name>#{SCOPE_PATTERN})(?<scope_symbol>[.#])(?<method_name>#{METHOD_NAME_PATTERN})\z/
@@ -15,18 +15,18 @@ module Mutant
 
       # Return method matcher
       #
-      # @param [Cache] cache
+      # @param [Env] env
       #
       # @return [Matcher::Method]
       #
       # @api private
       #
-      def matcher(cache)
-        methods_matcher = MATCHERS.fetch(scope_symbol).new(cache, scope)
+      def matcher(env)
+        methods_matcher = MATCHERS.fetch(scope_symbol).new(env, scope)
         method = methods_matcher.methods.detect do |meth|
           meth.name.equal?(method_name)
         end or raise NameError, "Cannot find method #{identifier}"
-        methods_matcher.matcher.build(cache, scope, method)
+        methods_matcher.matcher.build(env, scope, method)
       end
 
     private
@@ -71,16 +71,6 @@ module Mutant
         match[__method__]
       end
 
-      # Return matcher class
-      #
-      # @return [Class:Mutant::Matcher]
-      #
-      # @api private
-      #
-      def methods_matcher(cache)
-        MATCHERS.fetch(scope_symbol).new(cache, scope)
-      end
-
     end # Method
   end # Expression
 end # Mutant

data/lib/mutant/expression/methods.rb

@@ -4,10 +4,10 @@ module Mutant
     # Abstrat base class for methods expression
     class Methods < self
 
-      MATCHERS = {
+      MATCHERS = IceNine.deep_freeze(
         '.' => Matcher::Methods::Singleton,
         '#' => Matcher::Methods::Instance
-      }.freeze
+      )
 
       register(
         /\A(?<scope_name>#{SCOPE_PATTERN})(?<scope_symbol>[.#])\z/
@@ -15,14 +15,14 @@ module Mutant
 
       # Return method matcher
       #
-      # @param [Cache] cache
+      # @param [Env] env
       #
       # @return [Matcher::Method]
       #
       # @api private
       #
-      def matcher(cache)
-        MATCHERS.fetch(scope_symbol).new(cache, scope)
+      def matcher(env)
+        MATCHERS.fetch(scope_symbol).new(env, scope)
       end
 
     private

data/lib/mutant/expression/namespace.rb

@@ -26,14 +26,14 @@ module Mutant
 
         # Return matcher
         #
-        # @param [Cache] cache
+        # @param [Env] env
         #
         # @return [Matcher]
         #
         # @api private
         #
-        def matcher(cache)
-          Matcher::Namespace.new(cache, self)
+        def matcher(env)
+          Matcher::Namespace.new(env, self)
         end
 
         # Return length of match
@@ -61,7 +61,7 @@ module Mutant
         # @api private
         #
         def namespace
-          match[__method__] || ''
+          match[__method__] || EMPTY_STRING
         end
 
       end # Recursive
@@ -75,14 +75,14 @@ module Mutant
 
         # Return matcher
         #
-        # @param [Cache] cache
+        # @param [Cache] env
         #
         # @return [Matcher]
         #
         # @api private
         #
-        def matcher(cache)
-          Matcher::Scope.new(cache, Mutant.constant_lookup(namespace))
+        def matcher(env)
+          Matcher::Scope.new(env, Mutant.constant_lookup(namespace), self)
         end
 
       private

data/lib/mutant/integration.rb

@@ -44,16 +44,6 @@ module Mutant
       self
     end
 
-    # Perform integration teardown
-    #
-    # @return [self]
-    #
-    # @api private
-    #
-    def teardown
-      self
-    end
-
     # Return all available tests by integration
     #
     # @return [Enumerable<Test>]

data/lib/mutant/isolation.rb

@@ -3,23 +3,49 @@ module Mutant
   module Isolation
     Error = Class.new(RuntimeError)
 
-    # Call block in isolation
-    #
-    # This isolation implements the fork strategy.
-    # Future strategies will probably use a process pool that can
-    # handle multiple mutation kills, in-isolation at once.
-    #
-    # @return [Object]
-    #
-    # @raise [Error]
-    #
-    # @api private
-    #
-    def self.call(&block)
-      Parallel.map([block], in_processes: 1) do
+    module None
+
+      # Call block in isolation
+      #
+      # @return [Object]
+      #
+      # @raise [Error]
+      #   if block terminates abnormal
+      #
+      # @api private
+      #
+      def self.call(&block)
         block.call
-      end.first
+      rescue => exception
+        fail Error, exception
+      end
     end
 
+    module Fork
+
+      # Call block in isolation
+      #
+      # This isolation implements the fork strategy.
+      # Future strategies will probably use a process pool that can
+      # handle multiple mutation kills, in-isolation at once.
+      #
+      # @return [Object]
+      #   returns block execution result
+      #
+      # @raise [Error]
+      #   if block terminates abnormal
+      #
+      # @api private
+      #
+      def self.call(&block)
+        Parallel.map([block], in_processes: 1) do
+          block.call
+        end.first
+      rescue Parallel::DeadWorker => exception
+        fail Error, exception
+      end
+
+    end # Fork
+
   end # Isolator
 end # Mutant