piggly-nsd 2.3.3 → 2.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b53364d89c087bf4c2ce49ec451ece2cb1c17694bab9e765e034a05493ef3999
-  data.tar.gz: a46eea287041eeaa4130b730dd409f1f35663e6fca5258e96c639b1f567eeb11
+  metadata.gz: 3aed72758cfe5ef63b8635586386845b2b3766a742cb398a9fc8121bd70e966f
+  data.tar.gz: 98e694a96ccff107b670de06d747b3a015a361a1e806c190e7bc6f9c36c0ec5f
 SHA512:
-  metadata.gz: 1cfd022ed8e03c56d372911943bd7b662a6ff967f63bde7b09a01e010b5117bc41ad0f5c245a30e72139776a5eece380ab9d2d60175462555a874cfb008e73c8
-  data.tar.gz: b8653bb06b92d31eee24e5c9a317fe912dc61e01d46fae649dadeb4610b831f4ad50199683996cddc756727124be68514fc0d919b372d80f70347851539d7751
+  metadata.gz: 889952ad1338856df2c539e199a18805236921b647add649937a9cfcec99578504915a000fd8174edeef13e485cab5cdda8a3ed03aa8e1a2273fe99bd5049235
+  data.tar.gz: 1de357aa82135b51d0c31b7515c102aa251bd489495f290aeaf71db302c2acc2bd19fee7dcc3410d7f1bf5e587b8852874994b02e61df6c03684114e5be53f9d

data/README.md

@@ -51,6 +51,10 @@ these events and generates prettified source code that is annotated with coverag
 This fork continues the version numbering from the original piggly project:
 - **2.3.1** - Last version of original piggly by Kyle Putnam
 - **2.3.2** - NSD fork with UTF-8 encoding support and updated dependencies
+- **2.3.3** - Fixed issues
+- **2.3.4** - Added SonarQube integration and line coverage metrics:
+  - New `--sonar-report-path PATH` option to generate SonarQube generic coverage XML
+  - Added LINES and LINE COVERAGE columns to HTML reports
 
 ## How to Install
 
@@ -122,11 +126,19 @@ might run:
     etc.
 
 To build the coverage report, have piggly read that file in by executing `piggly report < messages.txt`,
- or `piggly report -f messages.txt`. You don't actually need the intermediate file, you can pipe your
+or `piggly report -f messages.txt`. You don't actually need the intermediate file, you can pipe your
 test suite directly in like `ant test 2>&1 | piggly report`.
 
 Once the report is built you can open it in `piggly/reports/index.html`.
 
+### SonarQube Integration
+
+To generate a SonarQube-compatible coverage report, use the `--sonar-report-path` (or `-x`) option:
+
+    $ piggly report -f messages.txt --sonar-report-path piggly/sonar/coverage.xml
+
+This generates an XML file in SonarQube's [generic test coverage format](https://docs.sonarsource.com/sonarqube-server/latest/analyzing-source-code/test-coverage/generic-test-data/).
+
 ## Running the Examples
 
     $ cd piggly

data/lib/piggly/command/report.rb

@@ -13,7 +13,7 @@ module Piggly
     class << Report
       def main(argv)
         require "pp"
-        io, config = configure(argv)
+        io, config, sonar_path, html_report_requested = configure(argv)
 
         profile = Profile.new
         index   = Dumper::Index.new(config)
@@ -33,12 +33,23 @@ module Piggly
 
         profile_procedures(config, procedures, profile)
         clear_coverage(config, profile)
-
         read_profile(config, io, profile)
         store_coverage(profile)
 
-        create_index(config, index, procedures, profile)
-        create_reports(config, procedures, profile)
+        # Generate HTML coverage report if requested
+        if html_report_requested
+          create_index(config, index, procedures, profile)
+          create_reports(config, procedures, profile)
+        end
+        
+        # Generate Sonar coverage report if requested
+        if sonar_path
+          create_sonar_report(config, procedures, profile, sonar_path)
+        end
+        
+        unless html_report_requested || sonar_path
+          puts "Warning: No report output specified. Use -o for HTML reports or -x for Sonar report."
+        end
       end
 
       # Adds the given procedures to Profile
@@ -118,14 +129,32 @@ module Piggly
         queue.execute
       end
 
