active_mutator 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45e58d5b8880a6716b7a78ee4011f0e5529600b3daa222ad39854723d08bd9d3
-  data.tar.gz: d9c9067771e0596e3241d8a0bb408c3c9f041e98eac33f08066b1118feedb5b8
+  metadata.gz: a334e2726728421ba66d6a08db715587b8e0439b934489857b70d746912e89b8
+  data.tar.gz: cdce7a7856fd4b1f68b4cbf9dc5a62d58a1926555b203a01474d64aa95b6fbbe
 SHA512:
-  metadata.gz: 2e6881dce81b23302b40220a9b593b290b22b08eb5f6c4426da96e2f5557e369cd635525f32aa357078c6ae10f289c05d216b025992ce23ff607841b42b71b1b
-  data.tar.gz: 25fbb644044f506fcc4663ed26be6898187a4205a91778fdfc049240ecf7c1bb54a52f81b38e2ab9f59f75c00f0bbcd5d93b8ad6bc0d7c7a149d90cdc4f69cf4
+  metadata.gz: d1cfeffd4210a83fcd974a3b175eabf0da02a54b7d253664e3252ed5fc0487fd60fcf4ad3db54d29d12e53363842e0a5116e0602c6ce83a971813e8895a84dbf
+  data.tar.gz: d21dae9ed1a6e6b668517ad99130a7a6e2d7de6d6f9ebf4f620de5ce7e0690bc81d105e8f3d78aff72c288034a2366ae6a0dced6a35d2101b63421fde0ef1da0

data/README.md

@@ -131,10 +131,15 @@ discarded before scheduling and reported as a count only. Exit code is `1`
 if unaccepted survivors or errors exist (or, with `--fail-at`, if the score
 is below the threshold), `0` otherwise, including when there are only
 `uncovered` or `accepted` results. The JSON report's `exit_reason` field
-(`unaccepted_survivors`, `worker_errors`, `clean`) is independent of the
-`--fail-at` gate. A `--since`
-or `--subject` run that plans zero mutants prints no score; it warns with the
-cause and exits `1` unless `--allow-empty` is given.
+(`unaccepted_survivors`, `worker_errors`, `clean`, `empty_plan`) is
+independent of the `--fail-at` gate. A `--since` or `--subject` run that
+plans zero mutants skips the baseline, prints the usual count block with
+every status at `0` and no `Mutation score:` line (JSON: `score` is `null`,
+`exit_reason` is `empty_plan`), then warns with the cause and exits `1`
+unless `--allow-empty` is given. The count block is printed on every run,
+whatever the exit code, so log-scraping never has to handle a missing block.
+`--allow-empty` forgives the empty plan only when the `--since` diff changed
+no code in a candidate source file; see [Empty plans in CI](#empty-plans-in-ci).
 
 When survivors exist, the summary also prints a per-operator table showing
 how often each operator's mutants survive, to help spot likely-equivalent
@@ -245,6 +250,33 @@ survivors show inline on the PR diff. Pairs with the CI recipe:
   residual blind spot — constant-reference detection handles the common
   newly-covering-example case since 0.2)
 
+### Empty plans in CI
+
+A `--since` PR run that plans zero mutants skips the baseline, prints the
+zero-count block, and exits `1`. Pass `--allow-empty` to let it decide for
+itself whether that emptiness is fine:
+
+- **Exit 0** when the diff contains no candidate file. A candidate is a
+  changed or untracked `.rb` file inside the scanned paths (positional args
+  or the default `app`/`lib`), not under a spec path, and not matching an
+  `--exclude` pattern. Docs-only, spec-only, and excluded-path PRs pass.
+- **Exit 0** with `--no-class-level` when every changed line in the
+  candidate files falls inside class-body code that flag dropped. The
+  warning names `--no-class-level` as the reason.
+- **Exit 0** when the only changes in the candidate files are comments or
+  blank lines, added or deleted. A magic comment such as
+  `# frozen_string_literal: true` counts as code, and so does a file that
+  fails to parse.
+- **Exit 1** otherwise. A candidate file's code changed but produced no
+  mutants, and the warning lists the file(s). A deletion-only code edit
+  counts as a real change here.
+- With `--subject` and no `--since` there is no diff to judge, so
+  `--allow-empty` exits `0` unconditionally.
+
+`--changed` follows the same rule, and an untracked candidate `.rb` file
+counts as a candidate. This replaces the repo-side log-scraping script some
+projects used to tell a docs-only PR from a broken `--since` range.
+
 ## Flags
 
 | Flag | Default | Meaning |
