piggly-nsd 2.3.3 → 2.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b53364d89c087bf4c2ce49ec451ece2cb1c17694bab9e765e034a05493ef3999
-  data.tar.gz: a46eea287041eeaa4130b730dd409f1f35663e6fca5258e96c639b1f567eeb11
+  metadata.gz: 736495bc6e9ad8785b755afb2b3a834cd0dff2e62983b0397e4d6fdf6f0fe3af
+  data.tar.gz: 958489e0a1a542230ad57dc8748ef4a231e9c03cea1452c34246887e9789746f
 SHA512:
-  metadata.gz: 1cfd022ed8e03c56d372911943bd7b662a6ff967f63bde7b09a01e010b5117bc41ad0f5c245a30e72139776a5eece380ab9d2d60175462555a874cfb008e73c8
-  data.tar.gz: b8653bb06b92d31eee24e5c9a317fe912dc61e01d46fae649dadeb4610b831f4ad50199683996cddc756727124be68514fc0d919b372d80f70347851539d7751
+  metadata.gz: ba81b385db041ea25c62a0777838d84ed89a165e489d6d4ef3f60ea908902acad3ba2a186e3eb7325a7520f407eead2ae3e6121fd8f4429664a3a9f00a848b01
+  data.tar.gz: e076e78ce56f6e8e7ed238f7fa354dfe9799b2707520394e5635162f8029359c581bf5d055b53efd0c0739b58410c59ee5cb9e94c08b7dd600ecf64f478fb7d4

data/README.md

@@ -1,4 +1,4 @@
-[![CI](https://github.com/sergeiboikov/piggly/actions/workflows/ci.yml/badge.svg)](https://github.com/sergeiboikov/piggly/actions/workflows/ci.yml)
+[![CI](https://github.com/NSDDeveloper/piggly/actions/workflows/ci.yml/badge.svg)](https://github.com/NSDDeveloper/piggly/actions/workflows/ci.yml)
 # Piggly-NSD
 
 Code coverage reports for PostgreSQL PL/pgSQL stored procedures
@@ -51,12 +51,16 @@ 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
 
 To install the latest from github:
 
-    $ git clone https://github.com/sergeiboikov/piggly.git
+    $ git clone https://github.com/NSDDeveloper/piggly.git
     $ cd piggly
     $ bundle install
     $ bundle exec rake spec
@@ -122,11 +126,33 @@ 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/).
+
+### Schema CSV Report
+
+To generate a schema-level CSV report, use the `--schema-csv-path` option:
+
+    $ piggly report -f messages.txt --schema-csv-path piggly/reports/coverage_by_schema.csv
+
+The CSV report groups procedures by schema and contains the following columns:
+
+- `No`
+- `Schema Name`
+- `Objects Count`
+- `Covered Objects`
+- `Line Coverage Percent`
+
 ## Running the Examples
 
     $ cd piggly
@@ -167,4 +193,4 @@ Once the report is built you can open it in `piggly/reports/index.html`.
 
 ## Bugs & Issues
 
-Please report any issues or feature requests on the [github tracker](https://github.com/sergeiboikov/piggly/issues).
+Please report any issues or feature requests on the [github tracker](https://github.com/NSDDeveloper/piggly/issues).

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, schema_csv_path, html_report_requested = configure(argv)
 
         profile = Profile.new
         index   = Dumper::Index.new(config)
@@ -33,12 +33,28 @@ 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
+
+        # Generate schema-level CSV report if requested
+        if schema_csv_path
+          create_schema_csv_report(config, procedures, profile, schema_csv_path)
+        end
+
+        unless html_report_requested || sonar_path || schema_csv_path
+          puts "Warning: No report output specified. Use -o for HTML reports, -x for Sonar report, or --schema-csv-path for CSV report."
+        end
       end
 
       # Adds the given procedures to Profile
@@ -118,14 +134,45 @@ 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
+
+      # Create schema-level CSV coverage report
+      #
+      def create_schema_csv_report(config, procedures, profile, output_path)
+        puts "creating schema CSV coverage report"
+        reporter = Reporter::SchemaCsv.new(config, profile, output_path)
+        path = reporter.report(procedures)
+        puts "Schema CSV coverage report written to: #{path}"
+      end
+
       def configure(argv, config = Config.new)
         io = $stdin
+        sonar_path = nil
+        schema_csv_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("--schema-csv-path PATH", "generate schema-level CSV coverage report at PATH") do |path|
+            schema_csv_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 +187,18 @@ module Piggly
 
         begin
           p.parse! argv
+
+          unless html_report_requested || sonar_path || schema_csv_path
+            raise OptionParser::MissingArgument,
+              "at least one report type required: use -o for HTML reports, -x for Sonar report, or --schema-csv-path for CSV 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, schema_csv_path, html_report_requested
         rescue OptionParser::InvalidOption,
                OptionParser::InvalidArgument,
                OptionParser::MissingArgument

data/lib/piggly/compiler/coverage_report.rb

@@ -23,7 +23,7 @@ module Piggly
         data = trace.compile(procedure)
 
         return :html  => traverse(data[:tree], profile),
-               :lines => 1 .. procedure.source(@config).count("\n") + 1
+               :lines => 1 .. Util::LineNumbers.count(procedure.source(@config))
       end
 
     protected

data/lib/piggly/compiler/line_coverage.rb

@@ -0,0 +1,211 @@
+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)
+        max_line = Util::LineNumbers.count(source)
+        return true if line_number < 1 || line_number > max_line
+
+        line_content = source.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
+        
+        start_line = Util::LineNumbers.at_offset(source, start_pos)
+        end_line = Util::LineNumbers.at_offset(source, end_pos + 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