mutaruby 0.1.0 → 0.1.1

data/lib/mutaruby/runner.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-require_relative 'generator'
 require_relative 'ignore_file'
 require_relative 'sandbox'
 require_relative 'command'
@@ -31,82 +29,79 @@ module Mutaruby
 
     Options = Struct.new(:root, :command, :patterns, :since, :jobs, :timeout, :timeout_factor, :methods,
                          :exclude_methods, :lines, :exclude_lines, :shard, :ignore_file, :operators, :copy_excludes,
-                         :progress, :keyword_init => true)
+                         :progress, keyword_init: true) do
+      def self.build(**kw)
+        new(root: '.', patterns: [], jobs: 1, timeout_factor: 3.0, methods: [], exclude_methods: [], lines: [],
+            exclude_lines: [], copy_excludes: [], progress: false, **kw)
+      end
+    end
+
+    MARK = { killed: '.', timeout: 'T', survived: 'S', equivalent: 'e' }.freeze
 
     def initialize(opts, out: $stderr)
       @o = opts
       @out = out
-      @root = File.expand_path(opts.root || Dir.pwd)
-      @warnings = []
+      @root = File.expand_path(opts.root)
     end
 
     # Mutants of the selected files after every filter, plus what is needed to report them.
     def plan
-      @plan ||= begin
-        sel = selection
-        files = sel.files
-        sources = files.to_h { |f| [f, File.read(File.join(@root, f), encoding: 'UTF-8')] }
-        all = files.flat_map do |f|
-          g = Generator.new(sources[f], path: File.join(@root, f), rel: f, operators: operator_set)
-          ms = g.mutations
-          @warnings.concat(g.errors)
-          ms
-        end
-        all.each_with_index { |m, i| m.id = i }
-        ignore = load_ignore
-        if ignore
-          errs = ignore.validate(sources)
-          raise Error, "ignore file #{ignore.path}:\n  #{errs.join("\n  ")}" if errs.any?
-        end
-        { files: files, sources: sources, mutations: sel.filter(all), ignore: ignore, complete: sel.complete? && @o.operators.nil? }
+      sel = selection
+      files = sel.files
+      sources = files.to_h { |f| [f, File.read(File.join(@root, f), encoding: 'UTF-8')] }
+      warnings = []
+      all = files.flat_map do |f|
+        g = Generator.new(sources[f], path: File.join(@root, f), rel: f, operators: @o.operators)
+        ms = g.mutations
+        warnings.concat(g.errors)
+        ms
       end
+      all.each_with_index { |m, i| m.id = i }
+      ignore = load_ignore
+      errs = ignore ? ignore.validate(sources) : []
+      raise Error, "ignore file #{ignore.path}:\n  #{errs.join("\n  ")}" if errs.any?
+
+      { files: files, sources: sources, mutations: sel.filter(all), ignore: ignore, warnings: warnings,
+        complete: sel.complete? && @o.operators.nil? }
     end
 
     def run
-      t0 = monotonic
-      p = plan
       sandboxes = []
-      sandboxes << Sandbox.new(@root, excludes: @o.copy_excludes || [])
       cmd = Command.new(@o.command, root: @root)
-      base = cmd.run(sandboxes[0].dir, capture: true)
+      t0 = monotonic
+      p = plan
+      first = Sandbox.new(@root, excludes: @o.copy_excludes)
+      sandboxes << first
+      base = cmd.run(first.dir, capture: true)
       unless base.passed?
-        raise BaselineFailed, "the test command fails on the UNMUTATED code (#{base.timeout? ? 'timed out' : "exit #{base.exitstatus}"}); " \
-                              "every mutant would count as killed, so nothing would be measured.\n" \
-                              "command: #{@o.command}\n--- output (tail) ---\n#{base.output}"
+        raise BaselineFailed, "the test command fails on the UNMUTATED code (exit #{base.exitstatus}); every mutant " \
+                              "would count as killed, so nothing would be measured.\ncommand: #{@o.command}\n" \
+                              "--- output (tail) ---\n#{base.output}"
       end
-      timeout = @o.timeout || ((base.seconds * (@o.timeout_factor || 3.0)) + 5).ceil
+      timeout = @o.timeout || ((base.seconds * @o.timeout_factor) + 5).ceil
       outcomes = execute(p, cmd, sandboxes, timeout)
