git_game_show 0.1.0

data/lib/git_game_show/version.rb

@@ -0,0 +1,4 @@
+module GitGameShow
+  # Current version of Git Game Show
+  VERSION = "0.1.0"
+end

data/lib/git_game_show.rb

@@ -0,0 +1,49 @@
+require 'git'
+require 'colorize'
+require 'tty-prompt'
+require 'tty-table'
+require 'tty-cursor'
+require 'json'
+require 'eventmachine'
+require 'websocket-eventmachine-server'
+require 'websocket-client-simple'
+require 'thor'
+require 'uri'
+require 'clipboard'
+require 'readline'
+require 'timeout'
+
+# Define module and constants first before loading any other files
+module GitGameShow
+  # VERSION is defined in version.rb
+  
+  # Default configuration
+  DEFAULT_CONFIG = {
+    port: 3030,
+    rounds: 3,
+    question_timeout: 30, # seconds
+    question_display_time: 5, # seconds to show results before next question
+    transition_delay: 5 # seconds between rounds
+  }.freeze
+  
+  # Message types for WebSocket communication
+  module MessageType
+    JOIN_REQUEST = 'join_request'
+    JOIN_RESPONSE = 'join_response'
+    GAME_START = 'game_start'
+    QUESTION = 'question'
+    ANSWER = 'answer'
+    ANSWER_FEEDBACK = 'answer_feedback' # New message type for immediate feedback
+    ROUND_RESULT = 'round_result'
+    SCOREBOARD = 'scoreboard'
+    GAME_END = 'game_end'
+    GAME_RESET = 'game_reset' # New message type for resetting the game
+    CHAT = 'chat'
+  end
+end
+
+# Load all files in the git_game_show directory
+Dir[File.join(__dir__, 'git_game_show', '*.rb')].sort.each { |file| require file }
+
+# Load all mini-games
+Dir[File.join(__dir__, '..', 'mini_games', '*.rb')].sort.each { |file| require file }

data/mini_games/author_quiz.rb

@@ -0,0 +1,142 @@
+module GitGameShow
+  class AuthorQuiz < MiniGame
+    self.name = "Author Quiz"
+    self.description = "Guess which team member made each commit!"
+    self.questions_per_round = 5
+    
+    # Custom timing for this mini-game (overrides default config)
+    def self.question_timeout
+      15 # 15 seconds per question
+    end
+    
+    def self.question_display_time
+      5 # 5 seconds between questions
+    end
+    
+    def generate_questions(repo)
+      # For testing, manually add some questions if we can't get meaningful ones from repo
+      questions = []
+      
+      begin
+        # Get commits from the past year
+        one_year_ago = Time.now - (365 * 24 * 60 * 60) # One year in seconds
+        
+        # Get all commits
+        all_commits = get_all_commits(repo)
+        
+        # Filter commits from the past year, if any
+        commits_from_past_year = all_commits.select do |commit|
+          # Be safe with date parsing
+          begin
+            commit_time = commit.date.is_a?(Time) ? commit.date : Time.parse(commit.date.to_s)
+            commit_time > one_year_ago
+          rescue
+            false # If we can't parse the date, exclude it
+          end
+        end
+        
+        # If we don't have enough commits from the past year, use all commits
+        commits = commits_from_past_year.size >= 10 ? commits_from_past_year : all_commits
+        
+        authors = get_commit_authors(commits)
+        
+        # We need at least 2 authors for this game to be meaningful
+        if authors.size < 2
+          return generate_sample_questions
+        end
+        
+        # Shuffle all commits to ensure randomness, then select commits for questions
+        selected_commits = commits.shuffle.sample(self.class.questions_per_round)
+        
+        selected_commits.each do |commit|
+        # Get the real author
+        correct_author = commit.author.name
+        
+        # Get incorrect options (other authors)
+        incorrect_authors = shuffled_excluding(authors, correct_author).take(3)
+        
+        # Create options array with the correct answer and incorrect ones
+        all_options = ([correct_author] + incorrect_authors).shuffle
+        
+        # Extract the commit message, but handle multi-line messages gracefully
+        message_lines = commit.message.lines.reject(&:empty?)
+        message_preview = message_lines.first&.strip || "No message"
+        
+        # For longer messages, add an indication that there's more
+        if message_lines.size > 1
+          message_preview += "..." 
+        end
+        
+        # Create a more compact question format to avoid overflows
+        # Add proper indentation to the commit message with spaces
+        questions << {
+          question: "Who authored this commit?\n\n   \"#{message_preview}\"",
+          commit_info: "#{commit.sha[0..7]} (#{commit.date.strftime('%b %d, %Y')})",
+          options: all_options,
+          correct_answer: correct_author
+        }
+      end
+      rescue => e
+        # Silently fail and use sample questions instead
+        return generate_sample_questions
+      end
+      
+      # If we couldn't generate enough questions, add sample ones
+      if questions.empty?
+        return generate_sample_questions
+      end
+      
+      questions
+    end
+    
+    def generate_sample_questions
+      # Create sample questions in case the repo doesn't have enough data
+      sample_authors = ["Alice", "Bob", "Charlie", "David", "Emma"]
+      
+      questions = []
+      
+      5.times do |i|
+        correct_author = sample_authors.sample
+        incorrect_authors = sample_authors.reject { |a| a == correct_author }.sample(3)
+        
+        all_options = ([correct_author] + incorrect_authors).shuffle
+        
+        questions << {
+          question: "Who authored this commit?\n\n   \"Sample commit message ##{i+1}\"",
+          commit_info: "abc123#{i} (Jan #{i+1}, 2025)",
+          options: all_options,
+          correct_answer: correct_author
+        }
+      end
+      
+      questions
+    end
+    
+    def evaluate_answers(question, player_answers)
+      results = {}
+      
+      player_answers.each do |player_name, answer_data|
+        answered = answer_data[:answered] || false
+        player_answer = answer_data[:answer]
+        correct = player_answer == question[:correct_answer]
+        
+        points = correct ? 10 : 0
+        
+        # Bonus points for fast answers (if correct)
+        if correct && answer_data[:time_taken] < 5
+          points += 5
+        elsif correct && answer_data[:time_taken] < 10
+          points += 3
+        end
+        
+        results[player_name] = {
+          answer: player_answer,
+          correct: correct,
+          points: points
+        }
+      end
+      
+      results
+    end
+  end
+end

