Aggregate error codes by phase of approach

Author: RISCfuture

app/controllers/squadron_pilots_controller.rb

@@ -40,6 +40,7 @@ def show
     @passes = @pilot.passes.where(time: start_date..end_date).order(time: :desc)
     @boarding_rate = calculate_boarding_rate(@passes)
     @error_statistics = calculate_error_statistics(@passes)
+    @error_statistics_by_phase = calculate_error_statistics_by_phase(@passes)
 
     respond_with @pilot
   end
@@ -72,7 +73,21 @@ def calculate_error_statistics(passes)
     end
 
     aggregator = ErrorCodeAggregator.new(all_errors)
-    aggregator.top(5)
+    aggregator.top(3)
+  end
+
+  def calculate_error_statistics_by_phase(passes)
+    all_errors = []
+
+    passes.each do |pass|
+      next if pass.notes.blank?
+
+      parser = RemarksParser.new(pass.notes)
+      all_errors.concat(parser.parse)
+    end
+
+    aggregator = ErrorCodeAggregator.new(all_errors)
+    aggregator.by_phase(3)
   end
 
   def valid_date_params?

app/services/error_code_aggregator.rb

@@ -66,4 +66,26 @@ def aggregate
   # @param n [Integer] The number of top errors to return
   # @return [Array<Hash>] The top N aggregated errors
   def top(n=5) = aggregate.first(n)
+
+  # Aggregates errors by phase, calculating top N errors for each phase.
+  #
+  # @param n [Integer] The number of top errors to return per phase
+  # @param exclude_phases [Array<String>] Phases to exclude from results
+  # @return [Hash] Hash with phase codes as keys and arrays of top errors as values
+  #   Only includes phases that have errors
+  def by_phase(n=3, exclude_phases: %w[AW])
+    @technique_errors.
+        reject { |e| exclude_phases.include?(e.phase) }.
+        group_by(&:phase).
+        transform_values do |phase_errors|
+      ErrorCodeAggregator.new(phase_errors).top(n)
+    end.
+        reject { |_phase, errors| errors.empty? }.
+        sort_by { |phase, _errors| PHASE_ORDER.index(phase) || 999 }.
+        to_h
+  end
+
+  # @api private
+  PHASE_ORDER = %w[X BC IM IC AR TL IW AW].freeze
+  private_constant :PHASE_ORDER
 end

app/views/squadron_pilots/show.json.jbuilder

@@ -11,9 +11,29 @@ end
 
 json.boarding_rate @boarding_rate
 
-json.error_statistics @error_statistics do |stat|
-  json.code stat[:code]
-  json.description t("error_codes.#{stat[:code]}", default: nil)
-  json.score stat[:score]
-  json.count stat[:count]
+json.error_statistics do
+  json.overall @error_statistics do |stat|
+    json.code stat[:code]
+    json.description t("error_codes.#{stat[:code]}", default: nil)
+    json.score stat[:score]
+    json.count stat[:count]
+  end
+
+  if @error_statistics_by_phase.empty?
+    json.by_phase({})
+  else
+    json.by_phase do
+      @error_statistics_by_phase.each do |phase, stats|
+        json.set! phase do
+          json.phase_description t("phase_codes.#{phase}", default: phase)
+          json.errors stats do |stat|
+            json.code stat[:code]
+            json.description t("error_codes.#{stat[:code]}", default: nil)
+            json.score stat[:score]
+            json.count stat[:count]
+          end
+        end
+      end
+    end
+  end
 end

spec/requests/squadron_pilots_request_spec.rb

@@ -102,28 +102,63 @@
         expect(body["boarding_rate"]).to eq(0.5)
       end
 
-      it "returns aggregated error statistics" do
+      it "returns aggregated error statistics with overall top 3" do
         get "/squadrons/#{squadron.to_param}/pilots/#{pilot.to_param}.json?start_date=#{start_date}&end_date=#{end_date}"
 
         body = response.parsed_body
         stats = body["error_statistics"]
 
-        expect(stats).to be_an(Array)
-        expect(stats.length).to be <= 5 # Top 5 only
+        expect(stats).to be_a(Hash)
+        expect(stats).to include("overall", "by_phase")
+
+        overall = stats["overall"]
+        expect(overall).to be_an(Array)
+        expect(overall.length).to be <= 3 # Top 3 only
 
         # LUL should be the top error (appears 3 times with high intensity)
