scully 0.0.1 → 0.1.0

data/lib/scully/render/terminal.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Scully
+  module Render
+    # Decides whether output may use colour and OSC 8 hyperlinks, and applies them.
+    #
+    # Neither can be queried from the terminal, so both are guessed from the environment.
+    # Colour is on for a TTY unless NO_COLOR is set to a non-empty value. Hyperlinks follow a reduced port of the
+    # decision order of the npm package supports-hyperlinks: an allowlist of terminals known to
+    # render them, so older terminals never print escape junk. Colour and hyperlinks are decided
+    # independently, and `--color` / `--hyperlinks` (always, never) override each guess.
+    class Terminal
+      STYLES = { error: '1;31', warning: '1;33', secondary: '34' }.freeze
+
+      # Minimum TERM_PROGRAM_VERSION per TERM_PROGRAM; nil means any version.
+      PROGRAMS = { 'iTerm.app' => [3, 1], 'WezTerm' => [20_200_620], 'vscode' => [1, 72], 'ghostty' => nil,
+                   'zed' => nil, 'Orca' => nil, 'WarpTerminal' => nil }.freeze
+      # VTE 0.50.0 crashes on hyperlinks.
+      VTE_MINIMUM = [0, 50, 1].freeze
+      TERMS = %w[alacritty xterm-kitty].freeze
+
+      # +env+ is a Hash-like environment; +tty+ says whether stdout is a terminal.
+      def initialize(env:, tty:, color: 'auto', hyperlinks: 'auto')
+        @env = env
+        @tty = tty
+        @color = decide(color) { tty && env['NO_COLOR'].to_s.empty? }
+        @hyperlinks = decide(hyperlinks) { detect_hyperlinks }
+      end
+
+      def color? = @color
+
+      def hyperlinks? = @hyperlinks
+
+      # +text+ in the SGR style named +style+ (a key of STYLES) when colour is on.
+      def paint(text, style) = color? ? "\e[#{STYLES.fetch(style)}m#{text}\e[0m" : text
+
+      # +text+ as an OSC 8 hyperlink to +url+ when hyperlinks are on.
+      def link(text, url) = hyperlinks? ? "\e]8;;#{url}\e\\#{text}\e]8;;\e\\" : text
+
+      private
+
+      def decide(option)
+        case option
+        when 'always' then true
+        when 'never' then false
+        else yield
+        end
+      end
+
+      # First match wins: FORCE_HYPERLINK, then no TTY or CI, then known terminals.
+      def detect_hyperlinks
+        force = @env['FORCE_HYPERLINK'].to_s
+        return force != '0' unless force.empty?
+        return false unless @tty && !ci?
+
+        @env.key?('WT_SESSION') || program? || vte? || TERMS.include?(@env['TERM'])
+      end
+
+      def ci? = @env.key?('CI') || @env.key?('TEAMCITY_VERSION')
+
+      def program?
+        name = @env['TERM_PROGRAM']
+        return false unless PROGRAMS.key?(name)
+
+        minimum = PROGRAMS[name]
+        minimum.nil? || at_least?(version(@env['TERM_PROGRAM_VERSION']), minimum)
+      end
+
+      # VTE_VERSION is either dotted (0.50.1) or packed as major * 10000 + minor * 100 + micro (5001).
+      def vte?
+        value = @env['VTE_VERSION'].to_s
+        parts = value.include?('.') ? version(value) : unpack(value)
+        at_least?(parts, VTE_MINIMUM)
+      end
+
+      def unpack(value)
+        return unless value.match?(/\A\d+\z/)
+
+        number = value.to_i
+        [number / 10_000, number / 100 % 100, number % 100]
+      end
+
+      # The leading dotted number: `1.95.0-insider` is [1, 95, 0], `20200620-160318-e00b076c` is [20200620].
+      def version(value) = value.to_s[/\A\d+(\.\d+)*/]&.split('.')&.map(&:to_i)
+
+      def at_least?(parts, minimum)
+        return false if parts.nil?
+
+        size = [parts.size, minimum.size].max
+        (parts.fill(0, parts.size...size) <=> minimum.dup.fill(0, minimum.size...size)) >= 0
+      end
+
+      # Neither colour nor hyperlinks.
+      PLAIN = new(env: {}, tty: false)
+    end
+  end
+end

