mutant 0.8.7 → 0.8.8

data/lib/mutant/matcher/static.rb

@@ -0,0 +1,17 @@
+module Mutant
+  class Matcher
+    # Matcher returning subjects already known at its creation time
+    class Static
+      include Concord.new(:subjects)
+
+      # Call matcher
+      #
+      # @return [Enumerable<Subject>]
+      #
+      # @api private
+      def call(_env)
+        subjects
+      end
+    end # Static
+  end # Matcher
+end # Mutant

data/lib/mutant/mutation.rb

@@ -59,15 +59,10 @@ module Mutant
 
     # Insert mutated node
     #
-    # FIXME: Cache subject visibility in a better way! Ideally dont mutate it
-    #   implicitly. Also subject.public? should NOT be a public interface it
-    #   is a detail of method mutations.
-    #
     # @return [self]
     #
     # @api private
     def insert
-      subject.public?
       subject.prepare
       Loader::Eval.call(root, subject)
       self

data/lib/mutant/reporter/cli/format.rb

@@ -41,9 +41,8 @@ module Mutant
           # @return [Boolean]
           #
           # @api private
-          def tty?
-            @tty
-          end
+          alias_method :tty?, :tty
+          public :tty?
 
           %i[puts write].each do |name|
             define_method(name) do |*args, &block|

data/lib/mutant/reporter/cli/printer/env_progress.rb

@@ -10,34 +10,51 @@ module Mutant
             :amount_mutations,
             :amount_mutations_alive,
             :amount_mutations_killed,
+            :amount_mutation_results,
             :runtime,
             :killtime,
             :overhead,
             :env
           )
 
+          # rubocop:disable SpaceInsideBrackets
+          FORMATS = IceNine.deep_freeze([
+            [:info,   'Subjects:        %s',      :amount_subjects          ],
+            [:info,   'Mutations:       %s',      :amount_mutations         ],
+            [:info,   'Results:         %s',      :amount_mutation_results  ],
+            [:info,   'Kills:           %s',      :amount_mutations_killed  ],
+            [:info,   'Alive:           %s',      :amount_mutations_alive   ],
+            [:info,   'Runtime:         %0.2fs',  :runtime                  ],
+            [:info,   'Killtime:        %0.2fs',  :killtime                 ],
+            [:info,   'Overhead:        %0.2f%%', :overhead_percent         ],
+            [:info,   'Mutations/s:     %0.2f',   :mutations_per_second     ],
+            [:status, 'Coverage:        %0.2f%%', :coverage_percent         ],
+            [:status, 'Expected:        %0.2f%%', :expected_coverage_percent]
+          ])
+
           # Run printer
           #
           # @return [undefined]
           #
-          # rubocop:disable AbcSize
-          #
           # @api private
           def run
             visit(Config, env.config)
-            info 'Subjects:        %s',        amount_subjects
-            info 'Mutations:       %s',        amount_mutations
-            info 'Kills:           %s',        amount_mutations_killed
-            info 'Alive:           %s',        amount_mutations_alive
-            info 'Runtime:         %0.2fs',    runtime
-            info 'Killtime:        %0.2fs',    killtime
-            info 'Overhead:        %0.2f%%',   overhead_percent
-            status 'Coverage:        %0.2f%%', coverage_percent
-            status 'Expected:        %0.2f%%', (env.config.expected_coverage * 100)
+            FORMATS.each do |report, format, value|
+              __send__(report, format, __send__(value))
+            end
           end
 
         private
 
+          # Mutations processed per second
+          #
+          # @return [Float]
+          #
+          # @api private
+          def mutations_per_second
+            amount_mutation_results / runtime
+          end
+
           # Coverage in percent
           #
           # @return [Float]
@@ -47,6 +64,15 @@ module Mutant
             coverage * 100
           end
 
+          # Expected coverage in percent
+          #
+          # @return [Float]
+          #
+          # @api private
+          def expected_coverage_percent
+            env.config.expected_coverage * 100
+          end
+
           # Overhead in percent
           #
           # @return [Float]