-        lul_stat = stats.find { |s| s["code"] == "LUL" }
+        lul_stat = overall.find { |s| s["code"] == "LUL" }
         expect(lul_stat).not_to be_nil
         expect(lul_stat["description"]).to eq("Lined up left")
         expect(lul_stat["score"]).to eq(6.0) # 3 * 2.0 (high intensity)
         expect(lul_stat["count"]).to eq(3)
       end
 
-      it "sorts error statistics by score descending" do
+      it "returns error statistics grouped by phase" do
         get "/squadrons/#{squadron.to_param}/pilots/#{pilot.to_param}.json?start_date=#{start_date}&end_date=#{end_date}"
 
         body = response.parsed_body
-        stats = body["error_statistics"]
+        by_phase = body["error_statistics"]["by_phase"]
+
+        expect(by_phase).to be_a(Hash)
+
+        # X phase should have LUL and F errors
+        expect(by_phase).to have_key("X")
+        expect(by_phase["X"]["phase_description"]).to eq("At the start")
+        x_errors = by_phase["X"]["errors"]
+        expect(x_errors).to be_an(Array)
+        expect(x_errors.length).to be <= 3
+
+        lul_in_x = x_errors.find { |e| e["code"] == "LUL" }
+        expect(lul_in_x).not_to be_nil
+
+        # IM phase should have LUL and DL errors
+        expect(by_phase).to have_key("IM")
+        expect(by_phase["IM"]["phase_description"]).to eq("In the middle")
+
+        # IC phase should have AFU errors
+        expect(by_phase).to have_key("IC")
+        expect(by_phase["IC"]["phase_description"]).to eq("In close")
+
+        # IW phase should have 3PTS and B errors
+        expect(by_phase).to have_key("IW")
+        expect(by_phase["IW"]["phase_description"]).to eq("In the wires")
+      end
+
+      it "sorts overall error statistics by score descending" do
+        get "/squadrons/#{squadron.to_param}/pilots/#{pilot.to_param}.json?start_date=#{start_date}&end_date=#{end_date}"
+
+        body = response.parsed_body
+        stats = body["error_statistics"]["overall"]
 
         scores = stats.pluck("score")
         expect(scores).to eq(scores.sort.reverse)
@@ -133,9 +168,14 @@
         get "/squadrons/#{squadron.to_param}/pilots/#{pilot.to_param}.json?start_date=#{start_date}&end_date=#{end_date}"
 
         body = response.parsed_body
-        stats = body["error_statistics"]
-
-        expect(stats).to all(include("code", "description", "score", "count"))
+        overall = body["error_statistics"]["overall"]
+        by_phase = body["error_statistics"]["by_phase"]
+
+        expect(overall).to all(include("code", "description", "score", "count"))
+        by_phase.each_value do |phase_data|
+          expect(phase_data).to include("phase_description", "errors")
+          expect(phase_data["errors"]).to all(include("code", "description", "score", "count"))
+        end
       end
     end
 
@@ -148,7 +188,8 @@
 
         expect(body["passes"]).to be_empty
         expect(body["boarding_rate"]).to eq(0.0)
-        expect(body["error_statistics"]).to be_empty
+        expect(body["error_statistics"]["overall"]).to be_empty
+        expect(body["error_statistics"]["by_phase"]).to be_empty
       end
     end
 
@@ -164,7 +205,8 @@
         get "/squadrons/#{squadron.to_param}/pilots/#{pilot.to_param}.json?start_date=#{start_date}&end_date=#{end_date}"
 
         body = response.parsed_body
-        expect(body["error_statistics"]).to be_empty
+        expect(body["error_statistics"]["overall"]).to be_empty
+        expect(body["error_statistics"]["by_phase"]).to be_empty
       end
     end
 
@@ -176,7 +218,8 @@
       expect(response).to have_http_status(:success)
       body = response.parsed_body
       expect(body["passes"].count).to eq(1)
-      expect(body["error_statistics"]).to be_empty
+      expect(body["error_statistics"]["overall"]).to be_empty
+      expect(body["error_statistics"]["by_phase"]).to be_empty
     end
   end
 end

