chore: style(controllers/analytics): auto-correct rubocop offenses

Applied rubocop auto-corrections to analytics controllers:
- Add frozen_string_literal comments
- Fix string literals and spacing
- Improve code formatting

Author: Bulletdev

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

@@ -1,54 +1,68 @@
-class Api::V1::Analytics::ChampionsController < Api::V1::BaseController
-  def show
-    player = organization_scoped(Player).find(params[:player_id])
-
-    stats = PlayerMatchStat.where(player: player)
-                          .group(:champion)
-                          .select(
-                            'champion',
-                            'COUNT(*) as games_played',
-                            'SUM(CASE WHEN matches.victory THEN 1 ELSE 0 END) as wins',
-                            'AVG((kills + assists)::float / NULLIF(deaths, 0)) as avg_kda'
-                          )
-                          .joins(:match)
-                          .order('games_played DESC')
-
-    champion_stats = stats.map do |stat|
-      win_rate = stat.games_played.zero? ? 0 : (stat.wins.to_f / stat.games_played)
-      {
-        champion: stat.champion,
-        games_played: stat.games_played,
-        win_rate: win_rate,
-        avg_kda: stat.avg_kda&.round(2) || 0,
-        mastery_grade: calculate_mastery_grade(win_rate, stat.avg_kda)
-      }
-    end
-
-    champion_data = {
-      player: PlayerSerializer.render_as_hash(player),
-      champion_stats: champion_stats,
-      top_champions: champion_stats.take(5),
-      champion_diversity: {
-        total_champions: champion_stats.count,
-        highly_played: champion_stats.count { |c| c[:games_played] >= 10 },
-        average_games: champion_stats.empty? ? 0 : (champion_stats.sum { |c| c[:games_played] } / champion_stats.count.to_f).round(1)
-      }
-    }
-
-    render_success(champion_data)
-  end
-
-  private
-
-  def calculate_mastery_grade(win_rate, avg_kda)
-    score = (win_rate * 100 * 0.6) + ((avg_kda || 0) * 10 * 0.4)
-
-    case score
-    when 80..Float::INFINITY then 'S'
-    when 70...80 then 'A'
-    when 60...70 then 'B'
-    when 50...60 then 'C'
-    else 'D'
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Api
+  module V1
+    module Analytics
+      class ChampionsController < Api::V1::BaseController
+        def show
+          player = organization_scoped(Player).find(params[:player_id])
+
+          stats = PlayerMatchStat.where(player: player)
+                                 .group(:champion)
+                                 .select(
+                                   'champion',
+                                   'COUNT(*) as games_played',
+                                   'SUM(CASE WHEN matches.victory THEN 1 ELSE 0 END) as wins',
+                                   'AVG((kills + assists)::float / NULLIF(deaths, 0)) as avg_kda'
+                                 )
+                                 .joins(:match)
+                                 .order('games_played DESC')
+
+          champion_stats = stats.map do |stat|
+            win_rate = stat.games_played.zero? ? 0 : (stat.wins.to_f / stat.games_played)
+            {
+              champion: stat.champion,
+              games_played: stat.games_played,
+              win_rate: win_rate,
+              avg_kda: stat.avg_kda&.round(2) || 0,
+              mastery_grade: calculate_mastery_grade(win_rate, stat.avg_kda)
+            }
+          end
+
+          champion_data = {
+            player: PlayerSerializer.render_as_hash(player),
+            champion_stats: champion_stats,
+            top_champions: champion_stats.take(5),
+            champion_diversity: {
+              total_champions: champion_stats.count,
+              highly_played: champion_stats.count { |c| c[:games_played] >= 10 },
+              average_games: if champion_stats.empty?
+                               0
+                             else
+                               (champion_stats.sum do |c|
+                                 c[:games_played]
+                               end / champion_stats.count.to_f).round(1)
+                             end
+            }
+          }
+
+          render_success(champion_data)
+        end
+
+        private
+
+        def calculate_mastery_grade(win_rate, avg_kda)
+          score = (win_rate * 100 * 0.6) + ((avg_kda || 0) * 10 * 0.4)
+
+          case score
+          when 80..Float::INFINITY then 'S'
+          when 70...80 then 'A'
+          when 60...70 then 'B'
+          when 50...60 then 'C'
+          else 'D'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,49 +1,57 @@
-class Api::V1::Analytics::KdaTrendController < Api::V1::BaseController
-  def show
-    player = organization_scoped(Player).find(params[:player_id])
-
-    # Get recent matches for the player
-    stats = PlayerMatchStat.joins(:match)
-                          .where(player: player, matches: { organization_id: current_organization.id })
-                          .order('matches.game_start DESC')
-                          .limit(50)
-                          .includes(:match)
-
-    trend_data = {
-      player: PlayerSerializer.render_as_hash(player),
-      kda_by_match: stats.map do |stat|
-        kda = stat.deaths.zero? ? (stat.kills + stat.assists).to_f : ((stat.kills + stat.assists).to_f / stat.deaths)
-        {
-          match_id: stat.match.id,
-          date: stat.match.game_start,
-          kills: stat.kills,
-          deaths: stat.deaths,
-          assists: stat.assists,
-          kda: kda.round(2),
-          champion: stat.champion,
-          victory: stat.match.victory
-        }
-      end,
-      averages: {
-        last_10_games: calculate_kda_average(stats.limit(10)),
-        last_20_games: calculate_kda_average(stats.limit(20)),
-        overall: calculate_kda_average(stats)
-      }
-    }
-
-    render_success(trend_data)
-  end
-
-  private
-
-  def calculate_kda_average(stats)
-    return 0 if stats.empty?
-
-    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
-end
+# frozen_string_literal: true
+
+module Api
+  module V1
+    module Analytics
+      class KdaTrendController < Api::V1::BaseController
+        def show
+          player = organization_scoped(Player).find(params[:player_id])
+
+          # Get recent matches for the player
+          stats = PlayerMatchStat.joins(:match)
+                                 .where(player: player, matches: { organization_id: current_organization.id })
+                                 .order('matches.game_start DESC')
+                                 .limit(50)
+                                 .includes(:match)
+
+          trend_data = {
+            player: PlayerSerializer.render_as_hash(player),
+            kda_by_match: stats.map do |stat|
+              kda = stat.deaths.zero? ? (stat.kills + stat.assists).to_f : ((stat.kills + stat.assists).to_f / stat.deaths)
+              {
+                match_id: stat.match.id,
+                date: stat.match.game_start,
+                kills: stat.kills,
+                deaths: stat.deaths,
+                assists: stat.assists,
+                kda: kda.round(2),
+                champion: stat.champion,
+                victory: stat.match.victory
+              }
+            end,
+            averages: {
+              last_10_games: calculate_kda_average(stats.limit(10)),
+              last_20_games: calculate_kda_average(stats.limit(20)),
+              overall: calculate_kda_average(stats)
+            }
+          }
+
+          render_success(trend_data)
+        end
+
+        private
+
+        def calculate_kda_average(stats)
+          return 0 if stats.empty?
+
+          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
+      end
+    end
+  end
+end

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