+      # Create Sonar coverage XML report
+      #
+      def create_sonar_report(config, procedures, profile, output_path)
+        puts "creating Sonar coverage report"
+        reporter = Reporter::Sonar.new(config, profile, output_path)
+        path = reporter.report(procedures)
+        puts "Sonar coverage report written to: #{path}"
+      end
+
       def configure(argv, config = Config.new)
         io = $stdin
+        sonar_path = nil
+        html_report_requested = false
+
         p  = OptionParser.new do |o|
           o.on("-t", "--dry-run",           "only print the names of matching procedures", &o_dry_run(config))
           o.on("-s", "--select PATTERN",    "select procedures matching PATTERN", &o_select(config))
           o.on("-r", "--reject PATTERN",    "ignore procedures matching PATTERN", &o_reject(config))
           o.on("-c", "--cache-root PATH",   "local cache directory", &o_cache_root(config))
-          o.on("-o", "--report-root PATH",  "report output directory", &o_report_root(config))
+          o.on("-o", "--report-root PATH",  "report output directory") do |path|
+            config.report_root = path
+            html_report_requested = true
+          end
+          o.on("-x", "--sonar-report-path PATH",  "generate Sonar coverage XML report at PATH") do |path|
+            sonar_path = path
+          end
           o.on("-a", "--accumulate",        "accumulate data from the previous run", &o_accumulate(config))
           o.on("-V", "--version",           "show version", &o_version(config))
           o.on("-h", "--help",              "show this message") { abort o.to_s }
@@ -140,13 +169,18 @@ module Piggly
 
         begin
           p.parse! argv
+
+          unless html_report_requested || sonar_path
+            raise OptionParser::MissingArgument,
+              "at least one report type required: use -o for HTML reports or -x for Sonar report"
+          end
           
           if io.eql?($stdin) and $stdin.tty?
             raise OptionParser::MissingArgument,
               "stdin must be a pipe, or use --input PATH"
           end
 
-          return io, config
+          return io, config, sonar_path, html_report_requested
         rescue OptionParser::InvalidOption,
                OptionParser::InvalidArgument,
                OptionParser::MissingArgument

data/lib/piggly/compiler/line_coverage.rb

