refactor: use unwrap_or_default instead of unwrap_or_else

Replace unwrap_or_else(Vec::new) with unwrap_or_default() for better
readability and performance.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: unhappychoice

src/domain/services/challenge_generator/challenge_generator.rs

@@ -1,6 +1,5 @@
 use super::{
-    chunk_splitter::ChunkSplitter,
-    code_character_counter::CodeCharacterCounter,
+    chunk_splitter::ChunkSplitter, code_character_counter::CodeCharacterCounter,
     progress_tracker::ProgressTracker,
 };
 use crate::domain::models::{Challenge, CodeChunk, DifficultyLevel};
@@ -40,10 +39,10 @@ impl ChallengeGenerator {
         let mut valid_chunks: Vec<_> = chunks
             .into_iter()
             .filter(|chunk| {
-                !chunk.content.trim().is_empty() &&
-                chunk.start_line > 0 &&
-                chunk.end_line > 0 &&
-                chunk.start_line <= chunk.end_line
+                !chunk.content.trim().is_empty()
+                    && chunk.start_line > 0
+                    && chunk.end_line > 0
+                    && chunk.start_line <= chunk.end_line
             })
             .collect();
 
@@ -56,7 +55,9 @@ impl ChallengeGenerator {
 
         let chunk_challenges: Vec<Challenge> = valid_chunks
             .par_iter()
-            .inspect(|_| { progress_tracker.increment_and_report(progress); })
+            .inspect(|_| {
+                progress_tracker.increment_and_report(progress);
+            })
             .flat_map(|chunk| {
                 let code_char_count = self.character_counter.count_code_characters(chunk);
 
@@ -80,27 +81,27 @@ impl ChallengeGenerator {
         code_char_count: usize,
     ) -> Vec<Challenge> {
         let (_, max_chars) = difficulty.char_limits();
-        
+
         match (difficulty, code_char_count > max_chars) {
             (DifficultyLevel::Zen | DifficultyLevel::Wild, _) | (_, false) => {
                 Challenge::from_chunk(chunk, Some(*difficulty))
                     .map(|challenge| vec![challenge])
-                    .unwrap_or_else(Vec::new)
-            }
-            (_, true) => {
-                self.chunk_splitter.split(chunk, difficulty)
-                    .map(|(truncated_content, adjusted_comment_ranges, end_line)| {
-                        vec![Challenge::from_content_and_chunk(
-                            truncated_content,
-                            chunk,
-                            chunk.start_line,
-                            end_line,
-                            &adjusted_comment_ranges,
-                            Some(*difficulty),
-                        )]
-                    })
-                    .unwrap_or_else(Vec::new)
+                    .unwrap_or_default()
             }
+            (_, true) => self
+                .chunk_splitter
+                .split(chunk, difficulty)
+                .map(|(truncated_content, adjusted_comment_ranges, end_line)| {
+                    vec![Challenge::from_content_and_chunk(
+                        truncated_content,
+                        chunk,
+                        chunk.start_line,
+                        end_line,
+                        &adjusted_comment_ranges,
+                        Some(*difficulty),
+                    )]
+                })
+                .unwrap_or_default(),
         }
     }
 }

src/domain/services/source_code_parser/source_code_parser.rs

@@ -1,7 +1,7 @@
 use crate::domain::models::Language;
 use crate::domain::models::{CodeChunk, ExtractionOptions};
-use crate::domain::services::source_code_parser::ChunkExtractor;
 use crate::domain::services::source_code_parser::parsers::parse_with_thread_local;
+use crate::domain::services::source_code_parser::ChunkExtractor;
 use crate::infrastructure::git::LocalGitRepositoryClient;
 use crate::presentation::game::models::StepType;
 use crate::presentation::game::screens::loading_screen::ProgressReporter;
@@ -45,8 +45,14 @@ impl SourceCodeParser {
                 Self::read_and_parse_file(&git_root, &path, language).into_par_iter()
             })
             .flat_map(|(tree, content, file_path, git_root, language)| {
-                ChunkExtractor::extract_chunks_from_tree(&tree, &content, &file_path, &git_root, language.as_ref())
-                    .unwrap_or(Vec::new())
+                ChunkExtractor::extract_chunks_from_tree(
+                    &tree,
+                    &content,
+                    &file_path,
+                    &git_root,
+                    language.as_ref(),
+                )
+                .unwrap_or_default()
             })
             .collect();
 
@@ -63,9 +69,7 @@ impl SourceCodeParser {
             .first()
             .map(|(first_file, _)| first_file)
             .and_then(|path| LocalGitRepositoryClient::get_repository_root(path))
-            .ok_or_else(|| {
-                GitTypeError::ExtractionFailed("Git repository not found".to_string())
-            })
+            .ok_or_else(|| GitTypeError::ExtractionFailed("Git repository not found".to_string()))
     }
 
     fn filter_and_sort_files(
@@ -111,11 +115,18 @@ impl SourceCodeParser {
         }
     }
 
+    #[allow(clippy::type_complexity)]
     fn read_and_parse_file(
         git_root: &Path,
         file_path: &Path,
         language: Box<dyn Language>,
-    ) -> Option<(tree_sitter::Tree, String, PathBuf, PathBuf, Box<dyn Language>)> {
+    ) -> Option<(
+        tree_sitter::Tree,
+        String,
+        PathBuf,
+        PathBuf,
+        Box<dyn Language>,
+    )> {
         let content = fs::read_to_string(file_path).ok()?;
         let tree = parse_with_thread_local(language.name(), &content)?;