refactor(api): improve team comparison API controller code quality

Refactored the Api::V1::Analytics::TeamComparisonController to:
- Reduce method complexity (AbcSize, CyclomaticComplexity)
- Break down large methods into smaller, single-responsibility methods
- Add comprehensive class documentation
- Extract filtering logic into dedicated methods
- Improve code readability and maintainability
- Fix all MultilineBlockChain violations

Changes:
- Split build_matches_query into focused filter methods
- Create dedicated helper methods for date range handling
- Extract player statistics building into separate methods
- Reduce method length from 13 to <10 lines each
- Add predicate methods for better readability (date_range_params?)

Author: Bulletdev

app/controllers/api/v1/analytics/team_comparison_controller.rb

@@ -1,118 +1,151 @@
-class Api::V1::Analytics::TeamComparisonController < Api::V1::BaseController
-  def index
-    players = organization_scoped(Player).active.includes(:player_match_stats)
-    matches = build_matches_query
-
-    comparison_data = build_comparison_data(players, matches)
-
-    render json: { data: comparison_data }
-  end
-
-  private
-
-  def build_matches_query
-    matches = organization_scoped(Match)
-
-    matches = apply_date_filter(matches)
-
-    matches = matches.where(opponent_team_id: params[:opponent_team_id]) if params[:opponent_team_id].present?
-
-    matches = matches.where(match_type: params[:match_type]) if params[:match_type].present?
-
-    matches
-  end
-
-  def apply_date_filter(matches)
-    if params[:start_date].present? && params[:end_date].present?
-      matches.in_date_range(params[:start_date], params[:end_date])
-    elsif params[:days].present?
-      matches.recent(params[:days].to_i)
-    else
-      matches.recent(30)
-    end
-  end
-
-  def build_comparison_data(players, matches)
-    {
-      players: build_player_comparisons(players, matches),
-      team_averages: calculate_team_averages(matches),
-      role_rankings: calculate_role_rankings(players, matches)
-    }
-  end
-
-  def build_player_comparisons(players, matches)
-    players.map do |player|
-      build_player_stats(player, matches)
-    end.compact.sort_by { |p| -p[:avg_performance_score] }
-  end
-
-  def build_player_stats(player, matches)
-    stats = PlayerMatchStat.where(player: player, match: matches)
-    return nil if stats.empty?
-
-    {
-      player: PlayerSerializer.render_as_hash(player),
-      games_played: stats.count,
-      kda: calculate_kda(stats),
-      avg_damage: stats.average(:damage_dealt_total)&.round(0) || 0,
-      avg_gold: stats.average(:gold_earned)&.round(0) || 0,
-      avg_cs: stats.average(:cs)&.round(1) || 0,
-      avg_vision_score: stats.average(:vision_score)&.round(1) || 0,
-      avg_performance_score: stats.average(:performance_score)&.round(1) || 0,
-      multikills: build_multikills(stats)
-    }
-  end
-
-  def build_multikills(stats)
-    {
-      double: stats.sum(:double_kills),
-      triple: stats.sum(:triple_kills),
-      quadra: stats.sum(:quadra_kills),
-      penta: stats.sum(:penta_kills)
-    }
-  end
-
-  def calculate_kda(stats)
-    total_kills = stats.sum(:kills)
-    total_deaths = stats.sum(:deaths)
-    total_assists = stats.sum(:assists)
-
-    deaths = total_deaths.zero? ? 1 : total_deaths
-    ((total_kills + total_assists).to_f / deaths).round(2)
-  end
-
-  def calculate_team_averages(matches)
-    all_stats = PlayerMatchStat.where(match: matches)
-
-    {
-      avg_kda: calculate_kda(all_stats),
-      avg_damage: all_stats.average(:damage_dealt_total)&.round(0) || 0,
-      avg_gold: all_stats.average(:gold_earned)&.round(0) || 0,
-      avg_cs: all_stats.average(:cs)&.round(1) || 0,
-      avg_vision_score: all_stats.average(:vision_score)&.round(1) || 0
-    }
-  end
-
-  def calculate_role_rankings(players, matches)
-    rankings = {}
-
-    %w[top jungle mid adc support].each do |role|
-      role_players = players.where(role: role)
-      role_data = role_players.map do |player|
-        stats = PlayerMatchStat.where(player: player, match: matches)
-        next if stats.empty?
-
-        {
-          player_id: player.id,
-          summoner_name: player.summoner_name,
-          avg_performance: stats.average(:performance_score)&.round(1) || 0,
-          games: stats.count
-        }
-      end.compact.sort_by { |p| -p[:avg_performance] }
-
-      rankings[role] = role_data
-    end
-
-    rankings
-  end
-end
+# frozen_string_literal: true
+
+module Api
+  module V1
+    module Analytics
+      # API Controller for team performance comparison and analytics
+      # Provides endpoints to compare player statistics, team averages, and role rankings
+      # with advanced filtering options
+      class TeamComparisonController < Api::V1::BaseController
+        def index
+          players = fetch_active_players
+          matches = build_matches_query
+
+          comparison_data = build_comparison_data(players, matches)
+
+          render json: { data: comparison_data }
+        end
+
+        private
+
+        def fetch_active_players
+          organization_scoped(Player).active.includes(:player_match_stats)
+        end
+
+        def build_matches_query
+          matches = organization_scoped(Match)
+          matches = apply_date_filter(matches)
+          matches = apply_opponent_filter(matches)
+          apply_match_type_filter(matches)
+        end
+
+        def apply_date_filter(matches)
+          return matches.in_date_range(params[:start_date], params[:end_date]) if date_range_params?
+          return matches.recent(params[:days].to_i) if params[:days].present?
+
+          matches.recent(30)
+        end
+
+        def date_range_params?
+          params[:start_date].present? && params[:end_date].present?
+        end
+
+        def apply_opponent_filter(matches)
+          return matches unless params[:opponent_team_id].present?
+
+          matches.where(opponent_team_id: params[:opponent_team_id])
+        end
+
+        def apply_match_type_filter(matches)
+          return matches unless params[:match_type].present?
+
+          matches.where(match_type: params[:match_type])
+        end
+
+        def build_comparison_data(players, matches)
+          {
+            players: build_player_comparisons(players, matches),
+            team_averages: calculate_team_averages(matches),
+            role_rankings: calculate_role_rankings(players, matches)
+          }
+        end
+
+        def build_player_comparisons(players, matches)
+          player_stats = players.map { |player| build_player_stats(player, matches) }
+          sorted_stats = player_stats.compact
+          sorted_stats.sort_by { |p| -p[:avg_performance_score] }
+        end
+
+        def build_player_stats(player, matches)
+          stats = PlayerMatchStat.where(player: player, match: matches)
+          return nil if stats.empty?
+
+          {
+            player: PlayerSerializer.render_as_hash(player),
+            games_played: stats.count,
+            kda: calculate_kda(stats),
+            avg_damage: calculate_average(stats, :damage_dealt_total, 0),
+            avg_gold: calculate_average(stats, :gold_earned, 0),
+            avg_cs: calculate_average(stats, :cs, 1),
+            avg_vision_score: calculate_average(stats, :vision_score, 1),
+            avg_performance_score: calculate_average(stats, :performance_score, 1),
+            multikills: build_multikills(stats)
+          }
+        end
+
+        def calculate_average(stats, column, precision)
+          stats.average(column)&.round(precision) || 0
+        end
+
+        def build_multikills(stats)
+          {
+            double: stats.sum(:double_kills),
+            triple: stats.sum(:triple_kills),
+            quadra: stats.sum(:quadra_kills),
+            penta: stats.sum(:penta_kills)
+          }
+        end
+
+        def calculate_kda(stats)
+          total_kills = stats.sum(:kills)
+          total_deaths = stats.sum(:deaths)
+          total_assists = stats.sum(:assists)
+
+          deaths = total_deaths.zero? ? 1 : total_deaths
+          ((total_kills + total_assists).to_f / deaths).round(2)
+        end
+
+        def calculate_team_averages(matches)
+          all_stats = PlayerMatchStat.where(match: matches)
+
+          {
+            avg_kda: calculate_kda(all_stats),
+            avg_damage: calculate_average(all_stats, :damage_dealt_total, 0),
+            avg_gold: calculate_average(all_stats, :gold_earned, 0),
+            avg_cs: calculate_average(all_stats, :cs, 1),
+            avg_vision_score: calculate_average(all_stats, :vision_score, 1)
+          }
+        end
+
+        def calculate_role_rankings(players, matches)
+          rankings = {}
+
+          %w[top jungle mid adc support].each do |role|
+            rankings[role] = calculate_role_ranking(players, matches, role)
+          end
+
+          rankings
+        end
+
+        def calculate_role_ranking(players, matches, role)
+          role_players = players.where(role: role)
+          role_data = role_players.map { |player| build_role_player_data(player, matches) }
+          sorted_data = role_data.compact
+          sorted_data.sort_by { |p| -p[:avg_performance] }
+        end
+
+        def build_role_player_data(player, matches)
+          stats = PlayerMatchStat.where(player: player, match: matches)
+          return nil if stats.empty?
+
+          {
+            player_id: player.id,
+            summoner_name: player.summoner_name,
+            avg_performance: stats.average(:performance_score)&.round(1) || 0,
+            games: stats.count
+          }
+        end
+      end
+    end
+  end
+end

config.ru

@@ -1,6 +1,8 @@
-# This file is used by Rack-based servers to start the application.
-
-require_relative "config/environment"
-
-run Rails.application
-Rails.application.load_server
+# frozen_string_literal: true
+
+# This file is used by Rack-based servers to start the application.
+
+require_relative 'config/environment'
+
+run Rails.application
+Rails.application.load_server