Add source match expression

docs/configuration.md

@@ -126,6 +126,7 @@ matcher:
   - Your::App::Namespace#some_method # select a specific instance method
   - Your::App::Namespace.some_method # select a specific class method
   - descendants:ApplicationController # select all descendands of application controller (and itself)
+  - source:lib/**/*.rb # select all subjects that are defined in toplevel constants (modules and classes), recursively
   # Expressions of subjects to ignore during mutation testing.
   # Multiple entries are allowed and matches from each expression
   # are unioned.

lib/mutant.rb

@@ -204,6 +204,7 @@ module Mutant
     require 'mutant/expression/methods'
     require 'mutant/expression/namespace'
     require 'mutant/expression/parser'
+    require 'mutant/expression/source'
     require 'mutant/test'
     require 'mutant/test/runner'
     require 'mutant/test/runner/sink'
@@ -347,7 +348,8 @@ class Config
           Expression::Method,
           Expression::Methods,
           Expression::Namespace::Exact,
-          Expression::Namespace::Recursive
+          Expression::Namespace::Recursive,
+          Expression::Source
         ]
       ),
       environment_variables: EMPTY_HASH,

lib/mutant/bootstrap.rb

@@ -38,7 +38,7 @@ def self.call(env)
           .with(matchable_scopes: matchable_scopes(env))
 
         matched_subjects = env.record(:subject_match) do
-          Matcher.from_config(env.config.matcher).call(env)
+          Matcher.expand(env: env).call(env)
         end
 
         selected_subjects = subject_select(env, matched_subjects)

lib/mutant/expression/descendants.rb

@@ -11,7 +11,8 @@ def syntax
         "descendants:#{const_name}"
       end
 
-      def matcher
+      # rubocop:disable Lint/UnusedMethodArgument
+      def matcher(env:)
         Matcher::Descendants.new(const_name: const_name)
       end
     end # Descendants

lib/mutant/expression/method.rb

@@ -39,7 +39,9 @@ def initialize(*)
       # Matcher for expression
       #
       # @return [Matcher]
-      def matcher
+      #
+      # rubocop:disable Lint/UnusedMethodArgument
+      def matcher(env:)
         matcher_candidates = MATCHERS.fetch(scope_symbol)
           .map { |submatcher| submatcher.new(scope: scope) }
 

lib/mutant/expression/methods.rb

@@ -34,7 +34,9 @@ def initialize(*)
       # Matcher on expression
       #
       # @return [Matcher::Method]
-      def matcher
+      #
+      # rubocop:disable Lint/UnusedMethodArgument
+      def matcher(env:)
         matcher_candidates = MATCHERS.fetch(scope_symbol)
           .map { |submatcher| submatcher.new(scope: scope) }
 

lib/mutant/expression/namespace.rb

@@ -34,7 +34,9 @@ def initialize(*)
         # Matcher for expression
         #
         # @return [Matcher]
-        def matcher
+        #
+        # rubocop:disable Lint/UnusedMethodArgument
+        def matcher(env:)
           Matcher::Namespace.new(expression: self)
         end
 
@@ -65,7 +67,7 @@ class Exact < self
         # Matcher matcher on expression
         #
         # @return [Matcher]
-        def matcher
+        def matcher(env:)
           raw_scope = find_raw_scope
 
           if raw_scope

lib/mutant/expression/source.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Expression
+    class Source < self
+      include Anima.new(:glob_expression)
+
+      REGEXP = /\Asource:(?<glob_expression>.+)\z/
+
+      def syntax
+        "source:#{glob_expression}"
+      end
+
+      def matcher(env:)
+        Matcher::Chain.new(matchers: find_matchers(env: env))
+      end
+
+    private
+
+      def find_matchers(env:)
+        scope_names(env: env).uniq.map do |scope_name|
+          Namespace::Recursive.new(scope_name: scope_name).matcher(env: nil)
+        end
+      end
+
+      def scope_names(env:)
+        env.world.pathname.glob(glob_expression).flat_map do |path|
+          toplevel_consts(env.parser.call(path).node).map(&Unparser.public_method(:unparse))
+        end
+      end
+
+      def toplevel_consts(node)
+        children = node.children
+
+        case node.type
+        when :class, :module
+          [children.fetch(0)]
+        when :begin
+          children.flat_map(&method(__method__))
+        else
+          EMPTY_ARRAY
+        end
+      end
+    end # Source
+  end # Expression
+end # Mutant

lib/mutant/matcher.rb

@@ -15,13 +15,15 @@ class Matcher
 
     # Turn config into matcher
     #
-    # @param [Config] config
+    # @param [Env] env
     #
     # @return [Matcher]
-    def self.from_config(config)
+    def self.expand(env:)
+      matcher_config = env.config.matcher
+
       Filter.new(
-        matcher:   Chain.new(matchers: config.subjects.map(&:matcher)),
-        predicate: method(:allowed_subject?).curry.call(config)
+        matcher:   Chain.new(matchers: matcher_config.subjects.map { |subject| subject.matcher(env: env) }),
+        predicate: method(:allowed_subject?).curry.call(matcher_config)
       )
     end
 

lib/mutant/parser.rb

@@ -18,7 +18,7 @@ def initialize
     #
     # @return [AST::Node]
     def call(path)
-      @cache[path] ||= parse(path.read)
+      @cache[path.expand_path] ||= parse(path.read)
     end
 
   private

spec/unit/mutant/expression/descendants_spec.rb

@@ -6,7 +6,7 @@
 
   describe '#matcher' do
     def apply
-      object.matcher
+      object.matcher(env: instance_double(Mutant::Env))
     end
 
     it 'returns expected matcher' do

spec/unit/mutant/expression/method_spec.rb

@@ -25,7 +25,7 @@
   end
 
   describe '#matcher' do
-    subject { object.matcher }
+    subject { object.matcher(env: instance_double(Mutant::Env)) }
 
     context 'with an instance method' do
       let(:input) { instance_method }

spec/unit/mutant/expression/methods_spec.rb

@@ -48,7 +48,7 @@
   end
 
   describe '#matcher' do
-    subject { object.matcher }
+    subject { object.matcher(env: instance_double(Mutant::Env)) }
 
     let(:scope) do
       Mutant::Scope.new(

spec/unit/mutant/expression/namespace/exact_spec.rb

@@ -5,7 +5,7 @@
   let(:input)  { 'TestApp::Literal'      }
 
   describe '#matcher' do
-    subject { object.matcher }
+    subject { object.matcher(env: instance_double(Mutant::Env)) }
 
     let(:scope) do
       Mutant::Scope.new(

spec/unit/mutant/expression/namespace/recursive_spec.rb

@@ -5,7 +5,7 @@
   let(:input)  { 'TestApp::Literal*'     }
 
   describe '#matcher' do
-    subject { object.matcher }
+    subject { object.matcher(env: instance_double(Mutant::Env)) }
 
     it { should eql(Mutant::Matcher::Namespace.new(expression: object)) }
   end