simplecov-ai 0.10.3 → 0.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b180d86c54ffab95578a779a8765ec546495b6bc3bd1e353674cf81697b9afe
-  data.tar.gz: f86ba3e7b0b6e5b3ded6c40799424fded61d2f2d980cb92e784685d340ac31f6
+  metadata.gz: 21fb51a293aef52967848c9b4fcc176b83aa274c347fb29abeaf76a34f040754
+  data.tar.gz: b43d99c3b4064c5e2914be0df4251774f78f0f6fa41cc51ae85c4e4547a586e9
 SHA512:
-  metadata.gz: 4cd0db7e047ccb21fdfc6ccf1c4e2855542c209051b6a0f663ec8037deddf6a4b8481865c492343ccee81f9ed42e5b937d0286b5d5f18dec0e07897aaf6cd902
-  data.tar.gz: 92f1698f205c2ff941287b45c53290e52306e8e9b1ae3916e84477917c8045d3ed17c5a2653c33a4ea842e837b9c96521a3bb85bc44799e8135962ae65346f1f
+  metadata.gz: 55f0042ff2503ffc573c39a1393a407e66988e2de5f3e79d5d35eb539f70645bb1bcd6374870d84682dba430a87b7b0f9601baa446e9beb99f1e9e7aa3c45cf1
+  data.tar.gz: 2a94566df43e8bdd3c8e68ffcbe95bbda0683be0cd661313ede1af5a421d0972ad03d3b0363cf72259d631e80a490529075adc2b13df58a02d7ffa4c777ef95c

data/lib/simplecov-ai/ast_resolver.rb

@@ -43,6 +43,11 @@ module SimpleCov
             @end_line = end_line
             @bypasses = bypasses
           end
+
+          sig { params(bypass: String).void }
+          def add_bypass(bypass)
+            @bypasses << bypass
+          end
         end
 
         # Orchestrates the initial mapping algorithm on a target file to extract structural
@@ -54,115 +59,118 @@ module SimpleCov
         def self.resolve(file_path)
           return [] unless File.exist?(file_path)
 
-          begin
-            source = File.read(file_path)
-            ast, comments = Parser::CurrentRuby.parse_with_comments(source)
-            new.traverse(ast, comments)
-          rescue Parser::SyntaxError
-            []
-          end
+          source = File.read(file_path)
+          ast, comments = Parser::CurrentRuby.parse_with_comments(source)
+
+          resolver = new
+          nodes = resolver.traverse(ast)
+          resolver.assign_bypasses(nodes, comments)
+          nodes
         end
 
         # Recursively navigates an abstract node hierarchy, building SemanticNodes mappings
         # around modules, classes, singleton, and instance methods while aggregating parent paths.
         #
         # @param node [Parser::AST::Node] The root AST node from which traversal executes.
-        # @param comments [Array<Parser::Source::Comment>] Lexical comments corresponding to nodes.
         # @param context [String] An accumulated identifier linking namespaces to inner entities.
         # @return [Array<SemanticNode>] Accumulation of all sub-tree defined endpoints.
         sig do