spec/services/error_code_aggregator_spec.rb

@@ -137,6 +137,98 @@
     end
   end
 
+  describe "#by_phase" do
+    it "groups errors by phase and returns top N for each" do
+      errors = [
+          technique_error.new(code: "LUL", intensity: :high, phase: "X", modifiers: []),
+          technique_error.new(code: "F", intensity: :medium, phase: "X", modifiers: []),
+          technique_error.new(code: "H", intensity: :low, phase: "X", modifiers: []),
+          technique_error.new(code: "DR", intensity: :low, phase: "X", modifiers: []),
+          technique_error.new(code: "LUL", intensity: :high, phase: "IM", modifiers: []),
+          technique_error.new(code: "F", intensity: :high, phase: "IM", modifiers: []),
+          technique_error.new(code: "H", intensity: :medium, phase: "IC", modifiers: [])
+      ]
+
+      aggregator = described_class.new(errors)
+      result = aggregator.by_phase(3)
+
+      expect(result.keys).to contain_exactly("X", "IM", "IC")
+
+      # X phase: LUL (2.0), F (1.0), H (0.5), DR (0.5) -> top 3: LUL, F, H
+      expect(result["X"].length).to eq(3)
+      expect(result["X"][0][:code]).to eq("LUL")
+      expect(result["X"][1][:code]).to eq("F")
+      expect(result["X"][2][:code]).to eq("H")
+
+      # IM phase: LUL (2.0), F (2.0)
+      expect(result["IM"].length).to eq(2)
+
+      # IC phase: H (1.0)
+      expect(result["IC"].length).to eq(1)
+      expect(result["IC"][0][:code]).to eq("H")
+    end
+
+    it "excludes AW phase by default" do
+      errors = [
+          technique_error.new(code: "LUL", intensity: :high, phase: "X", modifiers: []),
+          technique_error.new(code: "F", intensity: :high, phase: "AW", modifiers: [])
+      ]
+
+      aggregator = described_class.new(errors)
+      result = aggregator.by_phase(3)
+
+      expect(result.keys).to contain_exactly("X")
+      expect(result).not_to have_key("AW")
+    end
+
+    it "excludes custom phases when specified" do
+      errors = [
+          technique_error.new(code: "LUL", intensity: :high, phase: "X", modifiers: []),
+          technique_error.new(code: "F", intensity: :high, phase: "IM", modifiers: []),
+          technique_error.new(code: "H", intensity: :high, phase: "IC", modifiers: [])
+      ]
+
+      aggregator = described_class.new(errors)
+      result = aggregator.by_phase(3, exclude_phases: %w[AW IM])
+
+      expect(result.keys).to contain_exactly("X", "IC")
+    end
+
+    it "returns phases in correct order" do
+      errors = [
+          technique_error.new(code: "H", intensity: :high, phase: "IC", modifiers: []),
+          technique_error.new(code: "LUL", intensity: :high, phase: "X", modifiers: []),
+          technique_error.new(code: "F", intensity: :high, phase: "IW", modifiers: []),
+          technique_error.new(code: "DR", intensity: :high, phase: "IM", modifiers: [])
+      ]
+
+      aggregator = described_class.new(errors)
+      result = aggregator.by_phase(3)
+
+      expect(result.keys).to eq(%w[X IM IC IW])
+    end
+
+    it "handles nil phase errors" do
+      errors = [
+          technique_error.new(code: "LUL", intensity: :high, phase: "X", modifiers: []),
+          technique_error.new(code: "F", intensity: :high, phase: nil, modifiers: [])
+      ]
+
+      aggregator = described_class.new(errors)
+      result = aggregator.by_phase(3)
+
+      expect(result.keys).to include("X")
+      expect(result.keys).to include(nil)
+    end
+
+    it "handles empty errors array" do
+      aggregator = described_class.new([])
+      result = aggregator.by_phase(3)
+
+      expect(result).to be_empty
+    end
+  end
+
   describe "integration with RemarksParser" do
     it "aggregates errors from parsed remarks" do
       remarks = "GRADE:WO  (DLX)  _LULX_  _LULIM_  (DLIM)  WO(AFU)IC"