@@ -256,7 +288,7 @@ survivors show inline on the PR diff. Pairs with the CI recipe:
 | `--exclude PAT` | none | skip files matching glob during subject discovery (repeatable, gitignore-like) |
 | `--max-mutants N` | none | deterministic sample of the first N mutants (quick smoke run on huge scopes; accepted/uncovered mutants count against N) |
 | `--debug-plan` | off | print planned mutants as JSON and exit without running |
-| `--allow-empty` | off | exit 0 when `--since`/`--subject` plan no mutants (default: warn and exit 1) |
+| `--allow-empty` | off | forgive an empty `--since`/`--subject` plan, but only when the `--since` diff changed no code in a candidate source file (default: warn and exit 1) |
 | `--format terminal\|json\|stryker-json\|github` | terminal | report format |
 | `--accept-survivors` | off | record survivors to the acceptance ledger |
 | `--force-baseline` | off | ignore cached coverage map |

data/lib/active_mutator/baseline_hooks.rb

@@ -9,11 +9,16 @@ module ActiveMutator
     RECORDS = {}
     TIMES = {}
 
-    def self.diff_coverage(before, after, root, spec_paths: ["spec"])
+    def self.diff_coverage(before, after, root, spec_paths: ["spec"], gem_dirs: [])
       prefixes = spec_paths.map { |sp| "/#{sp}/" }
+      gem_prefixes = gem_dirs.map { |dir| File.join(dir, "") }
       hits = []
       after.each do |path, data|
         next unless path.start_with?(root)
+        # Gems installed under the root (e.g. `bundle config path
+        # vendor/bundle` on CI) would otherwise be recorded per example and
+        # blow up the map's memory.
+        next if gem_prefixes.any? { |p| path.start_with?(p) }
 
         # Relative to root, not a global substring check: `root` itself may
         # contain "/spec/" (e.g. a fixture nested under this gem's own
@@ -33,6 +38,20 @@ module ActiveMutator
       hits
     end
 
+    # Computed per example, not at load: this file loads via RUBYOPT before
+    # Bundler sets up its install path.
+    def self.gem_dirs
+      dirs = Gem.path.dup
+      if defined?(Bundler)
+        begin
+          dirs << Bundler.bundle_path.to_s
+        rescue Bundler::BundlerError
+          # No Gemfile, so Gem.path covers it.
+        end
+      end
+      dirs.uniq
+    end
+
     def self.build_payload(records, times, expected_examples: nil)
       payload = { "version" => 2, "records" => records, "times" => times }
       payload["expected_examples"] = expected_examples if expected_examples
@@ -56,7 +75,10 @@ if ENV["ACTIVE_MUTATOR_BASELINE_OUT"]
       root = ENV.fetch("ACTIVE_MUTATOR_ROOT")
       spec_paths = ENV.fetch("ACTIVE_MUTATOR_SPEC_PATHS", "spec").split(":")
       ActiveMutator::BaselineHooks::RECORDS[example.id] =
-        ActiveMutator::BaselineHooks.diff_coverage(before, after, root, spec_paths: spec_paths)
+        ActiveMutator::BaselineHooks.diff_coverage(
+          before, after, root,
+          spec_paths: spec_paths, gem_dirs: ActiveMutator::BaselineHooks.gem_dirs
+        )
       # NOT example.execution_result.run_time: that is nil until after
       # around hooks complete.
       ActiveMutator::BaselineHooks::TIMES[example.id] = elapsed

data/lib/active_mutator/cli.rb

@@ -66,7 +66,9 @@ module ActiveMutator
         o.on("--exclude PAT", "Skip files matching glob, relative to root (repeatable)") { |v| options[:exclude] << v }
         o.on("--max-mutants N", Integer, "Deterministically sample the first N mutants") { |v| options[:max_mutants] = v }
         o.on("--debug-plan", "Print the planned mutant list as JSON and exit") { options[:debug_plan] = true }
