piggly-nsd 2.3.3 → 2.3.5

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/schema_csv.rb

@@ -0,0 +1,98 @@
+require "csv"
+require "fileutils"
+
+module Piggly
+  module Reporter
+
+    #
+    # Generates schema-level coverage summary in CSV format.
+    #
+    class SchemaCsv < Base
+      HEADERS = ["No", "Schema Name", "Objects Count", "Covered Objects", "Line Coverage Percent"].freeze
+      NO_SCHEMA = "<no schema>".freeze
+
+      def initialize(config, profile, output_path = nil)
+        @config = config
+        @profile = profile
+        @output_path = output_path || File.join(@config.report_root, "coverage_by_schema.csv")
+        @line_coverage = Compiler::LineCoverage.new(config)
+      end
+
+      # Generate CSV schema coverage report for all procedures
+      # @param procedures [Array<Dumper::ReifiedProcedure>] list of procedures
+      def report(procedures)
+        FileUtils.makedirs(File.dirname(@output_path))
+        aggregates = aggregate_by_schema(procedures)
+
+        CSV.open(@output_path, "wb:UTF-8") do |csv|
+          csv << HEADERS
+
+          aggregates.each_with_index do |row, index|
+            csv << [
+              index + 1,
+              row[:schema_name],
+              row[:objects_count],
+              row[:covered_objects],
+              format("%0.2f", row[:coverage_percent])
+            ]
+          end
+        end
+
+        @output_path
+      end
+
+    private
+
+      def aggregate_by_schema(procedures)
+        grouped = Hash.new do |hash, key|
+          hash[key] = {
+            schema_name: key,
+            objects_count: 0,
+            covered_objects: 0,
+            coverage_values: []
+          }
+        end
+
+        procedures.each do |procedure|
+          schema_name = schema_label(procedure)
+          row = grouped[schema_name]
+          row[:objects_count] += 1
+
+          begin
+            percent = line_coverage_percent(procedure)
+            next if percent.nil?
+
+            row[:covered_objects] += 1 if percent > 0.0
+            row[:coverage_values] << percent
+          rescue => e
+            $stderr.puts "Warning: Could not calculate schema CSV coverage for #{procedure.name}: #{e.message}"
+          end
+        end
+
+        grouped.keys.sort.map do |schema_name|
+          row = grouped[schema_name]
+          values = row[:coverage_values]
+          average = values.empty? ? 0.0 : values.inject(0.0, :+) / values.size
+
+          {
+            schema_name: row[:schema_name],
+            objects_count: row[:objects_count],
+            covered_objects: row[:covered_objects],
+            coverage_percent: average
+          }
+        end
+      end
+
+      def schema_label(procedure)
+        schema = procedure.name.schema.to_s.strip
+        schema.empty? ? NO_SCHEMA : schema
+      end
+
+      def line_coverage_percent(procedure)
+        coverage = @line_coverage.calculate(procedure, @profile)
+        @line_coverage.summary(coverage)[:percent]
+      end
+    end
+
+  end
+end

data/lib/piggly/reporter/sonar.rb

@@ -0,0 +1,99 @@
+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)}\">"
+
+        source = procedure.source(@config)
+        max_line = Util::LineNumbers.count(source)
+
+        # Sort lines and output coverage data
+        coverage.keys.sort.each do |line|
+          next if line < 1 || line > max_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,7 @@ module Piggly
     autoload :Base,       "piggly/reporter/base"
     autoload :Index,      "piggly/reporter/index"
     autoload :Procedure,  "piggly/reporter/procedure"
+    autoload :Sonar,      "piggly/reporter/sonar"
+    autoload :SchemaCsv,  "piggly/reporter/schema_csv"
   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/task.rb

@@ -118,12 +118,14 @@ module Piggly
   class ReportTask < AbstractTask
     attr_accessor :report_root,   # Where to store reports (default piggly/report)
                   :accumulate,    # Accumulate coverage from the previous run (default false)
-                  :trace_file
+                  :trace_file,
+                  :schema_csv_path
 
     def initialize(name = :report)
       @accumulate  = false
       @trace_file  = nil
       @report_root = nil
+      @schema_csv_path = nil
       super(name)
     end
 
@@ -141,6 +143,7 @@ module Piggly
           opts.concat(["--trace-file",  @trace_file])
           opts.concat(["--cache-root",  @cache_root]) if @cache_root
           opts.concat(["--report-root", @report_root]) if @report_root
+          opts.concat(["--schema-csv-path", @schema_csv_path]) if @schema_csv_path
 
           case @procedures
           when String then opts.concat(["--name", @procedures])

data/lib/piggly/util/line_numbers.rb

@@ -0,0 +1,25 @@
+module Piggly
+  module Util
+
+    module LineNumbers
+      module_function
+
+      def count(source)
+        return 0 if source.nil? || source.empty?
+
+        source.lines.count
+      end
+
+      # 1-based line number for a byte offset, clamped to [1, count(source)].
+      def at_offset(source, offset)
+        return 1 if source.nil? || source.empty?
+
+        offset = [[offset, 0].max, source.length].min
+        line = source[0...offset].count("\n") + 1
+        max_line = count(source)
+        [[line, 1].max, max_line].min
+      end
+    end
+
+  end
+end

data/lib/piggly/util.rb

