rspec-covers 0.1.0

data/lib/rspec/covers/static_method_scanner.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+require_relative "code_location"
+require_relative "method_entry"
+
+module RSpec
+  module Covers
+    class StaticMethodScanner
+      def initialize(config)
+        @config = config
+      end
+
+      def scan
+        @config.production_files.flat_map { |file| scan_file(file) }
+      end
+
+      private
+
+      def scan_file(file)
+        source = File.read(file)
+        sexp = Ripper.sexp(source)
+        return [] unless sexp
+
+        entries = []
+        walk(sexp, [], file, entries, source)
+        entries
+      rescue Errno::ENOENT
+        []
+      end
+
+      def walk(node, namespace, file, entries, source, singleton: false)
+        return unless node.is_a?(Array)
+
+        case node.first
+        when :module
+          walk(node[2], namespace + [constant_name(node[1])].compact, file, entries, source)
+        when :class
+          walk(node[3], namespace + [constant_name(node[1])].compact, file, entries, source)
+        when :sclass
+          walk(node[2], namespace, file, entries, source, singleton: self_node?(node[1]))
+        when :def
+          record_method(node, namespace, file, entries, source, singleton: singleton)
+          walk_children(node, namespace, file, entries, source, singleton: singleton)
+        when :defs
+          record_singleton_method(node, namespace, file, entries, source)
+          walk_children(node, namespace, file, entries, source, singleton: singleton)
+        when :method_add_block
+          record_define_method(node, namespace, file, entries, source, singleton: singleton)
+          walk_children(node, namespace, file, entries, source, singleton: singleton)
+        else
+          walk_children(node, namespace, file, entries, source, singleton: singleton)
+        end
+      end
+
+      def walk_children(node, namespace, file, entries, source, singleton: false)
+        node.each { |child| walk(child, namespace, file, entries, source, singleton: singleton) if child.is_a?(Array) }
+      end
+
+      def record_method(node, namespace, file, entries, source, singleton:)
+        return if namespace.empty?
+
+        name_token = node[1]
+        method_name = token_value(name_token)
+        line = token_line(name_token)
+        return unless method_name && line
+
+        separator = singleton ? "." : "#"
+        label = "#{namespace.join("::")}#{separator}#{method_name}"
+        entries << method_entry(label, file, line, source)
+      end
+
+      def record_singleton_method(node, namespace, file, entries, source)
+        owner = singleton_owner(node[1], namespace)
+        name_token = node[3]
+        method_name = token_value(name_token)
+        line = token_line(name_token)
+        return unless owner && method_name && line
+
+        entries << method_entry("#{owner}.#{method_name}", file, line, source)
+      end
+
+      def record_define_method(node, namespace, file, entries, source, singleton:)
+        return if namespace.empty?
+        return unless define_method_call?(node[1])
+
+        method_name = define_method_name(node[1])
+        line = define_method_line(node[1])
+        return unless method_name && line
+
+        separator = singleton ? "." : "#"
+        entries << method_entry("#{namespace.join("::")}#{separator}#{method_name}", file, line, source)
+      end
+
+      def method_entry(label, file, line, source)
+        region = CodeRegion.new(file: file, lines: line..method_end_line(source, line), label: label)
+        MethodEntry.new(label: label, file: File.expand_path(file), line: line, region: region)
+      end
+
+      def method_end_line(source, start_line)
+        tokens = Ripper.lex(source).select { |token| token[0][0] >= start_line }
+        depth = 0
+        seen_open = false
+
+        tokens.each do |position, type, value, _state|
+          next unless type == :on_kw
+
+          if opening_keyword?(value)
+            depth += 1
+            seen_open = true
+          elsif value == "end" && seen_open
+            depth -= 1
+            return position[0] if depth.zero?
+          end
+        end
+
+        start_line
+      end
+
+      def opening_keyword?(value)
+        %w[def class module if unless case begin for while until do].include?(value)
+      end
+
+      def define_method_call?(node)
+        node.is_a?(Array) &&
+          node[0] == :method_add_arg &&
+          node[1].is_a?(Array) &&
+          node[1][0] == :fcall &&
+          token_value(node[1][1]) == "define_method"
+      end
+
+      def define_method_name(node)
+        token = define_method_arg_token(node)
+        token_value(token)
+      end
+
+      def define_method_line(node)
+        token = define_method_arg_token(node)
+        token_line(token)
+      end
+
+      def define_method_arg_token(node)
+        args = node.dig(2, 1, 1)
+        first_arg = args&.first
+        return first_arg[1][1] if first_arg&.first == :symbol_literal
+        return first_arg.dig(1, 1) if first_arg&.first == :string_literal
+
+        nil
+      end
+
+      def singleton_owner(node, namespace)
+        return namespace.join("::") if self_node?(node) && namespace.any?
+
+        constant_name(node)
+      end
+
+      def self_node?(node)
+        node.is_a?(Array) && node[0] == :var_ref && token_value(node[1]) == "self"
+      end
+
+      def constant_name(node)
+        return unless node.is_a?(Array)
+
+        case node.first
+        when :const_ref, :var_ref
+          token_value(node[1])
+        when :const_path_ref
+          [constant_name(node[1]), token_value(node[2])].compact.join("::")
+        when :top_const_ref
+          token_value(node[1])
+        end
+      end
+
+      def token_value(token)
+        token[1] if token.is_a?(Array) && token[0].to_s.start_with?("@")
+      end
+
+      def token_line(token)
+        token[2][0] if token.is_a?(Array) && token[2].is_a?(Array)
+      end
+    end
+  end
+end

