fix: rm wasm32 bytes_stream reader impl

Author: zmh-program

src/net/mod.rs

@@ -411,7 +411,6 @@ impl RemoteAnalyzer {
     ) -> Result<ProjectAnalysis> {
         let mut project_analysis = ProjectAnalysis::new(project_name);
 
-        // Use global config to build client for direct downloads
         let client = self.build_global_client()?;
 
         let response = client.get(url).send().await.map_err(|e| {
@@ -428,31 +427,56 @@ impl RemoteAnalyzer {
         let total_size = response.content_length();
         self.progress_hook.on_download_progress(0, total_size);
 
-        let stream = response.bytes_stream();
-        let progress_hook = Arc::clone(&self.progress_hook);
-        let stream_reader = stream::StreamReader::new(
-            stream,
-            Box::new(move |downloaded, total| {
-                progress_hook.on_download_progress(downloaded, total);
-                log::debug!(
-                    "Downloaded: {} bytes of {} total",
-                    downloaded,
-                    total
-                        .map(|t| t.to_string())
-                        .unwrap_or_else(|| "unknown".to_string())
-                );
-            }),
-            total_size,
-        );
-
-        self.progress_hook.on_processing_start("Processing...");
-        stream::process_tarball_stream(
-            stream_reader,
-            &mut project_analysis,
-            &self.filter,
-            self.progress_hook.as_ref(),
-        )
-        .await?;
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            let stream = response.bytes_stream();
+            let progress_hook = Arc::clone(&self.progress_hook);
+            let stream_reader = stream::StreamReader::new(
+                stream,
+                Box::new(move |downloaded, total| {
+                    progress_hook.on_download_progress(downloaded, total);
+                    log::debug!(
+                        "Downloaded: {} bytes of {} total",
+                        downloaded,
+                        total
+                            .map(|t| t.to_string())
+                            .unwrap_or_else(|| "unknown".to_string())
+                    );
+                }),
+                total_size,
+            );
+
+            self.progress_hook.on_processing_start("Processing...");
+            stream::process_tarball_stream(
+                stream_reader,
+                &mut project_analysis,
+                &self.filter,
+                self.progress_hook.as_ref(),
+            )
+            .await?;
+        }
+
+        #[cfg(target_arch = "wasm32")]
+        {
+            let bytes = response.bytes().await.map_err(|e| {
+                crate::core::error::AnalysisError::network(format!(
+                    "Failed to read response bytes: {}",
+                    e
+                ))
+            })?;
+
+            self.progress_hook
+                .on_download_progress(bytes.len() as u64, total_size);
+            self.progress_hook.on_processing_start("Processing...");
+
+            stream::process_tarball(
+                bytes,
+                &mut project_analysis,
+                &self.filter,
+                self.progress_hook.as_ref(),
+            )
+            .await?;
+        }
 
         Ok(project_analysis)
     }

src/net/stream.rs

@@ -173,6 +173,42 @@ impl Read for StreamReader {
     }
 }
 
+pub async fn process_tarball(
+    bytes: bytes::Bytes,
+    project_analysis: &mut ProjectAnalysis,
+    filter: &IntelligentFilter,
+    _progress_hook: &dyn ProgressHook,
+) -> Result<()> {
+    let decoder = GzDecoder::new(Cursor::new(bytes));
+    let mut archive = Archive::new(decoder);
+
+    let entries = archive
+        .entries()
+        .map_err(|e| AnalysisError::archive(format!("Failed to read tar entries: {}", e)))?;
+
+    let mut stats = FilterStats::new();
+
+    for entry in entries {
+        let entry = entry
+            .map_err(|e| AnalysisError::archive(format!("Failed to read tar entry: {}", e)))?;
+
+        if let Ok(metrics) = process_tar_entry_sync(entry, filter, &mut stats) {
+            project_analysis.add_file_metrics(metrics)?;
+        }
+    }
+
+    #[cfg(feature = "cli")]
+    log::info!(
+        "Filter stats: processed {}/{} files ({:.1}% filtered), saved {}",
+        stats.processed,
+        stats.total_entries,
+        stats.filter_ratio() * 100.0,
+        stats.format_bytes_saved()
+    );
+
+    Ok(())
+}
+
 pub async fn process_tarball_stream(
     stream_reader: StreamReader,
     project_analysis: &mut ProjectAnalysis,

src/worker.rs

@@ -4,6 +4,8 @@ use crate::{core::filter::IntelligentFilter, net::RemoteAnalyzer};
 use std::collections::HashMap;
 use wasm_bindgen::prelude::*;
 
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+
 fn console(message: &str) {
     web_sys::console::log_1(&message.into());
 }
@@ -49,6 +51,8 @@ impl Default for AnalysisOptions {
 struct WASMDebugInfo {
     total_languages: usize,
     total_files: usize,
+    spend_time: u64,
+    version: String,
 }
 
 #[derive(serde::Serialize)]
@@ -114,19 +118,24 @@ impl AnalysisOptions {
     }
 }
 
-fn create_wasm_result(analysis: &crate::core::analysis::ProjectAnalysis) -> WASMAnalysisResult {
+fn create_wasm_result(
+    analysis: &crate::core::analysis::ProjectAnalysis,
+    spend_time: u64,
+) -> WASMAnalysisResult {
     WASMAnalysisResult {
         project_name: analysis.project_name.clone(),
         summary: analysis.get_summary(),
         language_statistics: analysis.get_language_statistics(),
         debug_info: WASMDebugInfo {
             total_languages: analysis.language_analyses.len(),
             total_files: analysis.global_metrics.file_count,
+            spend_time,
+            version: VERSION.to_string(),
         },
     }
 }
 
-fn create_error_result(error: AnalysisError, url: String) -> WASMErrorResult {
+fn create_error_result(error: AnalysisError, url: String, spend_time: u64) -> WASMErrorResult {
     let error_type = match error {
         AnalysisError::NetworkError { .. } => "network_error",
         _ => "analysis_error",
@@ -139,6 +148,8 @@ fn create_error_result(error: AnalysisError, url: String) -> WASMErrorResult {
         debug_info: WASMDebugInfo {
             total_languages: 0,
             total_files: 0,
+            spend_time,
+            version: VERSION.to_string(),
         },
     }
 }
@@ -148,6 +159,8 @@ pub async fn analyze_url(url: String, options: JsValue) -> Result<JsValue, JsVal
     let opts: AnalysisOptions = serde_wasm_bindgen::from_value(options)?;
     console(&format!("Starting analysis for URL: {}", url));
 
+    let start_time = std::time::Instant::now();
+
     let mut analyzer = RemoteAnalyzer::new();
     analyzer.set_global_config(opts.to_provider_config());
 
@@ -161,7 +174,7 @@ pub async fn analyze_url(url: String, options: JsValue) -> Result<JsValue, JsVal
 
     let result = match analyzer.analyze_url(&url).await {
         Ok(analysis) => {
-            let result = create_wasm_result(&analysis);
+            let result = create_wasm_result(&analysis, start_time.elapsed().as_secs());
             console(&format!(
                 "Analysis completed successfully for project: {} ({} files, {} languages)",
                 analysis.project_name,
@@ -173,7 +186,7 @@ pub async fn analyze_url(url: String, options: JsValue) -> Result<JsValue, JsVal
         Err(e) => {
             console(&format!("Analysis failed: {}", e));
             console(&format!("Error details - URL: {}, Error: {:?}", url, e));
-            let error_result = create_error_result(e, url);
+            let error_result = create_error_result(e, url, start_time.elapsed().as_secs());
             serde_wasm_bindgen::to_value(&error_result)?
         }
     };