-      stale = []
-      if p[:ignore]
-        matched = outcomes.select { |o| o.status == :equivalent }.map(&:ignore).to_set
-        stale = p[:complete] ? p[:ignore].stale(matched, p[:files]) : []
-      end
+      matched = outcomes.select { |o| o.status == :equivalent }.map(&:ignore)
+      stale = p[:ignore] && p[:complete] ? p[:ignore].stale(matched, p[:files]) : []
       Report.new(root: @root, command: @o.command, files: p[:files], outcomes: outcomes, sources: p[:sources],
-                 stale: stale, warnings: @warnings, baseline_seconds: base.seconds, timeout: timeout,
+                 stale: stale, warnings: p[:warnings], baseline_seconds: base.seconds, timeout: timeout,
                  jobs: jobs, seconds: monotonic - t0, complete: p[:complete])
-    rescue Interrupt, SignalException
-      cmd&.kill_all
+    rescue Interrupt
+      cmd.kill_all
       raise
     ensure
-      sandboxes&.each(&:cleanup)
+      sandboxes.each(&:cleanup)
     end
 
     private
 
     def jobs
-      [@o.jobs || 1, 1].max
+      [@o.jobs, 1].max
     end
 
     def selection
-      Selection.new(root: @root, patterns: @o.patterns || [], since: @o.since, methods: @o.methods || [],
-                    exclude_methods: @o.exclude_methods || [], lines: @o.lines || [],
-                    exclude_lines: @o.exclude_lines || [], shard: @o.shard)
-    end
-
-    def operator_set
-      return nil unless @o.operators
-
-      @o.operators.to_set
+      Selection.new(root: @root, patterns: @o.patterns, since: @o.since, methods: @o.methods,
+                    exclude_methods: @o.exclude_methods, lines: @o.lines, exclude_lines: @o.exclude_lines,
+                    shard: @o.shard)
     end
 
     def load_ignore
@@ -124,30 +119,13 @@ module Mutaruby
       queue = Queue.new
       plan[:mutations].each { |m| queue << m }
       n = [jobs, plan[:mutations].size].min
-      (sandboxes.size...n).each { sandboxes << Sandbox.new(@root, excludes: @o.copy_excludes || []) }
+      sandboxes << Sandbox.new(@root, excludes: @o.copy_excludes) while sandboxes.size < n
       results = []
       lock = Mutex.new
-      threads = Array.new(n) do |w|
+      threads = sandboxes.map do |box|
         Thread.new do
-          box = sandboxes[w]
-          loop do
-            m = begin
-              queue.pop(true)
-            rescue ThreadError
-              break
-            end
-            original = plan[:sources][m.file]
-            r = box.with_file(m.file, m.text, original) do
-              cmd.run(box.dir, timeout: timeout,
-                               env: { 'MUTARUBY_MUTANT_ID' => m.id.to_s, 'MUTARUBY_FILE' => m.file })
-            end
-            entry = plan[:ignore]&.match(m)
-            status = if r.timeout? then :timeout
-                     elsif !r.passed? then :killed
-                     elsif entry then :equivalent
-                     else :survived
-                     end
-            o = Outcome.new(mutation: m, status: status, seconds: r.seconds, ignore: entry)
+          while (m = next_mutation(queue))
+            o = evaluate(m, box, plan, cmd, timeout)
             lock.synchronize do
               results << o
               progress(o)
@@ -157,7 +135,7 @@ module Mutaruby
       end
       begin
         threads.each(&:join)
-      rescue Exception # rubocop:disable Lint/RescueException -- stop the workers, then re-raise
+      rescue Interrupt
         threads.each(&:kill)
         raise
       end
@@ -165,7 +143,24 @@ module Mutaruby
       results.sort_by { |o| o.mutation.id }
     end
 
-    MARK = { killed: '.', timeout: 'T', survived: 'S', equivalent: 'e' }.freeze
+    def next_mutation(queue)
+      queue.pop(true)
+    rescue ThreadError
+      nil
+    end
+
+    def evaluate(m, box, plan, cmd, timeout)
+      r = box.with_file(m.file, m.text, plan[:sources][m.file]) do
+        cmd.run(box.dir, timeout: timeout, env: { 'MUTARUBY_MUTANT_ID' => m.id.to_s, 'MUTARUBY_FILE' => m.file })
+      end
+      entry = plan[:ignore]&.match(m)
+      status = if r.timeout? then :timeout
+               elsif !r.passed? then :killed
+               elsif entry then :equivalent
+               else :survived
+               end
+      Outcome.new(mutation: m, status: status, seconds: r.seconds, ignore: entry)
+    end
 
     def progress(outcome)
       return unless @o.progress

