sixth_sense 0.1.0

data/lib/sixth_sense/analyzers/quality_flakiness.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../analyzer"
+
+module SixthSense
+  module Analyzers
+    class QualityFlakiness < Analyzer
+      analyzer_id "quality/flakiness"
+      axis :quality
+      level 0
+
+      reference authors: "Luo, Q.; Hariri, F.; Eloussi, L.; Marinov, D.",
+                title: "An Empirical Analysis of Flaky Tests",
+                venue: "FSE",
+                year: 2014,
+                doi: "10.1145/2635868.2635920"
+
+      # Paper basis: Luo et al. 2014 (doi:10.1145/2635868.2635920) categorizes
+      # flaky-test causes; this analyzer flags static triggers from those classes.
+      def analyze(test_file, _context)
+        findings = test_file.test_cases.filter_map { |test_case| flaky_finding(test_case) }
+        score = [100.0 - (20.0 * findings.length), 0.0].max
+
+        result(score: score.round(2), findings: findings, confidence: :high)
+      end
+
+      private
+
+      def flaky_finding(test_case)
+        rule = rule_for(test_case.body)
+        return unless rule
+
+        finding(
+          rule_id: rule,
+          severity: :warning,
+          location: test_case.location,
+          message: "Example contains a common flaky-test trigger: #{rule}.",
+          suggestion: "Replace timing, wall-clock, or global-order dependency with deterministic test control."
+        )
+      end
+
+      # Paper basis: Luo et al. 2014 identifies sleep, wall-clock time, and
+      # order/randomness dependencies as common flaky-test causes.
+      def rule_for(body)
+        return "sleepy_test" if body.match?(/\bsleep(?:\s|\()/)
+        return "wall_clock_time" if body.match?(/\b(Time\.now|Date\.today|DateTime\.now)\b/)
+        return "order_dependency" if body.match?(/\b(RSpec\.configuration\.order|config\.order|rand\()/)
+
+        nil
+      end
+    end
+  end
+end

data/lib/sixth_sense/analyzers/quality_test_smells.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require_relative "../analyzer"
+
+module SixthSense
+  module Analyzers
+    class QualityTestSmells < Analyzer
+      analyzer_id "quality/test_smells"
+      axis :quality
+      level 0
+
+      reference authors: "van Deursen, A.; Moonen, L.; van den Bergh, A.; Kok, G.",
+                title: "Refactoring Test Code",
+                venue: "XP",
+                year: 2001
+      reference authors: "Meszaros, G.",
+                title: "xUnit Test Patterns: Refactoring Test Code",
+                venue: "Addison-Wesley",
+                year: 2007
+      reference authors: "Peruma, A. et al.",
+                title: "tsDetect: An Open Source Test Smells Detection Tool",
+                venue: "ESEC/FSE",
+                year: 2020,
+                doi: "10.1145/3368089.3417921"
+      reference authors: "Luo, Q.; Hariri, F.; Eloussi, L.; Marinov, D.",
+                title: "An Empirical Analysis of Flaky Tests",
+                venue: "FSE",
+                year: 2014,
+                doi: "10.1145/2635868.2635920"
+
+      WEIGHTS = {
+        assertion_roulette: 3,
+        eager_test: 3,
+        mystery_guest: 3,
+        sleepy_test: 3,
+        general_fixture: 2,
+        conditional_logic: 2,
+        sensitive_equality: 2,
+        empty_or_pending: 2,
+        duplicate_assert: 1,
+        magic_number: 1
+      }.freeze
+
+      # Paper/book basis: van Deursen et al. 2001, Meszaros 2007, and
+      # tsDetect/Peruma et al. 2020 (doi:10.1145/3368089.3417921)
+      # define the test-smell families aggregated here.
+      def analyze(test_file, context)
+        findings = test_file.test_cases.flat_map { |test_case| findings_for(test_case, context) }
+        findings.reject! { |finding| disabled?(test_file, finding) }
+        score = quality_score(test_file, findings, context)
+
+        result(score: score, findings: findings, confidence: :high)
+      end
+
+      private
+
+      def findings_for(test_case, context)
+        [
+          assertion_roulette(test_case, context),
+          eager_test(test_case),
+          mystery_guest(test_case),
+          sensitive_equality(test_case),
+          conditional_logic(test_case),
+          sleepy_test(test_case),
+          empty_or_pending(test_case),
+          general_fixture(test_case),
+          duplicate_assert(test_case),
+          magic_number(test_case)
+        ].flatten.compact
+      end
+
+      # Reference basis: van Deursen et al. 2001 and Meszaros 2007 describe
+      # assertion roulette as multiple unlabeled assertions obscuring failures.
+      def assertion_roulette(test_case, context)
+        threshold = context.config_fetch(:quality, :assertion_roulette_threshold, default: 3)
+        threshold += 2 if test_case.metadata[:aggregate_failures] || test_case.body.include?("aggregate_failures")
+        unlabelled = test_case.assertions.count { |assertion| assertion.message.to_s.empty? }
+        return if unlabelled < threshold
+
+        finding(
+          rule_id: "assertion_roulette",
+          severity: :warning,
+          location: test_case.location,
+          message: "#{unlabelled} expectations share one example without explanatory messages.",
+          suggestion: "Split the example or add expectation messages so failures identify intent."
+        )
+      end
+
+      # Reference basis: van Deursen et al. 2001 and tsDetect/Peruma et al. 2020
+      # identify eager tests as examples exercising too many production methods.
+      def eager_test(test_case)
+        method_calls = test_case.body.scan(/\b([a-z_]\w*)\.([a-z_]\w*[!?=]?)\b/).filter_map do |receiver, method_name|
+          next if %w[expect is_expected to not_to to_not should should_not].include?(receiver)
+          next if %w[to not_to to_not should should_not eq eql equal include match be].include?(method_name)
+
+          "#{receiver}.#{method_name}"
+        end.uniq
+        return if method_calls.length < 3
+
+        finding(
+          rule_id: "eager_test",
+          severity: :warning,
+          location: test_case.location,
+          message: "Example exercises #{method_calls.length} distinct public calls.",
+          suggestion: "Keep one behavioral reason to fail per example where practical."
+        )
+      end
+
+      # Reference basis: van Deursen et al. 2001 and Meszaros 2007 define
+      # mystery guests as hidden external fixture/file dependencies.
+      def mystery_guest(test_case)
+        return unless test_case.body.match?(/\b(File\.read|YAML\.load_file|fixture_file|fixtures\/|fixtures_path)\b/)
+
+        finding(
+          rule_id: "mystery_guest",
+          severity: :warning,
+          location: test_case.location,
+          message: "Example depends directly on external fixture or file content.",
+          suggestion: "Route fixture setup through named factories or helpers."
+        )
+      end
+
+      # Reference basis: tsDetect/Peruma et al. 2020 includes fragile equality
+      # checks over stringified representations among test-smell detectors.
+      def sensitive_equality(test_case)
+        return unless test_case.body.match?(/(to_s|inspect)\)?\.to\s+(eq|eql|match)|expect\([^)]*\.(to_s|inspect)\)/)
+
+        finding(
+          rule_id: "sensitive_equality",
+          severity: :warning,
+          location: test_case.location,
+          message: "Example compares stringified object representation.",
+          suggestion: "Assert on stable domain attributes instead of formatting."
+        )
+      end
+
+      # Reference basis: Meszaros 2007 and tsDetect/Peruma et al. 2020 treat
+      # control flow in tests as a maintainability smell.
+      def conditional_logic(test_case)
+        return unless test_case.body.match?(/\b(if|case|unless|while|until|for)\b|\.each\s+do\b/)
+
+        finding(
+          rule_id: "conditional_logic",
+          severity: :warning,
+          location: test_case.location,
+          message: "Example contains control flow.",
+          suggestion: "Move branching setup into separate examples or helpers."
+        )
+      end
+
+      # Paper basis: Luo et al. 2014 (doi:10.1145/2635868.2635920) reports
+      # timing and asynchronous waits as common flaky-test triggers.
+      def sleepy_test(test_case)
+        return unless test_case.body.match?(/\bsleep(?:\s|\()|\bTime\.now\b|\bDate\.today\b/)
+
+        finding(
+          rule_id: "sleepy_test",
+          severity: :warning,
+          location: test_case.location,
+          message: "Example uses sleep or wall-clock time directly.",
+          suggestion: "Use deterministic waiting or time-freezing support."
+        )
+      end
+
+      # Reference basis: van Deursen et al. 2001 and Meszaros 2007 describe
+      # general fixtures as broad setup not used by each individual test.
+      def general_fixture(test_case)
+        fixtures = Array(test_case.metadata[:fixtures])
+        return if fixtures.empty?
+
+        unused = fixtures.filter_map do |fixture|
+          names = [fixture[:name], *fixture[:ivars]].compact.reject(&:empty?)
+          next if names.empty?
+          next if names.any? { |name| test_case.body.include?(name.to_s) }
+
+          fixture
+        end
+        return if unused.empty?
+
+        finding(
+          rule_id: "general_fixture",
+          severity: :warning,
+          location: test_case.location,
+          message: "Example does not use #{unused.length} fixture setup item(s).",
+          suggestion: "Move unused setup into examples that need it or narrower contexts."
+        )
+      end
+
+      # Reference basis: tsDetect/Peruma et al. 2020 includes empty and skipped
+      # tests among executable-test quality smells.
+      def empty_or_pending(test_case)
+        return unless test_case.metadata[:pending] || test_case.body.strip.empty? || test_case.body.match?(/\b(pending|skip)\b/)
+
+        finding(
+          rule_id: "empty_or_pending",
+          severity: :warning,
+          location: test_case.location,
+          message: "Example is empty, pending, or skipped.",
+          suggestion: "Remove it or turn it into an executable expectation."
+        )
+      end
+
+      # Reference basis: tsDetect/Peruma et al. 2020 motivates duplicate
+      # assertion detection as a low-severity maintainability smell.
+      def duplicate_assert(test_case)
+        duplicates = test_case.assertions.group_by(&:signature).select { |_signature, assertions| assertions.length > 1 }
+        return if duplicates.empty?
+
+        finding(
+          rule_id: "duplicate_assert",
+          severity: :info,
+          location: test_case.location,
+          message: "Example repeats #{duplicates.length} assertion signature(s).",
+          suggestion: "Delete duplicate expectations unless repetition documents separate behavior."
+        )
+      end
+
+      # Reference basis: Meszaros 2007 and tsDetect/Peruma et al. 2020 treat
+      # unexplained expected literals as a context-dependent test smell.
+      def magic_number(test_case)
+        literal_expectations = test_case.body.scan(/\b(?:eq|eql|be|be_within)\(?\s*(-?\d+(?:\.\d+)?)\b/)
+        return if literal_expectations.length < 3
+
+        finding(
+          rule_id: "magic_number",
+          severity: :info,
+          location: test_case.location,
+          message: "Example uses #{literal_expectations.length} numeric expected values.",
+          suggestion: "Name important constants or derive expected values from domain terms."
+        )
+      end
+
+      # Paper basis: Bavota et al. 2015 (doi:10.1007/s10664-014-9313-0) and
+      # Spadini et al. 2018 (doi:10.1109/ICSME.2018.00010) motivate weighted
+      # smell impact; this score keeps those weights tiered rather than learned.
+      def quality_score(test_file, findings, context)
+        cap = context.config_fetch(:quality, :smell_cap, default: 5)
+        penalty = findings.group_by { |item| item.rule_id.to_sym }.sum do |rule_id, rule_findings|
+          WEIGHTS.fetch(rule_id, 1) * [rule_findings.length, cap].min
+        end
+        loc_norm = [test_file.executable_loc / 100.0, 1.0].max
+        quality_raw = 100.0 - (12.0 * penalty / loc_norm)
+        [[quality_raw, 0.0].max, 100.0].min.round(2)
+      end
+
+      def disabled?(test_file, finding)
+        source = File.file?(test_file.path) ? File.read(test_file.path) : ""
+        directives = source.scan(/#\s*sixth_sense:disable\s+([A-Za-z0-9_\/,-]+)/).flatten.flat_map { |item| item.split(",") }
+        directives.include?(finding.rule_id) || directives.include?(finding.analyzer_id) || directives.include?("all")
+      end
+    end
+  end
+end

data/lib/sixth_sense/analyzers/redundancy_clone.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../analyzer"
+
+module SixthSense
+  module Analyzers
+    class RedundancyClone < Analyzer
+      analyzer_id "redundancy/clone"
+      axis :redundancy
+      level 0
+
+      reference authors: "Roy, C. K.; Cordy, J. R.",
+                title: "A Survey on Software Clone Detection Research",
+                venue: "Queen's University Technical Report",
+                year: 2007
+
+      # Paper basis: Roy/Cordy 2007 surveys Type-1/2 clone detection; this
+      # groups normalized test bodies as a low-confidence clone signal.
+      def analyze(test_file, _context)
+        groups = test_file.test_cases.group_by { |test_case| normalize_body(test_case.body) }
+        clone_groups = groups.reject { |normalized, cases| normalized.empty? || cases.length < 2 }
+        duplicate_count = clone_groups.values.sum { |cases| cases.length - 1 }
+        score = 100.0 * (1.0 - duplicate_count.to_f / [test_file.test_cases.length, 1].max)
+        findings = clone_groups.values.flat_map do |cases|
+          cases.drop(1).map do |test_case|
+            finding(
+              rule_id: "test_clone",
+              severity: :info,
+              location: test_case.location,
+              message: "Example body is a Type-1/2 clone of another example in this file.",
+              suggestion: "Extract setup or merge examples only if the behavioral intent is identical."
+            )
+          end
+        end
+
+        result(score: score.round(2), findings: findings, confidence: :low)
+      end
+
+      private
+
+      # Paper basis: Roy/Cordy 2007 Type-2 clones allow renamed literals/tokens,
+      # so literals are normalized before duplicate grouping.
+      def normalize_body(body)
+        body.to_s
+            .gsub(/#.*$/, "")
+            .gsub(/(["']).*?\1/, "STR")
+            .gsub(/:\w+/, ":SYM")
+            .gsub(/\b-?\d+(?:\.\d+)?\b/, "NUM")
+            .gsub(/\s+/, " ")
+            .strip
+      end
+    end
+  end
+end

data/lib/sixth_sense/analyzers/redundancy_coverage.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "redundancy_requirement"
+
+module SixthSense
+  module Analyzers
+    class RedundancyCoverage < Analyzer
+      include RedundancyRequirement
+
+      analyzer_id "redundancy/coverage_based"
+      axis :redundancy
+      level 1
+
+      reference authors: "Harrold, M. J.; Gupta, R.; Soffa, M. L.",
+                title: "A Methodology for Controlling the Size of a Test Suite",
+                venue: "ACM TOSEM",
+                year: 1993,
+                doi: "10.1145/152388.152391"
+      reference authors: "Rothermel, G.; Harrold, M. J.; Ostrin, J.; Hong, C.",
+                title: "An Empirical Study of the Effects of Minimization on the Fault Detection Capabilities of Test Suites",
+                venue: "ICSM",
+                year: 1998,
+                doi: "10.1109/ICSM.1998.738487"
+
+      # Paper basis: Harrold/Gupta/Soffa 1993 (doi:10.1145/152388.152391)
+      # models minimization through requirement coverage; Rothermel et al. 1998
+      # (doi:10.1109/ICSM.1998.738487) motivates conservative reporting.
+      def analyze(test_file, context)
+        coverage = context.coverage_map_for(test_file)
+        return unmeasured(confidence: :low) unless coverage
+
+        requirements = test_file.test_cases.to_h do |test_case|
+          [test_case.id, coverage.branch_requirements_for(test_case.id)]
+        end
+        analyze_requirements(test_file, requirements, confidence: :medium)
+      end
+    end
+  end
+end

data/lib/sixth_sense/analyzers/redundancy_mutation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "redundancy_requirement"
+
+module SixthSense
+  module Analyzers
+    class RedundancyMutation < Analyzer
+      include RedundancyRequirement
+
+      analyzer_id "redundancy/mutation_based"
+      axis :redundancy
+      level 2
+
+      reference authors: "Koochakzadeh, N.; Garousi, V.",
+                title: "A Tester-Assisted Methodology for Test Redundancy Detection",
+                venue: "Advances in Software Engineering",
+                year: 2010,
+                doi: "10.1155/2010/932686"
+      reference authors: "Yoo, S.; Harman, M.",
+                title: "Regression Testing Minimization, Selection and Prioritization: A Survey",
+                venue: "STVR",
+                year: 2012,
+                doi: "10.1002/stvr.430"
+
+      # Paper basis: Koochakzadeh/Garousi 2010 (doi:10.1155/2010/932686)
+      # uses mutation kill sets for redundancy; Yoo/Harman 2012
+      # (doi:10.1002/stvr.430) surveys minimization/selection tradeoffs.
+      def analyze(test_file, context)
+        matrix = context.kill_matrix_for(test_file)
+        return unmeasured(confidence: :low) unless matrix&.matrix?
+
+        requirements = test_file.test_cases.to_h do |test_case|
+          [test_case.id, matrix.kill_requirements_for(test_case.id)]
+        end
+        analyze_requirements(test_file, requirements, confidence: :high)
+      end
+    end
+  end
+end

data/lib/sixth_sense/analyzers/redundancy_requirement.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "../analyzer"
+
+module SixthSense
+  module Analyzers
+    module RedundancyRequirement
+      private
+
+      # Paper basis: Harrold/Gupta/Soffa 1993 reduces suite size by retaining
+      # representatives that cover requirements; Rothermel et al. 1998 motivates
+      # preserving oracle-distinct tests instead of blindly deleting them.
+      def analyze_requirements(test_file, requirements_by_id, confidence:)
+        return result(score: 100.0, findings: [], confidence: confidence) if test_file.test_cases.empty?
+
+        selected_ids = greedy_representatives(test_file, requirements_by_id)
+        redundant = test_file.test_cases.reject { |test_case| selected_ids.include?(test_case.id) }
+        penalties = redundant.to_h do |test_case|
+          [test_case, oracle_penalty(test_case, test_file, selected_ids)]
+        end
+        score = 100.0 * (1.0 - penalties.values.sum / [test_file.test_cases.length, 1].max)
+        findings = penalties.map do |test_case, penalty|
+          finding(
+            rule_id: "redundant_candidate",
+            severity: :warning,
+            location: test_case.location,
+            message: "Example is covered by the representative requirement set.",
+            suggestion: penalty >= 1.0 ? "Review for consolidation." : "Coverage overlaps, but assertions differ; review manually."
+          )
+        end
+
+        result(score: [[score, 0.0].max, 100.0].min.round(2), findings: findings, confidence: confidence)
+      end
+
+      # Paper basis: Harrold/Gupta/Soffa 1993; greedy set-cover approximation
+      # selects tests that cover the most still-uncovered requirements.
+      def greedy_representatives(test_file, requirements_by_id)
+        uncovered = requirements_by_id.values.reduce(Set.new, :|)
+        selected = Set.new
+
+        until uncovered.empty?
+          candidate = test_file.test_cases.max_by do |test_case|
+            new_coverage = requirements_by_id.fetch(test_case.id, Set.new) & uncovered
+            [new_coverage.length, test_case.assertions.length, -(test_case.location&.line || 0)]
+          end
+          break unless candidate
+
+          covered_now = requirements_by_id.fetch(candidate.id, Set.new) & uncovered
+          break if covered_now.empty?
+
+          selected << candidate.id
+          uncovered -= covered_now
+        end
+
+        selected
+      end
+
+      # Paper basis: Rothermel et al. 1998; overlap is penalized less when the
+      # assertion/oracle signature differs, preserving possible fault detection.
+      def oracle_penalty(test_case, test_file, selected_ids)
+        signature_set = test_case.assertions.map(&:signature).to_set
+        selected_signature_sets = test_file.test_cases.select { |item| selected_ids.include?(item.id) }
+                                         .map { |item| item.assertions.map(&:signature).to_set }
+        selected_signature_sets.include?(signature_set) ? 1.0 : 0.5
+      end
+    end
+  end
+end

data/lib/sixth_sense/changed_files.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module SixthSense
+  class ChangedFiles
+    def self.test_files(diff_ref)
+      new(diff_ref).test_files
+    end
+
+    def initialize(diff_ref)
+      @diff_ref = diff_ref
+    end
+
+    def test_files
+      names = changed_names
+      specs = names.select { |path| path.end_with?("_spec.rb") && File.file?(path) }
+      inferred_specs = names.flat_map { |path| infer_spec_paths(path) }
+      (specs + inferred_specs).uniq.sort
+    end
+
+    private
+
+    attr_reader :diff_ref
+
+    def changed_names
+      output, status = Open3.capture2("git", "diff", "--name-only", diff_ref)
+      return [] unless status.success?
+
+      output.lines.map(&:strip).reject(&:empty?)
+    end
+
+    def infer_spec_paths(path)
+      return [] unless path.start_with?("lib/", "app/")
+      return [] unless path.end_with?(".rb")
+
+      relative = path.sub(%r{\A(?:lib|app)/}, "").sub(/\.rb\z/, "_spec.rb")
+      candidates = [File.join("spec", relative)]
+      if path.start_with?("app/")
+        candidates << File.join("spec", path.sub(%r{\Aapp/}, "").sub(/\.rb\z/, "_spec.rb"))
+      end
+      candidates.select { |candidate| File.file?(candidate) }
+    end
+  end
+end