@@ -1,61 +1,70 @@
-class Api::V1::Analytics::LaningController < Api::V1::BaseController
-  def show
-    player = organization_scoped(Player).find(params[:player_id])
-
-    stats = PlayerMatchStat.joins(:match)
-                          .where(player: player, match: { organization: current_organization })
-                          .order('matches.game_start DESC')
-                          .limit(20)
-
-    laning_data = {
-      player: PlayerSerializer.render_as_hash(player),
-      cs_performance: {
-        avg_cs_total: stats.average('minions_killed + jungle_minions_killed')&.round(1),
-        avg_cs_per_min: calculate_avg_cs_per_min(stats),
-        best_cs_game: stats.maximum('minions_killed + jungle_minions_killed'),
-        worst_cs_game: stats.minimum('minions_killed + jungle_minions_killed')
-      },
-      gold_performance: {
-        avg_gold: stats.average(:gold_earned)&.round(0),
-        best_gold_game: stats.maximum(:gold_earned),
-        worst_gold_game: stats.minimum(:gold_earned)
-      },
-      cs_by_match: stats.map do |stat|
-        match_duration_mins = stat.match.game_duration ? stat.match.game_duration / 60.0 : 25
-        cs_total = (stat.minions_killed || 0) + (stat.jungle_minions_killed || 0)
-        cs_per_min = cs_total / match_duration_mins
-
-        {
-          match_id: stat.match.id,
-          date: stat.match.game_start,
-          cs_total: cs_total,
-          cs_per_min: cs_per_min.round(1),
-          gold: stat.gold_earned,
-          champion: stat.champion,
-          victory: stat.match.victory
-        }
-      end
-    }
-
-    render_success(laning_data)
-  end
-
-  private
-
-  def calculate_avg_cs_per_min(stats)
-    total_cs = 0
-    total_minutes = 0
-
-    stats.each do |stat|
-      if stat.match.game_duration
-        cs = (stat.minions_killed || 0) + (stat.jungle_minions_killed || 0)
-        minutes = stat.match.game_duration / 60.0
-        total_cs += cs
-        total_minutes += minutes
-      end
-    end
-
-    return 0 if total_minutes.zero?
-    (total_cs / total_minutes).round(1)
-  end
-end
+# frozen_string_literal: true
+
+module Api
+  module V1
+    module Analytics
+      class LaningController < Api::V1::BaseController
+        def show
+          player = organization_scoped(Player).find(params[:player_id])
+
+          stats = PlayerMatchStat.joins(:match)
+                                 .where(player: player, match: { organization: current_organization })
+                                 .order('matches.game_start DESC')
+                                 .limit(20)
+
+          laning_data = {
+            player: PlayerSerializer.render_as_hash(player),
+            cs_performance: {
+              avg_cs_total: stats.average('minions_killed + jungle_minions_killed')&.round(1),
+              avg_cs_per_min: calculate_avg_cs_per_min(stats),
+              best_cs_game: stats.maximum('minions_killed + jungle_minions_killed'),
+              worst_cs_game: stats.minimum('minions_killed + jungle_minions_killed')
+            },
+            gold_performance: {
+              avg_gold: stats.average(:gold_earned)&.round(0),
+              best_gold_game: stats.maximum(:gold_earned),
+              worst_gold_game: stats.minimum(:gold_earned)
+            },
+            cs_by_match: stats.map do |stat|
+              match_duration_mins = stat.match.game_duration ? stat.match.game_duration / 60.0 : 25
+              cs_total = (stat.minions_killed || 0) + (stat.jungle_minions_killed || 0)
+              cs_per_min = cs_total / match_duration_mins
+
+              {
+                match_id: stat.match.id,
+                date: stat.match.game_start,
+                cs_total: cs_total,
+                cs_per_min: cs_per_min.round(1),
+                gold: stat.gold_earned,
+                champion: stat.champion,
+                victory: stat.match.victory
+              }
+            end
+          }
+
+          render_success(laning_data)
+        end
+
+        private
+
+        def calculate_avg_cs_per_min(stats)
+          total_cs = 0
+          total_minutes = 0
+
+          stats.each do |stat|
+            next unless stat.match.game_duration
+
+            cs = (stat.minions_killed || 0) + (stat.jungle_minions_killed || 0)
+            minutes = stat.match.game_duration / 60.0
+            total_cs += cs
+            total_minutes += minutes
+          end
+
+          return 0 if total_minutes.zero?
+
+          (total_cs / total_minutes).round(1)
+        end
+      end
+    end
+  end
+end