data/lib/mutaruby/sandbox.rb

@@ -12,14 +12,17 @@ module Mutaruby
   # is written back before the next mutant.
   class Sandbox
     DEFAULT_EXCLUDES = %w[.git coverage].freeze
+    PREFIX = 'mutaruby-'
 
     attr_reader :dir
 
-    def initialize(root, excludes: [], prefix: 'mutaruby-')
-      @root = File.expand_path(root)
+    def initialize(root, excludes: [])
+      # The real path: Find does not descend into a symlink, so a root reached through one (/tmp on macOS) would
+      # otherwise be copied as an empty directory.
+      @root = File.realpath(root)
       @excludes = DEFAULT_EXCLUDES + excludes
-      @prefix = prefix
-      @base = Dir.mktmpdir(prefix)
+      @base = Dir.mktmpdir(PREFIX)
+      @tmp_parent = File.realpath(File.dirname(@base))
       @dir = File.join(@base, File.basename(@root))
       copy_tree
     end
@@ -31,10 +34,12 @@ module Mutaruby
     # Writes `text` to `rel` inside the sandbox, yields, and restores the original bytes afterwards (also on error).
     def with_file(rel, text, original)
       target = path(rel)
-      File.binwrite(target, text)
-      yield
-    ensure
-      File.binwrite(target, original) if target
+      begin
+        File.binwrite(target, text)
+        yield
+      ensure
+        File.binwrite(target, original)
+      end
     end
 
     def cleanup
@@ -51,10 +56,10 @@ module Mutaruby
     end
 
     # A sandbox directory (this one or another worker's). When the temporary directory lies inside the project (for
-    # example TMPDIR=./tmp), copying it would copy the sandbox into itself.
+    # example TMPDIR=./tmp), copying it would copy the sandbox into itself. Paths found under the real root are real.
     def sandbox?(path)
-      File.basename(path).start_with?(@prefix) && File.directory?(path) &&
-        File.realpath(File.dirname(path)) == File.realpath(File.dirname(@base))
+      File.directory?(path) && File.basename(path).start_with?(PREFIX) &&
+        File.dirname(path) == @tmp_parent
     end
 
     def copy_tree
@@ -63,17 +68,14 @@ module Mutaruby
         next if src == @root
 
         rel = src.delete_prefix("#{@root}/")
-        if excluded?(rel) || sandbox?(src)
-          Find.prune
-          next
-        end
+        Find.prune if excluded?(rel) || sandbox?(src)
         dest = File.join(@dir, rel)
         st = File.lstat(src)
         if st.symlink?
           File.symlink(File.readlink(src), dest)
         elsif st.directory?
           FileUtils.mkdir_p(dest)
-        elsif st.file?
+        elsif st.file? # not sockets, FIFOs or devices: copying a FIFO would block
           FileUtils.cp(src, dest, preserve: true)
         end
       end

data/lib/mutaruby/selection.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'open3'
+require_relative 'error'
 
 module Mutaruby
   # Which files to mutate and which of their mutants to run.
@@ -21,16 +22,17 @@ module Mutaruby
       to = (m[3] || m[2]).to_i
       raise Error, "bad line spec #{spec.inspect} (FROM > TO)" if from > to
 
-      LineSpec.new(m[1]&.sub(%r{\A\./}, ''), from, to)
+      LineSpec.new(m[1]&.delete_prefix('./'), from, to)
     end
 
     def self.parse_shard(spec)
-      m = spec.to_s.match(%r{\A(\d+)/(\d+)\z})
-      raise Error, "bad --shard #{spec.inspect} (expected I/N, 1 <= I <= N)" unless m && m[2].to_i.positive? && m[1].to_i.between?(1, m[2].to_i)
+      i, n = spec.match(%r{\A(\d+)/(\d+)\z})&.captures&.map(&:to_i)
+      raise Error, "bad --shard #{spec.inspect} (expected I/N, 1 <= I <= N)" unless i&.between?(1, n)
 
-      [m[1].to_i, m[2].to_i]
+      [i, n]
     end
 
+    # lines / exclude_lines: LineSpec objects (see parse_line_spec). shard: [i, n] or nil.
     def initialize(root:, patterns: [], since: nil, methods: [], exclude_methods: [], lines: [], exclude_lines: [],
                    shard: nil)
       @root = File.expand_path(root)
