Add PksWrapper to run pks check with JSON output

Shells out to `pks check --output-format json <files>`, parses the
response, and converts violations to PksOffense objects. Handles pks
binary not found gracefully by raising PksBinaryNotFoundError.

Author: martinemde

lib/danger-packwerk.rb

@@ -16,4 +16,5 @@ module DangerPackwerk
   require 'danger-packwerk/update/offenses_formatter'
   require 'danger-packwerk/update/default_formatter'
   require 'danger-packwerk/pks_offense'
+  require 'danger-packwerk/pks_wrapper'
 end

lib/danger-packwerk/pks_wrapper.rb

@@ -0,0 +1,39 @@
+# typed: strict
+
+require 'open3'
+require 'json'
+
+module DangerPackwerk
+  class PksWrapper
+    extend T::Sig
+
+    class PksBinaryNotFoundError < StandardError; end
+
+    sig { params(files: T::Array[String]).returns(T::Array[PksOffense]) }
+    def self.get_offenses_for_files(files)
+      return [] if files.empty?
+
+      stdout, stderr, _status = run_pks_check(files)
+
+      if stderr.include?('command not found') || stderr.include?('No such file or directory')
+        raise PksBinaryNotFoundError, 'pks binary not found. Please install pks to use this feature.'
+      end
+
+      PksOffense.from_json(stdout)
+    end
+
+    sig { params(files: T::Array[String]).returns([String, String, Process::Status]) }
+    def self.run_pks_check(files)
+      require 'shellwords'
+      escaped_files = files.map { |f| Shellwords.escape(f) }.join(' ')
+      command = "pks check --output-format json #{escaped_files}"
+      Open3.capture3(command)
+    end
+
+    sig { returns(T::Boolean) }
+    def self.pks_available?
+      _, _, status = Open3.capture3('which', 'pks')
+      !!status.success?
+    end
+  end
+end

spec/danger_packwerk/pks_wrapper_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+module DangerPackwerk
+  RSpec.describe PksWrapper do
+    let(:plugin) { dangerfile.packwerk }
+
+    let(:valid_json_output) do
+      {
+        'offenses' => [
+          {
+            'violation_type' => 'privacy',
+            'file' => 'packs/my_pack/app/models/user.rb',
+            'line' => 42,
+            'column' => 10,
+            'constant_name' => '::OtherPack::PrivateClass',
+            'referencing_pack_name' => 'packs/my_pack',
+            'defining_pack_name' => 'packs/other_pack',
+            'strict' => false,
+            'message' => 'Privacy violation'
+          }
+        ]
+      }.to_json
+    end
+
+    let(:empty_json_output) do
+      { 'offenses' => [] }.to_json
+    end
+
+    # Use real Process::Status from a successful command for Sorbet compatibility
+    let(:success_status) { `true`; $? }
+    let(:failure_status) { `false`; $? }
+
+    describe '.get_offenses_for_files' do
+      it 'returns empty array when files is empty' do
+        expect(described_class.get_offenses_for_files([])).to eq([])
+      end
+
+      it 'calls pks check with JSON output format' do
+        allow(described_class).to receive(:run_pks_check)
+          .with(['file1.rb', 'file2.rb'])
+          .and_return([valid_json_output, '', success_status])
+
+        described_class.get_offenses_for_files(['file1.rb', 'file2.rb'])
+
+        expect(described_class).to have_received(:run_pks_check).with(['file1.rb', 'file2.rb'])
+      end
+
+      it 'returns PksOffense objects from JSON output' do
+        allow(described_class).to receive(:run_pks_check)
+          .and_return([valid_json_output, '', success_status])
+
+        offenses = described_class.get_offenses_for_files(['file1.rb'])
+
+        expect(offenses.length).to eq(1)
+        expect(offenses.first).to be_a(PksOffense)
+        expect(offenses.first.violation_type).to eq('privacy')
+        expect(offenses.first.file).to eq('packs/my_pack/app/models/user.rb')
+      end
+
+      it 'returns empty array when no violations found' do
+        allow(described_class).to receive(:run_pks_check)
+          .and_return([empty_json_output, '', success_status])
+
+        offenses = described_class.get_offenses_for_files(['file1.rb'])
+
+        expect(offenses).to eq([])
+      end
+
+      it 'raises PksBinaryNotFoundError when pks command not found' do
+        allow(described_class).to receive(:run_pks_check)
+          .and_return(['', 'command not found: pks', failure_status])
+
+        expect do
+          described_class.get_offenses_for_files(['file1.rb'])
+        end.to raise_error(PksWrapper::PksBinaryNotFoundError, /pks binary not found/)
+      end
+
+      it 'raises PksBinaryNotFoundError for No such file error' do
+        allow(described_class).to receive(:run_pks_check)
+          .and_return(['', 'No such file or directory', failure_status])
+
+        expect do
+          described_class.get_offenses_for_files(['file1.rb'])
+        end.to raise_error(PksWrapper::PksBinaryNotFoundError, /pks binary not found/)
+      end
+    end
+
+    describe '.run_pks_check' do
+      it 'executes pks command with proper escaping' do
+        allow(Open3).to receive(:capture3)
+          .with('pks check --output-format json file1.rb file2.rb')
+          .and_return([empty_json_output, '', success_status])
+
+        described_class.run_pks_check(['file1.rb', 'file2.rb'])
+
+        expect(Open3).to have_received(:capture3)
+          .with('pks check --output-format json file1.rb file2.rb')
+      end
+
+      it 'escapes file paths with special characters' do
+        allow(Open3).to receive(:capture3).and_return([empty_json_output, '', success_status])
+
+        described_class.run_pks_check(['file with spaces.rb'])
+
+        expect(Open3).to have_received(:capture3)
+          .with('pks check --output-format json file\\ with\\ spaces.rb')
+      end
+    end
+
+    describe '.pks_available?' do
+      it 'returns true when pks is in PATH' do
+        allow(Open3).to receive(:capture3)
+          .with('which', 'pks')
+          .and_return(['/usr/local/bin/pks', '', success_status])
+
+        expect(described_class.pks_available?).to eq(true)
+      end
+
+      it 'returns false when pks is not in PATH' do
+        allow(Open3).to receive(:capture3)
+          .with('which', 'pks')
+          .and_return(['', '', failure_status])
+
+        expect(described_class.pks_available?).to eq(false)
+      end
+    end
+  end
+end