data/lib/scully/render/why.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Scully
+  module Render
+    # Renders `scully why`: the finding block followed by its explanation.
+    #
+    #   <finding block, as in the report>
+    #
+    #   because:
+    #     <the rule's rationale>
+    #
+    #   what happened:
+    #     <the rule's explain lines>
+    #
+    #   help:
+    #     <the rule's fix guidance>
+    #
+    #   evidence: <the file's status>
+    #   see also: <companion cops>
+    class Why
+      # Longest line, indent included: wrapped text stays shorter than 92 columns.
+      WIDTH = 91
+      INDENT = '  '
+      COMPLETE = 'evidence: static analysis (complete file)'
+      SEE_ALSO = 'see also: '
+      NO_COMPANION = 'no matching cop in rubocop-rspec or rubocop-minitest'
+      URL_INDENT = ' ' * 12
+      DETAILS = 'Use `scully why <location>` for details:'
+      OTHERS = 'Findings in this file:'
+      COLUMN_GAP = '  '
+
+      # +file+ is a FileReport and +findings+ its findings in report order; +rules+ maps rule ids
+      # to rules; +source+ responds to line(number); +terminal+ adds colour and hyperlinks when
+      # they are on.
+      def initialize(file, findings:, rules:, source:, terminal: Terminal::PLAIN)
+        @file = file
+        @findings = findings
+        @rules = rules
+        @source = source
+        @terminal = terminal
+      end
+
+      # Every finding whose primary span starts on +line+, by column then rule id, explained in
+      # full and separated by blank lines; nil when there is none.
+      def location(line)
+        found = @findings.select { it.primary.span.start_line == line }
+        return if found.empty?
+
+        found.sort_by { [it.primary.span.start_column, it.rule_id.to_s] }.map { explanation(it) }.join("\n")
+      end
+
+      # The file's findings, one row each, then a `scully why` command for each.
+      def index
+        return "#{@file.path}#{status}: no findings\n" if @findings.empty?
+
+        "#{@file.path}#{status}\n\n#{table(rows).join}\n#{DETAILS}\n\n#{commands.join}"
+      end
+
+      # The report's skip line when the file was skipped, so it never looks clean; nil otherwise.
+      def skipped = (Report.skip_line(@file) if @file.status == :skipped)
+
+      # The message for a +line+ without findings, pointing at the file's findings instead.
+      def missing(line)
+        others = @findings.empty? ? "No findings in this file.\n" : "#{OTHERS}\n#{commands("  ").join}"
+        "scully: no finding at #{@file.path}:#{line}\n#{others}"
+      end
+
+      # Wraps +text+ greedily on spaces so no line exceeds +width+ characters, prefix included.
+      # The first line starts with +first+, the others with +indent+. A word longer than the
+      # width is never broken. Returns the lines without terminators.
+      def self.wrap(text, indent:, first: indent, width: WIDTH)
+        rows = [[first]]
+        text.split(' ').each do |word|
+          row = rows.last
+          rows << (row = [indent]) if row.size > 1 && "#{row.first}#{[*row.drop(1), word].join(" ")}".size > width
+          row << word
+        end
+        rows.map { |prefix, *words| "#{prefix}#{words.join(" ")}" }
+      end
+
+      private
+
+      def status = @file.status == :incomplete ? Snippet::INCONCLUSIVE : ''
+
+      def message(finding) = @rules.fetch(finding.rule_id).class.message
+
+      # Each column but the last padded to its widest cell.
+      def table(rows)
+        widths = rows.transpose[0...-1].map { |cells| cells.map(&:size).max }
+        rows.map do |*cells, last|
+          "#{INDENT}#{cells.zip(widths).map { |cell, width| cell.ljust(width) }.join(COLUMN_GAP)}#{COLUMN_GAP}#{last}\n"
+        end
+      end
+
+      def rows
+        @findings.map do
+          span = it.primary.span
+          ["#{it.severity}[#{it.rule_id}]", "#{span.start_line}:#{span.start_column}", message(it)]
+        end
+      end
+
+      def commands(indent = '') = Report.commands(@findings).map { "#{indent}#{it}\n" }
+
+      def explanation(finding)
+        block = Snippet.render(finding, message: message(finding), source: @source, terminal: @terminal)
+        rule = @rules.fetch(finding.rule_id)
+        declaration = rule.class
+        lines = [*section('because', [declaration.because]), *section('what happened', rule.explain(finding)),
+                 *section('help', [declaration.help]), '', *evidence, *see_also(declaration.companions)]
+        "#{block}#{lines.map { "#{it}\n" }.join}"
+      end
+
+      def section(title, paragraphs) = ['', "#{title}:", *paragraphs.flat_map { self.class.wrap(it, indent: INDENT) }]
+
+      # The file's status, not the finding's: a parse finding is certain, but its file is not.
+      def evidence
+        lines = @file.parse_errors.map { it.span.start_line }.uniq
+        return [COMPLETE] if lines.empty?
+
+        self.class.wrap("inconclusive. This file has parse errors on #{line_list(lines)}, so parts of it may not " \
+                        'have been analyzed. Fix them and run again.', first: 'evidence: ', indent: INDENT)
+      end
+
+      def line_list(lines)
+        return "line #{lines.first}" if lines.one?
+
+        "lines #{lines[0...-1].join(", ")} and #{lines.last}"
+      end
+
+      def see_also(companions)
+        return ["#{SEE_ALSO}#{NO_COMPANION}"] if companions.empty?
+
+        companions.each_with_index.flat_map do |companion, index|
+          prefix = index.zero? ? SEE_ALSO : ' ' * SEE_ALSO.size
+          url = "#{URL_INDENT}#{companion.url}" unless @terminal.hyperlinks?
+          ["#{prefix}#{companion_text(companion)}", *url]
+        end
+      end
+
+      def companion_text(companion)
+        state = ', disabled by default' unless companion.default_enabled
+        "#{@terminal.link(companion.cop, companion.url)} (#{companion.plugin}#{state})"
+      end
+    end
+  end
+end