-          params(node: Parser::AST::Node, comments: T::Array[Parser::Source::Comment],
+          params(node: T.nilable(Parser::AST::Node),
                  context: String).returns(T::Array[SemanticNode])
         end
-        def traverse(node, comments, context = '')
+        def traverse(node, context = '')
           return [] unless node.is_a?(Parser::AST::Node)
 
           nodes = T.let([], T::Array[SemanticNode])
-          current_context, semantic_node = extract_node_metadata(node, comments, context)
+          current_context, semantic_node = extract_node_metadata(node, context)
           nodes << semantic_node if semantic_node
 
           node.children.grep(Parser::AST::Node).each do |child|
-            nodes.concat(traverse(child, comments, current_context))
+            nodes.concat(traverse(child, current_context))
           end
 
           nodes
         end
 
+        sig { params(nodes: T::Array[SemanticNode], comments: T::Array[Parser::Source::Comment]).void }
+        def assign_bypasses(nodes, comments)
+          comments.each do |c|
+            c_text = T.cast(c.text, String)
+            next unless c_text.include?(':nocov:')
+
+            assign_bypass(nodes, c, c_text.strip)
+          end
+        end
+
         private
 
+        sig { params(nodes: T::Array[SemanticNode], comment: Parser::Source::Comment, text: String).void }
+        def assign_bypass(nodes, comment, text)
+          c_loc = T.cast(comment.loc, Parser::Source::Map)
+          c_line = T.cast(c_loc.line, Integer)
+
+          innermost_node = nodes.reverse.find { |n| c_line.between?(n.start_line - 1, n.end_line + 1) }
+          innermost_node&.add_bypass(text)
+        end
+
         sig do
-          params(node: Parser::AST::Node, comments: T::Array[Parser::Source::Comment], context: String)
+          params(node: Parser::AST::Node, context: String)
             .returns([String, T.nilable(SemanticNode)])
         end
-        def extract_node_metadata(node, comments, context)
+        def extract_node_metadata(node, context)
           case node.type
           when :class, :module
-            extract_class_metadata(node, comments, context)
+            extract_class_metadata(node, context)
           when :def
-            extract_instance_method_metadata(node, comments, context)
+            extract_instance_method_metadata(node, context)
           when :defs
-            extract_singleton_method_metadata(node, comments, context)
+            extract_singleton_method_metadata(node, context)
           else
             [context, nil]
           end
         end
 
         sig do
-          params(node: Parser::AST::Node, comments: T::Array[Parser::Source::Comment], context: String)
+          params(node: Parser::AST::Node, context: String)
             .returns([String, T.nilable(SemanticNode)])
         end
-        def extract_class_metadata(node, comments, context)
+        def extract_class_metadata(node, context)
           const_node = T.cast(node.children[0], Parser::AST::Node)
           const_node_name = T.cast(T.cast(const_node.loc, Parser::Source::Map::Constant).name, Parser::Source::Range)
           name = T.cast(const_node_name.source, String)
           ctx = context.empty? ? name : "#{context}::#{name}"
-          [ctx, build_node(node, comments, ctx, node.type.to_s.capitalize)]
+          [ctx, build_node(node, ctx, node.type.to_s.capitalize)]
         end
 
         sig do
-          params(node: Parser::AST::Node, comments: T::Array[Parser::Source::Comment], context: String)
+          params(node: Parser::AST::Node, context: String)
             .returns([String, T.nilable(SemanticNode)])
         end
-        def extract_instance_method_metadata(node, comments, context)
+        def extract_instance_method_metadata(node, context)
           name = T.cast(node.children.first, Symbol).to_s
           ctx = context.empty? ? "##{name}" : "#{context}##{name}"
-          [ctx, build_node(node, comments, ctx, 'Instance Method')]
+          [ctx, build_node(node, ctx, 'Instance Method')]
         end
 
         sig do
-          params(node: Parser::AST::Node, comments: T::Array[Parser::Source::Comment], context: String)
+          params(node: Parser::AST::Node, context: String)
             .returns([String, T.nilable(SemanticNode)])
         end
-        def extract_singleton_method_metadata(node, comments, context)
+        def extract_singleton_method_metadata(node, context)
           name = T.cast(node.children[1], Symbol).to_s
           ctx = context.empty? ? ".#{name}" : "#{context}.#{name}"
-          [ctx, build_node(node, comments, ctx, 'Singleton Method')]
+          [ctx, build_node(node, ctx, 'Singleton Method')]
         end
 
         sig do
-          params(node: Parser::AST::Node, comments: T::Array[Parser::Source::Comment], name: String,
+          params(node: Parser::AST::Node, name: String,
                  type: String).returns(SemanticNode)
         end
-        def build_node(node, comments, name, type)
+        def build_node(node, name, type)
           loc = T.cast(node.loc, Parser::Source::Map)
           start_ln = T.cast(loc.line, Integer)
           end_ln = T.cast(loc.last_line, Integer)
-          bypasses = extract_bypasses(comments, start_ln, end_ln)
-          SemanticNode.new(name: name, type: type, start_line: start_ln, end_line: end_ln, bypasses: bypasses)
-        end
-
-        sig do
-          params(comments: T::Array[Parser::Source::Comment], start_line: Integer, end_line: Integer)
-            .returns(T::Array[String])
-        end
-        def extract_bypasses(comments, start_line, end_line)
-          matched = comments.select do |c|
-            c_loc = T.cast(c.loc, Parser::Source::Map)
-            c_line = T.cast(c_loc.line, Integer)
-            c_text = T.cast(c.text, String)
-            c_line.between?(start_line - 1, end_line + 1) && c_text.include?(':nocov:')
-          end
-          matched.map { |c| T.cast(c.text, String).strip }
+          SemanticNode.new(name: name, type: type, start_line: start_ln, end_line: end_ln, bypasses: [])
         end
       end
     end

data/lib/simplecov-ai/markdown_builder/bypass_compiler.rb

@@ -52,8 +52,11 @@ module SimpleCov
           end
           def write_file_bypasses(buffer, file, bypasses)
             buffer.puts "### `#{file.project_filename}`"
-            bypasses.each do |node|
-              buffer.puts "- `#{node.name}`\n  - **Bypass Present:** Contains `:nocov:` directive."
+            total = bypasses.size
+            bypasses.each_with_index do |node, idx|
+              buffer.puts "- `#{node.name}`\n  " \
+                          '- **Bypass Present:** Contains `:nocov:` directive artificially ' \
+                          "ignoring coverage (Occurrence #{idx + 1} of #{total})."
             end
             buffer.puts ''
           end

data/lib/simplecov-ai/markdown_builder/deficit_compiler.rb

@@ -107,7 +107,7 @@ module SimpleCov
             line_num = line.line_number
             text = truncate_snippet(fetch_snippet_text([line_num], source_lines), @config.max_snippet_lines)
             occurrence_str = calculate_occurrence(line_num, source_lines, node)
-            buffer.puts "  - **Line Deficit:** #{occurrence_str}`#{text}`"
+            buffer.puts "  - **Line Deficit:** `#{text}` #{occurrence_str}".rstrip
           end
 
           sig do

data/lib/simplecov-ai/markdown_builder/deficit_grouper.rb

@@ -26,20 +26,39 @@ module SimpleCov
             grouper = new(nodes)
             grouper.group_missed_lines(file)
             grouper.group_missed_branches(file)
-            grouper.node_deficits
+            grouper.sort_deficits
+          end
+
+          sig { returns(T::Hash[String, DeficitGroup]) }
+          def sort_deficits
+            T.let(
+              @node_deficits.sort_by do |name, group|
+                if (node = group.semantic_node)
+                  node.start_line
+                else
+                  name.match(/\d+/)&.to_s&.to_i || Float::INFINITY
+                end
+              end.to_h,
+              T::Hash[String, DeficitGroup]
+            )
           end
 
           sig { params(file: SimpleCov::SourceFile).void }
           def group_missed_lines(file)
             file.missed_lines.each do |line|
-              line_num = line.line_number
-              node = @nodes.find { |n| line_num.between?(n.start_line, n.end_line) }
-              node_name = node ? node.name : "Line #{line_num}"
-              @node_deficits[node_name] ||= DeficitGroup.new(semantic_node: node)
-              T.must(@node_deficits[node_name]).lines << line
+              add_missed_line(line)
             end
           end
 
+          sig { params(line: SimpleCov::SourceFile::Line).void }
+          def add_missed_line(line)
+            line_num = line.line_number
+            node = @nodes.reverse.find { |n| line_num.between?(n.start_line, n.end_line) }
+            node_name = node ? node.name : "Line #{line_num}"
+            @node_deficits[node_name] ||= DeficitGroup.new(semantic_node: node)
+            T.must(@node_deficits[node_name]).lines << line
+          end
+
           sig { params(file: SimpleCov::SourceFile).void }
           def group_missed_branches(file)
             return unless file.respond_to?(:branches) && file.branches.any?
@@ -53,7 +72,7 @@ module SimpleCov
           def add_missed_branch(branch)
             start_line = branch.start_line
             end_line = branch.end_line
-            node = @nodes.find { |n| start_line >= n.start_line && end_line <= n.end_line }
+            node = @nodes.reverse.find { |n| start_line >= n.start_line && end_line <= n.end_line }
             node_name = node ? node.name : "Lines #{start_line}-#{end_line}"
             @node_deficits[node_name] ||= DeficitGroup.new(semantic_node: node)
             T.must(@node_deficits[node_name]).branches << branch

data/lib/simplecov-ai/markdown_builder/snippet_formatter.rb

@@ -48,7 +48,7 @@ module SimpleCov
 
             occurrences, current = count_snippet_occurrences(first_line_of_snippet, line_num, source_lines, node)
 
-            occurrences > 1 ? "(Occurrence #{current} of #{occurrences}) " : ''
+            occurrences > 1 ? "(Occurrence #{current} of #{occurrences})." : ''
           end
 
           sig do

data/lib/simplecov-ai/markdown_builder.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative 'ast_resolver'
+require 'time'
 require_relative 'markdown_builder/snippet_formatter'
 require_relative 'markdown_builder/bypass_compiler'
 require_relative 'markdown_builder/deficit_grouper'
@@ -79,7 +80,7 @@ module SimpleCov
           @buffer.puts "**Status:** #{status}"
           @buffer.puts "**Global Line Coverage:** #{@result.covered_percent.round(1)}%"
           @buffer.puts "**Global Branch Coverage:** #{calculate_branch_pct.round(1)}%"
-          @buffer.puts "**Generated At:** #{Time.now}"
+          @buffer.puts "**Generated At:** #{Time.now.iso8601} (Local Timezone)"
           @buffer.puts ''
         end
 
@@ -87,18 +88,22 @@ module SimpleCov
         def calculate_branch_pct
           return 0.0 unless @result.respond_to?(:covered_branches) && @result.respond_to?(:total_branches)
 
-          T.cast(@result.covered_branches, Float) / @result.total_branches * 100
-        rescue StandardError
-          0.0
+          total = @result.total_branches
+          return 0.0 if total.to_i.zero?
+
+          covered = @result.covered_branches
+          covered.to_f / total * 100.0
         end
 
         # Appends a critical alert if the output hit the token-ceiling constraint and was forcibly terminated.
         sig { void }
         def write_truncation_warning
           @buffer.puts '> **[WARNING] TRUNCATION NOTIFICATION:**'
-          msg = "> The total coverage deficit report exceeded the maximum token constraint (#{@config.max_file_size_kb} kB). " \
-                'The report was truncated. The deficits detailed above represent the lowest-coverage files. ' \
-                'Please resolve these deficits to reveal the remaining uncovered files.'
+          msg = '> The total coverage deficit report exceeded the maximum token ' \
+                "constraint (#{@config.max_file_size_kb} kB). " \
+                'The report was truncated. The deficits detailed above represent ' \
+                'the lowest-coverage (most critical) files. ' \
+                'Please resolve these deficits to reveal the remaining uncovered files in subsequent test runs.'
           @buffer.puts msg
         end
       end

data/lib/simplecov-ai/version.rb

@@ -8,7 +8,7 @@ module SimpleCov
     class AIFormatter
       # The semantic version identifier for the gem, used for dependency resolution
       # and enforcing compatibility across upgrades.
-      VERSION = T.let('0.10.3', String)
+      VERSION = T.let('0.10.4', String)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simplecov-ai
 version: !ruby/object:Gem::Version
-  version: 0.10.3
+  version: 0.10.4
 platform: ruby
 authors:
 - Vitalii Lazebnyi
@@ -336,7 +336,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="