@@ -0,0 +1,213 @@
+module Piggly
+  module Compiler
+
+    #
+    # Calculates line-level coverage from tagged parse tree nodes.
+    #
+    class LineCoverage
+      def initialize(config)
+        @config = config
+      end
+
+      # Calculate line coverage for a procedure
+      # @param procedure [Dumper::ReifiedProcedure, Dumper::SkeletonProcedure]
+      # @param profile [Profile]
+      # @return [Hash] { line_number => { covered: bool } }
+      def calculate(procedure, profile)
+        Parser.parser
+        
+        compiler = TraceCompiler.new(@config)
+        
+        # Let compile() handle staleness - it will recompile if needed
+        data = compiler.compile(procedure)
+        
+        # Return empty if compilation failed (tree is nil)
+        tree = data[:tree]
+        return {} if tree.nil?
+        
+        source = procedure.source(@config)
+        
+        coverage = {}
+        traverse(tree, profile, source, coverage)
+        coverage
+      end
+
+      # Calculate summary statistics from coverage data
+      # @param coverage [Hash] line coverage data from calculate()
+      # @return [Hash] { count: Integer, percent: Float }
+      def summary(coverage)
+        return { count: 0, percent: nil } if coverage.empty?
+        
+        total_lines = coverage.size
+        covered_lines = coverage.count { |_, v| v[:covered] }
+        
+        {
+          count: total_lines,
+          percent: total_lines > 0 ? (covered_lines.to_f / total_lines * 100) : nil
+        }
+      end
+
+
+    protected
+
+      # Traverse the parse tree and collect coverage data for each line
+      # @param node [NodeClass] parse tree node
+      # @param profile [Profile] coverage profile with tags
+      # @param source [String] source code text
+      # @param coverage [Hash] accumulator for line coverage data
+      def traverse(node, profile, source, coverage)
+        if node.tagged?
+          begin
+            tag = profile[node.tag_id]
+            
+            # Get line numbers for this node
+            start_line, end_line = node_line_range(node, source)
+            
+            # Record coverage for each line spanned by this node
+            # Skip lines containing only structural keywords (begin, end, declare, etc.)
+            if start_line && end_line && start_line > 0 && end_line >= start_line
+              (start_line..end_line).each do |line|
+                next if excluded_line?(source, line)
+                record_line_coverage(coverage, line, tag)
+              end
+            end
+          rescue RuntimeError => e
+            # Skip nodes where tag lookup fails (expected for some nodes)
+          rescue => e
+            # Skip nodes with unexpected errors
+          end
+        end
+        
+        # Recurse into child nodes
+        if node.respond_to?(:elements) && node.elements
+          node.elements.each { |child| traverse(child, profile, source, coverage) }
+        end
+        
+        coverage
+      end
+
+      # Check if a source line should be excluded from coverage
+      # Lines containing only structural keywords or comments are not executable
+      # @param source [String] full source code
+      # @param line_number [Integer] 1-based line number
+      # @return [Boolean] true if line should be excluded
+      def excluded_line?(source, line_number)
+        lines = source.split("\n")
+        return true if line_number < 1 || line_number > lines.length
+        
+        line_content = lines[line_number - 1].strip.downcase
+        
+        # Exclude lines containing only structural keywords or comments
+        excluded_patterns = [
+          /\A\s*end\s*;\s*\z/i,           # end;
+          /\A\s*begin\s*\z/i,             # begin
+          /\A\s*declare\s*\z/i,           # declare
+          /\A\s*\$\$\s*\z/,               # $$ (dollar quoting)
+          /\A\s*\z/,                      # empty lines
+          /\A\s*--/,                      # single-line comments (-- ...)
+          /\A\s*\/\*.*\*\/\s*\z/          # single-line block comments (/* ... */)
+        ]
+        
+        excluded_patterns.any? { |pattern| line_content =~ pattern }
+      end
+
+      # Calculate the line range for a node
+      # @param node [NodeClass] parse tree node
+      # @param source [String] source code text
+      # @return [Array<Integer, Integer>] start_line and end_line, or [nil, nil] if unable to calculate
+      def node_line_range(node, source)
+        return [nil, nil] unless node.respond_to?(:interval)
+        return [nil, nil] unless source.is_a?(String) && !source.empty?
+        
+        interval = node.interval
+        return [nil, nil] unless interval.is_a?(Range)
+        
+        start_pos = interval.first.to_i
+        return [nil, nil] if start_pos < 0
+        
+        # Handle exclusive ranges (most common in Treetop)
+        if interval.exclude_end?
+          end_pos = [interval.end.to_i - 1, start_pos].max
+        else
+          end_pos = interval.end.to_i
+        end
+        
+        # Clamp to source bounds
+        source_len = source.length
+        start_pos = [start_pos, source_len - 1].min if source_len > 0
+        end_pos = [end_pos, source_len - 1].min if source_len > 0
+        
+        # Calculate line numbers by counting newlines
+        # Line numbers are 1-based
+        start_line = source[0...start_pos].count("\n") + 1
+        end_line = source[0..end_pos].count("\n") + 1
+        
+        [start_line, end_line]
+      end
+
+      # Record coverage data for a specific line
+      # @param coverage [Hash] accumulator
+      # @param line [Integer] line number
+      # @param tag [Tags::AbstractTag] the tag for this node
+      def record_line_coverage(coverage, line, tag)
+        coverage[line] ||= {
+          covered: nil,           # nil = no block/loop tags yet, will be determined by branches if any
+          has_block_or_loop: false
+        }
+        
+        case tag.type
+        when :block
+          # Block tags affect line coverage - line is covered if block was executed
+          coverage[line][:has_block_or_loop] = true
+          if coverage[line][:covered].nil?
+            coverage[line][:covered] = tag.complete?
+          else
+            coverage[line][:covered] = coverage[line][:covered] && tag.complete?
+          end
+          
+        when :loop
+          # A loop is covered if it was executed at least once (any iteration pattern)
+          coverage[line][:has_block_or_loop] = true
+          loop_executed = loop_was_executed?(tag)
+          if coverage[line][:covered].nil?
+            coverage[line][:covered] = loop_executed
+          else
+            coverage[line][:covered] = coverage[line][:covered] && loop_executed
+          end
+          
+        when :branch
+          # For lines with only branches, mark as covered if at least one branch was taken
+          unless coverage[line][:has_block_or_loop]
+            if tag.is_a?(Tags::ConditionalBranchTag)
+              branch_taken = tag.true || tag.false
+              if coverage[line][:covered].nil?
+                coverage[line][:covered] = branch_taken
+              else
+                coverage[line][:covered] = coverage[line][:covered] || branch_taken
+              end
+            else
+              # Unconditional branches (return, exit, etc.)
+              if coverage[line][:covered].nil?
+                coverage[line][:covered] = tag.complete?
+              else
+                coverage[line][:covered] = coverage[line][:covered] || tag.complete?
+              end
+            end
+          end
+        end
+        
+        # Ensure covered has a boolean value (default to false if still nil)
+        coverage[line][:covered] = false if coverage[line][:covered].nil?
+      end
+
+      # Check if a loop tag indicates the loop was executed at least once
+      # For Sonar, partial loop coverage counts as covered
+      # @param tag [Tags::AbstractLoopTag] the loop tag
+      # @return [Boolean] true if loop was executed (any iteration pattern)
+      def loop_was_executed?(tag)
+        tag.pass || tag.once || tag.twice || tag.ends
+      end
+    end
+
+  end
+end