data/lib/scully/rule.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Scully
+  # A RuboCop cop that covers the same ground as a rule.
+  Companion = Data.define(:cop, :plugin, :url, :default_enabled)
+
+  # Base class for rules. A subclass declares its fields with the class-level DSL:
+  #
+  #   class NoAssertion < Scully::Rule
+  #     id         :no_assertion
+  #     severity   :warning
+  #     message    'test makes no assertion'
+  #     because    '...'
+  #     help       '...'
+  #     companions Companion.new(...), Companion.new(...)   # or: companions :none
+  #
+  #     def check(test_case) = [...]   # -> Array<Finding>
+  #     def explain(finding) = [...]   # -> Array<String>
+  #   end
+  #
+  # A subclass that omits a field raises DeclarationError when its class body ends.
+  class Rule
+    class DeclarationError < Scully::Error; end
+
+    FIELDS = %i[id severity message because help companions].freeze
+
+    class << self
+      def inherited(subclass)
+        super
+        trace = TracePoint.new(:end) do |event|
+          next unless event.self.equal?(subclass)
+
+          trace.disable
+          subclass.validate!
+        end
+        trace.enable
+      end
+
+      def id(value = nil) = declare(:id, value)
+      def severity(value = nil) = declare(:severity, value)
+      def message(value = nil) = declare(:message, value)
+      def because(value = nil) = declare(:because, value)
+      def help(value = nil) = declare(:help, value)
+
+      # Companion cops, or :none when no cop matches. Reads return an Array.
+      def companions(*values)
+        return declare(:companions, values == [:none] ? [] : values) unless values.empty?
+
+        declared(:companions)
+      end
+
+      def validate!
+        missing = FIELDS.reject { instance_variable_defined?(:"@#{it}") }
+        raise DeclarationError, "#{name || "rule"} does not declare #{missing.join(", ")}" unless missing.empty?
+        raise DeclarationError, "#{id}: unknown severity #{severity.inspect}" unless SEVERITIES.include?(severity)
+        return if companions.all?(Companion)
+
+        raise DeclarationError, "#{id}: companions must be Companion values or :none"
+      end
+
+      private
+
+      def declare(field, value)
+        return declared(field) if value.nil?
+
+        instance_variable_set(:"@#{field}", value)
+      end
+
+      def declared(field) = instance_variable_get(:"@#{field}")
+    end
+
+    def check(_test_case) = raise(NotImplementedError, "#{self.class} must implement #check")
+
+    def explain(_finding) = raise(NotImplementedError, "#{self.class} must implement #explain")
+
+    private
+
+    # Builds a finding for this rule. Evidence starts :static; the analyzer downgrades it
+    # for incomplete files.
+    def finding(primary:, test_name:, secondary: [], facts: {})
+      Finding.new(rule_id: self.class.id, severity: self.class.severity, primary:, secondary:,
+                  test_name:, facts:, evidence: :static)
+    end
+  end
+end

