mutaruby 0.1.0 → 0.1.1

data/lib/mutaruby/generator.rb

@@ -26,7 +26,7 @@ module Mutaruby
       'loop-condition-false' => 'while c: c -> false',
       'literal-int' => 'n -> n + 1, n - 1, 0, 1 (each distinct value once)',
       'literal-float' => 'x -> 0.0, x + 1.0',
-      'literal-string' => '"abc" -> "", "" -> "mutaruby"',
+      'literal-string' => '"abc" -> "", "" -> "mutaruby" (also single-quoted and %q/%Q strings)',
       'literal-symbol' => ':sym -> :__mutaruby__',
       'literal-boolean' => 'true <-> false',
       'literal-nil' => 'nil -> true',
@@ -62,23 +62,26 @@ module Mutaruby
     DECLARATIONS = %i[require require_relative load autoload attr_reader attr_writer attr_accessor include extend prepend
                       private public protected module_function private_constant public_constant
                       private_class_method public_class_method define_method alias_method raise fail].freeze
-    VISIBILITY = %i[private public protected module_function].freeze
+    # Bare visibility calls (`private` on its own line) are never deleted: that only changes which methods are public.
+    VISIBILITY_CALLS = %i[private public protected module_function].map { |v| Parser::AST::Node.new(:send, [nil, v]) }.freeze
     # Definitions are not deleted as statements: deleting a whole class or method is caught by any test that touches
     # it, and the interesting mutants are inside (method-body-nil and the operators on the body).
     STRUCTURAL = %i[module class sclass def defs].freeze
     PREDICATE_SKIP = %i[block_given? frozen? respond_to? respond_to_missing? nil?].freeze
     DISABLE_MARK = 'mutaruby:disable'
+    MAX_ARGS = 6 # argument-removal skips calls with more arguments than this
 
     attr_reader :errors
 
     # path: file path for messages; rel: path relative to the project root (stored on the mutants).
+    # operators: nil (all) or a list of operator ids.
     def initialize(source, path:, rel: path, operators: nil)
       @src = source
       @path = path
       @rel = rel
-      @operators = operators # nil = all, else a Set of ids
+      @operators = operators
       @valid_encoding = source.valid_encoding?
-      @lines = @valid_encoding ? source.split("\n", -1) : []
+      @lines = @valid_encoding ? source.lines.map(&:strip) : []
       @occurrence = occurrence_index(@lines)
       @errors = []
     end
@@ -97,20 +100,19 @@ module Mutaruby
       ast = Parsing.parse(@path, @src)
       @out = []
       @seen = {}
-      @scope = []  # namespace names ("Foo", "Bar")
-      @meth = []   # enclosing method names, qualified
-      @singleton = 0
-      walk(ast, nil) if ast
+      @scope = []   # namespace names ("Foo", "Bar")
+      @meth = []    # enclosing method names, qualified; @singleton: inside `class << self`
+      walk(ast, nil)
       @out.each_with_index { |m, i| m.id = i }
-      @out
-    rescue Parser::SyntaxError, EncodingError, ArgumentError => e
-      @errors << "#{@path}: cannot parse (#{e.message}); skipped"
+    rescue Parser::SyntaxError => e
+      @errors << "#{@path}: cannot parse (#{e}); skipped"
       []
     end
 
+    # lineno => 1-based index of that line among the identical (stripped) lines of the file.
     def occurrence_index(lines)
       seen = Hash.new(0)
-      lines.each_with_index.to_h { |l, i| [i + 1, seen[l.strip] += 1] }
+      lines.each_with_index.to_h { |l, i| [i + 1, seen[l] += 1] }
     end
 
     def enabled?(op)
@@ -125,7 +127,7 @@ module Mutaruby
       return if orig == repl
 
       lineno = range.line
-      line = @lines[lineno - 1].to_s
+      line = @lines[lineno - 1]
       return if line.include?(DISABLE_MARK)
 
       text = Splicer.splice(@src, range.begin_pos, range.end_pos, orig, repl)