-        o.on("--allow-empty", "Exit 0 when --since/--subject plan no mutants (default: exit 1)") { options[:allow_empty] = true }
+        o.on("--allow-empty",
+             "Exit 0 when --since/--subject plan no mutants and the --since diff changed no code " \
+             "in a mutable source file (default: exit 1)") { options[:allow_empty] = true }
         o.on("--fail-at SCORE", Float, "Exit 0 if mutation score >= SCORE even with survivors (default: any survivor fails)") do |v|
           raise OptionParser::InvalidArgument, "--fail-at must be within 0..100" unless (0..100).cover?(v)
           options[:fail_at] = v

data/lib/active_mutator/reporter/github.rb

@@ -12,8 +12,8 @@ module ActiveMutator
 
       def on_result(result) = @terminal.on_result(result)
 
-      def summary(results, invalid_count:)
-        @terminal.summary(results, invalid_count: invalid_count)
+      def summary(results, invalid_count:, empty_plan: false)
+        @terminal.summary(results, invalid_count: invalid_count, empty_plan: empty_plan)
         results.select { |r| r.status == :survived }.each { |r| annotate(r) }
       end
 

data/lib/active_mutator/reporter/json.rb

@@ -9,23 +9,26 @@ module ActiveMutator
 
       def on_result(result); end
 
-      def summary(results, invalid_count:)
-        counts = results.group_by(&:status).transform_values(&:size)
+      # An empty plan has no score (null) and its own exit_reason, so a CI
+      # consumer can tell "nothing to mutate" from "everything was killed" (#45).
+      def summary(results, invalid_count:, empty_plan: false)
+        counts = Terminal.counts(results)
         @out.puts JSON.pretty_generate(
-          "score" => Terminal.score(counts),
+          "score" => empty_plan ? nil : Terminal.score(counts),
           "counts" => counts.transform_keys(&:to_s),
           "invalid" => invalid_count,
           "operators" => OperatorStats.call(results),
           "results" => results.map { |r| serialize(r) },
-          "exit_reason" => exit_reason(counts)
+          "exit_reason" => exit_reason(counts, empty_plan)
         )
       end
 
       private
 
-      def exit_reason(counts)
-        return "unaccepted_survivors" if counts.fetch(:survived, 0).positive?
-        return "worker_errors" if counts.fetch(:error, 0).positive?
+      def exit_reason(counts, empty_plan)
+        return "empty_plan" if empty_plan
+        return "unaccepted_survivors" if counts[:survived].positive?
+        return "worker_errors" if counts[:error].positive?
 
         "clean"
       end

data/lib/active_mutator/reporter/stryker_json.rb

@@ -1,4 +1,5 @@
 require "json"
+require "fileutils"
 
 module ActiveMutator
   module Reporter
@@ -31,9 +32,13 @@ module ActiveMutator
         @out.print(Terminal::CHARS.fetch(result.status))
       end
 
-      def summary(results, invalid_count:)
+      # A zero-mutant report is valid schema output, so an empty plan writes the
+      # same file with no files/mutants; the flag is accepted for contract parity.
+      def summary(results, invalid_count:, empty_plan: false)
         report = build_report(results, invalid_count)
         path = File.join(@root, REPORT_PATH)
+        # An empty plan skips the baseline, which used to create this dir.
+        FileUtils.mkdir_p(File.dirname(path))
         AtomicFile.write(path, JSON.pretty_generate(report))
         @out.puts "", "", "Stryker report written to #{REPORT_PATH}"
       end

data/lib/active_mutator/reporter/terminal.rb

@@ -12,14 +12,21 @@ module ActiveMutator
         @out.print(CHARS.fetch(result.status))
       end
 
-      def summary(results, invalid_count:)
-        counts = results.group_by(&:status).transform_values(&:size)
+      # Every status key is present (zero when absent) so the block has the same
+      # shape on every run, including an empty plan.
+      def self.counts(results)
+        tallies = results.group_by(&:status).transform_values(&:size)
+        CHARS.keys.to_h { |status| [status, tallies.fetch(status, 0)] }
+      end
+
+      # `empty_plan: true` means a --since/--subject scope planned nothing: the
+      # count block still prints, but there is no score to report (#45).
+      def summary(results, invalid_count:, empty_plan: false)
+        counts = self.class.counts(results)
         @out.puts "", ""
