pg_sql_triggers 1.0.1 → 1.1.0

data/lib/pg_sql_triggers/testing/function_tester.rb

@@ -8,6 +8,7 @@ module PgSqlTriggers
       end
 
       # Test ONLY the function, not the trigger
+      # rubocop:disable Lint/UnusedMethodArgument
       def test_function_only(test_context: {})
         results = {
           function_created: false,
@@ -16,15 +17,44 @@ module PgSqlTriggers
           output: []
         }
 
+        # Check if function_body is present
+        if @trigger.function_body.blank?
+          results[:success] = false
+          results[:errors] << "Function body is missing"
+          return results
+        end
+
+        # Extract function name to verify it matches
+        function_name_from_body = nil
+        if @trigger.function_body.present?
+          pattern = /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/i
+          match = @trigger.function_body.match(pattern)
+          function_name_from_body = match[1] if match
+        end
+
+        # If function_body doesn't contain a valid function definition, fail early
+        unless function_name_from_body
+          results[:success] = false
+          results[:errors] << "Function body does not contain a valid CREATE FUNCTION statement"
+          return results
+        end
+
+        # rubocop:disable Metrics/BlockLength
         ActiveRecord::Base.transaction do
           # Create function in transaction
-          ActiveRecord::Base.connection.execute(@trigger.function_body)
-          results[:function_created] = true
-          results[:output] << "✓ Function created in test transaction"
+          begin
+            ActiveRecord::Base.connection.execute(@trigger.function_body)
+            results[:function_created] = true
+            results[:output] << "✓ Function created in test transaction"
+          rescue ActiveRecord::StatementInvalid, StandardError => e
+            results[:success] = false
+            results[:errors] << "Error during function creation: #{e.message}"
+            # Don't raise here, let it fall through to ensure block for rollback
+          end
 
           # Try to invoke function directly (if test context provided)
           # Note: Empty hash {} is not "present" in Rails, so check if it's not nil
-          if !test_context.nil? && results[:function_created]
+          if results[:function_created]
             # This would require custom invocation logic
             # For now, just verify it was created - if function was successfully created,
             # we can assume it exists and is executable within the transaction
@@ -51,40 +81,50 @@ module PgSqlTriggers
             end
 
             # Verify function exists in database by checking pg_proc
-            # Since the function was created successfully (function_created is true),
-            # it exists and is executable
-            results[:function_executed] = true
-
             # Try to verify via query if function_name is available
             if function_name.present?
-              sanitized_name = ActiveRecord::Base.connection.quote_string(function_name)
-              check_sql = <<~SQL.squish
-                SELECT COUNT(*) as count
-                FROM pg_proc p
-                JOIN pg_namespace n ON p.pronamespace = n.oid
-                WHERE p.proname = '#{sanitized_name}'
-                AND n.nspname = 'public'
-              SQL
-
               begin
+                sanitized_name = begin
+                  ActiveRecord::Base.connection.quote_string(function_name)
+                rescue StandardError => e
+                  # If quote_string fails, use the function name as-is (less safe but allows test to continue)
+                  results[:errors] << "Error during function name sanitization: #{e.message}"
+                  function_name
+                end
+                check_sql = <<~SQL.squish
+                  SELECT COUNT(*) as count
+                  FROM pg_proc p
+                  JOIN pg_namespace n ON p.pronamespace = n.oid
+                  WHERE p.proname = '#{sanitized_name}'
+                  AND n.nspname = 'public'
+                SQL
+
                 result = ActiveRecord::Base.connection.execute(check_sql).first
-                results[:output] << if result && result["count"].to_i.positive?
+                results[:function_executed] = result && result["count"].to_i.positive?
+                results[:output] << if results[:function_executed]
                                       "✓ Function exists and is callable"
                                     else
                                       "✓ Function created (verified via successful creation)"
                                     end