data/lib/rspec/covers/strict_verdict.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "production_inventory"
+
+module RSpec
+  module Covers
+    class StrictVerdict
+      attr_reader :risky, :reason, :undeclared_locations, :declaration
+
+      def initialize(risky:, reason:, undeclared_locations:, declaration:)
+        @risky = risky
+        @reason = reason
+        @undeclared_locations = undeclared_locations
+        @declaration = declaration
+      end
+
+      def risky?
+        risky
+      end
+
+      def clean?
+        !risky?
+      end
+
+      def message
+        case reason
+        when :undeclared_example
+          "rspec-covers: example executed production code without covers metadata"
+        when :strict_miss
+          "rspec-covers: example executed production code outside covers/uses metadata"
+        else
+          "rspec-covers: clean"
+        end
+      end
+
+      def grouped_evidence(limit: 10, config: RSpec::Covers.configuration)
+        undeclared_locations.group_by(&:file).flat_map do |file, locations|
+          lines = locations.map(&:line).sort.take(limit)
+          methods = ProductionInventory.new(config).methods_for_locations(locations)
+          [{
+            file: file,
+            lines: lines,
+            methods: methods.map(&:label),
+            note: "coverage from threads spawned inside the example may be included"
+          }]
+        end
+      end
+
+      def to_h
+        {
+          risky: risky?,
+          reason: reason,
+          undeclared_locations: undeclared_locations.map(&:to_h),
+          evidence: grouped_evidence
+        }
+      end
+
+      def self.call(executed_locations:, declaration:, config:)
+        executed_locations = Set.new(executed_locations)
+
+        if !declaration.declared?
+          risky = config.undeclared == :risky && executed_locations.any?
+          return new(
+            risky: risky,
+            reason: executed_locations.any? ? :undeclared_example : :clean,
+            undeclared_locations: executed_locations,
+            declaration: declaration
+          )
+        end
+
+        allowed = declaration.locations
+        misses = executed_locations.reject { |location| allowed.include?(location) }.to_set
+
+        new(
+          risky: config.strict && misses.any?,
+          reason: misses.any? ? :strict_miss : :clean,
+          undeclared_locations: misses,
+          declaration: declaration
+        )
+      end
+    end
+
+    class StrictCoverageError < Error
+      attr_reader :verdict
+
+      def initialize(verdict)
+        @verdict = verdict
+        super(build_message(verdict))
+      end
+
+      private
+
+      def build_message(verdict)
+        evidence = verdict.grouped_evidence.flat_map do |item|
+          lines = ["  #{item[:file]}:#{item[:lines].join(",")}"]
+          lines << "    methods: #{item[:methods].join(", ")}" if item[:methods].any?
+          lines << "    note: #{item[:note]}" if item[:note]
+          lines
+        end
+
+        ([verdict.message] + evidence).join("\n")
+      end
+    end
+  end
+end

