piggly-nsd 2.3.4 → 2.3.6

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

@@ -52,9 +52,14 @@ module Piggly
         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

data/lib/piggly/reporter.rb

@@ -5,5 +5,6 @@ module Piggly
     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/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  = 4
+    TINY  = 6
 
-    RELEASE_DATE = "2026-02-12"
+    RELEASE_DATE = "2026-06-01"
   end
 
   class << VERSION

data/spec/examples/dumper/definition_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+module Piggly
+  module Dumper
+
+    describe SkeletonProcedure, "definition" do
+      def qname(schema, name)
+        QualifiedName.new(schema, name)
+      end
+
+      def qtype(*args)
+        QualifiedType.parse(*args)
+      end
+
+      it "quotes user-defined types but not built-in types" do
+        expect(qtype("character varying").quote).to eq("varchar")
+        expect(qtype("pg_catalog", "varchar").quote).to eq("varchar")
+        expect(qtype("bigint").quote).to eq("bigint")
+        expect(qtype("private", "mytype").quote).to eq('"private"."mytype"')
+      end
+
+      it "generates valid SQL for functions with table return columns" do
+        procedure = ReifiedProcedure.new(
+          "begin end;",
+          1,
+          qname("public", "f_test_function"),
+          false,
+          false,
+          true,
+          qtype("pg_catalog", "varchar"),
+          "volatile",
+          %w[in in in t],
+          %w[p_payment_session_id p_payment_type_start p_payment_type_end type_mnemo].map { |n| qname(nil, n) },
+          ["bigint", "character varying", "character varying", "character varying"].map { |t| qtype(t) },
+          [nil, nil, nil, nil]
+        )
+
+        sql = procedure.definition("begin end;")
+
+        expect(sql).to include('in "p_payment_session_id" bigint')
+        expect(sql).to include('in "p_payment_type_start" varchar')
+        expect(sql).to include('returns table ("type_mnemo" varchar)')
+        expect(sql).not_to include('t "type_mnemo"')
+        expect(sql).not_to include('"varchar"')
+      end
+    end
+
+  end
+end

data/spec/examples/dumper/procedure_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Piggly
   

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

@@ -15,6 +15,18 @@ module Piggly
       it "allows an initial assignment" do
         node = parse(:stmtDeclare, "declare a text := 10;")
       end
+
+      it "parses parameterized cursor declarations" do
+        parse(:stmtDeclare, <<~SQL)
+          declare
+            c_lic_acc_value cursor(c_lic_acc_id bigint, c_date_old timestamp) for
+              select date_v, beg_val from public.t_table_value where link_lic_acc = c_lic_acc_id;
+        SQL
+      end
+
+      it "parses cursor declarations without space before parameter list" do
+        parse(:stmtDeclare, "declare c cursor(x int) for select 1;")
+      end
     end
 
   end

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

@@ -62,6 +62,12 @@ module Piggly
           node.should be_statement
           node.count{|e| e.comment? }.should == 3
         end
+
+        it "allows then immediately after closing parenthesis" do
+          node, rest = parse_some(:statement, 'IF exists(select 1)then null; end if;')
+          node.should be_statement
+          rest.should == ''
+        end
       end
 
       describe "if .. then .. else .. end if" do

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,28 @@ module Piggly
         rest.should == ''
       end
 
+      it "parses ANALYZE statements" do
+        node, rest = parse_some(:statement, 'ANALYZE tt_test;')
+        node.should be_statement
+        node.count{|e| e.sql? }.should == 1
+        node.find{|e| e.sql? }.source_text.should == 'ANALYZE tt_test;'
+        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