data/lib/scully/rules/no_assertion.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Scully
+  module Rules
+    # Reports a test that runs code but never checks a result.
+    class NoAssertion < Rule
+      id         :no_assertion
+      severity   :warning
+      message    'test makes no assertion'
+      because    'A test with no assertion passes whatever the code does, so it gives coverage without evidence.'
+      help       'Add an assertion that states what the test claims. If an assertion lives in a helper defined ' \
+                 'in another file, scully cannot see it yet and this finding may be a false positive.'
+      companions Companion.new(cop: 'RSpec/NoExpectationExample', plugin: 'rubocop-rspec',
+                               url: 'https://docs.rubocop.org/rubocop-rspec/latest/cops_rspec.html#rspecnoexpectationexample',
+                               default_enabled: true),
+                 Companion.new(cop: 'Minitest/NoAssertions', plugin: 'rubocop-minitest',
+                               url: 'https://docs.rubocop.org/rubocop-minitest/latest/cops_minitest.html#minitestnoassertions',
+                               default_enabled: false)
+
+      LABEL = 'this test runs code but never checks a result'
+      # How a candidate helper was resolved, for helpers that did not count as assertions.
+      RESOLUTIONS = { same_file_without_assertion: 'defined in this file, no assertions',
+                      unresolved: 'not defined in this file, not followed' }.freeze
+      LISTED_HELPERS = 5
+
+      def check(test_case)
+        return [] unless test_case.status == :active && test_case.assertions.empty?
+
+        [finding(primary: Label.new(span: test_case.span, text: LABEL), test_name: test_case.name,
+                 facts: { helper_calls: test_case.helper_calls.map { [it.name, it.resolution] } })]
+      end
+
+      def explain(finding)
+        ["No assertion, expectation, or assertion helper was found in this test's body.",
+         "Calls checked as possible helpers: #{helpers(finding.facts[:helper_calls])}."]
+      end
+
+      private
+
+      # Each helper once, at its first call: up to LISTED_HELPERS, then a count of the rest.
+      def helpers(calls)
+        calls = calls.uniq(&:first)
+        return 'none' if calls.empty?
+
+        items = calls.first(LISTED_HELPERS).map { |name, resolution| "`#{name}` (#{RESOLUTIONS.fetch(resolution)})" }
+        items << "#{calls.size - LISTED_HELPERS} more" if calls.size > LISTED_HELPERS
+        items.size == 1 ? items.first : "#{items[0...-1].join(", ")} and #{items.last}"
+      end
+    end
+  end
+end

data/lib/scully/rules/parse.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Scully
+  module Rules
+    # Reports the syntax errors Prism found in a file, one finding per line that has any.
+    #
+    # Built in: the analyzer runs it on every file report, not on test cases.
+    class Parse < Rule
+      id         :parse
+      severity   :error
+      message    'syntax error'
+      because    'Scully can only check code it can read. A file with syntax errors is analyzed only in part, ' \
+                 'so its results are inconclusive.'
+      help       'Fix the syntax error. `ruby -c <path>` shows Ruby\'s own message.'
+      companions :none
+
+      def check(_test_case) = []
+
+      # Every message Prism gave for the finding's line.
+      def explain(finding) = finding.facts[:messages]
+
+      # +file+'s parse errors are already sorted by line, column, then message bytes, so the
+      # first error on each line labels the finding and the rest are counted.
+      def findings(file)
+        file.parse_errors.group_by { it.span.start_line }.values.map do |errors|
+          first = errors.first
+          more = errors.size > 1 ? " (+#{errors.size - 1} more)" : ''
+          finding(primary: Label.new(span: first.span, text: "#{first.message}#{more}"), test_name: nil,
+                  facts: { messages: errors.map(&:message) })
+        end
+      end
+    end
+  end
+end