@@ -134,7 +136,7 @@ module Mutaruby
       @seen[text] = true
       return unless Parsing.valid?(@path, text)
 
-      @out << Mutation.new(file: @rel, operator: op, orig: orig, repl: repl, lineno: lineno, line_text: line.strip,
+      @out << Mutation.new(file: @rel, operator: op, orig: orig, repl: repl, lineno: lineno, line_text: line,
                            occurrence: @occurrence[lineno], method: @meth.last, text: text)
     end
 
@@ -151,31 +153,34 @@ module Mutaruby
 
       case node.type
       when :module, :class
-        visit(node, parent)
         @scope.push(src_of(node.children[0]))
-        node.children.each { |c| walk(c, node) }
+        walk_children(node)
         @scope.pop
       when :sclass
-        visit(node, parent)
-        @singleton += 1
-        node.children.each { |c| walk(c, node) }
-        @singleton -= 1
+        outer = @singleton
+        @singleton = true
+        walk_children(node)
+        @singleton = outer
       when :def, :defs
         @meth.push(qualified(node))
         visit(node, parent)
-        node.children.each { |c| walk(c, node) }
+        walk_children(node)
         @meth.pop
       else
         visit(node, parent)
-        node.children.each { |c| walk(c, node) }
+        walk_children(node)
       end
     end
 
+    def walk_children(node)
+      node.children.each { |c| walk(c, node) }
+    end
+
     def qualified(node)
       ns = @scope.join('::')
       if node.type == :defs
         "#{ns.empty? ? src_of(node.children[0]) : ns}.#{node.children[1]}"
-      elsif @singleton.positive?
+      elsif @singleton
         "#{ns}.#{node.children[0]}"
       else
         ns.empty? ? node.children[0].to_s : "#{ns}##{node.children[0]}"
@@ -218,44 +223,31 @@ module Mutaruby
 
     def visit_send(n, parent)
       recv, meth, *args = *n
-      sel = n.loc.selector
       SWAPS.each do |op, table|
-        add(sel, table[meth].to_s, op) if table.key?(meth) && recv && args.size == 1 && sel
-      end
-      if meth == :! && recv
-        add(n.loc.expression, src_of(recv), 'negation-removal')
-      elsif meth == :-@ && recv
-        add(n.loc.expression, src_of(recv), 'unary-minus-removal')
+        add(n.loc.selector, table[meth].to_s, op) if table.key?(meth) && args.size == 1
       end
-      add(n.loc.dot, '.', 'safe-navigation') if n.type == :csend && n.loc.dot
-      if recv.nil? && %i[raise fail].include?(meth)
-        add(n.loc.expression, 'nil', 'raise-removal')
-        return
-      end
-      name = meth.to_s
-      if name.end_with?('?') && !PREDICATE_SKIP.include?(meth)
+      add(n.loc.expression, src_of(recv), 'negation-removal') if meth == :!
+      add(n.loc.expression, src_of(recv), 'unary-minus-removal') if meth == :-@
+      add(n.loc.dot, '.', 'safe-navigation') if n.type == :csend
+      add(n.loc.expression, 'nil', 'raise-removal') if recv.nil? && %i[raise fail].include?(meth)
+      if meth.end_with?('?') && !PREDICATE_SKIP.include?(meth)
         add(n.loc.expression, 'true', 'predicate-true')
         add(n.loc.expression, 'false', 'predicate-false')
       end
-      plain = name.match?(/\A[a-z_]\w*[?!]?\z/) # a named method, not an operator or a writer
+      plain = meth.match?(/\A[a-z_]\w*[?!]?\z/) # a named method, not an operator or a writer
       block_call = parent&.type == :block && parent.children[0].equal?(n)
-      if recv && plain && sel && !block_call
+      if recv && plain && !block_call
         add(n.loc.expression, src_of(recv), 'call-to-receiver')
-        first = args.first
-        add(n.loc.expression, src_of(first), 'call-to-argument') if first && !%i[block_pass splat kwsplat hash].include?(first.type)
+        add(n.loc.expression, src_of(args.first), 'call-to-argument') if args.any?
       end
-      remove_arguments(n, args) if plain && !DECLARATIONS.include?(meth) && args.any? && parent&.type != :masgn
+      remove_arguments(args) if plain && !DECLARATIONS.include?(meth) && args.size.between?(1, MAX_ARGS)
     end
 
-    def remove_arguments(n, args)
-      return if args.size > 6
-
-      first = args.first.loc.expression
-      last = args.last.loc.expression
-      range = first.join(last)
+    def remove_arguments(args)
+      range = args.first.loc.expression.join(args.last.loc.expression)
       args.each_index do |i|
-        rest = args.each_with_index.reject { |_, j| j == i }.map { |a, _| src_of(a) }
-        add(range, rest.join(', '), 'argument-removal')
+        rest = args.reject.with_index { |_, j| j == i }
+        add(range, rest.map { |a| src_of(a) }.join(', '), 'argument-removal')
       end
     end
 
@@ -269,53 +261,47 @@ module Mutaruby
     end
 
     def visit_if(n)
-      cond = n.children[0]
-      return unless cond.is_a?(Parser::AST::Node)
-
+      cond = n.children.first
       add(cond.loc.expression, "!(#{src_of(cond)})", 'condition-negate')
       add(cond.loc.expression, 'true', 'condition-true')
       add(cond.loc.expression, 'false', 'condition-false')
     end
 
     def visit_loop(n)
-      cond = n.children[0]
+      cond = n.children.first
       add(cond.loc.expression, "!(#{src_of(cond)})", 'loop-condition-negate')
       add(cond.loc.expression, 'false', 'loop-condition-false') if %i[while while_post].include?(n.type)
     end
 
     def visit_int(n)
-      v = n.children[0]
-      [v + 1, v - 1, 0, 1].uniq.reject { |x| x == v }.each { |x| add(n.loc.expression, x.to_s, 'literal-int') }
+      v = n.children.first
+      [v + 1, v - 1, 0, 1].each { |x| add(n.loc.expression, x.to_s, 'literal-int') }
     end
 
     def visit_float(n)
-      v = n.children[0]
+      v = n.children.first
       add(n.loc.expression, '0.0', 'literal-float') unless v.zero?
       add(n.loc.expression, (v + 1.0).to_s, 'literal-float') if v.finite?
     end
 
+    # Strings with both delimiters in the source: '...', "...", %q(...), %Q[...]. Not heredocs, not the parts of an
+    # interpolated string, not %w elements, not ?c character literals.
     def visit_str(n, parent)
-      return if parent && %i[dstr xstr dsym regexp].include?(parent.type)
       return if declaration?(parent)
 
-      q = n.loc.respond_to?(:begin) && n.loc.begin ? n.loc.begin.source : nil
-      return unless ['"', "'"].include?(q)
+      open = n.loc.begin if n.loc.respond_to?(:begin)
+      close = n.loc.end if open
+      return unless close
 
-      if n.children[0].empty?
-        add(n.loc.expression, "#{q}mutaruby#{q}", 'literal-string')
-      else
-        add(n.loc.expression, "#{q}#{q}", 'literal-string')
-      end
+      fill = n.children.first.empty? ? 'mutaruby' : ''
+      add(n.loc.expression, "#{open.source}#{fill}#{close.source}", 'literal-string')
     end
 
     def visit_body(n)
-      kids = n.children
-      return unless kids.size > 1
+      return unless n.children.size > 1
 
-      kids.each do |k|
-        next unless k.is_a?(Parser::AST::Node)
-        next if STRUCTURAL.include?(k.type)
-        next if k.type == :send && k.children[0].nil? && VISIBILITY.include?(k.children[1]) && k.children.size == 2
+      n.children.each do |k|
+        next if STRUCTURAL.include?(k.type) || VISIBILITY_CALLS.include?(k)
 
         add(k.loc.expression, 'nil', 'statement-delete')
       end
@@ -323,11 +309,10 @@ module Mutaruby
 
     def visit_def(n)
       body = n.children.last
-      return unless body.is_a?(Parser::AST::Node)
+      return unless body
 
       add(body.loc.expression, 'nil', 'method-body-nil')
-      name = n.type == :def ? n.children[0] : n.children[1]
-      return unless name.to_s.end_with?('?')
+      return unless n.children[n.type == :def ? 0 : 1].end_with?('?')
 
       add(body.loc.expression, 'true', 'method-body-bool')
       add(body.loc.expression, 'false', 'method-body-bool')

data/lib/mutaruby/ignore_file.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'yaml'
+require_relative 'generator'
 
 module Mutaruby
   # The ignore file lists equivalent mutants: mutants that cannot be killed because they do not change behaviour.
@@ -31,13 +32,20 @@ module Mutaruby
     end
 
     KEYS = %w[file operator line occurrence method mutation lineno reason].freeze
+    REQUIRED = %w[file operator line reason].freeze
+    STRINGS = %w[file operator reason method mutation].freeze
 
     attr_reader :entries, :path
 
     def self.load(path)
-      new(YAML.safe_load(File.read(path), permitted_classes: [], aliases: false), path: path)
+      new(YAML.safe_load(File.read(path)), path: path)
     rescue Psych::SyntaxError => e
-      raise Invalid, "#{path}: not valid YAML (#{e.message})"
+      raise Invalid, "#{path}: not valid YAML (#{e})"
+    end
+
+    # How many lines of `source` read `text` once stripped.
+    def self.count_lines(source, text)
+      source.each_line.count { |l| l.strip == text }
     end
 
     def initialize(data, path: '(ignore file)')
@@ -51,21 +59,19 @@ module Mutaruby
 
     # Static validation against the current sources: { rel_path => source }. Returns error strings.
     def validate(sources)
-      errs = []
-      @entries.each do |e|
+      @entries.filter_map do |e|
         src = sources[e.file]
         next unless src # file not part of this run
 
-        count = src.split("\n", -1).count { |l| l.strip == e.line }
+        count = self.class.count_lines(src, e.line)
         if count.zero?
-          errs << "STALE (the line is no longer in the file; re-review or remove the entry): #{e.label}"
+          "STALE (the line is no longer in the file; re-review or remove the entry): #{e.label}"
         elsif e.occurrence.nil? && count > 1
-          errs << "AMBIGUOUS (the line occurs #{count} times; add `occurrence`): #{e.label}"
+          "AMBIGUOUS (the line occurs #{count} times; add `occurrence`): #{e.label}"
         elsif e.occurrence && e.occurrence > count
-          errs << "STALE (occurrence #{e.occurrence} but the line now occurs #{count} time(s)): #{e.label}"
+          "STALE (occurrence #{e.occurrence} but the line now occurs #{count} time(s)): #{e.label}"
         end
       end
-      errs
     end
 
     # The entry covering this mutant, or nil.
@@ -74,7 +80,7 @@ module Mutaruby
         e.file == mutation.file && e.operator == mutation.operator && e.line == mutation.line_text &&
           (e.occurrence || 1) == mutation.occurrence &&
           (e.method.nil? || e.method == mutation.method) &&
-          (e.mutation.nil? || normalize(e.mutation) == mutation.change)
+          (e.mutation.nil? || e.mutation == mutation.change)
       end
     end
 
@@ -88,44 +94,34 @@ module Mutaruby
     def self.stub_for(mutations, sources)
       mutations.map do |m|
         h = { 'file' => m.file, 'operator' => m.operator, 'line' => m.line_text }
-        count = sources[m.file].to_s.split("\n", -1).count { |l| l.strip == m.line_text }
-        h['occurrence'] = m.occurrence if count > 1
+        h['occurrence'] = m.occurrence if count_lines(sources[m.file], m.line_text) > 1
         h['method'] = m.method if m.method
-        h['mutation'] = m.change
-        h['lineno'] = m.lineno
-        h['reason'] = ''
-        h
+        h.merge('mutation' => m.change, 'lineno' => m.lineno, 'reason' => '')
       end.to_yaml
     end
 
     private
 
-    def normalize(s)
-      s.to_s.gsub(/\s+/, ' ').strip
-    end
-
     def parse_entry(raw, i)
       where = "#{@path}: entry ##{i + 1}"
       raise Invalid, "#{where}: expected a mapping" unless raw.is_a?(Hash)
 
-      unknown = raw.keys.map(&:to_s) - KEYS
+      unknown = raw.keys - KEYS
       raise Invalid, "#{where}: unknown key(s) #{unknown.join(', ')}" if unknown.any?
 
-      %w[file operator line reason].each do |k|
-        v = raw[k]
-        raise Invalid, "#{where}: `#{k}` is required" if v.nil? || v.to_s.strip.empty?
+      REQUIRED.each { |k| raise Invalid, "#{where}: `#{k}` is required" if raw[k].to_s.strip.empty? }
+      STRINGS.each do |k|
+        raise Invalid, "#{where}: `#{k}` must be a string" unless raw[k].nil? || raw[k].is_a?(String)
       end
       %w[occurrence lineno].each do |k|
         v = raw[k]
         raise Invalid, "#{where}: `#{k}` must be a positive integer" unless v.nil? || (v.is_a?(Integer) && v.positive?)
       end
-      unless Generator::OPERATORS.key?(raw['operator'].to_s)
-        raise Invalid, "#{where}: unknown operator #{raw['operator'].inspect}"
-      end
+      raise Invalid, "#{where}: unknown operator #{raw['operator'].inspect}" unless Generator::OPERATORS.key?(raw['operator'])
 
-      Entry.new(file: raw['file'].to_s.sub(%r{\A\./}, ''), operator: raw['operator'].to_s, line: raw['line'].to_s.strip,
-                occurrence: raw['occurrence'], method: raw['method']&.to_s, mutation: raw['mutation']&.to_s,
-                lineno: raw['lineno'], reason: raw['reason'].to_s.strip, index: i)
+      Entry.new(file: raw['file'].delete_prefix('./'), operator: raw['operator'], line: raw['line'].to_s.strip,
+                occurrence: raw['occurrence'], method: raw['method'], mutation: raw['mutation'] && Mutation.squeeze(raw['mutation']),
+                lineno: raw['lineno'], reason: raw['reason'].strip, index: i)
     end
   end
 end

data/lib/mutaruby/mutation.rb

@@ -13,9 +13,17 @@ module Mutaruby
   #   text       the complete mutated file
   Mutation = Struct.new(:id, :file, :operator, :orig, :repl, :lineno, :line_text, :occurrence, :method, :text,
                         keyword_init: true) do
-    def short(str, max = 80)
+    LABEL_MAX = 80
+
+    # Whitespace runs collapsed to one space, ends stripped.
+    def self.squeeze(text)
+      text.gsub(/\s+/, ' ').strip
+    end
+
+    # One-line form of a source slice, cut to LABEL_MAX characters.
+    def short(str)
       s = str.gsub(/\s+/, ' ')
-      s.length > max ? "#{s[0, max - 3]}..." : s
+      s.length > LABEL_MAX ? "#{s[0, LABEL_MAX - 3]}..." : s
     end
 
     # Human label: "comparison: > => >="
@@ -23,26 +31,21 @@ module Mutaruby
       "#{operator}: #{short(orig)} => #{short(repl)}"
     end
 
-    # Normalised "orig => repl" (whitespace collapsed); the optional `mutation` field of an ignore entry.
+    # "orig => repl", squeezed; the optional `mutation` field of an ignore entry.
     def change
-      "#{orig.gsub(/\s+/, ' ').strip} => #{repl.gsub(/\s+/, ' ').strip}"
+      Mutation.squeeze("#{orig} => #{repl}")
     end
 
     def location
       "#{file}:#{lineno}"
     end
 
-    # The mutated region with one line of context, as a minimal unified-style diff.
+    # The replaced lines and their replacement, as a minimal unified-style diff.
     def diff(original_source)
-      lines = original_source.lines
-      mlines = text.lines
       i = lineno - 1
-      orig_n = orig.count("\n") + 1
-      repl_n = repl.count("\n") + 1
-      out = []
-      (lines[i, orig_n] || []).each { |l| out << "- #{l.chomp}" }
-      (mlines[i, repl_n] || []).each { |l| out << "+ #{l.chomp}" }
-      out.join("\n")
+      old = original_source.lines[i, orig.count("\n") + 1].map { |l| "- #{l.chomp}" }
+      new = text.lines[i, repl.count("\n") + 1].map { |l| "+ #{l.chomp}" }
+      (old + new).join("\n")
     end
 
     def to_h

data/lib/mutaruby/parsing.rb

@@ -1,40 +1,36 @@
 # frozen_string_literal: true
 
 require 'parser'
+require_relative 'error'
 
 module Mutaruby
   # Picks the newest `parser` grammar that is not newer than the running Ruby. `parser/current` prints a warning on
   # Rubies it does not know yet; choosing the class ourselves keeps the output clean and the behaviour explicit.
   module Parsing
+    OLDEST = 31 # Ruby 3.1
+
     class << self
       def parser_class
-        @parser_class ||= begin
-          major, minor = RUBY_VERSION.split('.').map(&:to_i)
-          wanted = (major * 10) + minor
-          found = nil
-          wanted.downto(31) do |v|
-            begin
-              require "parser/ruby#{v}"
-              found = Parser.const_get("Ruby#{v}")
-              break
-            rescue LoadError, NameError
-              next
-            end
-          end
-          found || raise(Error, "no parser grammar available for Ruby #{RUBY_VERSION}")
-        end
+        @parser_class ||= grammar_for(RUBY_VERSION)
       end
 
-      def buffer(path, source)
-        Parser::Source::Buffer.new(path, source: source)
+      # The parser class for a Ruby version string ("3.3.5" -> Parser::Ruby33), falling back to older grammars.
+      def grammar_for(version)
+        major, minor = version.split('.').map(&:to_i)
+        ((major * 10) + minor).downto(OLDEST) do |v|
+          require "parser/ruby#{v}"
+          return Parser.const_get("Ruby#{v}")
+        rescue LoadError
+          # this `parser` release has no grammar for v; try the next older one
+        end
+        raise Error, "no parser grammar available for Ruby #{version}"
       end
 
       # Parse `source`; returns the AST or raises Parser::SyntaxError.
       def parse(path, source)
         p = parser_class.new
         p.diagnostics.all_errors_are_fatal = true
-        p.diagnostics.ignore_warnings = true
-        p.parse(buffer(path, source))
+        p.parse(Parser::Source::Buffer.new(path, source: source))
       end
 
       def valid?(path, source)

data/lib/mutaruby/reporters.rb

@@ -22,7 +22,7 @@ module Mutaruby
           io.puts
           io.puts "  #{m.location}#{m.method ? " in #{m.method}" : ''}  [##{m.id}]"
           io.puts "    #{m.label}"
-          m.diff(report.sources[m.file]).each_line { |l| io.puts "    #{l.chomp}" }
+          io.puts m.diff(report.sources[m.file]).gsub(/^/, '    ')
         end
         io.puts
       end
@@ -53,11 +53,11 @@ module Mutaruby
         score: report.score&.round(4), complete: report.complete,
         counts: { mutants: report.outcomes.size, killed: report.killed, timeout: report.count(:timeout),
                   survived: report.count(:survived), equivalent: report.count(:equivalent) },
-        files: report.files, baseline_seconds: report.baseline_seconds.round(3), timeout: report.timeout,
+        files: report.files, baseline_seconds: secs(report.baseline_seconds), timeout: report.timeout,
         mutants: report.outcomes.map do |o|
-          o.mutation.to_h.merge(status: o.status.to_s, seconds: o.seconds.round(3), ignore_reason: o.ignore&.reason)
+          o.mutation.to_h.merge(status: o.status, seconds: secs(o.seconds), ignore_reason: o.ignore&.reason)
         end,
-        stale_ignores: report.stale.map(&:to_h).map { |h| h.compact.except(:index) },
+        stale_ignores: report.stale.map { |e| e.to_h.compact.except(:index) },
         warnings: report.warnings
       }
     end