data/lib/mutant/reporter/cli/printer/status_progressive.rb

@@ -41,7 +41,7 @@ module Mutant
           #
           # @api private
           def object
-            super.payload
+            super().payload
           end
         end # StatusProgressive
       end # Printer

data/lib/mutant/scope.rb

@@ -0,0 +1,6 @@
+module Mutant
+  # Class or Module bound to an exact expression
+  class Scope
+    include Concord::Public.new(:raw, :expression)
+  end # Scope
+end # Mutant

data/lib/mutant/subject/method.rb

@@ -3,13 +3,6 @@ module Mutant
     # Abstract base class for method subjects
     class Method < self
 
-      # Test if method is public
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      abstract_method :public?
-
       # Method name
       #
       # @return [Expression]

data/lib/mutant/subject/method/instance.rb

@@ -7,16 +7,6 @@ module Mutant
         NAME_INDEX = 0
         SYMBOL     = '#'.freeze
 
-        # Test if method is public
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        def public?
-          scope.public_method_defined?(name)
-        end
-        memoize :public?
-
         # Prepare subject for mutation insertion
         #
         # @return [self]

data/lib/mutant/subject/method/singleton.rb

@@ -7,16 +7,6 @@ module Mutant
         NAME_INDEX = 1
         SYMBOL     = '.'.freeze
 
-        # Test if method is public
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        def public?
-          scope.singleton_class.public_method_defined?(name)
-        end
-        memoize :public?
-
         # Prepare subject for mutation insertion
         #
         # @return [self]

data/lib/mutant/version.rb

@@ -1,4 +1,4 @@
 module Mutant
   # Current mutant version
-  VERSION = '0.8.7'.freeze
+  VERSION = '0.8.8'.freeze
 end # Mutant

data/lib/mutant/zombifier.rb

@@ -10,6 +10,7 @@ module Mutant
       :root_require,
       :pathname
     )
+    private(*anima.attribute_names)
 
     include AST::Sexp
 
@@ -56,7 +57,7 @@ module Mutant
     #
     # @api private
     def include?(logical_name)
-      !@zombified.include?(logical_name) && @includes =~ logical_name
+      !@zombified.include?(logical_name) && includes =~ logical_name
     end
 
     # Require file in zombie namespace

data/mutant-rspec.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |gem|
   gem.extra_rdoc_files = %w[TODO LICENSE]
 
   gem.add_runtime_dependency('mutant', "~> #{gem.version}")
-  gem.add_runtime_dependency('rspec-core', '>= 3.2.0', '< 3.4.0')
+  gem.add_runtime_dependency('rspec-core', '>= 3.2.0', '< 3.5.0')
 
   gem.add_development_dependency('bundler', '~> 1.3', '>= 1.3.5')
 end

data/spec/integration/mutant/rspec_spec.rb

@@ -2,7 +2,7 @@ RSpec.describe 'rspec integration', mutant: false do
 
   let(:base_cmd) { 'bundle exec mutant -I lib --require test_app --use rspec' }
 
-  %w[3.2 3.3].each do |version|
+  %w[3.2 3.3 3.4].each do |version|
     context "RSpec #{version}" do
       let(:gemfile) { "Gemfile.rspec#{version}" }
 

data/spec/shared/method_matcher_behavior.rb

@@ -1,38 +1,45 @@
 RSpec.shared_examples_for 'a method matcher' do
-
-  before { subject }
-
   let(:node)              { mutation_subject.node    }
   let(:context)           { mutation_subject.context }
-  let(:mutation_subject)  { yields.first             }
+  let(:mutation_subject)  { subject.first            }
 
-  it 'should return one subject' do
-    expect(yields.size).to be(1)
+  it 'returns one subject' do
+    expect(subject.size).to be(1)
   end
 
