Reduce matcher interface

config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 18
-total_score: 1248
+total_score: 1232

lib/mutant.rb

@@ -132,6 +132,7 @@ def self.ci?
 require 'mutant/loader'
 require 'mutant/context'
 require 'mutant/context/scope'
+require 'mutant/scope'
 require 'mutant/subject'
 require 'mutant/subject/method'
 require 'mutant/subject/method/instance'
@@ -148,6 +149,7 @@ def self.ci?
 require 'mutant/matcher/scope'
 require 'mutant/matcher/filter'
 require 'mutant/matcher/null'
+require 'mutant/matcher/static'
 require 'mutant/expression'
 require 'mutant/expression/parser'
 require 'mutant/expression/method'

lib/mutant/env/bootstrap.rb

@@ -4,10 +4,18 @@ class Env
     class Bootstrap
       include Adamantium::Flat, Concord::Public.new(:config, :cache), Procto.call(:env)
 
-      SEMANTICS_MESSAGE =
-        "Fix your lib to follow normal ruby semantics!\n" \
+      SEMANTICS_MESSAGE_FORMAT =
+        "%<message>s. Fix your lib to follow normal ruby semantics!\n" \
         '{Module,Class}#name should return resolvable constant name as String or nil'.freeze
 
+      CLASS_NAME_RAISED_EXCEPTION =
+        '%<scope_class>s#name from: %<scope>s raised an error: %<exception>s'.freeze
+
+      CLASS_NAME_TYPE_MISMATCH_FORMAT =
+        '%<scope_class>s#name from: %<scope>s returned %<name>s'.freeze
+
+      private_constant(*constants(false))
+
       # Scopes that are eligible for matching
       #
       # @return [Enumerable<Matcher::Scope>]
@@ -84,7 +92,12 @@ def env
       def scope_name(scope)
         scope.name
       rescue => exception
-        warn("#{scope.class}#name from: #{scope.inspect} raised an error: #{exception.inspect}. #{SEMANTICS_MESSAGE}")
+        semantics_warning(
+          CLASS_NAME_RAISED_EXCEPTION,
+          scope_class: scope.class,
+          scope:       scope,
+          exception:   exception.inspect
+        )
         nil
       end
 
@@ -95,7 +108,7 @@ def scope_name(scope)
       # @api private
       def infect
         config.includes.each(&$LOAD_PATH.method(:<<))
-        config.requires.each(&method(:require))
+        config.requires.each(&Kernel.method(:require))
         @integration = config.integration.new(config).setup
       end
 
@@ -105,7 +118,7 @@ def infect
       #
       # @api private
       def matched_subjects
-        Matcher::Compiler.call(self, config.matcher).to_a
+        Matcher::Compiler.call(config.matcher).call(self)
       end
 
       # Initialize matchable scopes
@@ -115,8 +128,8 @@ def matched_subjects
       # @api private
       def initialize_matchable_scopes
         scopes = ObjectSpace.each_object(Module).each_with_object([]) do |scope, aggregate|
-          expression = expression(scope)
-          aggregate << Matcher::Scope.new(self, scope, expression) if expression
+          expression = expression(scope) || next
+          aggregate << Scope.new(scope, expression)
         end
 
         @matchable_scopes = scopes.sort_by { |scope| scope.expression.syntax }
@@ -137,12 +150,27 @@ def expression(scope)
         name = scope_name(scope) or return
 
         unless name.instance_of?(String)
-          warn("#{scope.class}#name from: #{scope.inspect} returned #{name.inspect}. #{SEMANTICS_MESSAGE}")
+          semantics_warning(
+            CLASS_NAME_TYPE_MISMATCH_FORMAT,
+            scope_class: scope.class,
+            scope:       scope,
+            name:        name
+          )
           return
         end
 
         config.expression_parser.try_parse(name)
       end
+
+      # Write a semantics warning
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def semantics_warning(format, options)
+        message = format % options
+        warn(SEMANTICS_MESSAGE_FORMAT % { message: message })
+      end
     end # Boostrap
   end # Env
 end # Mutant

lib/mutant/expression/method.rb

@@ -32,15 +32,13 @@ def syntax
 
       # Matcher for expression
       #
-      # @param [Env] env
-      #
       # @return [Matcher]
       #
       # @api private
-      def matcher(env)
-        methods_matcher = MATCHERS.fetch(scope_symbol).new(env, scope)
+      def matcher
+        methods_matcher = MATCHERS.fetch(scope_symbol).new(scope)
 
-        Matcher::Filter.build(methods_matcher) { |subject| subject.expression.eql?(self) }
+        Matcher::Filter.new(methods_matcher, ->(subject) { subject.expression.eql?(self) })
       end
 
     private

lib/mutant/expression/methods.rb

