Add GameTrasactions (Create/Start/End)

This allows us to track which User:
- created a Game
- started a Game,
- made the final winning/losing move to end a Game.

To support this, we now have to pass a User object into the methods that
create, start, and end Games.

Note: For now, I'm keeping the Game#started_at and Game#ended_at
attributes. Though, I may remove these soon since they're redundant at
this point.

Also, fix an inconsistency in the test fixtures where the Game with
Status "Standing By" had a `started_at` value.

Also, fix ConsoleObjectBehaviors mix-in to not try to include has_many
associations as automatic Console objects. Because this gets in the way
of operations performed on the collection, such as `clear`.

app/controllers/games/new/behaviors.rb

@@ -5,14 +5,16 @@ module Games::New::Behaviors
   # :reek:FeatureEnvy
 
   def find_or_create_current_game(settings:)
-    Game.find_or_create_current(settings:).tap { |current_game|
-      if current_game.just_created?
-        DutyRoster.clear
-        WarRoomChannel.broadcast_refresh
+    Game.
+      find_or_create_current(settings:, user: current_user).
+      tap { |current_game|
+        if current_game.just_created?
+          DutyRoster.clear
+          WarRoomChannel.broadcast_refresh
 
-        store_board_settings(current_game)
-      end
-    }
+          store_board_settings(current_game)
+        end
+      }
   end
 
   private

app/models/board.rb

@@ -63,10 +63,10 @@ def pattern
     @pattern ||= Pattern.find_by!(name: settings.name)
   end
 
-  def check_for_victory
+  def check_for_victory(user:)
     return unless game.status_sweep_in_progress?
 
-    all_safe_cells_have_been_revealed? and game.end_in_victory
+    all_safe_cells_have_been_revealed? and game.end_in_victory(user:)
   end
 
   def cells_at(coordinates_array)

app/models/cell/reveal.rb

@@ -49,7 +49,7 @@ def already_revealed?
   end
 
   def start_game_if_standing_by
-    game.start(seed_cell: cell)
+    game.start(seed_cell: cell, user:)
   end
 
   def reveal_cell
@@ -62,7 +62,7 @@ def reveal_cell
   def end_game_in_defeat_if_mine_revealed
     return unless cell.mine?
 
-    game.end_in_defeat
+    game.end_in_defeat(user:)
     throw(:return, self)
   end
 
@@ -74,6 +74,6 @@ def recursively_reveal_neighbors_if_revealed_cell_was_blank
   end
 
   def end_game_in_victory_if_all_safe_cells_revealed
-    board.check_for_victory
+    board.check_for_victory(user:)
   end
 end

app/models/cell/reveal_neighbors.rb

@@ -87,11 +87,11 @@ def reveal_neighbor(neighboring_cell)
   def reveal(neighboring_cell)
     neighboring_cell.reveal
 
-    end_in_defeat if neighboring_cell.mine?
+    end_in_defeat(user:) if neighboring_cell.mine?
   end
 
   def end_in_defeat
-    game.end_in_defeat
+    game.end_in_defeat(user:)
     throw(:return, self)
   end
 
@@ -102,6 +102,6 @@ def recursively_reveal_neighbors(neighboring_cell)
   end
 
   def end_game_in_victory_if_all_safe_cells_revealed
-    board.check_for_victory
+    board.check_for_victory(user:)
   end
 end

app/models/game.rb

@@ -20,7 +20,7 @@
 # @attr bbbvps [Float] The 3BV/s rating of a solved {Board}.
 # @attr efficiency [Float] The ratio of actual clicks vs necessary clicks (3BV)
 #   used to solve the associated {Board}.
-class Game < ApplicationRecord
+class Game < ApplicationRecord # rubocop:disable Metrics/ClassLength
   self.inheritance_column = nil
   self.implicit_order_column = "created_at"
 
@@ -48,6 +48,11 @@ class Game < ApplicationRecord
   has_many :cell_flag_transactions, through: :cells
   has_many :cell_unflag_transactions, through: :cells
 
+  has_many :game_transactions, dependent: :delete_all
+  has_one :game_create_transaction
+  has_one :game_start_transaction
+  has_one :game_end_transaction
+
   has_many :users,
            -> { select("DISTINCT ON(users.id) users.*").order("users.id") },
            through: :cell_transactions
@@ -91,10 +96,11 @@ def self.current(within: DEFAULT_JUST_ENDED_DURATION)
       last
   end
 