data/lib/scully/rules/tautology.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Scully
+  module Rules
+    # Reports an assertion that compares a stubbed call with the value the stub returns.
+    class Tautology < Rule
+      id         :tautology
+      severity   :error
+      message    'assertion checks a value the test stubbed'
+      because    'The assertion checks a value the test itself stubbed, so it can never fail and says nothing ' \
+                 'about the code under test.'
+      help       'Assert on the result of the code that uses the stubbed object, not on the stub itself. If the ' \
+                 'test only documents the stub, delete it.'
+      companions :none
+
+      LABEL = 'compares the stub with its own return value'
+      PLACES = { setup: 'in setup', body: 'here' }.freeze
+
+      def check(test_case)
+        return [] unless test_case.status == :active
+
+        test_case.assertions.filter_map { tautology(it, test_case) }
+      end
+
+      def explain(finding)
+        facts = finding.facts
+        ["`#{facts[:subject]}` is stubbed to return `#{facts[:value]}` (line #{facts[:stub_line]}), and the " \
+         "expectation on line #{facts[:assertion_line]} compares `#{facts[:subject]}` with `#{facts[:value]}`. " \
+         'No code under test runs between the stub and the assertion.']
+      end
+
+      private
+
+      def tautology(assertion, test_case)
+        call = stubbed_call(assertion) or return
+        double = nearest(test_case.doubles, call, assertion.span)
+        return unless double&.stub_source && double.returns && same?(double.returns, assertion.expected)
+
+        report(assertion, double, test_case)
+      end
+
+      # The `R.m` an equality assertion checks: a call with a receiver and no arguments.
+      def stubbed_call(assertion)
+        call = assertion.subject
+        call if assertion.comparison && call.is_a?(Prism::CallNode) && call.receiver &&
+                call.arguments.nil? && call.block.nil?
+      end
+
+      # The last double for the same receiver and method that is visible at the assertion: a later
+      # stub replaces an earlier one, so only the nearest one decides.
+      def nearest(doubles, call, at)
+        doubles.select { it.method_name == call.name && same_receiver?(it.receiver, call.receiver) && visible?(it, at) }
+               .last
+      end
+
+      # Bare identifiers (a local variable, or a `let` read as a method call) match by name;
+      # anything else must be structurally equal.
+      def same_receiver?(left, right)
+        names = [identifier(left), identifier(right)]
+        names.all? ? names.uniq.size == 1 : same?(left, right)
+      end
+
+      # Prism's `Node#===` compares structure and ignores source positions, so `tax . rate`
+      # equals `tax.rate`; `==` would compare identity.
+      def same?(left, right)
+        left === right # rubocop:disable Style/CaseEquality
+      end
+
+      def identifier(node)
+        case node
+        when Prism::LocalVariableReadNode then node.name
+        when Prism::CallNode then node.name if node.receiver.nil? && node.arguments.nil? && node.block.nil?
+        end
+      end
+
+      # Setup runs before the body; a body stub must come before the assertion; a block stub
+      # only applies inside its block.
+      def visible?(double, at)
+        (double.origin == :setup || (position(double.span) <=> position(at)).negative?) &&
+          (double.scope.nil? || inside?(at, double.scope))
+      end
+
+      def inside?(span, scope)
+        (position(span) <=> position(scope)) >= 0 && (position(span) <=> [scope.end_line, scope.end_column]).negative?
+      end
+
+      def position(span) = [span.start_line, span.start_column]
+
+      def report(assertion, double, test_case)
+        value = double.returns.slice
+        secondary = Label.new(span: double.span, text: "stubbed #{PLACES.fetch(double.origin)} to return `#{value}`")
+        facts = { stub_line: double.span.start_line, value:, subject: assertion.subject.slice,
+                  assertion_line: assertion.span.start_line }
+        finding(primary: Label.new(span: assertion.span, text: LABEL), secondary: [secondary],
+                test_name: test_case.name, facts:)
+      end
+    end
+  end
+end