data/lib/piggly/compiler.rb

@@ -3,5 +3,6 @@ module Piggly
     autoload :CacheDir,       "piggly/compiler/cache_dir"
     autoload :TraceCompiler,  "piggly/compiler/trace_compiler"
     autoload :CoverageReport, "piggly/compiler/coverage_report"
+    autoload :LineCoverage,   "piggly/compiler/line_coverage"
   end
 end

data/lib/piggly/reporter/base.rb

@@ -31,13 +31,15 @@ module Piggly
 
     private
 
-      def aggregate(label, summary)
+      def aggregate(label, summary, line_summary = nil)
         tag :p, label, :class => "summary"
         tag :table, :class => "summary" do
           tag :tr do
+            tag :th, "Lines"
             tag :th, "Blocks"
             tag :th, "Loops"
             tag :th, "Branches"
+            tag :th, "Line Coverage"
             tag :th, "Block Coverage"
             tag :th, "Loop Coverage"
             tag :th, "Branch Coverage"
@@ -49,13 +51,27 @@ module Piggly
               tag(:td, :class => "count") { tag :span, -1 }
               tag(:td, :class => "count") { tag :span, -1 }
               tag(:td, :class => "count") { tag :span, -1 }
+              tag(:td, :class => "count") { tag :span, -1 }
+              tag(:td, :class => "pct")   { tag :span, -1 }
               tag(:td, :class => "pct")   { tag :span, -1 }
               tag(:td, :class => "pct")   { tag :span, -1 }
               tag(:td, :class => "pct")   { tag :span, -1 }
             else
+              # Line coverage (from LineCoverage module)
+              if line_summary
+                tag(:td, (line_summary[:count] || 0), :class => "count")
+              else
+                tag(:td, :class => "count") { tag :span, -1 }
+              end
               tag(:td, (summary[:block][:count]  || 0), :class => "count")
               tag(:td, (summary[:loop][:count]   || 0), :class => "count")
               tag(:td, (summary[:branch][:count] || 0), :class => "count")
+              # Line coverage percentage
+              if line_summary
+                tag(:td, :class => "pct") { percent(line_summary[:percent]) }
+              else
+                tag(:td, :class => "pct") { tag :span, -1 }
+              end
               tag(:td, :class => "pct") { percent(summary[:block][:percent])  }
               tag(:td, :class => "pct") { percent(summary[:loop][:percent])   }
               tag(:td, :class => "pct") { percent(summary[:branch][:percent]) }

data/lib/piggly/reporter/index.rb

@@ -5,11 +5,16 @@ module Piggly
 
       def initialize(config, profile)
         @config, @profile = config, profile
+        @line_coverage = Compiler::LineCoverage.new(config)
       end
 
       def report(procedures, index)
         io = File.open("#{report_path}/index.html", "w")
 