@@ -5,5 +5,6 @@ module Piggly
     autoload :Cacheable,    "piggly/util/cacheable"
     autoload :Enumerable,   "piggly/util/enumerable"
     autoload :File,         "piggly/util/file"
+    autoload :LineNumbers,  "piggly/util/line_numbers"
   end
 end

data/lib/piggly/version.rb

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

data/spec/examples/grammar/statements/loop_spec.rb

@@ -23,6 +23,15 @@ module Piggly
           cond.source_text.should == 'SELECT * FROM table '
           cond.should be_sql
         end
+
+        it "can loop over parenthesized query without whitespace after IN" do
+          node = parse(:stmtForLoop, 'FOR x IN(SELECT * FROM table) LOOP a := x; END LOOP;')
+          node.should be_statement
+
+          cond = node.find{|e| e.named?(:cond) }
+          cond.source_text.should == '(SELECT * FROM table) '
+          cond.should be_expression
+        end
       end
 
       describe "while loops" do

data/spec/examples/grammar/statements/sql_spec.rb

@@ -13,6 +13,20 @@ module Piggly
         rest.should == ''
       end
 
+      it "parses MERGE statements" do
+        node, rest = parse_some(:statement, <<-SQL.strip)
+          MERGE INTO users u
+          USING (SELECT 1 AS id) s
+          ON s.id = u.id
+          WHEN NOT MATCHED THEN
+            INSERT (id) VALUES (s.id);
+        SQL
+        node.should be_statement
+        node.count{|e| e.sql? }.should == 1
+        node.find{|e| e.sql? }.source_text.should =~ /\Amerge into users/mi
+        rest.should == ''
+      end
+
       it "must end with a semicolon" do
         expect{ parse(:statement, 'SELECT id FROM users') }.to raise_error(Piggly::Parser::Failure)
         expect{ parse_some(:statement, 'SELECT id FROM users') }.to raise_error(Piggly::Parser::Failure)

data/spec/examples/reporter/schema_csv_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+require "csv"
+require "tmpdir"
+require "fileutils"
+
+module Piggly
+
+  describe Reporter::SchemaCsv do
+    let(:profile) { double(:profile) }
+    let(:line_coverage) { double(:line_coverage) }
+    let(:tmpdir) { Dir.mktmpdir("piggly-schema-csv") }
+    let(:config) { double(:config, :report_root => tmpdir) }
+    let(:output_path) { File.join(tmpdir, "schema-coverage.csv") }
+
+    def procedure(schema, name)
+      qualified_name = Dumper::QualifiedName.new(schema, name)
+      double(:procedure, :name => qualified_name)
+    end
+
+    before do
+      allow(Compiler::LineCoverage).to receive(:new).with(config).and_return(line_coverage)
+    end
+
+    after do
+      FileUtils.remove_entry(tmpdir) if File.exist?(tmpdir)
+    end
+
+    it "writes schema coverage CSV with headers and aggregated rows" do
+      first_public = procedure("public", "alpha")
+      second_public = procedure("public", "beta")
+      app_proc = procedure("app", "gamma")
+      no_schema_proc = procedure(nil, "delta")
+
+      allow(line_coverage).to receive(:calculate).with(first_public, profile).and_return(:cov_public_1)
+      allow(line_coverage).to receive(:calculate).with(second_public, profile).and_return(:cov_public_2)
+      allow(line_coverage).to receive(:calculate).with(app_proc, profile).and_return(:cov_app)
+      allow(line_coverage).to receive(:calculate).with(no_schema_proc, profile).and_return(:cov_no_schema)
+
+      allow(line_coverage).to receive(:summary).with(:cov_public_1).and_return(:percent => 100.0)
+      allow(line_coverage).to receive(:summary).with(:cov_public_2).and_return(:percent => 0.0)
+      allow(line_coverage).to receive(:summary).with(:cov_app).and_return(:percent => nil)
+      allow(line_coverage).to receive(:summary).with(:cov_no_schema).and_return(:percent => 75.0)
+
+      reporter = Reporter::SchemaCsv.new(config, profile, output_path)
+      result_path = reporter.report([first_public, second_public, app_proc, no_schema_proc])
+
+      expect(result_path).to eq(output_path)
+      expect(File).to exist(output_path)
+
+      rows = CSV.read(output_path, :headers => true)
+
+      expect(rows.headers).to eq(["No", "Schema Name", "Objects Count", "Covered Objects", "Line Coverage Percent"])
+
+      by_schema = rows.each_with_object({}) do |row, hash|
+        hash[row["Schema Name"]] = row
+      end
+
+      expect(by_schema.fetch("public")["Objects Count"]).to eq("2")
+      expect(by_schema.fetch("public")["Covered Objects"]).to eq("1")
+      expect(by_schema.fetch("public")["Line Coverage Percent"]).to eq("50.00")
+
+      expect(by_schema.fetch("app")["Objects Count"]).to eq("1")
+      expect(by_schema.fetch("app")["Covered Objects"]).to eq("0")
+      expect(by_schema.fetch("app")["Line Coverage Percent"]).to eq("0.00")
+
+      expect(by_schema.fetch("<no schema>")["Objects Count"]).to eq("1")
+      expect(by_schema.fetch("<no schema>")["Covered Objects"]).to eq("1")
+      expect(by_schema.fetch("<no schema>")["Line Coverage Percent"]).to eq("75.00")
+    end
+  end
+
+end