-  it_should_behave_like 'an #each method'
-
-  it 'should have correct method name' do
+  it 'has expected method name' do
     expect(name).to eql(method_name)
   end
 
-  it 'should have correct line number' do
+  it 'has epxected line number' do
     expect(node.location.expression.line).to eql(method_line)
   end
 
-  it 'should have correct arity' do
+  it 'has expected arity' do
     expect(arguments.children.length).to eql(method_arity)
   end
 
-  it 'should have correct scope in context' do
+  it 'has expected scope in context' do
     expect(context.scope).to eql(scope)
   end
 
-  it 'should have the correct source path in context' do
+  it 'has source path in context' do
     expect(context.source_path).to eql(source_path)
   end
 
-  it 'should have the correct node type' do
+  it 'has the correct node type' do
     expect(node.type).to be(type)
   end
 end
+
+RSpec.shared_examples_for 'skipped candidate' do
+  it 'does not emit matcher' do
+    expect(subject).to eql([])
+  end
+
+  it 'does warn' do
+    subject
+
+    expect(env.config.reporter.warn_calls).to eql(expected_warnings)
+  end
+end

data/spec/spec_helper.rb

@@ -43,6 +43,12 @@ module ParserHelper
     Unparser.unparse(node)
   end
 
+  def test_env
+    Fixtures::TEST_ENV.with(
+      config: Mutant::Config::DEFAULT.with(reporter: Mutant::Reporter::Trace.new)
+    )
+  end
+
   def parse(string)
     Unparser::Preprocessor.run(Parser::CurrentRuby.parse(string))
   end

data/spec/unit/mutant/env/boostrap_spec.rb

@@ -1,16 +1,29 @@
+# This spec is a good example for:
+#
+# If test look that ugly the class under test sucks.
+#
+# As the bootstrap needs to infect global VM state
+# this is to some degree acceptable.
+#
+# Still the bootstrap needs to be cleaned up.
+# And the change that added this warning did the groundwork.
 RSpec.describe Mutant::Env::Bootstrap do
+  let(:matcher_config)       { Mutant::Matcher::Config::DEFAULT     }
+  let(:integration)          { instance_double(Mutant::Integration) }
+  let(:integration_class)    { instance_double(Class)               }
+  let(:object_space_modules) { []                                   }
+
   let(:config) do
     Mutant::Config::DEFAULT.with(
-      jobs:     1,
-      reporter: Mutant::Reporter::Trace.new,
-      includes: [],
-      requires: [],
-      matcher:  Mutant::Matcher::Config::DEFAULT
+      jobs:        1,
+      reporter:    Mutant::Reporter::Trace.new,
+      includes:    [],
+      requires:    [],
+      integration: integration_class,
+      matcher:     matcher_config
     )
   end
 