+        # Calculate line coverage for all procedures
+        all_line_coverage = calculate_all_line_coverage(procedures)
+        overall_line_summary = @line_coverage.summary(all_line_coverage)
+
         html(io) do
           tag :html do
             tag :head do
@@ -20,7 +25,7 @@ module Piggly
             end
 
             tag :body do
-              aggregate("PL/pgSQL Coverage Summary", @profile.summary)
+              aggregate("PL/pgSQL Coverage Summary", @profile.summary, overall_line_summary)
               table(procedures.sort_by{|p| index.label(p) }, index)
               timestamp
             end
@@ -32,14 +37,38 @@ module Piggly
 
     private
 
+      # Calculate combined line coverage summary for all procedures
+      # Returns aggregated coverage data that can be passed to @line_coverage.summary()
+      def calculate_all_line_coverage(procedures)
+        all_coverage = {}
+        next_key = 1  # Use sequential keys to avoid collisions
+        
+        procedures.each do |procedure|
+          begin
+            coverage = @line_coverage.calculate(procedure, @profile)
+            # Add each line's coverage data with a unique key
+            # Keys don't need to represent actual line numbers for summary calculation
+            coverage.each do |_line, data|
+              all_coverage[next_key] = data
+              next_key += 1
+            end
+          rescue => e
+            $stderr.puts "Index: ERROR calculating coverage for #{procedure.name}: #{e.class}: #{e.message}"
+          end
+        end
+        all_coverage
+      end
+
       def table(procedures, index)
         tag :div, :class => "table-wrapper" do
           tag :table, :class => "summary sortable" do
             tag :tr do
               tag :th, "Procedure"
+              tag :th, "Lines"
               tag :th, "Blocks"
               tag :th, "Loops"
               tag :th, "Branches"
+              tag :th, "Line Coverage"
               tag :th, "Block Coverage"
               tag :th, "Loop Coverage"
               tag :th, "Branch Coverage"
@@ -50,6 +79,15 @@ module Piggly
               row     = k.modulo(2) == 0 ? "even" : "odd"
               label   = index.label(procedure)
 
+              # Calculate line coverage for this procedure
+              line_summary = nil
+              begin
+                coverage = @line_coverage.calculate(procedure, @profile)
+                line_summary = @line_coverage.summary(coverage)
+              rescue => e
+                # Skip if can't calculate
+              end
+
               tag :tr, :class => row do
                 unless summary.include?(:block) or summary.include?(:loop) or summary.include?(:branch)
                   # Parser couldn't parse this file
@@ -57,14 +95,18 @@ module Piggly
                   tag(:td, :class => "count") { tag :span, -1 }
                   tag(:td, :class => "count") { tag :span, -1 }
                   tag(:td, :class => "count") { tag :span, -1 }
+                  tag(:td, :class => "count") { tag :span, -1 }
+                  tag(:td, :class => "pct") { tag :span, -1 }
                   tag(:td, :class => "pct") { tag :span, -1 }
                   tag(:td, :class => "pct") { tag :span, -1 }
                   tag(:td, :class => "pct") { tag :span, -1 }
                 else
                   tag(:td, :class => "file") { tag :a, label, :href => procedure.identifier + ".html" }
+                  tag :td, (line_summary ? line_summary[:count] : 0), :class => "count"
                   tag :td, (summary[:block][:count]  || 0), :class => "count"
                   tag :td, (summary[:loop][:count]   || 0), :class => "count"
                   tag :td, (summary[:branch][:count] || 0), :class => "count"
+                  tag(:td, :class => "pct") { percent(line_summary ? line_summary[:percent] : nil) }
                   tag(:td, :class => "pct") { percent(summary[:block][:percent])  }
                   tag(:td, :class => "pct") { percent(summary[:loop][:percent])   }
                   tag(:td, :class => "pct") { percent(summary[:branch][:percent]) }

data/lib/piggly/reporter/procedure.rb

@@ -5,6 +5,7 @@ module Piggly
 
       def initialize(config, profile)
         @config, @profile = config, profile
+        @line_coverage = Compiler::LineCoverage.new(config)
       end
 
       def report(procedure)
@@ -14,6 +15,15 @@ module Piggly
           compiler = Compiler::CoverageReport.new(@config)
           data     = compiler.compile(procedure, @profile)
 