@@ -38,8 +40,8 @@ module Mutaruby
       @since = since
       @methods = methods
       @exclude_methods = exclude_methods
-      @lines = lines.map { |s| s.is_a?(LineSpec) ? s : self.class.parse_line_spec(s) }
-      @exclude_lines = exclude_lines.map { |s| s.is_a?(LineSpec) ? s : self.class.parse_line_spec(s) }
+      @lines = lines
+      @exclude_lines = exclude_lines
       @shard = shard
     end
 
@@ -48,19 +50,16 @@ module Mutaruby
       @methods.empty? && @exclude_methods.empty? && @lines.empty? && @exclude_lines.empty? && @shard.nil?
     end
 
-    # Sorted paths relative to the root.
+    # Sorted paths of the matching files, relative to the root.
     def files
-      found = @patterns.flat_map do |pat|
-        full = File.expand_path(pat, @root)
-        if File.file?(full)
-          [relative(full)]
-        else
-          Dir.glob(pat, base: @root).select { |f| File.file?(File.join(@root, f)) }
-        end
+      found = @patterns.flat_map { |pat| Dir.glob(pat, base: @root) }.map do |f|
+        full = File.expand_path(f, @root)
+        raise Error, "#{f} is outside the project root #{@root}" unless full.start_with?("#{@root}/")
+
+        full.delete_prefix("#{@root}/")
       end
-      found = found.map { |f| f.sub(%r{\A\./}, '') }.uniq.sort
-      found &= changed_files if @since
-      found
+      found = found.select { |f| File.file?(File.join(@root, f)) }.uniq.sort
+      @since ? found & changed_files : found
     end
 
     def filter(mutations)
@@ -73,35 +72,27 @@ module Mutaruby
       return kept unless @shard
 
       i, n = @shard
-      kept.each_with_index.select { |_, idx| idx % n == i - 1 }.map(&:first)
+      kept.select.with_index { |_, idx| idx % n == i - 1 }
     end
 
     private
 
-    def relative(full)
-      full.delete_prefix("#{@root}/")
-    end
-
     # A pattern matches the qualified name ("Calc#add", "Calc.build", "Calc#*") or the bare method name ("add").
+    # Code outside any method matches no pattern.
     def method_match?(pattern, name)
-      return false if name.nil?
-
-      bare = name.split(/[#.]/).last
-      File.fnmatch?(pattern, name) || File.fnmatch?(pattern, bare)
+      name ? File.fnmatch?(pattern, name) || File.fnmatch?(pattern, name.split(/[#.]/).last) : false
     end
 
     # Files changed relative to a git ref: committed, staged and unstaged edits, plus new untracked files.
     def changed_files
-      diff = git('diff', '--name-only', '--relative', @since, '--')
-      untracked = git('ls-files', '--others', '--exclude-standard')
-      (diff + untracked).uniq
+      git('diff', '--name-only', '--relative', @since, '--') + git('ls-files', '--others', '--exclude-standard')
     end
 
     def git(*args)
       out, err, st = Open3.capture3('git', '-C', @root, *args)
       raise Error, "git #{args.join(' ')} failed: #{err.strip}" unless st.success?
 
-      out.split("\n").reject(&:empty?)
+      out.lines(chomp: true)
     end
   end
 end

data/lib/mutaruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mutaruby
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/mutaruby.rb

@@ -1,19 +1,4 @@
 # frozen_string_literal: true
 
 # mutaruby: mutation testing for Ruby. See README.md.
-module Mutaruby
-  class Error < StandardError; end
-end
-
-require_relative 'mutaruby/version'
-require_relative 'mutaruby/parsing'
-require_relative 'mutaruby/splicer'
-require_relative 'mutaruby/mutation'
-require_relative 'mutaruby/generator'
-require_relative 'mutaruby/ignore_file'
-require_relative 'mutaruby/sandbox'
-require_relative 'mutaruby/command'
-require_relative 'mutaruby/selection'
-require_relative 'mutaruby/runner'
-require_relative 'mutaruby/reporters'
 require_relative 'mutaruby/cli'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutaruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Atlas Authorization
@@ -46,6 +46,7 @@ files:
 - lib/mutaruby.rb
 - lib/mutaruby/cli.rb
 - lib/mutaruby/command.rb
+- lib/mutaruby/error.rb
 - lib/mutaruby/generator.rb
 - lib/mutaruby/ignore_file.rb
 - lib/mutaruby/mutation.rb