-  let(:integration) { Mutant::Integration::Null.new(config) }
-
   let(:expected_env) do
     Mutant::Env.new(
       cache:            Mutant::Cache.new,
@@ -28,16 +41,40 @@ RSpec.describe Mutant::Env::Bootstrap do
     it { should eql(expected_env) }
   end
 
-  let(:object_space_modules) { [] }
-
   before do
-    allow(ObjectSpace).to receive(:each_object).with(Module).and_return(object_space_modules.each)
+    expect(integration_class).to receive(:new)
+      .with(config)
+      .and_return(integration)
+
+    expect(integration).to receive(:setup).and_return(integration)
+
+    expect(ObjectSpace).to receive(:each_object)
+      .with(Module)
+      .and_return(object_space_modules.each)
+  end
+
+  describe '#warn' do
+    let(:object)  { described_class.new(config) }
+    let(:message) { instance_double(String)     }
+
+    subject { object.warn(message) }
+
+    it 'reports a warning' do
+      expect { subject }
+        .to change { object.config.reporter.warn_calls }
+        .from([])
+        .to([message])
+    end
+
+    it_behaves_like 'a command method'
   end
 
   describe '.call' do
     subject { described_class.call(config) }
 
     context 'when Module#name calls result in exceptions' do
+      let(:object_space_modules) { [invalid_class] }
+
       let(:invalid_class) do
         Class.new do
           def self.name
@@ -46,8 +83,6 @@ RSpec.describe Mutant::Env::Bootstrap do
         end
       end
 
-      let(:object_space_modules) { [invalid_class] }
-
       after do
         # Fix Class#name so other specs do not see this one
         class << invalid_class
@@ -59,21 +94,41 @@ RSpec.describe Mutant::Env::Bootstrap do
 
       it 'warns via reporter' do
         expected_warnings = [
-          "Class#name from: #{invalid_class} raised an error: RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
+          "Class#name from: #{invalid_class} raised an error: " \
+          "RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
         ]
 
-        expect { subject }.to change { config.reporter.warn_calls }.from([]).to(expected_warnings)
+        expect { subject }
+          .to change { config.reporter.warn_calls }
+          .from([])
+          .to(expected_warnings)
       end
 
       include_examples 'bootstrap call'
     end
 
-    context 'when includes are present' do
+    context 'when requires are configured' do
+      let(:config) { super().with(requires: %w[foo bar]) }
+
+      before do
+        %w[foo bar].each do |component|
+          expect(Kernel).to receive(:require)
+            .with(component)
+            .and_return(true)
+        end
+      end
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when includes are configured' do
       let(:config) { super().with(includes: %w[foo bar]) }
 
       before do
         %w[foo bar].each do |component|
-          expect($LOAD_PATH).to receive(:<<).with(component).and_return($LOAD_PATH)
+          expect($LOAD_PATH).to receive(:<<)
+            .with(component)
+            .and_return($LOAD_PATH)
         end
       end
 
@@ -81,6 +136,8 @@ RSpec.describe Mutant::Env::Bootstrap do
     end
 
     context 'when Module#name does not return a String or nil' do
+      let(:object_space_modules) { [invalid_class] }
+
       let(:invalid_class) do
         Class.new do
           def self.name
@@ -89,8 +146,6 @@ RSpec.describe Mutant::Env::Bootstrap do
         end
       end
 
-      let(:object_space_modules) { [invalid_class] }
-
       after do
         # Fix Class#name so other specs do not see this one
         class << invalid_class
@@ -101,29 +156,36 @@ RSpec.describe Mutant::Env::Bootstrap do
       end
 
       it 'warns via reporter' do
-
         expected_warnings = [
           "Class#name from: #{invalid_class.inspect} returned Object. #{Mutant::Env::SEMANTICS_MESSAGE}"
         ]
 
-        expect { subject }.to change { config.reporter.warn_calls }.from([]).to(expected_warnings)
+        expect { subject }
+          .to change { config.reporter.warn_calls }
+          .from([]).to(expected_warnings)
       end
 
       include_examples 'bootstrap call'
     end
 
     context 'when scope matches expression' do
-      let(:mutations) { [double('Mutation')]                      }
-      let(:subjects)  { [double('Subject', mutations: mutations)] }
+      let(:object_space_modules) { [TestApp::Literal, TestApp::Empty]                               }
+      let(:match_expressions)    { object_space_modules.map(&:name).map(&method(:parse_expression)) }
 
-      before do
-        expect(Mutant::Matcher::Compiler).to receive(:call).and_return(subjects)
+      let(:matcher_config) do
+        super().with(match_expressions: match_expressions)
       end
 
       let(:expected_env) do
+        subjects = Mutant::Matcher::Scope.new(TestApp::Literal).call(Fixtures::TEST_ENV)
+
         super().with(
-          subjects:  subjects,
-          mutations: mutations
+          matchable_scopes: [
+            Mutant::Scope.new(TestApp::Empty,   match_expressions.last),
+            Mutant::Scope.new(TestApp::Literal, match_expressions.first)
+          ],
+          subjects:         subjects,
+          mutations:        subjects.flat_map(&:mutations)
         )
       end