@@ -26,13 +26,11 @@ def syntax
 
       # Matcher on expression
       #
-      # @param [Env] env
-      #
       # @return [Matcher::Method]
       #
       # @api private
-      def matcher(env)
-        MATCHERS.fetch(scope_symbol).new(env, scope)
+      def matcher
+        MATCHERS.fetch(scope_symbol).new(scope)
       end
 
       # Length of match with other expression

lib/mutant/expression/namespace.rb

@@ -35,13 +35,11 @@ def syntax
 
         # Matcher for expression
         #
-        # @param [Env::Bootstrap] env
-        #
         # @return [Matcher]
         #
         # @api private
-        def matcher(env)
-          Matcher::Namespace.new(env, self)
+        def matcher
+          Matcher::Namespace.new(self)
         end
 
         # Length of match with other expression
@@ -71,13 +69,11 @@ class Exact < self
 
         # Matcher matcher on expression
         #
-        # @param [Env::Bootstrap] env
-        #
         # @return [Matcher]
         #
         # @api private
-        def matcher(env)
-          Matcher::Scope.new(env, Object.const_get(scope_name), self)
+        def matcher
+          Matcher::Scope.new(Object.const_get(scope_name))
         end
 
         # Syntax for expression

lib/mutant/matcher.rb

@@ -1,30 +1,15 @@
 module Mutant
   # Abstract matcher to find subjects to mutate
   class Matcher
-    include Adamantium::Flat, Enumerable, AbstractType
+    include Adamantium::Flat, AbstractType
 
-    # Default matcher build implementation
+    # Call matcher
     #
     # @param [Env] env
-    # @param [Object] input
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def self.build(*arguments)
-      new(*arguments)
-    end
-
-    # Enumerate subjects
-    #
-    # @return [self]
-    #   if block given
     #
     # @return [Enumerable<Subject>]
-    #   otherwise
     #
-    # @api private
-    abstract_method :each
+    abstract_method :call
 
   end # Matcher
 end # Mutant

lib/mutant/matcher/chain.rb

@@ -1,26 +1,20 @@
 module Mutant
   class Matcher
-    # A chain of matchers
+    # Matcher chaining results of other matchers together
     class Chain < self
       include Concord.new(:matchers)
 
-      # Enumerate subjects
+      # Call matcher
       #
-      # @return [Enumerator<Subject]
-      #   if no block given
+      # @param [Env] env
       #
-      # @return [self]
-      #   otherwise
+      # @return [Enumerable<Subject>]
       #
       # @api private
-      def each(&block)
-        return to_enum unless block_given?
-
-        matchers.each do |matcher|
-          matcher.each(&block)
+      def call(env)
+        matchers.flat_map do |matcher|
+          matcher.call(env)
         end
-
-        self
       end
 
     end # Chain

lib/mutant/matcher/compiler.rb

@@ -3,7 +3,7 @@ class Matcher
 
     # Compiler for complex matchers
     class Compiler
-      include Concord.new(:env, :config), AST::Sexp, Procto.call(:result)
+      include Concord.new(:config), AST::Sexp, Procto.call(:result)
 
       # Generated matcher
       #
@@ -12,7 +12,7 @@ class Compiler
       # @api private
       def result
         Filter.new(
-          Chain.build(config.match_expressions.map(&method(:matcher))),
+          Chain.new(config.match_expressions.map(&:matcher)),
           Morpher::Evaluator::Predicate::Boolean::And.new(
             [
               ignored_subjects,
@@ -61,17 +61,6 @@ def filtered_subjects
         Morpher::Evaluator::Predicate::Boolean::And.new(config.subject_filters)
       end
 
-      # Matcher for expression on env
-      #
-      # @param [Mutant::Expression] expression
-      #
-      # @return [Matcher]
-      #
-      # @api private
-      def matcher(expression)
-        expression.matcher(env)
-      end
-
     end # Compiler
   end # Matcher
 end # Mutant

lib/mutant/matcher/filter.rb

@@ -4,30 +4,17 @@ class Matcher
     class Filter < self
       include Concord.new(:matcher, :predicate)
 
-      # New matcher
-      #
-      # @param [Matcher] matcher
-      #
-      # @return [Matcher]
-      #
-      # @api private
-      def self.build(matcher, &predicate)
-        new(matcher, predicate)
-      end
-
       # Enumerate matches
       #
-      # @return [self]
-      #   if block given
+      # @param [Env] env
       #
-      # @return [Enumerator<Subject>]
-      #   otherwise
+      # @return [Enumerable<Subject>]
       #
       # @api private
-      def each(&block)
-        return to_enum unless block_given?
-        matcher.select(&predicate.method(:call)).each(&block)
-        self
+      def call(env)
+        matcher
+          .call(env)
+          .select(&predicate.method(:call))
       end
 
     end # Filter