raider_reporter 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4d38649c7323d93145079d6de1aac3a00f4724a0d906a2f004ddf331e201b77
-  data.tar.gz: 8f5ad9717d74c2c626ba0ab7507e2ebc413f9f80337d0ecfd02343c69bc52051
+  metadata.gz: 61be0da46b6e8038ccb7da397ce371e20e398792aaa42aff9e93e2e765efd73b
+  data.tar.gz: 9d2859ced0b58e73ccd0f8d90fece82b3d8f379bca46ef958edb8089e81ae30e
 SHA512:
-  metadata.gz: d43a79f1ff81eff80f4fa8a9afbff388df98671e65920013b88cdb8cdd24ab3313266646e27e72bbebfbad4213231855c6d7470c28177ba601d0db1ddb1aea76
-  data.tar.gz: 61cd6025ab3d9c713fb075d5288eec3ce46c219eb317995129a6bc41fa139ecccf4026eca160cafeeeae0f25f8d4da290c9e661429cb1f21e8ad8520da007c94
+  metadata.gz: a805ca67f914f9413cb95913b2015c7a56020564bf709a45aadd96c25f183a374927fd572b6dab80cf2969adca7b2d6305edd04b617d0414f1af2caba108ddc4
+  data.tar.gz: 1f9ba4407c3677d5166ec09aced32f3d2c43ac4a599468eda510f3e7327ce417d6eea25af8de47ea308bacde60e45b9c8ba36414434bd0bd0d938bb2ecdd1bfc

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.4.0 — 2026-10-11
+
+- Add a Cucumber reporter (Cucumber >= 9, < 12; not a gem dependency). `require "raider_reporter/cucumber"` from `features/support/` registers it in plugin mode (recommended, works with any `--format` and no `--out`); `--format RaiderReporter::Cucumber::Formatter --out <file>` also works. Using both registers one listener
+- Identity: `file_path` is project-relative (`features/login.feature`), `full_name` is `"<Feature>: <Scenario>"` (outline rows add `(<Examples name>, row <n>)`; when several Examples tables share a label, each is numbered: `(Examples 1, row 1)`, `(Examples 2, row 1)`), `identifier` is `<file>:<line>`
+- Report the failing step (or Before/After hook) with its location in the failure message; ambiguous maps to failed, undefined to pending
+- Retries: only the final attempt is kept, with `attempts` set and earlier attachments dropped
+- Attachments: `RaiderReporter.attach` and Cucumber's `attach(path, media_type)` with an existing file path are captured; inline data and `log` messages are ignored
+- Dry runs (`cucumber --dry-run`) write and upload nothing; `parallel_tests` shards write `run-<n>.json`
+- No breaking changes: RSpec behaviour is unchanged
+
 ## 0.3.0 — 2026-10-11
 
 - Report pull request identity: `run.ci.repository`, `run.git.default_branch` and `run.git.pr` (number, base/head branch, head SHA) on `pull_request` and `pull_request_target` events. Requires a Raider server that accepts `git.pr`

data/README.md

@@ -1,6 +1,6 @@
 # raider_reporter
 
-Raider-schema test reporting for RSpec. `raider_reporter` is an RSpec formatter that records every example's result, failure details, screenshots and videos, writes them to a local `run.json` (schema v1), and can optionally upload the run to a Raider server. It replaces Allure for Ruby Raider projects.
+Raider-schema test reporting for RSpec and Cucumber. `raider_reporter` is an RSpec formatter and a Cucumber reporter that records every example's result, failure details, screenshots and videos, writes them to a local `run.json` (schema v1), and can optionally upload the run to a Raider server. It replaces Allure for Ruby Raider projects.
 
 It has no runtime dependencies and requires Ruby 3.2 or newer.
 
@@ -26,7 +26,80 @@ Enable the formatter in `.rspec`:
 --format RaiderReporter::RSpec::Formatter
 ```
 
-Run `bundle exec rspec` as usual. Results land in `raider-results/run.json`. A dry run (`rspec --dry-run`) writes and uploads nothing.
+Run `bundle exec rspec` as usual. (For Cucumber, see [Cucumber](#cucumber).) Results land in `raider-results/run.json`. A dry run (`rspec --dry-run`) writes and uploads nothing.
+
+## Cucumber
+
+Requirements: Cucumber 9, 10 or 11 in your own Gemfile (`gem "cucumber"`). It is not a dependency of this gem; requiring `raider_reporter/cucumber` without Cucumber raises a `LoadError` that says so. Cucumber 9.2.1 on Ruby 4 also needs `gem "logger"` in your Gemfile, because Cucumber requires it without declaring it.
+
+### Plugin mode (recommended)
+
+Require the reporter from a file under `features/support/`, for example `features/support/raider.rb`:
+
+```ruby
+require "raider_reporter/cucumber"
+```
+
+Then run Cucumber with any normal formatter and no `--out`:
+
+```
+# cucumber.yml
+default: --format pretty
+```
+
+The require registers one listener on Cucumber's event bus, so it sits next to `pretty`, `progress` or any other formatter. Results land in `raider-results/run.json`, and a dry run (`cucumber --dry-run`) writes and uploads nothing. Plugin mode registers once per Ruby process, because `require` is cached: a second in-process `Cucumber::Cli::Main` run in the same process does not register again.
+
+### Formatter mode
+
+You can also name the formatter explicitly:
+
+```
+cucumber --format pretty --format RaiderReporter::Cucumber::Formatter --out raider-results/cucumber.log
+```
+
+`--out` is required here. Cucumber rejects a second formatter on the same output stream ("All but one formatter must use --out", also in 9.2.1), and this formatter writes nothing to its stream, so give it any file path (it is never created). If both modes are active, only one listener is registered.
+
+### How tests are identified
+
+- `file_path` is relative to the project root (`features/login.feature`), even when Cucumber is given `./features/login.feature` or an absolute path.
+- `full_name` is `"<Feature name>: <Scenario name>"`. Scenario Outline rows are `"<Feature name>: <Scenario name> (<Examples name or 'Examples'>, row <n>)"`, where `n` is the 1-based data row of that Examples table. When two or more Examples tables of one outline share a label (for example two unnamed ones), every table with that label is numbered by its position among them, `(Examples 1, row 1)`, `(Examples 2, row 1)`, so each row keeps a distinct name; tables with a unique label are unchanged.
+- `identifier` is `"<file_path>:<line>"`: the scenario line, or the Examples row line for outline rows.
+- `tags` are the feature, scenario and Examples tags, merged, sorted, unique, without `@`.
+
+Statuses: passed, failed and ambiguous (reported as failed), pending and undefined (reported as pending), skipped.
+
+### Failures
+
+A failed test reports the step that failed, not the whole scenario:
+
+```
+When I fail on purpose (features/login.feature:9)
+
+expected 5, got 4
+```
+
+A failing `Before` or `After` hook is named `Before hook` or `After hook` in place of the step, so an `After` hook that raises after every step passed is still a failed test. Messages are capped at 10,000 characters and backtraces at 50 lines.
+
+### Retries
+
+With `--retry n`, only the final attempt of each scenario is reported, and `attempts` is the number of attempts. Each attempt starts with fresh attachments; attachments from earlier attempts are dropped.
+
+### Attachments
+
+Both of these are captured while a scenario runs:
+
+```ruby
+After do |scenario|
+  attach(path, "image/png") if scenario.failed?        # Cucumber's own attach, with an existing file path (a Pathname works too)
+  RaiderReporter.attach("screenshot", path, type: :png) # or the Raider helper, as in RSpec
+end
+```
+
+Cucumber's `attach` is captured only when given the path of an existing file. Inline data (`attach("some text", "text/plain")`) and `log` messages are ignored.
+
+### Parallel runs with Cucumber
+
+`parallel_tests` works with no configuration for Cucumber too: each process writes `run-<n>.json`. See [Parallel runs](#parallel-runs).
 
 ## Attaching screenshots and videos
 
@@ -183,6 +256,7 @@ Tip: run `rm -rf raider-results` before a parallel run. Each process only cleans
 ## Examples
 
 - `examples/rspec_basic` is a runnable RSpec project with a passing, a failing (with an attachment) and a skipped example. Run it with `cd examples/rspec_basic && bundle install && bundle exec rspec`; the failure is deliberate.
+- `examples/cucumber_basic` is the same for Cucumber (plugin mode): a passing scenario, a failing one with an attachment, and an outline. Run it with `cd examples/cucumber_basic && bundle install && bundle exec cucumber`; the failure is deliberate.
 - `examples/github_actions.yml` shows the workflow steps for CI.
 
 ## Schema
@@ -191,7 +265,7 @@ Tip: run `rm -rf raider-results` before a parallel run. Each process only cleans
 
 ## Contributing
 
-Bug reports and pull requests are welcome at https://github.com/RaiderHQ/raider_reporter. Run `bundle install && bundle exec rake` to run the specs.
+Bug reports and pull requests are welcome at https://github.com/RaiderHQ/raider_reporter. Run `bundle install && bundle exec rake` to run the specs. To test against another Cucumber, set `CUCUMBER_VERSION` (for example `CUCUMBER_VERSION="~> 9.0" bundle update cucumber && bundle exec rspec`).
 
 ## License
 

data/lib/raider_reporter/collector.rb

@@ -55,8 +55,18 @@ module RaiderReporter
     end
 
     def finish_test(**fields)
+      add_result(build_test(**fields))
+    end
+
+    # Closes the current test and returns its result without recording it, so a
+    # framework that retries can hold one result per test and replace it per attempt.
+    def build_test(**fields)
       result = TestResult.new(**fields, attachments: @pending_attachments || [])
       @pending_attachments = nil
+      result
+    end
+
+    def add_result(result)
       @results << result
       result
     end

data/lib/raider_reporter/cucumber/formatter.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "cucumber"
+require "cucumber/formatter/ast_lookup"
+require "raider_reporter"
+require "raider_reporter/text"
+
+module RaiderReporter
+  module Cucumber
+    # Translates Cucumber events into Collector calls. Every handler is guarded:
+    # a reporting bug must never fail or crash the user's run. The formatter
+    # writes nothing to its IO; the report goes to RaiderReporter's own writers.
+    #
+    # Inside this namespace `Cucumber` means RaiderReporter::Cucumber, so the
+    # gem's constants are always written ::Cucumber.
+    class Formatter
+      STATUSES = {
+        passed: "passed", failed: "failed", ambiguous: "failed",
+        pending: "pending", undefined: "pending", skipped: "skipped"
+      }.freeze
+
+      # Passed to the World's `attach`; reports an existing file as an attachment.
+      module AttachCapture
+        # Takes whatever Cucumber passes (file, media_type, filename, and any
+        # argument a later release adds) and forwards it untouched.
+        ruby2_keywords def attach(*args, &block)
+          result = super
+          Formatter.record_attachment(args[0], args[1])
+          result
+        end
+      end
+
+      @claimed = []
+
+      class << self
+        # One listener per run, whether it arrives as a --format or as a plugin.
+        # Cucumber copies the configuration for --out, but the event bus is shared.
+        def claim(config)
+          bus = config.event_bus
+          return false if @claimed.any? { |claimed| claimed.equal?(bus) }
+
+          @claimed << bus
+          true
+        end
+
+        # Inline text, IO objects and missing paths are ignored: only a file that
+        # exists can be copied. Never raises into the user's step.
+        def record_attachment(file, media_type)
+          # `log` is attach with this media type; a logged message is not a file.
+          return if media_type.to_s.start_with?("text/x.cucumber.log")
+
+          file = file.to_path if file.respond_to?(:to_path)
+          return unless file.is_a?(String) && RaiderReporter.collector&.in_test? && File.file?(file)
+
+          RaiderReporter.attach(File.basename(file), file, type: media_type)
+        rescue StandardError => e
+          RaiderReporter.warn("#{e.class}: #{e.message}")
+        end
+
+        # Called when the run ends, so the list does not outlive the run.
+        def release(config)
+          bus = config.event_bus
+          @claimed.reject! { |claimed| claimed.equal?(bus) }
+          RaiderReporter.dry_run = false
+        end
+
+        # Cucumber hands steps a World, not the formatter, so `attach` is observed
+        # by prepending to ProtoWorld. Installed once, at the first formatter.
+        # Event-bus alternatives were checked in cucumber 9.2.1, 10.2.0 and 11.1.1:
+        # there is no :attach_called event before 11, and even there (and in the
+        # :envelope attachment message) a file path has already been read into
+        # bytes with no name, so the basename the report needs is only available
+        # in ProtoWorld#attach, which exists unchanged in all three versions.
+        def capture_attach
+          return if @capturing
+
+          ::Cucumber::Glue::ProtoWorld.prepend(AttachCapture)
+          @capturing = true
+        end
+      end
+
+      def initialize(config)
+        @buffer = {}
+        @attempts = Hash.new(0)
+        @attempt = nil
+        guard { setup(config) if self.class.claim(config) }
+      end
+
+      private
+
+      def setup(config)
+        @config = config
+        @ast = ::Cucumber::Formatter::AstLookup.new(config)
+        @collector = RaiderReporter.start_collector!
+        RaiderReporter.dry_run = config.dry_run?
+        config.on_event(:test_run_started) { |_event| guard { @collector.start_run } }
+        config.on_event(:test_case_started) { |event| guard { case_started(event.test_case) } }
+        config.on_event(:test_step_finished) { |event| guard { step_finished(event.test_step, event.result) } }
+        config.on_event(:test_case_finished) { |event| guard { case_finished(event.test_case, event.result) } }
+        config.on_event(:test_run_finished) { |_event| guard { run_finished } }
+        # Last, and on its own: a broken attach hook may only lose attachments.
+        safely(nil) { self.class.capture_attach }
+      end
+
+      # Every attempt starts with an empty attachment list.
+      def case_started(test_case)
+        @collector.start_test
+        @attempt = { test_case: test_case }
+      end
+
+      # The first non-passed step explains why the scenario did not pass.
+      def step_finished(test_step, result)
+        return unless @attempt
+        return if @attempt[:problem] || result.passed?
+
+        @attempt[:problem] = { step: test_step, result: result }
+      end
+
+      def case_finished(test_case, result)
+        problem = @attempt && @attempt[:problem]
+        @attempt = nil
+        status = STATUSES.fetch(result.to_sym, "pending")
+        # Always buffer: a lookup problem may lose detail, never the scenario.
+        failure = status == "failed" ? safely(nil) { failure_for(problem, result, test_case) } : nil
+        fields = identity_for(test_case)
+        key = "#{test_case.location}|#{test_case.name}"
+        @attempts[key] += 1
+        # The newest attempt replaces the older one, taking its attachments with it.
+        @buffer[key] = @collector.build_test(
+          **fields, status: status, duration_ms: duration_ms(result), attempts: @attempts[key], failure: failure
+        )
+      end
+
+      def run_finished
+        @buffer.each_value { |result| @collector.add_result(result) }
+        @buffer.clear
+        RaiderReporter.finish!($stderr)
+      ensure
+        self.class.release(@config)
+      end
+
+      def identity_for(test_case)
+        file_path = relative_path(test_case.location.file)
+        line_number = test_case.location.lines.max
+        {
+          file_path: file_path,
+          line_number: line_number,
+          full_name: Text.utf8(full_name(test_case)),
+          identifier: "#{file_path}:#{line_number}",
+          tags: test_case.tags.map { |tag| tag.name.to_s.delete_prefix("@") }.uniq.sort
+        }
+      end
+
+      def full_name(test_case)
+        safely(test_case.name) do
+          feature = @ast.gherkin_document(test_case.location.file)&.feature
+          name = scenario_name(@ast.scenario_source(test_case))
+          next test_case.name unless name
+
+          feature ? "#{feature.name}: #{name}" : name
+        end
+      end
+
+      # nil when the scenario cannot be located in the AST.
+      def scenario_name(source)
+        case source&.type
+        when :ScenarioOutline
+          examples = source.examples
+          row = examples.table_body.index { |candidate| candidate.location.line == source.row.location.line }
+          row && "#{source.scenario_outline.name} (#{examples_label(source)}, row #{row + 1})"
+        when :Scenario
+          source.scenario.name
+        end
+      end
+
+      # "Examples" or the table's name. When several tables of one outline share a
+      # label (two unnamed ones, say), each gets its 1-based position among them,
+      # so rows of different tables never collide on full_name.
+      def examples_label(source)
+        tables = source.scenario_outline.examples
+        label = examples_name(source.examples)
+        same = tables.select { |table| examples_name(table) == label }
+        return label if same.size < 2
+
+        "#{label} #{same.index { |table| table.equal?(source.examples) || table.location.line == source.examples.location.line } + 1}"
+      end
+
+      def examples_name(table)
+        table.name.to_s.strip.empty? ? "Examples" : table.name.strip
+      end
+
+      # step_info is { step:, result: } for the first non-passed step, if any.
+      def failure_for(step_info, result, test_case)
+        exception = result.respond_to?(:exception) ? result.exception : nil
+        exception ||= step_info && step_info[:result].respond_to?(:exception) ? step_info[:result].exception : nil
+        return nil unless exception
+
+        Failure.new(
+          message: Text.utf8("#{step_label(step_info, test_case)}\n\n#{exception.message}")[0, Text::MAX_MESSAGE],
+          exception_class: Text.utf8(exception.class.name),
+          backtrace: (exception.backtrace || []).first(Text::MAX_BACKTRACE).map { |line| Text.utf8(line) }
+        )
+      end
+
+      def step_label(step_info, test_case)
+        return "Step" unless step_info
+
+        test_step = step_info[:step]
+        location = "(#{relative_path(test_step.location.file)}:#{test_step.location.lines.min})"
+        if test_step.hook?
+          "#{hook_kind(test_step, test_case)} hook #{location}"
+        else
+          "#{step_keyword(test_step)}#{test_step.text} #{location}"
+        end
+      end
+
+      def step_keyword(test_step)
+        safely("") { @ast.step_source(test_step).step.keyword.to_s }
+      end
+
+      # A hook with a real step before it runs after the scenario started.
+      def hook_kind(test_step, test_case)
+        steps = test_case.test_steps
+        index = steps.index { |candidate| candidate.equal?(test_step) }
+        index && steps.first(index).any? { |candidate| !candidate.hook? } ? "After" : "Before"
+      end
+
+      def duration_ms(result)
+        (result.duration.nanoseconds / 1_000_000.0).round
+      rescue StandardError
+        0
+      end
+
+      def relative_path(path)
+        absolute = Pathname.new(File.expand_path(path.to_s, Dir.pwd))
+        relative = absolute.relative_path_from(Pathname.new(Dir.pwd)).to_s
+        relative.start_with?("..") ? path.to_s.delete_prefix("./") : relative
+      rescue ArgumentError
+        # Windows: a path on another drive has no relative form.
+        path.to_s.delete_prefix("./")
+      end
+
+      def safely(fallback)
+        yield
+      rescue StandardError => e
+        RaiderReporter.warn("#{e.class}: #{e.message}")
+        fallback
+      end
+
+      def guard
+        yield
+      rescue StandardError => e
+        RaiderReporter.warn("#{e.class}: #{e.message}")
+      end
+    end
+  end
+end

data/lib/raider_reporter/cucumber.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+begin
+  require "cucumber"
+rescue LoadError => e
+  raise unless e.path == "cucumber"
+
+  raise LoadError, "raider_reporter/cucumber needs the cucumber gem (>= 9, < 12) in your Gemfile"
+end
+require "raider_reporter"
+require_relative "cucumber/formatter"
+
+module RaiderReporter
+  module Cucumber
+    # Plugin mode: requiring this file from features/support registers the
+    # listener through Cucumber's InstallPlugin hook, so no --format is needed
+    # (and none of the "one formatter per stream" juggling). Outside a Cucumber
+    # run there is no step-definition registry and this is a no-op.
+    def self.install_plugin
+      # Cucumber's public InstallPlugin DSL method, called on a throwaway object
+      # (it is only an instance method of Dsl; main is extended with it).
+      Object.new.extend(::Cucumber::Glue::Dsl).InstallPlugin(name: "raider_reporter") do |config, *|
+        RaiderReporter::Cucumber::Formatter.new(config)
+      end
+      true
+    rescue StandardError => e
+      # Outside a run there is no registry (Dsl has no rb_language) and nothing to
+      # report. Inside one, losing the listener must not be silent.
+      RaiderReporter.warn("could not register the Cucumber plugin: #{e.class}: #{e.message}") if run_active?
+      false
+    end
+
+    def self.run_active?
+      !::Cucumber::Glue::Dsl.instance_variable_get(:@rb_language).nil?
+    end
+    private_class_method :run_active?
+  end
+end
+
+RaiderReporter::Cucumber.install_plugin

data/lib/raider_reporter/rspec/formatter.rb

@@ -2,6 +2,7 @@
 
 require "rspec/core"
 require "raider_reporter"
+require "raider_reporter/text"
 
 module RaiderReporter
   module RSpec
@@ -13,8 +14,8 @@ module RaiderReporter
                                          :example_failed, :example_pending, :close
 
       NON_TAG_KEYS = %i[pending skip].freeze
-      MAX_MESSAGE = 10_000
-      MAX_BACKTRACE = 50
+      MAX_MESSAGE = Text::MAX_MESSAGE
+      MAX_BACKTRACE = Text::MAX_BACKTRACE
 
       def initialize(output)
         @output = output
@@ -77,14 +78,8 @@ module RaiderReporter
         )
       end
 
-      # JSON generation raises on invalid UTF-8, which would lose the whole run.
       def utf8(value)
-        str = value.to_s
-        if [Encoding::UTF_8, Encoding::BINARY, Encoding::US_ASCII].include?(str.encoding)
-          str.dup.force_encoding(Encoding::UTF_8).scrub("?")
-        else
-          str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "?")
-        end
+        Text.utf8(value)
       end
 
       def guard

data/lib/raider_reporter/text.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RaiderReporter
+  # Text limits and cleaning shared by the framework formatters.
+  module Text
+    MAX_MESSAGE = 10_000
+    MAX_BACKTRACE = 50
+
+    # JSON generation raises on invalid UTF-8, which would lose the whole run.
+    def self.utf8(value)
+      str = value.to_s
+      if [Encoding::UTF_8, Encoding::BINARY, Encoding::US_ASCII].include?(str.encoding)
+        str.dup.force_encoding(Encoding::UTF_8).scrub("?")
+      else
+        str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "?")
+      end
+    end
+  end
+end

data/lib/raider_reporter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RaiderReporter
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/raider_reporter.rb

@@ -3,6 +3,7 @@
 require "time"
 require "rbconfig"
 require_relative "raider_reporter/version"
+require_relative "raider_reporter/text"
 require_relative "raider_reporter/models"
 require_relative "raider_reporter/payload"
 require_relative "raider_reporter/configuration"
@@ -27,13 +28,18 @@ module RaiderReporter
       yield configuration
     end
 
+    # Set by the Cucumber formatter when the run is a --dry-run.
+    attr_writer :dry_run
+
     def reset!
+      @dry_run = false
       @collector&.cleanup
       @configuration = nil
       @collector = nil
     end
 
     def start_collector!
+      @dry_run = false
       @collector = Collector.new(
         max_attachment_bytes: configuration.max_attachment_bytes,
         warn: ->(message) { warn(message) }
@@ -104,8 +110,10 @@ module RaiderReporter
       "Raider report uploaded"
     end
 
-    # `rspec --dry-run` reports every example as passed without running it.
+    # `rspec --dry-run` and `cucumber --dry-run` report every example as passed without running it.
     def dry_run?
+      return true if @dry_run
+
       defined?(::RSpec.configuration) && ::RSpec.configuration.respond_to?(:dry_run?) &&
         ::RSpec.configuration.dry_run?
     end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: raider_reporter
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Augustin Gottlieb
 bindir: exe
 cert_chain: []
-date: 2026-10-11 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: RSpec formatter that records results, screenshots and videos in the Raider
-  schema, writes them locally, and optionally uploads them to a Raider server.
+description: RSpec and Cucumber formatters that record results, screenshots and videos
+  in the Raider schema, write them locally, and optionally upload them to a Raider
+  server.
 email:
 - 33221555+aguspe@users.noreply.github.com
 executables:
@@ -30,12 +31,15 @@ files:
 - lib/raider_reporter/comment/summary_client.rb
 - lib/raider_reporter/configuration.rb
 - lib/raider_reporter/content_types.rb
+- lib/raider_reporter/cucumber.rb
+- lib/raider_reporter/cucumber/formatter.rb
 - lib/raider_reporter/github_event.rb
 - lib/raider_reporter/models.rb
 - lib/raider_reporter/payload.rb
 - lib/raider_reporter/rspec.rb
 - lib/raider_reporter/rspec/formatter.rb
 - lib/raider_reporter/shard_detector.rb
+- lib/raider_reporter/text.rb
 - lib/raider_reporter/version.rb
 - lib/raider_reporter/writers/local.rb
 - lib/raider_reporter/writers/uploader.rb
@@ -60,7 +64,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.6
 specification_version: 4
-summary: 'Test reporting for Ruby Raider: local run.json and Raider uploads'
+summary: RSpec and Cucumber formatters that write Raider reports locally and upload
+  them to Raider
 test_files: []