-        CHARS.each_key do |status|
-          @out.puts "#{status}: #{counts.fetch(status, 0)}"
-        end
+        counts.each { |status, count| @out.puts "#{status}: #{count}" }
         @out.puts "invalid (discarded): #{invalid_count}"
-        @out.puts format("Mutation score: %.1f%%", score(counts) * 100)
+        @out.puts format("Mutation score: %.1f%%", score(counts) * 100) unless empty_plan
         print_group("Surviving mutants:", results.select { |r| r.status == :survived })
         print_group("Errored mutants (not detected):", results.select { |r| r.status == :error })
         print_group("Timed-out mutants (counted as detected):", results.select { |r| r.status == :timeout })

data/lib/active_mutator/runner.rb

@@ -2,6 +2,14 @@ require "json"
 
 module ActiveMutator
   class Runner
+    # What discovery saw, beyond the final subject list. `scanned_files` are
+    # root-relative source files after path expansion and excludes, minus
+    # spec_paths; `since_candidates` are the --since diff's files among them;
+    # `since_matched_all` are the since-covered subjects before --no-class-level
+    # drops class bodies; `since_filter` is the --since SinceFilter (nil
+    # without --since). The last three feed the --allow-empty verdict (#46).
+    Discovery = Data.define(:subjects, :scanned_files, :since_candidates, :since_matched_all, :since_filter)
+
     def initialize(config, reporter: nil)
       @config = config
       @reporter = reporter || build_reporter
@@ -13,14 +21,24 @@ module ActiveMutator
       ClosureReload.cap = @config.class_level_closure_cap
       preload!
       preload_spec_helper!
-      map = Baseline.new(root: @config.root, spec_paths: @config.spec_paths)
-              .coverage_map(force: @config.force_baseline)
-      @reporter.coverage_map = map if @reporter.respond_to?(:coverage_map=)
-      subjects = discover_subjects
+      discovery = discover
+      subjects = discovery.subjects
       analyses = subjects.map { |s| Engine.new.analyze(s) }
       mutations = analyses.flat_map(&:mutations)
       mutations = mutations.first(@config.max_mutants) if @config.max_mutants
       invalid_count = analyses.sum(&:invalid_count)
+      # Decide emptiness before the baseline: a scoped run that plans nothing
+      # has no use for a coverage map, and building one spawns the whole spec
+      # suite (#47).
+      if mutations.empty? && (@config.since || @config.subject_filter)
+        return debug_plan([], []) if @config.debug_plan
+
+        return empty_plan_exit(invalid_count, discovery)
+      end
+
+      map = Baseline.new(root: @config.root, spec_paths: @config.spec_paths)
+              .coverage_map(force: @config.force_baseline)
+      @reporter.coverage_map = map if @reporter.respond_to?(:coverage_map=)
 
       fingerprints = Fingerprint.for_mutations(mutations, root: @config.root)
       ledger = AcceptedLedger.load(@config.root)
@@ -29,7 +47,6 @@ module ActiveMutator
 
       items, pre_results, phase1_ids = plan_work(mutations, map, ledger: ledger, fingerprints: fingerprints)
       return debug_plan(items, pre_results) if @config.debug_plan
-      return empty_plan_exit if mutations.empty? && (@config.since || @config.subject_filter)
 
       pre_results.each { |r| @reporter.on_result(r) }
       calibrators = if @config.adaptive_timeout
@@ -145,18 +162,58 @@ module ActiveMutator
     # the usual cause is a --since range or --subject filter that matched no
     # mutable code, or class-body code dropped by --no-class-level (#23 covers
     # the zero-subject case for explicit paths).
-    def empty_plan_exit
+    def empty_plan_exit(invalid_count, discovery)
+      @reporter.summary([], invalid_count: invalid_count, empty_plan: true)
       causes = []
       causes << "--since #{@config.since} matched no mutable code" if @config.since
       causes << "--subject #{@config.subject_filter} matched no subjects" if @config.subject_filter
       causes << "--no-class-level excludes class-body code" unless @config.class_level
       warn "active_mutator: no mutants planned (#{causes.join("; ")})"
-      return 0 if @config.allow_empty
+      unless @config.allow_empty
+        warn "active_mutator: exiting 1; pass --allow-empty if an empty plan is expected"
+        return 1
+      end
+
+      allow_empty_exit(discovery)
+    end
+
+    # --allow-empty forgives an empty plan only when the --since diff touched no
+    # candidate source file (docs-only, spec-only, excluded paths) or changed
+    # only comments in them. A candidate whose code changed but planned
+    # nothing is the case worth failing on, unless the only code it touched
+    # is class-body code that --no-class-level dropped. --subject alone has no
+    # diff to judge, so it stays an unconditional 0.
+    def allow_empty_exit(discovery)
+      return 0 unless @config.since
+      return 0 if discovery.since_candidates.empty?
+
+      # Checked only here, on the empty-plan path: it runs `git show` per file.
+      candidates = discovery.since_candidates.reject { |file| discovery.since_filter.comment_only?(file) }
+      if candidates.empty?
+        warn "active_mutator: forgiving empty plan: only comments changed in " \
+             "#{discovery.since_candidates.join(", ")}"
+        return 0
+      end
 
-      warn "active_mutator: exiting 1; pass --allow-empty if an empty plan is expected"
+      if !@config.class_level && class_body_only?(discovery.since_matched_all, candidates)
+        warn "active_mutator: forgiving empty plan: changed lines are class-body code and --no-class-level is set"
+        return 0
+      end
+
+      warn "active_mutator: exiting 1; --allow-empty forgives an empty plan only when no candidate " \
+           "source file changed. Changed: #{candidates.join(", ")}"
       1
     end
 
+    # Every matched subject is a class body AND every candidate file has one:
+    # a candidate that matched nothing (comment-only edit, deletion) must not
+    # hide behind a class-body change in a different file. Candidates are
+    # non-empty here, so no matches at all fails the second test on its own.
+    def class_body_only?(subjects, candidates)
+      matched_files = subjects.map { |s| relative(s.file) }
+      subjects.all?(&:class_body?) && candidates.all? { |file| matched_files.include?(file) }
+    end
+
     # Single source of truth for lane/timeout/variable derivation, shared by
     # phase-1 planning and phase-2 escalation so the two never drift.
     def build_work_item(mutation, example_ids, map)
@@ -250,23 +307,39 @@ module ActiveMutator
       end
     end
 
-    def discover_subjects
+    def discover
       paths = @config.paths.empty? ? default_paths : @config.paths
-      subjects = paths
+      files = paths
         .flat_map { |p| expand_path_arg(p) }
         .uniq
         .reject { |file| excluded?(file) }
-        .sort.flat_map { |file| SubjectFinder.call(file) }
-      subjects = subjects.reject(&:class_body?) unless @config.class_level
+        .sort
+      scanned_files = files.map { |f| relative(f) }.reject { |rel| under_spec_paths?(rel) }
+      subjects = files.flat_map { |file| SubjectFinder.call(file) }
       if @config.subject_filter
         matcher = SubjectMatcher.new(@config.subject_filter)
         subjects = subjects.select { |s| matcher.match?(s.name) }
       end
+      since_candidates = []
       if @config.since
         filter = SinceFilter.new(ref: @config.since, root: @config.root)
         subjects = subjects.select { |s| filter.cover?(s) }
+        since_candidates = filter.changed_files & scanned_files
       end
-      subjects
+      # Class bodies drop out LAST so since_matched_all still knows about them.
+      since_matched_all = subjects
+      subjects = subjects.reject(&:class_body?) unless @config.class_level
+      Discovery.new(subjects: subjects, scanned_files: scanned_files,
+                    since_candidates: since_candidates, since_matched_all: since_matched_all,
+                    since_filter: filter)
+    end
+
+    def relative(file) = file.delete_prefix(@config.root.chomp("/") + "/")
+
+    # Scanned entries are files, so only the "inside this directory" test
+    # matters; the trailing slash keeps `spec` from swallowing `spec_tools/`.
+    def under_spec_paths?(rel)
+      @config.spec_paths.any? { |sp| rel.start_with?("#{sp.chomp("/")}/") }
     end
 
     # Positional args may be files or directories. Anything else is an error:
@@ -346,7 +419,7 @@ module ActiveMutator
     # MAINTENANCE: any future flag that narrows the mutant set below "every
     # subject in the scanned files" MUST be added to this nil-trigger list,
     # or scoped accept runs will clobber out-of-scope ledger entries (#24).
-    # --no-class-level drops every class_body subject (discover_subjects), so a
+    # --no-class-level drops every class_body subject (discover), so a
     # file's class-body fingerprint is absent even though the file is scanned;
     # without this guard its accepted ledger entry looks stale and gets pruned.
     def prune_scope(subjects)

data/lib/active_mutator/since_filter.rb

@@ -20,7 +20,45 @@ module ActiveMutator
       changed.reject { |_, lines| lines.empty? }
     end
 
+    # Every file the diff touched on the new side, including deletion-only
+    # files that `parse` drops (they add no lines, so nothing to cover, but
+    # the file still changed and must count as a --since candidate).
+    def self.touched_files(diff_text)
+      diff_text.each_line.filter_map do |line|
+        line.delete_prefix("+++ b/").strip if line.start_with?("+++ b/")
+      end.uniq
+    end
+
+    # Tokens that never change what the code does.
+    NOISE = %i[IGNORED_NEWLINE EMBDOC_BEGIN EMBDOC_LINE EMBDOC_END EOF].freeze
+
+    # True when two sources differ only in comments and blank lines. Magic
+    # comments (`# frozen_string_literal: true`) change behavior, so they
+    # count as code; so does anything that fails to parse.
+    def self.same_code?(old_source, new_source)
+      old_code = code_of(old_source)
+      !old_code.nil? && old_code == code_of(new_source)
+    end
+
+    def self.code_of(source)
+      result = Prism.parse_lex(source)
+      return nil if result.failure?
+
+      # A trailing comment swallows its line's newline, so comments become a
+      # newline instead of vanishing; runs of newlines collapse to one.
+      tokens = result.value.last.filter_map do |token, _state|
+        next if NOISE.include?(token.type)
+
+        %i[COMMENT NEWLINE].include?(token.type) ? :NEWLINE : [token.type, token.value]
+      end
+      tokens = tokens.chunk_while { |a, b| a == :NEWLINE && b == :NEWLINE }.map(&:first)
+      tokens.shift if tokens.first == :NEWLINE
+      tokens.pop if tokens.last == :NEWLINE
+      [tokens, result.magic_comments.map { |c| [c.key, c.value] }]
+    end
+
     def initialize(ref:, root:)
+      @ref = ref
       @root = root
       diff = IO.popen(
         ["git", "-C", root, "diff", "--unified=0", ref, "--", "*.rb"], &:read
@@ -28,13 +66,29 @@ module ActiveMutator
       raise Error, "git diff #{ref} failed" unless $?.success?
 
       @changed = self.class.parse(diff)
+      @touched = self.class.touched_files(diff)
       untracked = IO.popen(
         ["git", "-C", root, "ls-files", "--others", "--exclude-standard", "--", "*.rb"], &:read
       )
       # Untracked files are invisible to `git diff` but are agentic TDD's most
       # common case (brand-new file + spec). Whole-file sentinel: every line
       # counts as changed.
-      untracked.each_line { |l| @changed[l.strip] = :all unless l.strip.empty? }
+      untracked.split("\n").each { |l| @changed[l] = :all }
+      @touched |= @changed.keys
+    end
+
+    # Root-relative paths of every .rb file the diff touched (tracked files,
+    # including deletion-only ones, plus untracked files). Pure accessor: no
+    # further git calls.
+    def changed_files = @touched
+
+    # Whether a changed file's edits since the ref are only comments. Reads
+    # the old side with `git show`; a file missing there (untracked, renamed)
+    # prints nothing, so it compares against an empty source and any code in
+    # it counts.
+    def comment_only?(path)
+      old_source = IO.popen(["git", "-C", @root, "show", "#{@ref}:#{path}"], err: File::NULL, &:read)
+      self.class.same_code?(old_source, File.read(File.join(@root, path)))
     end
 
     def cover?(subject)

data/lib/active_mutator/version.rb

@@ -1,3 +1,3 @@
 module ActiveMutator
-  VERSION = "0.5.0"
+  VERSION = "0.6.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_mutator
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Daniel John