data/spec/examples/util/line_numbers_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module Piggly::Util
+
+  describe LineNumbers do
+    describe ".count" do
+      it "returns 0 for empty source" do
+        expect(LineNumbers.count("")).to eq(0)
+        expect(LineNumbers.count(nil)).to eq(0)
+      end
+
+      it "counts lines without a trailing newline" do
+        expect(LineNumbers.count("a\nb\nc")).to eq(3)
+      end
+
+      it "does not over-count when source ends with a newline" do
+        expect(LineNumbers.count("a\nb\nc\n")).to eq(3)
+      end
+
+      it "counts CRLF sources consistently" do
+        expect(LineNumbers.count("a\r\nb\r\nc\r\n")).to eq(3)
+      end
+
+      it "matches String#lines for a large trailing-newline body" do
+        source = (1..366).map { |i| "line#{i}" }.join("\n") + "\n"
+        expect(LineNumbers.count(source)).to eq(366)
+        expect(LineNumbers.count(source)).to eq(source.lines.count)
+      end
+    end
+
+    describe ".at_offset" do
+      let(:source) { "a\nb\nc\n" }
+
+      it "returns 1 for empty source" do
+        expect(LineNumbers.at_offset("", 0)).to eq(1)
+      end
+
+      it "maps byte offsets to 1-based line numbers" do
+        expect(LineNumbers.at_offset(source, 0)).to eq(1)
+        expect(LineNumbers.at_offset(source, 2)).to eq(2)
+        expect(LineNumbers.at_offset(source, 4)).to eq(3)
+      end
+
+      it "clamps offsets past EOF to the last line" do
+        expect(LineNumbers.at_offset(source, source.length)).to eq(3)
+        expect(LineNumbers.at_offset(source, source.length + 10)).to eq(3)
+      end
+
+      it "does not report a line beyond count when offset is on trailing newline" do
+        source = (1..366).map { |i| "line#{i}" }.join("\n") + "\n"
+        max_line = LineNumbers.count(source)
+
+        expect(LineNumbers.at_offset(source, source.length - 1)).to eq(max_line)
+        expect(LineNumbers.at_offset(source, source.length)).to eq(max_line)
+      end
+    end
+  end
+
+end

data/spec/issues/037_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+module Piggly
+  describe "GET CURRENT DIAGNOSTICS" do
+    include GrammarHelper
+
+    it "can parse a GET CURRENT DIAGNOSTICS statement" do
+      body = "GET CURRENT DIAGNOSTICS l_wdc_inserted := ROW_COUNT;"
+
+      node = parse(:statement, body)
+      node.should be_statement
+    end
+
+    it "can parse a procedure with GET CURRENT DIAGNOSTICS" do
+      body = <<-SQL
+      DECLARE
+        l_wdc_inserted bigint;
+      BEGIN
+        INSERT INTO foo DEFAULT VALUES;
+        GET CURRENT DIAGNOSTICS l_wdc_inserted := ROW_COUNT;
+        RETURN l_wdc_inserted;
+      END;
+      SQL
+
+      node = parse(:start, body.strip.downcase)
+      node.count { |e| e.assignment? }.should == 0
+      node.count { |e| Parser::Nodes::Return === e }.should == 1
+    end
+  end
+end

data/spec/issues/case_in_condition_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+module Piggly
+  describe "SQL CASE in PL/pgSQL conditions" do
+    include GrammarHelper
+
+    it "can parse IF with CASE in a function argument" do
+      body = <<-SQL
+      BEGIN
+        IF 0 = public.f_test(
+              p_doc_type_mnemo => line_rec.doc_type_mnemo,
+              p_person_id => CASE
+                               WHEN l_f_sub_acc = 1 THEN p_client_id
+                               WHEN l_f_sub_acc = 0 THEN l_person_id
+                             END,
+              p_repres_id => NULL
+            ) THEN
+          NULL;
+        END IF;
+      END;
+      SQL
+
+      node = parse(:start, body.strip.downcase)
+      node.count { |e| e.if? }.should == 1
+    end
+
+    it "can parse ELSIF with CASE in a function argument" do
+      body = <<-SQL
+      BEGIN
+        IF false THEN
+          NULL;
+        ELSIF 0 = public.f_test(
+                p_person_id => CASE WHEN l_flag = 1 THEN p_a ELSE p_b END
+              ) THEN
+          NULL;
+        END IF;
+      END;
+      SQL
+
+      node = parse(:start, body.strip.downcase)
+      node.count { |e| e.if? }.should == 2
+    end
+
+    it "does not break simple IF conditions" do
+      node = parse(:statement, "IF cond THEN a := 10; END IF;")
+      node.should be_statement
+      node.count { |e| e.if? }.should == 1
+    end
+  end
+end