-              rescue StandardError
-                results[:output] << "✓ Function created (verified via successful creation)"
+              rescue ActiveRecord::StatementInvalid, StandardError => e
+                results[:function_executed] = false
+                results[:success] = false
+                results[:errors] << "Error during function verification: #{e.message}"
+                results[:output] << "✓ Function created (verification failed)"
               end
             else
+              # If we can't extract function name, assume it was created successfully
+              # since function_created is true
+              results[:function_executed] = true
               results[:output] << "✓ Function created (execution verified via successful creation)"
             end
           end
 
-          results[:success] = true
-        rescue ActiveRecord::StatementInvalid => e
+          # Set success to true only if no errors occurred and function was created
+          results[:success] = results[:errors].empty? && results[:function_created]
+        rescue ActiveRecord::StatementInvalid, StandardError => e
           results[:success] = false
-          results[:errors] << e.message
+          results[:errors] << e.message unless results[:errors].include?(e.message)
         ensure
           raise ActiveRecord::Rollback
         end
@@ -92,6 +132,7 @@ module PgSqlTriggers
         results[:output] << "\n⚠ Function rolled back (test mode)"
         results
       end
+      # rubocop:enable Lint/UnusedMethodArgument, Metrics/BlockLength
 
       # Check if function already exists in database
       def function_exists?
@@ -100,7 +141,8 @@ module PgSqlTriggers
         rescue StandardError
           {}
         end
-        function_name = definition["function_name"]
+        function_name = definition["function_name"] || definition["name"] ||
+                        definition[:function_name] || definition[:name]
         return false if function_name.blank?
 
         sanitized_name = ActiveRecord::Base.connection.quote_string(function_name)

data/lib/pg_sql_triggers/testing/syntax_validator.rb

@@ -65,10 +65,33 @@ module PgSqlTriggers
           {}
         end
         function_name = definition["function_name"] || "test_validation_function"
+        events = Array(definition["events"] || [])
         sanitized_table = ActiveRecord::Base.connection.quote_string(@trigger.table_name)
         sanitized_function = ActiveRecord::Base.connection.quote_string(function_name)
         sanitized_condition = @trigger.condition
 
+        # Check if condition references OLD values
+        condition_uses_old = sanitized_condition.match?(/\bOLD\./i)
+
+        # Determine which event to use for validation
+        # If condition uses OLD, we must use UPDATE or DELETE since INSERT doesn't have OLD
+        # If condition doesn't use OLD, we can use INSERT
+        if condition_uses_old
+          # Condition references OLD, so it can't be used with INSERT
+          if events.include?("insert")
+            return {
+              valid: false,
+              error: "WHEN condition cannot reference OLD values for INSERT triggers. " \
+                     "Use UPDATE or DELETE events, or modify condition to only use NEW values."
+            }
+          end
+          # Use UPDATE for validation if available (it has OLD), otherwise use DELETE
+          test_event = events.include?("update") ? "UPDATE" : "DELETE"
+        else
+          # Condition doesn't reference OLD, so INSERT is fine
+          test_event = "INSERT"
+        end
+
         # Validate condition by creating a temporary trigger with the condition
         # This is the only way to validate WHEN conditions since they use NEW/OLD
         test_function_sql = <<~SQL.squish
@@ -81,7 +104,7 @@ module PgSqlTriggers
 
         test_trigger_sql = <<~SQL.squish
           CREATE TRIGGER test_validation_trigger