data/lib/rspec/covers/tracer/composite.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "../production_inventory"
+require_relative "dynamic"
+require_relative "dynamic_corpus"
+require_relative "lcba"
+require_relative "nc"
+require_relative "ncc"
+require_relative "suggestion"
+
+module RSpec
+  module Covers
+    module Tracer
+      class Composite
+        STRATEGIES = {
+          nc: NC,
+          ncc: NCC,
+          lcba: LCBA,
+          dynamic: Dynamic
+        }.freeze
+
+        def initialize(config, corpus: nil)
+          @config = config
+          @inventory = ProductionInventory.new(config)
+          @corpus = corpus
+        end
+
+        def suggest(example:, call_log:, executed_locations:, corpus: @corpus, limit: @config.suggestion_limit)
+          candidates = candidates_for(call_log, executed_locations)
+          return [] if candidates.empty?
+
+          weighted_scores = Hash.new(0.0)
+          reasons = Hash.new { |hash, key| hash[key] = [] }
+
+          STRATEGIES.each do |name, strategy_class|
+            weight = @config.suggestion_weights.fetch(name, 1.0).to_f
+            next if weight.zero?
+
+            strategy_scores = strategy_class.new.score(
+              example: example,
+              call_log: call_log,
+              candidates: candidates,
+              corpus: corpus
+            )
+
+            strategy_scores.each do |label, score|
+              next unless score.positive?
+
+              weighted_scores[label] += score * weight
+              reasons[label] << name
+            end
+          end
+
+          ranked = weighted_scores.sort_by { |_, score| -score }
+          ranked = ranked.first(limit) if limit
+
+          ranked.map do |label, score|
+            Suggestion.new(label: label, score: score, reasons: reasons[label])
+          end
+        end
+
+        private
+
+        def candidates_for(call_log, executed_locations)
+          labels = call_log&.labels || []
+          candidates = @inventory.methods_by_label(labels)
+          candidates += @inventory.methods_for_locations(executed_locations)
+          candidates.uniq(&:label)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/covers/tracer/dynamic.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Covers
+    module Tracer
+      class Dynamic
+        def score(example:, call_log:, candidates:, corpus: nil, **)
+          return corpus_score(example, candidates, corpus) if corpus
+
+          counts = call_log&.labels&.tally || {}
+          max_count = counts.values.max.to_f
+
+          candidates.each_with_object({}) do |candidate, scores|
+            scores[candidate.label] = max_count.positive? ? counts.fetch(candidate.label, 0) / max_count : 0.0
+          end
+        end
+
+        private
+
+        def corpus_score(example, candidates, corpus)
+          labels = candidates.map(&:label)
+          corpus.normalize(example.id, labels)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/covers/tracer/dynamic_corpus.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Covers
+    module Tracer
+      class DynamicCorpus
+        def initialize
+          @documents = {}
+        end
+
+        def record(example_id, labels)
+          @documents[example_id] = labels.tally
+        end
+
+        def score(example_id, label)
+          counts = @documents.fetch(example_id, {})
+          max_count = counts.values.max.to_f
+          return 0.0 unless max_count.positive?
+
+          term_frequency = counts.fetch(label, 0) / max_count
+          term_frequency * inverse_document_frequency(label)
+        end
+
+        def normalize(example_id, labels)
+          raw_scores = labels.to_h { |label| [label, score(example_id, label)] }
+          max_score = raw_scores.values.max.to_f
+          return raw_scores.transform_values { 0.0 } unless max_score.positive?
+
+          raw_scores.transform_values { |value| value / max_score }
+        end
+
+        private
+
+        def inverse_document_frequency(label)
+          total = @documents.length
+          document_frequency = @documents.values.count { |counts| counts.key?(label) }
+
+          Math.log((1.0 + total) / (1.0 + document_frequency)) + 1.0
+        end
+      end
+    end
+  end
+end

data/lib/rspec/covers/tracer/lcba.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Covers
+    module Tracer
+      class LCBA
+        def score(call_log:, candidates:, **)
+          labels = call_log&.labels_before_expectations || []
+
+          candidates.each_with_object({}) do |candidate, scores|
+            scores[candidate.label] = labels.include?(candidate.label) ? 1.0 : 0.0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/covers/tracer/nc.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "tokenizer"
+
+module RSpec
+  module Covers
+    module Tracer
+      class NC
+        def score(example:, candidates:, **)
+          expected_names = names_from_example(example)
+
+          candidates.each_with_object({}) do |candidate, scores|
+            owner = candidate.label.split(/[.#]/).first
+            scores[candidate.label] = expected_names.include?(owner) ? 1.0 : 0.0
+          end
+        end
+
+        private
+
+        def names_from_example(example)
+          names = []
+          described = example.metadata[:described_class]
+          names << described.name if described.respond_to?(:name)
+
+          file_path = example.metadata[:file_path]
+          if file_path
+            base = File.basename(file_path, "_spec.rb")
+            names << base.split("_").map(&:capitalize).join
+          end
+
+          names.compact
+        end
+      end
+    end
+  end
+end

data/lib/rspec/covers/tracer/ncc.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "tokenizer"
+
+module RSpec
+  module Covers
+    module Tracer
+      class NCC
+        def score(example:, candidates:, **)
+          description_tokens = Tokenizer.call(example.full_description).to_set
+
+          candidates.each_with_object({}) do |candidate, scores|
+            candidate_tokens = Tokenizer.call(candidate.label).to_set
+            overlap = description_tokens & candidate_tokens
+            scores[candidate.label] = candidate_tokens.empty? ? 0.0 : overlap.length.to_f / candidate_tokens.length
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/covers/tracer/suggestion.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Covers
+    module Tracer
+      Suggestion = Struct.new(:label, :score, :reasons, keyword_init: true) do
+        def to_h
+          {
+            label: label,
+            score: score.round(4),
+            reasons: reasons
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rspec/covers/tracer/tokenizer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Covers
+    module Tracer
+      module Tokenizer
+        module_function
+
+        def call(value)
+          value.to_s
+               .gsub(/([a-z\d])([A-Z])/, '\1 \2')
+               .downcase
+               .scan(/[a-z0-9]+/)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/covers/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Covers
+    VERSION = "0.1.0"
+  end
+end
+
+module Rspec
+  Covers = ::RSpec::Covers unless const_defined?(:Covers, false)
+end