data/spec/issues/commit_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+module Piggly
+  describe "standalone transaction statements" do
+    include GrammarHelper
+
+    it "can parse commit without trailing expression" do
+      node = parse(:statement, "commit;")
+      node.should be_statement
+      node.count { |e| e.sql? }.should == 1
+      node.find { |e| e.sql? }.source_text.should == "commit;"
+    end
+
+    it "can parse rollback without trailing expression" do
+      node = parse(:statement, "rollback;")
+      node.should be_statement
+      node.count { |e| e.sql? }.should == 1
+    end
+
+    it "can parse a procedure with multiple commit statements" do
+      body = <<-SQL
+      BEGIN
+        call i_schema.create_choice1(p_session_id => l_session_id);
+        commit;
+        call i_schema.create_choice2(l_session_id);
+        commit;
+      END;
+      SQL
+
+      node = parse(:start, body.strip.downcase)
+      node.count { |e| e.sql? }.should == 4
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -26,7 +26,7 @@ module Piggly
 
     COMMENTS = ["abc defghi", "abc -- abc", "quote's", "a 'str'"]
 
-    SQLWORDS = %w[select insert update delete drop alter commit set start]
+    SQLWORDS = %w[select insert update delete merge drop alter commit set start]
 
     KEYWORDS = %w[as := = alias begin by constant continue
                   cursor debug declare diagnostics else elsif elseif

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: piggly-nsd
 version: !ruby/object:Gem::Version
-  version: 2.3.4
+  version: 2.3.6
 platform: ruby
 authors:
 - Kvle Putnam
@@ -37,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.18.4
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.3'
 description: PostgreSQL PL/pgSQL stored procedure code coverage (NSD fork)
 email: putnam.kvle@gmail.com
 executables:
@@ -80,6 +94,7 @@ files:
 - lib/piggly/reporter/resources/highlight.js
 - lib/piggly/reporter/resources/piggly.css
 - lib/piggly/reporter/resources/sortable.js
+- lib/piggly/reporter/schema_csv.rb
 - lib/piggly/reporter/sonar.rb
 - lib/piggly/tags.rb
 - lib/piggly/task.rb
@@ -88,6 +103,7 @@ files:
 - lib/piggly/util/cacheable.rb
 - lib/piggly/util/enumerable.rb
 - lib/piggly/util/file.rb
+- lib/piggly/util/line_numbers.rb
 - lib/piggly/util/process_queue.rb
 - lib/piggly/util/thunk.rb
 - lib/piggly/version.rb
@@ -95,6 +111,7 @@ files:
 - spec/examples/compiler/report_spec.rb
 - spec/examples/compiler/trace_spec.rb
 - spec/examples/config_spec.rb
+- spec/examples/dumper/definition_spec.rb
 - spec/examples/dumper/index_spec.rb
 - spec/examples/dumper/procedure_spec.rb
 - spec/examples/grammar/expression_spec.rb
@@ -123,12 +140,14 @@ files:
 - spec/examples/reporter/html/dsl_spec.rb
 - spec/examples/reporter/html/index_spec.rb
 - spec/examples/reporter/html_spec.rb
+- spec/examples/reporter/schema_csv_spec.rb
 - spec/examples/reporter_spec.rb
 - spec/examples/tags_spec.rb
 - spec/examples/task_spec.rb
 - spec/examples/util/cacheable_spec.rb
 - spec/examples/util/enumerable_spec.rb
 - spec/examples/util/file_spec.rb
+- spec/examples/util/line_numbers_spec.rb
 - spec/examples/util/process_queue_spec.rb
 - spec/examples/util/thunk_spec.rb
 - spec/examples/version_spec.rb
@@ -138,9 +157,12 @@ files:
 - spec/issues/028_spec.rb
 - spec/issues/032_spec.rb
 - spec/issues/036_spec.rb
+- spec/issues/037_spec.rb
+- spec/issues/case_in_condition_spec.rb
+- spec/issues/commit_spec.rb
 - spec/spec_helper.rb
 - spec/spec_suite.rb
-homepage: https://github.com/sergeiboikov/piggly
+homepage: https://github.com/NSDDeveloper/piggly
 licenses:
 - BSD-2-Clause
 metadata: {}