-          BEFORE INSERT ON #{sanitized_table}
+          BEFORE #{test_event} ON #{sanitized_table}
           FOR EACH ROW
           WHEN (#{sanitized_condition})
           EXECUTE FUNCTION #{sanitized_function}();

data/lib/pg_sql_triggers/version.rb

@@ -11,5 +11,5 @@
 # 3. Run: bundle exec rake release
 # See RELEASE.md for detailed release instructions
 module PgSqlTriggers
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/lib/pg_sql_triggers.rb

@@ -9,6 +9,7 @@ module PgSqlTriggers
   class DriftError < Error; end
   class KillSwitchError < Error; end
   class ValidationError < Error; end
+  class UnsafeMigrationError < Error; end
 
   # Configuration
   mattr_accessor :kill_switch_enabled
@@ -35,6 +36,17 @@ module PgSqlTriggers
   mattr_accessor :excluded_tables
   self.excluded_tables = []
 
+  mattr_accessor :allow_unsafe_migrations
+  self.allow_unsafe_migrations = false
+
+  # Drift states
+  DRIFT_STATE_IN_SYNC = "in_sync"
+  DRIFT_STATE_DRIFTED = "drifted"
+  DRIFT_STATE_MANUAL_OVERRIDE = "manual_override"
+  DRIFT_STATE_DISABLED = "disabled"
+  DRIFT_STATE_DROPPED = "dropped"
+  DRIFT_STATE_UNKNOWN = "unknown"
+
   def self.configure
     yield self
   end

data/scripts/generate_coverage_report.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+require "active_support/core_ext/object/blank"
+
+def calculate_file_coverage(lines)
+  return 0.0 if lines.blank?
+
+  relevant_lines = lines.compact
+  return 0.0 if relevant_lines.empty?
+
+  covered = relevant_lines.count { |line| line&.positive? }
+  total = relevant_lines.count
+
+  (covered.to_f / total * 100).round(2)
+end
+
+def extract_file_path(full_path)
+  # Remove workspace root and get relative path
+  workspace_root = Pathname.new(__dir__).parent.realpath
+  file_path = Pathname.new(full_path)
+
+  if file_path.to_s.start_with?(workspace_root.to_s)
+    file_path.relative_path_from(workspace_root).to_s
+  else
+    # Fallback: try to extract relative path
+    full_path.sub(%r{.*/(lib|app)/}, '\1/')
+  end
+end
+
+def parse_coverage_data
+  coverage_dir = Pathname.new(__dir__).parent.join("coverage")
+  resultset_file = coverage_dir.join(".resultset.json")
+  last_run_file = coverage_dir.join(".last_run.json")
+
+  unless resultset_file.exist?
+    puts "Error: Coverage resultset file not found at #{resultset_file}"
+    exit 1
+  end
+
+  resultset_data = JSON.parse(File.read(resultset_file))
+  last_run_file.exist? ? JSON.parse(File.read(last_run_file)) : {}
+
+  # Get the first (and usually only) test suite result
+  test_suite_key = resultset_data.keys.first
+  coverage_data = resultset_data[test_suite_key]["coverage"] || {}
+
+  file_coverage = {}
+  total_lines = 0
+  total_covered = 0
+
+  coverage_data.each do |full_path, file_data|
+    next unless file_data["lines"]
+
+    relative_path = extract_file_path(full_path)
+    # Skip files in spec, vendor, etc.
+    next if relative_path.include?("/spec/") || relative_path.include?("/vendor/")
+
+    lines = file_data["lines"]
+    coverage_percentage = calculate_file_coverage(lines)
+
+    # Count relevant lines (non-nil lines)
+    relevant_lines = lines.compact
+    covered_lines = relevant_lines.count { |line| line&.positive? }
+
+    file_coverage[relative_path] = {
+      percentage: coverage_percentage,
+      total_lines: relevant_lines.count,
+      covered_lines: covered_lines,
+      missed_lines: relevant_lines.count - covered_lines
+    }
+
+    total_lines += relevant_lines.count
+    total_covered += covered_lines
+  end
+
+  total_coverage = total_lines.positive? ? (total_covered.to_f / total_lines * 100).round(2) : 0.0
+
+  {
+    file_coverage: file_coverage.sort_by { |_k, v| -v[:percentage] },
+    total_coverage: total_coverage,
+    total_lines: total_lines,
+    total_covered: total_covered
+  }
+end
+
+def generate_markdown(coverage_info)
+  markdown = "# Code Coverage Report\n\n"
+  markdown += "**Total Coverage: #{coverage_info[:total_coverage]}%**\n\n"
+  markdown += "Covered: #{coverage_info[:total_covered]} / #{coverage_info[:total_lines]} lines\n\n"
+  markdown += "---\n\n"
+  markdown += "## File Coverage\n\n"
+  markdown += "| File | Coverage | Covered Lines | Missed Lines | Total Lines |\n"
+  markdown += "|------|----------|---------------|--------------|-------------|\n"
+
+  coverage_info[:file_coverage].each do |file_path, data|
+    status_icon = if data[:percentage] >= 90
+                    "✅"
+                  else
+                    data[:percentage] >= 70 ? "⚠️" : "❌"
+                  end
+    markdown += "| `#{file_path}` | #{data[:percentage]}% #{status_icon} | " \
+                "#{data[:covered_lines]} | #{data[:missed_lines]} | #{data[:total_lines]} |\n"
+  end
+
+  markdown += "\n---\n\n"
+  markdown += "*Report generated automatically from SimpleCov results*\n"
+  markdown += "*To regenerate: Run `bundle exec rspec` and then `ruby scripts/generate_coverage_report.rb`*\n"
+
+  markdown
+end
+
+# Main execution
+begin
+  coverage_info = parse_coverage_data
+  markdown_content = generate_markdown(coverage_info)
+
+  output_file = Pathname.new(__dir__).parent.join("COVERAGE.md")
+  File.write(output_file, markdown_content)
+
+  puts "Coverage report generated: #{output_file}"
+  puts "Total Coverage: #{coverage_info[:total_coverage]}%"
+rescue StandardError => e
+  puts "Error generating coverage report: #{e.message}"
+  puts e.backtrace.first(5).join("\n")
+  exit 1
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_sql_triggers
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - samaswin87
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-28 00:00:00.000000000 Z
+date: 2025-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -190,6 +190,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
+- COVERAGE.md
 - Goal.md
 - LICENSE
 - README.md
@@ -212,8 +213,10 @@ files:
 - app/views/pg_sql_triggers/shared/_kill_switch_status.html.erb
 - app/views/pg_sql_triggers/tables/index.html.erb
 - app/views/pg_sql_triggers/tables/show.html.erb
+- config/initializers/pg_sql_triggers.rb
 - config/routes.rb
 - db/migrate/20251222000001_create_pg_sql_triggers_tables.rb
+- db/migrate/20251229071916_add_timing_to_pg_sql_triggers_registry.rb
 - docs/README.md
 - docs/api-reference.md
 - docs/configuration.md
@@ -236,6 +239,9 @@ files:
 - lib/pg_sql_triggers.rb
 - lib/pg_sql_triggers/database_introspection.rb
 - lib/pg_sql_triggers/drift.rb
+- lib/pg_sql_triggers/drift/db_queries.rb
+- lib/pg_sql_triggers/drift/detector.rb
+- lib/pg_sql_triggers/drift/reporter.rb
 - lib/pg_sql_triggers/dsl.rb
 - lib/pg_sql_triggers/dsl/trigger_definition.rb
 - lib/pg_sql_triggers/engine.rb
@@ -244,6 +250,9 @@ files:
 - lib/pg_sql_triggers/generator/service.rb
 - lib/pg_sql_triggers/migration.rb
 - lib/pg_sql_triggers/migrator.rb
+- lib/pg_sql_triggers/migrator/pre_apply_comparator.rb
+- lib/pg_sql_triggers/migrator/pre_apply_diff_reporter.rb
+- lib/pg_sql_triggers/migrator/safety_validator.rb
 - lib/pg_sql_triggers/permissions.rb
 - lib/pg_sql_triggers/permissions/checker.rb
 - lib/pg_sql_triggers/registry.rb
@@ -258,6 +267,7 @@ files:
 - lib/pg_sql_triggers/testing/syntax_validator.rb
 - lib/pg_sql_triggers/version.rb
 - lib/tasks/trigger_migrations.rake
+- scripts/generate_coverage_report.rb
 - sig/pg_sql_triggers.rbs
 homepage: https://github.com/samaswin87/pg_sql_triggers
 licenses: