Add PksOffense struct for pks JSON violations

Create a T::Struct that represents violations from pks JSON output with
fields for violation_type, file, line, column, constant_name, and pack
names. Includes methods for JSON deserialization and compatibility with
the BasicReferenceOffense interface used by existing formatters.

Author: martinemde

lib/danger-packwerk.rb

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

lib/danger-packwerk/pks_offense.rb

@@ -0,0 +1,99 @@
+# typed: strict
+
+require 'json'
+
+module DangerPackwerk
+  #
+  # PksOffense represents a violation from pks JSON output.
+  # It is designed to have a compatible interface with BasicReferenceOffense
+  # so it can be used with the Update::OffensesFormatter.
+  #
+  class PksOffense < T::Struct
+    extend T::Sig
+
+    const :violation_type, String
+    const :file, String
+    const :line, Integer
+    const :column, Integer
+    const :constant_name, String
+    const :referencing_pack_name, String
+    const :defining_pack_name, String
+    const :strict, T::Boolean
+    const :message, String
+
+    # Alias methods for compatibility with BasicReferenceOffense interface
+    sig { returns(String) }
+    def class_name
+      constant_name
+    end
+
+    sig { returns(String) }
+    def type
+      violation_type
+    end
+
+    sig { returns(String) }
+    def to_package_name
+      defining_pack_name
+    end
+
+    sig { returns(String) }
+    def from_package_name
+      referencing_pack_name
+    end
+
+    sig { returns(T::Boolean) }
+    def privacy?
+      violation_type == PRIVACY_VIOLATION_TYPE
+    end
+
+    sig { returns(T::Boolean) }
+    def dependency?
+      violation_type == DEPENDENCY_VIOLATION_TYPE
+    end
+
+    sig { params(other: PksOffense).returns(T::Boolean) }
+    def ==(other)
+      other.constant_name == constant_name &&
+        other.file == file &&
+        other.defining_pack_name == defining_pack_name &&
+        other.violation_type == violation_type
+    end
+
+    sig { params(other: PksOffense).returns(T::Boolean) }
+    def eql?(other)
+      self == other
+    end
+
+    sig { returns(Integer) }
+    def hash
+      [constant_name, file, defining_pack_name, violation_type].hash
+    end
+
+    class << self
+      extend T::Sig
+
+      sig { params(json_string: String).returns(T::Array[PksOffense]) }
+      def from_json(json_string)
+        data = JSON.parse(json_string)
+        offenses = data['offenses'] || []
+        offenses.map { |offense| from_hash(offense) }
+      end
+
+      sig { params(hash: T::Hash[String, T.untyped]).returns(PksOffense) }
+      def from_hash(hash)
+        PksOffense.new(
+          violation_type: hash.fetch('violation_type'),
+          file: hash.fetch('file'),
+          line: hash.fetch('line'),
+          column: hash.fetch('column'),
+          constant_name: hash.fetch('constant_name'),
+          referencing_pack_name: hash.fetch('referencing_pack_name'),
+          defining_pack_name: hash.fetch('defining_pack_name'),
+          strict: hash.fetch('strict', false),
+          message: hash.fetch('message', '')
+        )
+      end
+    end
+  end
+end