data/lib/scully/source_file.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Scully
+  # A test file read from disk and parsed with Prism.
+  #
+  # A file is incomplete when it could not be read, is not valid UTF-8, or has syntax errors.
+  # Unreadable and invalid files have no parse result; +problem+ says why.
+  class SourceFile
+    attr_reader :path, :source, :result, :parse_errors, :problem
+
+    # Reads +path+, resolved against +base+ when given; spans keep +path+ as written.
+    def self.read(path, base: nil)
+      bytes = File.binread(base ? File.join(base, path) : path)
+      source = bytes.force_encoding(Encoding::UTF_8)
+      return new(path, problem: 'file is not valid UTF-8') unless source.valid_encoding?
+
+      new(path, source:)
+    rescue SystemCallError => e
+      new(path, problem: "could not read file (#{e.class.name.split("::").last})")
+    end
+
+    def initialize(path, source: nil, problem: nil)
+      @path = path
+      @source = source
+      @problem = problem
+      @result = source && Prism.parse(source, filepath: path)
+      @parse_errors = @result ? collect_errors(@result.errors) : []
+      @lines = source ? source.lines.map { it.chomp.delete_suffix("\r") } : []
+    end
+
+    def incomplete? = !problem.nil? || !parse_errors.empty?
+
+    # The text of a 1-based line, without its line terminator.
+    def line(number) = @lines.fetch(number - 1, '')
+
+    # Converts a Prism location to a Span with 1-based character columns. End is exclusive.
+    def span(location)
+      Span.new(path:,
+               start_line: location.start_line, start_column: location.start_character_column + 1,
+               end_line: location.end_line, end_column: location.end_character_column + 1)
+    end
+
+    private
+
+    def collect_errors(errors)
+      errors.map { ParseError.new(span: span(it.location), message: it.message) }
+            .uniq { [it.span.start_line, it.span.start_column, it.message] }
+            .sort_by { [*it.span.sort_key, it.message.b] }
+    end
+  end
+end

data/lib/scully/version.rb

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

data/lib/scully.rb

@@ -4,5 +4,22 @@ require_relative 'scully/version'
 
 module Scully
   class Error < StandardError; end
-  # Your code goes here...
 end
+
+require_relative 'scully/model'
+require_relative 'scully/discovery'
+require_relative 'scully/source_file'
+require_relative 'scully/frameworks/detector'
+require_relative 'scully/frameworks/helpers'
+require_relative 'scully/frameworks/rspec'
+require_relative 'scully/frameworks/minitest'
+require_relative 'scully/rule'
+require_relative 'scully/rules/no_assertion'
+require_relative 'scully/rules/tautology'
+require_relative 'scully/rules/parse'
+require_relative 'scully/analyzer'
+require_relative 'scully/render/terminal'
+require_relative 'scully/render/snippet'
+require_relative 'scully/render/report'
+require_relative 'scully/render/why'
+require_relative 'scully/cli'

metadata

@@ -1,17 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: scully
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Theo Melo
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Scully statically checks RSpec and Minitest suites with Prism, without
+  running them, and reports tests that check nothing or can never fail.
 email:
 - 9499829+theomelo@users.noreply.github.com
-executables: []
+executables:
+- scully
 extensions: []
 extra_rdoc_files: []
 files:
@@ -20,17 +37,33 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- exe/scully
 - lib/scully.rb
+- lib/scully/analyzer.rb
+- lib/scully/cli.rb
+- lib/scully/discovery.rb
+- lib/scully/frameworks/detector.rb
+- lib/scully/frameworks/helpers.rb
+- lib/scully/frameworks/minitest.rb
+- lib/scully/frameworks/rspec.rb
+- lib/scully/model.rb
+- lib/scully/render/report.rb
+- lib/scully/render/snippet.rb
+- lib/scully/render/terminal.rb
+- lib/scully/render/why.rb
+- lib/scully/rule.rb
+- lib/scully/rules/no_assertion.rb
+- lib/scully/rules/parse.rb
+- lib/scully/rules/tautology.rb
+- lib/scully/source_file.rb
 - lib/scully/version.rb
 - sig/scully.rbs
-- sig/test_scully.rbs
 homepage: https://github.com/theomelo/scully
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/theomelo/scully
-  source_code_uri: https://github.com/theomelo/scully
   changelog_uri: https://github.com/theomelo/scully/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
@@ -49,5 +82,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.16
 specification_version: 4
-summary: Tests trustworthiness checking tool
+summary: Finds Ruby tests that cannot be trusted as evidence
 test_files: []