data/mini_games/commit_message_completion.rb

@@ -0,0 +1,205 @@
+module GitGameShow
+  class CommitMessageCompletion < MiniGame
+    self.name = "Complete the Commit"
+    self.description = "Complete the missing part of these commit messages! (20 seconds per question)"
+    self.questions_per_round = 5
+    
+    # Custom timing for this mini-game (20 seconds instead of 15)
+    def self.question_timeout
+      20 # 20 seconds per question
+    end
+    
+    def self.question_display_time
+      5 # 5 seconds between questions
+    end
+    
+    def generate_questions(repo)
+      begin
+        commits = get_all_commits(repo)
+        
+        # Filter commits with message length > 10 characters
+        valid_commits = commits.select { |commit| commit.message.strip.length > 10 }
+        
+        # Fall back to sample questions if not enough valid commits
+        if valid_commits.size < self.class.questions_per_round
+          return generate_sample_questions
+        end
+      rescue => e
+        # If there's any error, fall back to sample questions
+        return generate_sample_questions
+      end
+      
+      questions = []
+      valid_questions = 0
+      attempts = 0
+      max_attempts = 100  # Prevent infinite loops
+      
+      # Keep trying until we have exactly 5 questions or reach max attempts
+      while valid_questions < self.class.questions_per_round && attempts < max_attempts
+        attempts += 1
+        
+        # Get a random commit
+        commit = valid_commits.sample
+        message = commit.message.strip
+        
+        # Split message into beginning and end parts
+        words = message.split(/\s+/)
+        
+        # Skip if too few words
+        if words.size < 4
+          next
+        end
+        
+        # Determine how much to hide (1/3 to 1/2 of words)
+        hide_count = [words.size / 3, 2].max
+        hide_start = rand(0..(words.size - hide_count))
+        hidden_words = words[hide_start...(hide_start + hide_count)]
+        
+        # Replace hidden words with blanks
+        words[hide_start...(hide_start + hide_count)] = ['________'] * hide_count
+        
+        # Create question and actual answer
+        question_text = words.join(' ')
+        correct_answer = hidden_words.join(' ')
+        
+        # Generate incorrect options
+        other_messages = get_commit_messages(valid_commits) - [message]
+        other_messages_parts = []
+        
+        # Get parts of other messages that have similar length
+        other_messages.each do |other_msg|
+          other_words = other_msg.split(/\s+/)
+          if other_words.size >= hide_count
+            part_start = rand(0..(other_words.size - hide_count))
+            other_messages_parts << other_words[part_start...(part_start + hide_count)].join(' ')
+          end
+        end
+        
+        # Only proceed if we have enough options
+        if other_messages_parts.size < 3
+          next
+        end
+        
+        other_options = other_messages_parts.sample(3)
+        
+        # Create options array with the correct answer and incorrect ones
+        all_options = ([correct_answer] + other_options).shuffle
+        
+        # Format consistently with other mini-games
+        questions << {
+          question: "Complete this commit message:\n\n   \"#{question_text}\"",
+          commit_info: "#{commit.sha[0..7]} (#{commit.date.strftime('%b %d, %Y')})",
+          options: all_options,
+          correct_answer: correct_answer
+        }
+        
+        valid_questions += 1
+      end
+      
+      # If we couldn't generate enough questions, fall back to sample questions
+      if questions.size < self.class.questions_per_round
+        return generate_sample_questions
+      end
+      
+      questions
+    end
+    
+    # Generate sample questions when there aren't enough commits
+    def generate_sample_questions
+      questions = []
+      
+      # Sample commit messages that are realistic
+      sample_messages = [
+        {
+          full_message: "Add user authentication with OAuth2 support",
+          blank_text: "Add user __________ with OAuth2 support",
+          missing_part: "authentication",
+          wrong_options: ["registration", "profile", "settings"],
+          sha: "f8c7b3e",
+          date: "Mar 10, 2025"
+        },
+        {
+          full_message: "Fix memory leak in the background worker process",
+          blank_text: "Fix memory __________ in the background worker",
+          missing_part: "leak",
+          wrong_options: ["usage", "allocation", "error"],
+          sha: "2d9a45c",
+          date: "Feb 25, 2025"
+        },
+        {
+          full_message: "Update dependencies to latest stable versions",
+          blank_text: "Update __________ to latest stable versions",
+          missing_part: "dependencies",
+          wrong_options: ["documentation", "configurations", "references"],
+          sha: "7b3e9d1",
+          date: "Mar 5, 2025"
+        },
+        {
+          full_message: "Improve error handling in API response layer",
+          blank_text: "Improve error __________ in API response layer",
+          missing_part: "handling",
+          wrong_options: ["messages", "logging", "codes"],
+          sha: "c4e91a2",
+          date: "Feb 28, 2025"
+        },
+        {
+          full_message: "Add comprehensive test coverage for payment module",
+          blank_text: "Add comprehensive __________ coverage for payment module",
+          missing_part: "test",
+          wrong_options: ["code", "feature", "security"],
+          sha: "9f5d7e3",
+          date: "Mar 15, 2025"
+        }
+      ]
+      
+      # Create a question for each sample
+      self.class.questions_per_round.times do |i|
+        sample = sample_messages[i % sample_messages.size]
+        
+        # Create options array with the correct answer and incorrect ones
+        all_options = ([sample[:missing_part]] + sample[:wrong_options]).shuffle
+        
+        # Format consistently with other mini-games
+        questions << {
+          question: "Complete this commit message:\n\n   \"#{sample[:blank_text]}\"",
+          commit_info: "#{sample[:sha]} (#{sample[:date]})",
+          options: all_options,
+          correct_answer: sample[:missing_part]
+        }
+      end
+      
+      questions
+    end
+    
+    def evaluate_answers(question, player_answers)
+      results = {}
+      
+      player_answers.each do |player_name, answer_data|
+        player_answer = answer_data[:answer]
+        correct = player_answer == question[:correct_answer]
+        
+        points = 0
+        
+        if correct
+          points = 10 # Base points for correct answer
+          
+          # Bonus points for fast answers, adjusted for 20-second time limit
+          time_taken = answer_data[:time_taken] || 20
+          if time_taken < 7  # Increased from 5 to 7 seconds
+            points += 5
+          elsif time_taken < 13  # Increased from 10 to 13 seconds
+            points += 3
+          end
+        end
+        
+        results[player_name] = {
+          answer: player_answer,
+          correct: correct,
+          points: points
+        }
+      end
+      
+      results
+    end
+  end
+end