@@ -68,36 +68,41 @@ module Mutaruby
 
     # JUnit-style XML: one testcase per mutant. A survivor is a failure, an equivalent mutant is skipped.
     def junit(report, io)
-      x = ->(s) { CGI.escapeHTML(s.to_s) }
+      n = report.outcomes.size
       failures = report.count(:survived)
+      t = secs(report.seconds)
       io.puts '<?xml version="1.0" encoding="UTF-8"?>'
-      io.puts %(<testsuites name="mutaruby" tests="#{report.outcomes.size}" failures="#{failures}" time="#{report.seconds.round(3)}">)
-      io.puts %(  <testsuite name="mutaruby" tests="#{report.outcomes.size}" failures="#{failures}" errors="0" ) +
-              %(skipped="#{report.count(:equivalent)}" time="#{report.seconds.round(3)}">)
-      io.puts %(    <properties><property name="score" value="#{x.call(score_text(report))}"/></properties>)
+      io.puts %(<testsuites name="mutaruby" tests="#{n}" failures="#{failures}" time="#{t}">)
+      io.puts %(  <testsuite name="mutaruby" tests="#{n}" failures="#{failures}" errors="0" ) +
+              %(skipped="#{report.count(:equivalent)}" time="#{t}">)
+      io.puts %(    <properties><property name="score" value="#{score_text(report)}"/></properties>)
       report.outcomes.each do |o|
         m = o.mutation