+          # Calculate line coverage for this procedure
+          line_summary = nil
+          begin
+            coverage = @line_coverage.calculate(procedure, @profile)
+            line_summary = @line_coverage.summary(coverage)
+          rescue => e
+            # Skip if can't calculate
+          end
+
           html(io) do
             tag :html, :xmlns => "http://www.w3.org/1999/xhtml" do
               tag :head do
@@ -25,7 +35,7 @@ module Piggly
 
               tag :body do
                 tag :div, :class => "header" do
-                  aggregate(procedure.name, @profile.summary(procedure))
+                  aggregate(procedure.name, @profile.summary(procedure), line_summary)
                 end
 
                 tag :div, :class => "container" do

data/lib/piggly/reporter/resources/piggly.css

@@ -421,15 +421,15 @@ table.full td.covered {
   width: 100% !important;
 }
 
-/* SYNTAX HIGHLIGHTING - Modern color scheme */
-.tI { color: #475569; } /* identifier - slate-600 */
-.tD { color: #7c3aed; font-style: italic; } /* data type - violet-600 */
-.tK { color: #dc2626; font-weight: 500; } /* keyword - red-600 */
-.tC { color: #6366f1; font-style: italic; } /* comment - indigo-500 */
-.tQ { color: #059669; font-style: italic; } /* sql statement - emerald-600 */
-.tS { color: #10b981; } /* string literal - emerald-500 */
-.tL { color: #ea580c; font-style: italic; } /* label - orange-600 */
-.tM { color: var(--color-text-secondary); } /* dollar quote marker */
+/* SYNTAX HIGHLIGHTING - Inherit coverage colors, except comments */
+.tI { color: inherit; } /* identifier */
+.tD { color: inherit; font-style: italic; } /* data type */
+.tK { color: inherit; font-weight: 500; } /* keyword */
+.tC { color: var(--color-text); font-style: italic; } /* comment */
+.tQ { color: inherit; font-style: italic; } /* sql statement */
+.tS { color: inherit; } /* string literal */
+.tL { color: inherit; font-style: italic; } /* label */
+.tM { color: inherit; } /* dollar quote marker */
 
 /* CODE BLOCKS */
 .b {
@@ -460,18 +460,23 @@ table.full td.covered {
 }
 
 .c1 {
-  color: var(--color-text);
+  color: var(--color-success);
 }
 
 /* LOOP COVERAGE */
-.l0000, .l0001, .l0010, .l0100, .l0011, .l0101, .l0110, .l0111,
+.l0000 {
+  font-weight: 600;
+  color: var(--color-danger); /* red - never evaluated */
+}
+
+.l0001, .l0010, .l0100, .l0011, .l0101, .l0110, .l0111,
 .l1000, .l1001, .l1010, .l1100, .l1011, .l1101, .l1110 {
   font-weight: 600;
-  color: var(--color-warning);
+  color: var(--color-warning); /* orange - partial coverage */
 }
 
 .l1111 {
-  color: var(--color-text);
+  color: var(--color-success); /* green - full coverage */
 }
 
 /* BRANCH DECISIONS */
@@ -480,18 +485,14 @@ table.full td.covered {
   color: var(--color-danger);
 }
 
-.b01 {
-  font-weight: 600;
-  color: #10b981;
-}
-
+.b01,
 .b10 {
   font-weight: 600;
-  color: #f59e0b;
+  color: var(--color-warning);
 }
 
 .b11 {
-  color: var(--color-text);
+  color: var(--color-success);
 }
 
 /* SCROLLBAR STYLING (for webkit browsers) */

data/lib/piggly/reporter/sonar.rb

@@ -0,0 +1,94 @@
+module Piggly
+  module Reporter
+
+    #
+    # Generates SonarQube generic test coverage XML format.
+    #
+    # Format specification:
+    # https://docs.sonarsource.com/sonarqube-server/latest/analyzing-source-code/test-coverage/generic-test-data/
+    #
+    class Sonar < Base
+
+      def initialize(config, profile, output_path = nil)
+        @config = config
+        @profile = profile
+        @output_path = output_path || File.join(@config.report_root, "sonar-coverage.xml")
+        @line_coverage = Compiler::LineCoverage.new(config)
+      end
+
+      # Generate Sonar coverage report for all procedures
+      # @param procedures [Array<Dumper::ReifiedProcedure>] list of procedures
+      def report(procedures)
+        FileUtils.makedirs(File.dirname(@output_path))
+        
+        File.open(@output_path, "w:UTF-8") do |io|
+          io.puts '<?xml version="1.0" encoding="UTF-8"?>'
+          io.puts '<coverage version="1">'
+          
+          procedures.each do |procedure|
+            begin
+              write_procedure_coverage(io, procedure)
+            rescue => e
+              # Skip procedures that can't be processed
+              $stderr.puts "Warning: Could not generate Sonar coverage for #{procedure.name}: #{e.message}"
+            end
+          end
+          
+          io.puts '</coverage>'
+        end
+        
+        @output_path
+      end
+
+    private
+
+      # Write coverage data for a single procedure
+      def write_procedure_coverage(io, procedure)
+        coverage = @line_coverage.calculate(procedure, @profile)
+        return if coverage.empty?
+        
+        # Get the source file path and convert to relative path
+        absolute_path = procedure.source_path(@config)
+        source_path = make_relative_path(absolute_path)
+        
+        io.puts "  <file path=\"#{escape_xml(source_path)}\">"
+        
+        # Sort lines and output coverage data
+        coverage.keys.sort.each do |line|
+          line_data = coverage[line]
+          write_line_coverage(io, line, line_data)
+        end
+        
+        io.puts "  </file>"
+      end
+
+      # Write coverage data for a single line
+      def write_line_coverage(io, line_number, line_data)
+        attrs = []
+        attrs << "lineNumber=\"#{line_number}\""
+        attrs << "covered=\"#{line_data[:covered]}\""
+        
+        io.puts "    <lineToCover #{attrs.join(' ')}/>"
+      end
+
+      # Escape special XML characters
+      def escape_xml(text)
+        text.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub("\"", "&quot;")
+          .gsub("'", "&apos;")
+      end
+
+      # Convert absolute path to relative path from project root for cross-platform compatibility
+      def make_relative_path(absolute_path)
+        project_root = File.dirname(File.dirname(@config.cache_root))
+        
+        relative = absolute_path.sub(/^#{Regexp.escape(project_root)}[\/\\]?/, '')
+        relative.gsub('\\', '/')
+      end
+    end
+
+  end
+end

data/lib/piggly/reporter.rb

@@ -4,5 +4,6 @@ module Piggly
     autoload :Base,       "piggly/reporter/base"
     autoload :Index,      "piggly/reporter/index"
     autoload :Procedure,  "piggly/reporter/procedure"
+    autoload :Sonar,      "piggly/reporter/sonar"
   end
 end

data/lib/piggly/tags.rb

@@ -175,7 +175,7 @@ module Piggly
       end
 
       def style
-        "l#{[@pass, @once, @twice, @ends].map{|b| b ? 1 : 0}}"
+        "l#{[@pass, @once, @twice, @ends].map{|b| b ? 1 : 0}.join}"
       end
 
       def to_f

data/lib/piggly/version.rb

@@ -2,9 +2,9 @@ module Piggly
   module VERSION
     MAJOR = 2
     MINOR = 3
-    TINY  = 3
+    TINY  = 4
 
-    RELEASE_DATE = "2025-12-12"
+    RELEASE_DATE = "2026-02-12"
   end
 
   class << VERSION

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: piggly-nsd
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 2.3.4
 platform: ruby
 authors:
 - Kvle Putnam
@@ -56,6 +56,7 @@ files:
 - lib/piggly/compiler.rb
 - lib/piggly/compiler/cache_dir.rb
 - lib/piggly/compiler/coverage_report.rb
+- lib/piggly/compiler/line_coverage.rb
 - lib/piggly/compiler/trace_compiler.rb
 - lib/piggly/config.rb
 - lib/piggly/dumper.rb
@@ -79,6 +80,7 @@ files:
 - lib/piggly/reporter/resources/highlight.js
 - lib/piggly/reporter/resources/piggly.css
 - lib/piggly/reporter/resources/sortable.js
+- lib/piggly/reporter/sonar.rb
 - lib/piggly/tags.rb
 - lib/piggly/task.rb
 - lib/piggly/util.rb