-  def self.create_for(...)
-    build_for(...).tap { |new_game|
+  def self.create_for(user:, **)
+    build_for(**).tap { |new_game|
       transaction do
         new_game.save!
+        GameCreateTransaction.create_between(user:, game: new_game)
         new_game.board.on_create
       end
     }
@@ -115,27 +121,30 @@ def display_id = "##{id.to_s.rjust(self.class.display_id_width, "0")}"
 
   # :reek:TooManyStatements
 
-  def start(seed_cell:)
+  def start(seed_cell:, user:)
     return self unless status_standing_by?
 
     transaction do
       touch(:started_at)
+      GameStartTransaction.create_between(user:, game: self)
       board.on_game_start(seed_cell:)
       set_status_sweep_in_progress!
     end
 
     self
   end
 
-  def end_in_victory
-    end_game {
+  def end_in_victory(user:)
+    end_game(user:) {
       set_stats
       set_status_alliance_wins!
     }
   end
 
-  def end_in_defeat
-    end_game { set_status_mines_win! }
+  def end_in_defeat(user:)
+    end_game(user:) {
+      set_status_mines_win!
+    }
   end
 
   def on?
@@ -163,11 +172,12 @@ def board_settings = board&.settings
 
   private
 
-  def end_game
+  def end_game(user:)
     return self if over?
 
     transaction do
       touch(:ended_at)
+      GameEndTransaction.create_between(user:, game: self)
       yield
     end
 
@@ -242,7 +252,7 @@ def reset
       }
     end
 
-    # Like {#reset} but also resets status to "Standing By" and reset mines on
+    # Like {#reset} but also resets status to "Standing By" and resets mines on
     # the {Board}.
     def reset!
       do_reset {
@@ -285,6 +295,7 @@ def do_reset
           bbbvps: nil,
           efficiency: nil)
 
+        game_transactions.clear
         CellTransaction.for_id(cell_transaction_ids).delete_all
 
         yield

app/models/transactions/game_create_transaction.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# GameCreateTransaction is a {GameTransaction} marking which {User} created the
+# associated {Game}.
+class GameCreateTransaction < GameTransaction
+end

app/models/transactions/game_end_transaction.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# GameEndTransaction is a {GameTransaction} marking which {User} made the final
+# move during the associated {Game}.
+class GameEndTransaction < GameTransaction
+end

app/models/transactions/game_start_transaction.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# GameStartTransaction is a {GameTransaction} marking which {User} started the
+# associated {Game}.
+class GameStartTransaction < GameTransaction
+end

app/models/transactions/game_transaction.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# GameTransaction records events transacted by {User}s on a {Game} and when they
+# occurred.
+#
+# @attr type [String] The Subclass name.
+# @attr user_id [Integer] References the {User} involved in this Transaction.
+# @attr game_id [Integer] References the {Game} involved in this Transaction.
+# @attr created_at [DateTime] When this Transaction occurred.
+class GameTransaction < ApplicationRecord
+  self.implicit_order_column = "created_at"
+
+  include AbstractBaseClassBehaviors
+  include ConsoleBehaviors
+
+  as_abstract_class
+
+  belongs_to :user
+  belongs_to :game
+
+  scope :for_user, ->(user) { where(user:) }
+  scope :for_game, ->(game) { where(game:) }
+
+  validates :game, uniqueness: { scope: :type }
+
+  def self.create_between(user:, game:)
+    new(user:, game:).tap(&:save!)
+  end
+
+  def self.exists_between?(user:, game:)
+    for_user(user).for_game(game).exists?
+  end
+
+  # GameTransaction::Console acts like a {GameTransaction} but otherwise handles
+  # IRB Console-specific methods/logic.
+  class Console
+    include ConsoleObjectBehaviors
+
+    private
+
+    def inspect_info
+      [
+        [user.inspect, game.inspect].join(" -> "),
+        I18n.l(created_at, format: :debug),
+      ].join(" @ ")
+    end
+  end
+end

db/migrate/20241112041937_create_game_transactions.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Version: 20241112041937
+class CreateGameTransactions < ActiveRecord::Migration[8.0]
+  def change
+    create_table(:game_transactions) do |t|
+      t.string(:type, null: false, index: true)
+      t.references(
+        :user, type: :uuid, foreign_key: { on_delete: :nullify }, index: true)
+      t.references(
+        :game, null: false, foreign_key: { on_delete: :cascade })
+
+      t.datetime(:created_at, null: false, index: true)
+    end
+
+    add_index(:game_transactions, %i[game_id type], unique: true)
+  end
+end