-        name = "##{m.id} #{m.location} #{m.label}"
-        io.print %(    <testcase classname="#{x.call(m.file)}" name="#{x.call(name)}" time="#{o.seconds.round(3)}")
-        case o.status
-        when :survived
-          io.puts '>'
-          io.puts %(      <failure message="#{x.call("survived: #{m.label}")}" type="survived">#{x.call(m.diff(report.sources[m.file]))}</failure>)
-          io.puts '    </testcase>'
-        when :equivalent
-          io.puts '>'
-          io.puts %(      <skipped message="#{x.call("equivalent: #{o.ignore.reason}")}"/>)
-          io.puts '    </testcase>'
-        when :timeout
-          io.puts '>'
-          io.puts '      <system-out>killed by timeout</system-out>'
-          io.puts '    </testcase>'
-        else
-          io.puts '/>'
-        end
+        head = %(    <testcase classname="#{esc(m.file)}" name="#{esc("##{m.id} #{m.location} #{m.label}")}" ) +
+               %(time="#{secs(o.seconds)}")
+        detail = junit_detail(o, report)
+        io.puts(detail ? "#{head}>\n      #{detail}\n    </testcase>" : "#{head}/>")
       end
       io.puts '  </testsuite>'
       io.puts '</testsuites>'
     end
+
+    def junit_detail(outcome, report)
+      m = outcome.mutation
+      case outcome.status
+      when :survived
+        %(<failure message="#{esc("survived: #{m.label}")}" type="survived">#{esc(m.diff(report.sources[m.file]))}</failure>)
+      when :equivalent then %(<skipped message="#{esc("equivalent: #{outcome.ignore.reason}")}"/>)
+      when :timeout then '<system-out>killed by timeout</system-out>'
+      end
+    end
+
+    def esc(text)
+      CGI.escapeHTML(text)
+    end
+
+    def secs(seconds)
+      seconds.round(3)
+    end
   end
 end