spec/danger_packwerk/pks_offense_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+module DangerPackwerk
+  RSpec.describe PksOffense do
+    # PksOffense doesn't need Danger plugin context, but spec_helper includes it
+    let(:plugin) { dangerfile.packwerk }
+    let(:privacy_offense_hash) do
+      {
+        '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: ::OtherPack::PrivateClass is private'
+      }
+    end
+
+    let(:dependency_offense_hash) do
+      {
+        'violation_type' => 'dependency',
+        'file' => 'packs/my_pack/app/services/user_service.rb',
+        'line' => 15,
+        'column' => 5,
+        'constant_name' => '::ThirdPack::SomeConstant',
+        'referencing_pack_name' => 'packs/my_pack',
+        'defining_pack_name' => 'packs/third_pack',
+        'strict' => true,
+        'message' => 'Dependency violation: packs/my_pack does not declare packs/third_pack as a dependency'
+      }
+    end
+
+    describe '.from_hash' do
+      it 'creates a PksOffense from a hash' do
+        offense = described_class.from_hash(privacy_offense_hash)
+
+        expect(offense.violation_type).to eq('privacy')
+        expect(offense.file).to eq('packs/my_pack/app/models/user.rb')
+        expect(offense.line).to eq(42)
+        expect(offense.column).to eq(10)
+        expect(offense.constant_name).to eq('::OtherPack::PrivateClass')
+        expect(offense.referencing_pack_name).to eq('packs/my_pack')
+        expect(offense.defining_pack_name).to eq('packs/other_pack')
+        expect(offense.strict).to eq(false)
+        expect(offense.message).to eq('Privacy violation: ::OtherPack::PrivateClass is private')
+      end
+
+      it 'defaults strict to false when not provided' do
+        hash = privacy_offense_hash.except('strict')
+        offense = described_class.from_hash(hash)
+        expect(offense.strict).to eq(false)
+      end
+
+      it 'defaults message to empty string when not provided' do
+        hash = privacy_offense_hash.except('message')
+        offense = described_class.from_hash(hash)
+        expect(offense.message).to eq('')
+      end
+    end
+
+    describe '.from_json' do
+      it 'parses JSON string with offenses array' do
+        json = {
+          'offenses' => [privacy_offense_hash, dependency_offense_hash]
+        }.to_json
+
+        offenses = described_class.from_json(json)
+
+        expect(offenses.length).to eq(2)
+        expect(offenses[0].violation_type).to eq('privacy')
+        expect(offenses[1].violation_type).to eq('dependency')
+      end
+
+      it 'returns empty array when no offenses key' do
+        json = {}.to_json
+        offenses = described_class.from_json(json)
+        expect(offenses).to eq([])
+      end
+
+      it 'returns empty array when offenses is empty' do
+        json = { 'offenses' => [] }.to_json
+        offenses = described_class.from_json(json)
+        expect(offenses).to eq([])
+      end
+    end
+
+    describe 'BasicReferenceOffense interface compatibility' do
+      let(:offense) { described_class.from_hash(privacy_offense_hash) }
+
+      it 'provides class_name alias for constant_name' do
+        expect(offense.class_name).to eq(offense.constant_name)
+      end
+
+      it 'provides type alias for violation_type' do
+        expect(offense.type).to eq(offense.violation_type)
+      end
+
+      it 'provides to_package_name alias for defining_pack_name' do
+        expect(offense.to_package_name).to eq(offense.defining_pack_name)
+      end
+
+      it 'provides from_package_name alias for referencing_pack_name' do
+        expect(offense.from_package_name).to eq(offense.referencing_pack_name)
+      end
+    end
+
+    describe '#privacy?' do
+      it 'returns true for privacy violations' do
+        offense = described_class.from_hash(privacy_offense_hash)
+        expect(offense.privacy?).to eq(true)
+        expect(offense.dependency?).to eq(false)
+      end
+    end
+
+    describe '#dependency?' do
+      it 'returns true for dependency violations' do
+        offense = described_class.from_hash(dependency_offense_hash)
+        expect(offense.dependency?).to eq(true)
+        expect(offense.privacy?).to eq(false)
+      end
+    end
+
+    describe 'equality' do
+      let(:offense1) { described_class.from_hash(privacy_offense_hash) }
+      let(:offense2) { described_class.from_hash(privacy_offense_hash) }
+      let(:different_offense) { described_class.from_hash(dependency_offense_hash) }
+
+      it 'considers offenses equal when key fields match' do
+        expect(offense1).to eq(offense2)
+        expect(offense1.eql?(offense2)).to eq(true)
+      end
+
+      it 'considers offenses different when key fields differ' do
+        expect(offense1).not_to eq(different_offense)
+        expect(offense1.eql?(different_offense)).to eq(false)
+      end
+
+      it 'produces consistent hash values for equal offenses' do
+        expect(offense1.hash).to eq(offense2.hash)
+      end
+
+      it 'can be used in a Set' do
+        set = Set.new([offense1, offense2, different_offense])
+        expect(set.length).to eq(2)
+      end
+
+      it 'can be used as hash keys' do
+        hash = { offense1 => 'first', offense2 => 'second' }
+        expect(hash.length).to eq(1)
+        expect(hash[offense1]).to eq('second')
+      end
+    end
+  end
+end