Function bodies 125 total

Name: Aljefra Mapper analysis
Creator: Repobility
License: https://repobility.com/legal/terms/

accept_with_alpn function · rust · L54-L68 (15 LOC)

src/proxy/tls.rs

    pub async fn accept_with_alpn<IO>(
        &self,
        stream: IO,
    ) -> Result<(tokio_rustls::server::TlsStream<IO>, Option<Vec<u8>>), ProxyError>
    where
        IO: AsyncRead + AsyncWrite + Unpin,
    {
        let tls_stream = self.inner
            .accept(stream)
            .await
            .map_err(|e| ProxyError::TlsError(format!("TLS accept failed: {}", e)))?;

        let alpn = tls_stream.get_ref().1.alpn_protocol().map(|p| p.to_vec());
        Ok((tls_stream, alpn))
    }

verify_server_cert function · rust · L84-L93 (10 LOC)

src/proxy/tls.rs

        fn verify_server_cert(
            &self,
            _end_entity: &CertificateDer<'_>,
            _intermediates: &[CertificateDer<'_>],
            _server_name: &ServerName<'_>,
            _ocsp: &[u8],
            _now: UnixTime,
        ) -> Result<ServerCertVerified, rustls::Error> {
            Ok(ServerCertVerified::assertion())
        }

verify_tls12_signature function · rust · L94-L102 (9 LOC)

src/proxy/tls.rs

        fn verify_tls12_signature(
            &self,
            _message: &[u8],
            _cert: &CertificateDer<'_>,
            _dss: &DigitallySignedStruct,
        ) -> Result<HandshakeSignatureValid, rustls::Error> {
            Ok(HandshakeSignatureValid::assertion())
        }

verify_tls13_signature function · rust · L103-L111 (9 LOC)

src/proxy/tls.rs

        fn verify_tls13_signature(
            &self,
            _message: &[u8],
            _cert: &CertificateDer<'_>,
            _dss: &DigitallySignedStruct,
        ) -> Result<HandshakeSignatureValid, rustls::Error> {
            Ok(HandshakeSignatureValid::assertion())
        }

supported_verify_schemes function · rust · L112-L125 (14 LOC)

src/proxy/tls.rs

        fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
            vec![
                rustls::SignatureScheme::ECDSA_NISTP256_SHA256,
                rustls::SignatureScheme::ECDSA_NISTP384_SHA384,
                rustls::SignatureScheme::RSA_PKCS1_SHA256,
                rustls::SignatureScheme::RSA_PKCS1_SHA384,
                rustls::SignatureScheme::RSA_PKCS1_SHA512,
                rustls::SignatureScheme::RSA_PSS_SHA256,
                rustls::SignatureScheme::RSA_PSS_SHA384,
                rustls::SignatureScheme::RSA_PSS_SHA512,
                rustls::SignatureScheme::ED25519,
            ]
        }

test_alpn_h2_negotiation function · rust · L129-L170 (42 LOC)

src/proxy/tls.rs

    async fn test_alpn_h2_negotiation() {
        let temp_dir = tempfile::TempDir::new().unwrap();
        let ca = CertificateAuthority::new(
            temp_dir.path().join("ca.crt").to_str().unwrap(),
            temp_dir.path().join("ca.key").to_str().unwrap(),
            true,
            3650,
            365,
        )
        .unwrap();

        let cert = ca.get_cert_for_domain("localhost").await.unwrap();
        let acceptor = TlsAcceptor::from_certified_key(&cert).unwrap();

        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let addr = listener.local_addr().unwrap();

        // Server: accept TLS with ALPN
        let server = tokio::spawn(async move {
            let (stream, _) = listener.accept().await.unwrap();
            let (_, alpn) = acceptor.accept_with_alpn(stream).await.unwrap();
            alpn
        });

        // Client: connect with ALPN [h2, http/1.1]
        let mut config = rustls::ClientConfig::builder()
            .

new function · rust · L26-L74 (49 LOC)

src/rules/header.rs

    pub fn new(rules: Vec<HeaderRule>) -> Result<Self, RuleError> {
        let compiled: Result<Vec<CompiledHeaderRule>, RuleError> = rules
            .into_iter()
            .filter(|r| r.enabled)
            .map(|rule| {
                let url_pattern = Regex::new(&rule.url_pattern)?;

                let operations: Result<Vec<CompiledOperation>, RuleError> = rule
                    .operations
                    .iter()
                    .map(|op| {
                        // For remove action with wildcard support, compile name as regex
                        let name_regex = if op.action == HeaderAction::Remove
                            && (op.name.contains('*') || op.name.contains('?'))
                        {
                            let pattern = op.name.replace('*', ".*").replace('?', ".");
                            Some(Arc::new(Regex::new(&format!("^{}$", pattern))?))
                        } else if op.action == HeaderAction::Modify {

Methodology: Repobility · https://repobility.com/research/state-of-ai-code-2026/

rewrite_request_headers function · rust · L77-L100 (24 LOC)

src/rules/header.rs

    pub fn rewrite_request_headers(
        &self,
        url: &str,
        headers: &mut HashMap<String, String>,
    ) -> Vec<String> {
        let mut applied_rules = Vec::new();

        for compiled in &self.rules {
            if !compiled.rule.apply_to_request {
                continue;
            }

            if compiled.url_pattern.is_match(url) {
                debug!(
                    "Header rule '{}' matched request: {}",
                    compiled.rule.name, url
                );
                self.apply_operations(&compiled.operations, headers);
                applied_rules.push(compiled.rule.name.clone());
            }
        }

        applied_rules
    }

rewrite_response_headers function · rust · L103-L126 (24 LOC)

src/rules/header.rs

    pub fn rewrite_response_headers(
        &self,
        url: &str,
        headers: &mut HashMap<String, String>,
    ) -> Vec<String> {
        let mut applied_rules = Vec::new();

        for compiled in &self.rules {
            if !compiled.rule.apply_to_response {
                continue;
            }

            if compiled.url_pattern.is_match(url) {
                debug!(
                    "Header rule '{}' matched response: {}",
                    compiled.rule.name, url
                );
                self.apply_operations(&compiled.operations, headers);
                applied_rules.push(compiled.rule.name.clone());
            }
        }

        applied_rules
    }

apply_operations function · rust · L129-L203 (75 LOC)

src/rules/header.rs

    fn apply_operations(
        &self,
        operations: &[CompiledOperation],
        headers: &mut HashMap<String, String>,
    ) {
        for compiled_op in operations {
            let op = &compiled_op.operation;

            match op.action {
                HeaderAction::Add => {
                    if let Some(ref value) = op.value {
                        debug!("Adding header: {} = {}", op.name, value);
                        headers.insert(op.name.clone(), value.clone());
                    }
                }
                HeaderAction::Remove => {
                    if let Some(ref name_regex) = compiled_op.name_regex {
                        // Remove headers matching the pattern
                        let keys_to_remove: Vec<_> = headers
                            .keys()
                            .filter(|k| name_regex.is_match(k))
                            .cloned()
                            .collect();

                        for key in keys_to_rem

create_test_rule function · rust · L219-L233 (15 LOC)

src/rules/header.rs

    fn create_test_rule(
        name: &str,
        url_pattern: &str,
        operations: Vec<HeaderOperation>,
    ) -> HeaderRule {
        HeaderRule {
            name: name.to_string(),
            enabled: true,
            url_pattern: url_pattern.to_string(),
            apply_to_request: true,
            apply_to_response: true,
            operations,
        }
    }

test_add_header function · rust · L236-L277 (42 LOC)

src/rules/header.rs

    fn test_add_header() {
        let rules = vec![create_test_rule(
            "add-auth",
            r".*",
            vec![HeaderOperation {
                action: HeaderAction::Add,
                name: "Authorization".to_string(),
                value: Some("Bearer token123".to_string()),
                value_pattern: None,
                replacement: None,
            }],
        )];

        let rewriter = HeaderRewriter::new(rules).unwrap();
        let mut headers = HashMap::new();

        rewriter.rewrite_request_headers("https://api.example.com/test", &mut headers);

        assert_eq!(headers.get("Authorization"), Some(&"Bearer token123".to_string()));
    }

    #[test]
    fn test_remove_header() {
        let rules = vec![create_test_rule(
            "remove-cookie",
            r".*",
            vec![HeaderOperation {
                action: HeaderAction::Remove,
                name: "Cookie".to_string(),
                value: None,
                value_p

test_remove_header function · rust · L258-L305 (48 LOC)

src/rules/header.rs

    fn test_remove_header() {
        let rules = vec![create_test_rule(
            "remove-cookie",
            r".*",
            vec![HeaderOperation {
                action: HeaderAction::Remove,
                name: "Cookie".to_string(),
                value: None,
                value_pattern: None,
                replacement: None,
            }],
        )];

        let rewriter = HeaderRewriter::new(rules).unwrap();
        let mut headers = HashMap::from([("Cookie".to_string(), "session=abc".to_string())]);

        rewriter.rewrite_request_headers("https://api.example.com/test", &mut headers);

        assert!(!headers.contains_key("Cookie"));
    }

    #[test]
    fn test_remove_header_pattern() {
        let rules = vec![create_test_rule(
            "remove-x-headers",
            r".*",
            vec![HeaderOperation {
                action: HeaderAction::Remove,
                name: "X-*".to_string(),
                value: None,
                value_patter

test_remove_header_pattern function · rust · L280-L329 (50 LOC)

src/rules/header.rs

    fn test_remove_header_pattern() {
        let rules = vec![create_test_rule(
            "remove-x-headers",
            r".*",
            vec![HeaderOperation {
                action: HeaderAction::Remove,
                name: "X-*".to_string(),
                value: None,
                value_pattern: None,
                replacement: None,
            }],
        )];

        let rewriter = HeaderRewriter::new(rules).unwrap();
        let mut headers = HashMap::from([
            ("X-Custom-Header".to_string(), "value1".to_string()),
            ("X-Another-Header".to_string(), "value2".to_string()),
            ("Content-Type".to_string(), "application/json".to_string()),
        ]);

        rewriter.rewrite_request_headers("https://api.example.com/test", &mut headers);

        assert!(!headers.contains_key("X-Custom-Header"));
        assert!(!headers.contains_key("X-Another-Header"));
        assert!(headers.contains_key("Content-Type"));
    }

    #[test]
    fn tes

test_modify_header_regex function · rust · L308-L354 (47 LOC)

src/rules/header.rs

    fn test_modify_header_regex() {
        let rules = vec![create_test_rule(
            "modify-ua",
            r".*",
            vec![HeaderOperation {
                action: HeaderAction::Modify,
                name: "User-Agent".to_string(),
                value: None,
                value_pattern: Some(r"Chrome/\d+".to_string()),
                replacement: Some("Chrome/999".to_string()),
            }],
        )];

        let rewriter = HeaderRewriter::new(rules).unwrap();
        let mut headers = HashMap::from([
            ("User-Agent".to_string(), "Mozilla/5.0 Chrome/120 Safari".to_string()),
        ]);

        rewriter.rewrite_request_headers("https://api.example.com/test", &mut headers);

        assert!(headers.get("User-Agent").unwrap().contains("Chrome/999"));
    }

    #[test]
    fn test_url_pattern_match() {
        let rules = vec![create_test_rule(
            "api-only",
            r"https://api\.example\.com/.*",
            vec![HeaderOperation {

Repobility · severity-and-effort ranking · https://repobility.com

new function · rust · L14-L28 (15 LOC)

src/rules/map_local.rs

    pub fn new(rules: Vec<MapLocalRule>) -> Result<Self, RuleError> {
        let compiled: Result<Vec<CompiledRule<MapLocalRule>>, RuleError> = rules
            .into_iter()
            .filter(|r| r.enabled)
            .map(|rule| {
                let pattern = Regex::new(&rule.pattern)?;
                Ok(CompiledRule {
                    rule,
                    pattern: Arc::new(pattern),
                })
            })
            .collect();

        Ok(Self { rules: compiled? })
    }

match_url function · rust · L31-L47 (17 LOC)

src/rules/map_local.rs

    pub fn match_url(&self, url: &str) -> Option<MapLocalMatch> {
        for compiled in &self.rules {
            if compiled.pattern.is_match(url) {
                debug!("Map Local rule '{}' matched: {}", compiled.rule.name, url);

                let local_path = self.resolve_path(url, &compiled.rule, &compiled.pattern);

                return Some(MapLocalMatch {
                    rule_name: compiled.rule.name.clone(),
                    original_url: url.to_string(),
                    local_path,
                    mime_type: compiled.rule.mime_type.clone(),
                });
            }
        }
        None
    }

resolve_path function · rust · L50-L69 (20 LOC)

src/rules/map_local.rs

    fn resolve_path(&self, url: &str, rule: &MapLocalRule, pattern: &Regex) -> String {
        let local_path = &rule.local_path;

        // If the local path contains capture groups, use regex replacement
        if local_path.contains('$') {
            return pattern.replace(url, local_path).to_string();
        }

        // Check if local_path is a directory
        let path = Path::new(local_path);
        if path.is_dir() {
            // Extract the path component from the URL and append to local path
            if let Ok(parsed) = url::Url::parse(url) {
                let url_path = parsed.path().trim_start_matches('/');
                return path.join(url_path).to_string_lossy().to_string();
            }
        }

        local_path.clone()
    }

read_file function · rust · L72-L93 (22 LOC)

src/rules/map_local.rs

    pub async fn read_file(&self, path: &str) -> Result<MapLocalContent, RuleError> {
        let path = Path::new(path);

        if !path.exists() {
            return Ok(MapLocalContent {
                content: Vec::new(),
                mime_type: None,
                exists: false,
            });
        }

        let content = tokio::fs::read(path).await?;
        let mime_type = mime_guess::from_path(path)
            .first()
            .map(|m| m.to_string());

        Ok(MapLocalContent {
            content,
            mime_type,
            exists: true,
        })
    }

test_read_file function · rust · L149-L167 (19 LOC)

src/rules/map_local.rs

    async fn test_read_file() {
        let temp_dir = TempDir::new().unwrap();
        let test_file = temp_dir.path().join("test.txt");
        fs::write(&test_file, "Hello, World!").unwrap();

        let rules = vec![MapLocalRule {
            name: "test".to_string(),
            enabled: true,
            pattern: r".*".to_string(),
            local_path: test_file.to_string_lossy().to_string(),
            mime_type: None,
        }];

        let handler = MapLocalHandler::new(rules).unwrap();
        let content = handler.read_file(test_file.to_str().unwrap()).await.unwrap();

        assert!(content.exists);
        assert_eq!(content.content, b"Hello, World!");
    }

new function · rust · L14-L28 (15 LOC)

src/rules/map_remote.rs

    pub fn new(rules: Vec<MapRemoteRule>) -> Result<Self, RuleError> {
        let compiled: Result<Vec<CompiledRule<MapRemoteRule>>, RuleError> = rules
            .into_iter()
            .filter(|r| r.enabled)
            .map(|rule| {
                let pattern = Regex::new(&rule.pattern)?;
                Ok(CompiledRule {
                    rule,
                    pattern: Arc::new(pattern),
                })
            })
            .collect();

        Ok(Self { rules: compiled? })
    }

match_url function · rust · L31-L54 (24 LOC)

src/rules/map_remote.rs

    pub fn match_url(&self, url: &str) -> Option<MapRemoteMatch> {
        for compiled in &self.rules {
            if compiled.pattern.is_match(url) {
                debug!("Map Remote rule '{}' matched: {}", compiled.rule.name, url);

                let target_url = self.build_target_url(
                    url,
                    &compiled.rule.target,
                    &compiled.pattern,
                    compiled.rule.preserve_path,
                    compiled.rule.preserve_query,
                );

                if let Ok(target) = target_url {
                    return Some(MapRemoteMatch {
                        rule_name: compiled.rule.name.clone(),
                        original_url: url.to_string(),
                        target_url: target,
                    });
                }
            }
        }
        None
    }

build_target_url function · rust · L57-L83 (27 LOC)

src/rules/map_remote.rs

    fn build_target_url(
        &self,
        original_url: &str,
        target: &str,
        pattern: &Regex,
        preserve_path: bool,
        preserve_query: bool,
    ) -> Result<String, RuleError> {
        // If target contains capture groups, use regex replacement
        if target.contains('$') {
            let replaced = pattern.replace(original_url, target);
            return Ok(replaced.to_string());
        }

        let original = Url::parse(original_url)?;
        let mut target = Url::parse(target)?;

        if preserve_path {
            target.set_path(original.path());
        }

        if preserve_query {
            target.set_query(original.query());
        }

        Ok(target.to_string())
    }

Want this analysis on your repo? https://repobility.com/scan/

test_simple_match function · rust · L109-L146 (38 LOC)

src/rules/map_remote.rs

    fn test_simple_match() {
        let rules = vec![MapRemoteRule {
            name: "test".to_string(),
            enabled: true,
            pattern: r"https://api\.example\.com/.*".to_string(),
            target: "https://staging.example.com".to_string(),
            preserve_path: true,
            preserve_query: true,
        }];

        let handler = MapRemoteHandler::new(rules).unwrap();
        let result = handler.match_url("https://api.example.com/users?id=1");

        assert!(result.is_some());
        let matched = result.unwrap();
        assert_eq!(matched.rule_name, "test");
        assert!(matched.target_url.contains("staging.example.com"));
        assert!(matched.target_url.contains("/users"));
    }

    #[test]
    fn test_regex_replacement() {
        let rules = vec![MapRemoteRule {
            name: "version-replace".to_string(),
            enabled: true,
            pattern: r"https://api\.example\.com/v(\d+)/(.*)".to_string(),
            target: "http

test_regex_replacement function · rust · L130-L157 (28 LOC)

src/rules/map_remote.rs

    fn test_regex_replacement() {
        let rules = vec![MapRemoteRule {
            name: "version-replace".to_string(),
            enabled: true,
            pattern: r"https://api\.example\.com/v(\d+)/(.*)".to_string(),
            target: "https://api.example.com/v2/$2".to_string(),
            preserve_path: false,
            preserve_query: true,
        }];

        let handler = MapRemoteHandler::new(rules).unwrap();
        let result = handler.match_url("https://api.example.com/v1/users");

        assert!(result.is_some());
        let matched = result.unwrap();
        assert!(matched.target_url.contains("/v2/users"));
    }

    #[test]
    fn test_disabled_rule() {
        let rules = vec![MapRemoteRule {
            name: "disabled".to_string(),
            enabled: false,
            pattern: r".*".to_string(),
            target: "https://example.com".to_string(),
            preserve_path: true,
            preserve_query: true,
        }];

test_disabled_rule function · rust · L149-L164 (16 LOC)

src/rules/map_remote.rs

    fn test_disabled_rule() {
        let rules = vec![MapRemoteRule {
            name: "disabled".to_string(),
            enabled: false,
            pattern: r".*".to_string(),
            target: "https://example.com".to_string(),
            preserve_path: true,
            preserve_query: true,
        }];

        let handler = MapRemoteHandler::new(rules).unwrap();
        let result = handler.match_url("https://any.url.com/path");

        assert!(result.is_none());
    }
}

new function · rust · L39-L49 (11 LOC)

src/rules/mod.rs

    pub fn new(
        map_remote_rules: Vec<MapRemoteRule>,
        map_local_rules: Vec<MapLocalRule>,
        header_rules: Vec<HeaderRule>,
    ) -> Result<Self, RuleError> {
        Ok(Self {
            map_remote: MapRemoteHandler::new(map_remote_rules)?,
            map_local: MapLocalHandler::new(map_local_rules)?,
            header_rewriter: HeaderRewriter::new(header_rules)?,
        })
    }

new function · rust · L24-L33 (10 LOC)

src/traffic/mod.rs

    pub fn new(max_entries: usize) -> Self {
        let (tx, _) = broadcast::channel(1024);
        Self {
            entries: DashMap::new(),
            entry_order: DashMap::new(),
            counter: AtomicU64::new(0),
            tx,
            max_entries,
        }
    }

create_entry function · rust · L36-L62 (27 LOC)

src/traffic/mod.rs

    pub fn create_entry(&self, request: RequestInfo) -> String {
        let id = Uuid::new_v4().to_string();
        let order = self.counter.fetch_add(1, Ordering::SeqCst);

        let entry = TrafficEntry {
            id: id.clone(),
            order,
            request,
            response: None,
            timing: TimingInfo::new(),
            tags: Vec::new(),
            matched_rules: Vec::new(),
            is_websocket: false,
            websocket_messages: None,
        };

        self.entries.insert(id.clone(), entry.clone());
        self.entry_order.insert(order, id.clone());

        // Clean up old entries if needed
        self.cleanup_old_entries();

        // Broadcast event
        let _ = self.tx.send(TrafficEvent::NewRequest(entry));

        id
    }

set_response function · rust · L65-L71 (7 LOC)

src/traffic/mod.rs

    pub fn set_response(&self, id: &str, response: ResponseInfo) {
        if let Some(mut entry) = self.entries.get_mut(id) {
            entry.response = Some(response);
            entry.timing.response_received = Some(Utc::now());
            let _ = self.tx.send(TrafficEvent::ResponseReceived(entry.clone()));
        }
    }

mark_complete function · rust · L74-L79 (6 LOC)

src/traffic/mod.rs

    pub fn mark_complete(&self, id: &str) {
        if let Some(mut entry) = self.entries.get_mut(id) {
            entry.timing.completed = Some(Utc::now());
            let _ = self.tx.send(TrafficEvent::Completed(entry.clone()));
        }
    }

Repobility (the analyzer behind this table) · https://repobility.com

add_matched_rule function · rust · L82-L89 (8 LOC)

src/traffic/mod.rs

    pub fn add_matched_rule(&self, id: &str, rule_type: &str, rule_name: &str) {
        if let Some(mut entry) = self.entries.get_mut(id) {
            entry.matched_rules.push(MatchedRule {
                rule_type: rule_type.to_string(),
                rule_name: rule_name.to_string(),
            });
        }
    }

list function · rust · L104-L127 (24 LOC)

src/traffic/mod.rs

    pub fn list(&self, offset: usize, limit: usize) -> Vec<TrafficEntry> {
        let current = self.counter.load(Ordering::SeqCst);
        let start = if current > offset as u64 {
            current - offset as u64
        } else {
            0
        };

        let mut entries = Vec::new();
        let mut count = 0;
        let mut order = start;

        while count < limit && order > 0 {
            order -= 1;
            if let Some(id) = self.entry_order.get(&order) {
                if let Some(entry) = self.entries.get(id.value()) {
                    entries.push(entry.clone());
                    count += 1;
                }
            }
        }

        entries
    }

cleanup_old_entries function · rust · L147-L156 (10 LOC)

src/traffic/mod.rs

    fn cleanup_old_entries(&self) {
        while self.entries.len() > self.max_entries {
            let current = self.counter.load(Ordering::SeqCst);
            let oldest = current.saturating_sub(self.max_entries as u64);

            if let Some((_, id)) = self.entry_order.remove(&oldest) {
                self.entries.remove(&id);
            }
        }
    }

create_websocket_entry function · rust · L159-L183 (25 LOC)

src/traffic/mod.rs

    pub fn create_websocket_entry(&self, request: RequestInfo) -> String {
        let id = Uuid::new_v4().to_string();
        let order = self.counter.fetch_add(1, Ordering::SeqCst);

        let entry = TrafficEntry {
            id: id.clone(),
            order,
            request,
            response: None,
            timing: TimingInfo::new(),
            tags: vec!["websocket".to_string()],
            matched_rules: Vec::new(),
            is_websocket: true,
            websocket_messages: Some(Vec::new()),
        };

        self.entries.insert(id.clone(), entry.clone());
        self.entry_order.insert(order, id.clone());

        self.cleanup_old_entries();

        let _ = self.tx.send(TrafficEvent::NewRequest(entry));

        id
    }

record_websocket_message function · rust · L186-L210 (25 LOC)

src/traffic/mod.rs

    pub fn record_websocket_message(
        &self,
        id: &str,
        message: WebSocketMessageInfo,
        max_messages: usize,
    ) {
        let should_broadcast = if let Some(mut entry) = self.entries.get_mut(id) {
            let messages = entry.websocket_messages.get_or_insert_with(Vec::new);
            if messages.len() < max_messages {
                messages.push(message.clone());
                true
            } else {
                false
            }
        } else {
            false
        };

        if should_broadcast {
            let _ = self.tx.send(TrafficEvent::WebSocketMessage {
                entry_id: id.to_string(),
                message,
            });
        }
    }

search function · rust · L213-L227 (15 LOC)

src/traffic/mod.rs

    pub fn search(&self, pattern: &str) -> Vec<TrafficEntry> {
        let regex = regex::Regex::new(pattern).ok();

        self.entries
            .iter()
            .filter(|entry| {
                if let Some(ref re) = regex {
                    re.is_match(&entry.request.url)
                } else {
                    entry.request.url.contains(pattern)
                }
            })
            .map(|entry| entry.clone())
            .collect()
    }

new function · rust · L317-L323 (7 LOC)

src/traffic/mod.rs

    pub fn new() -> Self {
        Self {
            request_received: Utc::now(),
            response_received: None,
            completed: None,
        }
    }

event_type function · rust · L412-L420 (9 LOC)

src/traffic/mod.rs

    pub fn event_type(&self) -> &'static str {
        match self {
            TrafficEvent::NewRequest(_) => "request",
            TrafficEvent::ResponseReceived(_) => "response",
            TrafficEvent::Completed(_) => "completed",
            TrafficEvent::Cleared => "cleared",
            TrafficEvent::WebSocketMessage { .. } => "websocket_message",
        }
    }

Methodology: Repobility · https://repobility.com/research/state-of-ai-code-2026/

entry function · rust · L423-L431 (9 LOC)

src/traffic/mod.rs

    pub fn entry(&self) -> Option<&TrafficEntry> {
        match self {
            TrafficEvent::NewRequest(e) => Some(e),
            TrafficEvent::ResponseReceived(e) => Some(e),
            TrafficEvent::Completed(e) => Some(e),
            TrafficEvent::Cleared => None,
            TrafficEvent::WebSocketMessage { .. } => None,
        }
    }

test_traffic_store function · rust · L439-L481 (43 LOC)

src/traffic/mod.rs

    fn test_traffic_store() {
        let store = TrafficStore::new(100);

        let request = RequestInfo {
            method: "GET".to_string(),
            url: "https://example.com/test".to_string(),
            http_version: "HTTP/1.1".to_string(),
            headers: HashMap::new(),
            body: None,
            body_size: 0,
            client_addr: "127.0.0.1:12345".to_string(),
            host: "example.com".to_string(),
            path: "/test".to_string(),
        };

        let id = store.create_entry(request);
        assert!(store.get(&id).is_some());
        assert_eq!(store.count(), 1);
    }

    #[test]
    fn test_websocket_entry() {
        let store = TrafficStore::new(100);

        let request = RequestInfo {
            method: "GET".to_string(),
            url: "ws://example.com/ws".to_string(),
            http_version: "HTTP/1.1".to_string(),
            headers: HashMap::new(),
            body: None,
            body_size: 0,
            clien

test_websocket_entry function · rust · L460-L516 (57 LOC)

src/traffic/mod.rs

    fn test_websocket_entry() {
        let store = TrafficStore::new(100);

        let request = RequestInfo {
            method: "GET".to_string(),
            url: "ws://example.com/ws".to_string(),
            http_version: "HTTP/1.1".to_string(),
            headers: HashMap::new(),
            body: None,
            body_size: 0,
            client_addr: "127.0.0.1:12345".to_string(),
            host: "example.com".to_string(),
            path: "/ws".to_string(),
        };

        let id = store.create_websocket_entry(request);
        let entry = store.get(&id).unwrap();
        assert!(entry.is_websocket);
        assert_eq!(entry.tags, vec!["websocket"]);
        assert!(entry.websocket_messages.is_some());
        assert_eq!(entry.websocket_messages.unwrap().len(), 0);
    }

    #[test]
    fn test_websocket_message_recording() {
        let store = TrafficStore::new(100);

        let request = RequestInfo {
            method: "GET".to_string(),
            url: "ws

test_websocket_message_recording function · rust · L484-L549 (66 LOC)

src/traffic/mod.rs

    fn test_websocket_message_recording() {
        let store = TrafficStore::new(100);

        let request = RequestInfo {
            method: "GET".to_string(),
            url: "ws://example.com/ws".to_string(),
            http_version: "HTTP/1.1".to_string(),
            headers: HashMap::new(),
            body: None,
            body_size: 0,
            client_addr: "127.0.0.1:12345".to_string(),
            host: "example.com".to_string(),
            path: "/ws".to_string(),
        };

        let id = store.create_websocket_entry(request);

        let msg = WebSocketMessageInfo {
            timestamp: Utc::now(),
            direction: WebSocketDirection::ClientToServer,
            message_type: WebSocketMessageType::Text,
            payload: Some("hello".to_string()),
            payload_size: 5,
        };

        store.record_websocket_message(&id, msg, 1000);

        let entry = store.get(&id).unwrap();
        let messages = entry.websocket_messages.unwrap();

success function · rust · L43-L49 (7 LOC)

src/web/api.rs

    fn success(data: T) -> Json<Self> {
        Json(Self {
            success: true,
            data: Some(data),
            error: None,
        })
    }

api_ok function · rust · L51-L61 (11 LOC)

src/web/api.rs

fn api_ok() -> (StatusCode, Json<ApiResponse<()>>) {
    (
        StatusCode::OK,
        Json(ApiResponse {
            success: true,
            data: None,
            error: None,
        }),
    )
}

api_error function · rust · L62-L72 (11 LOC)

src/web/api.rs

fn api_error(msg: &str) -> (StatusCode, Json<ApiResponse<()>>) {
    (
        StatusCode::INTERNAL_SERVER_ERROR,
        Json(ApiResponse {
            success: false,
            data: None,
            error: Some(msg.to_string()),
        }),
    )
}

serve_js function · rust · L96-L101 (6 LOC)

src/web/mod.rs

async fn serve_js() -> impl IntoResponse {
    Response::builder()
        .header(header::CONTENT_TYPE, "application/javascript")
        .body(include_str!("../../static/app.js").to_string())
        .unwrap()
}

Repobility · severity-and-effort ranking · https://repobility.com

serve_css function · rust · L104-L109 (6 LOC)

src/web/mod.rs

async fn serve_css() -> impl IntoResponse {
    Response::builder()
        .header(header::CONTENT_TYPE, "text/css")
        .body(include_str!("../../static/style.css").to_string())
        .unwrap()
}

initTabs function · javascript · L19-L39 (21 LOC)

static/app.js

function initTabs() {
    const tabs = document.querySelectorAll('.tab');
    tabs.forEach(tab => {
        tab.addEventListener('click', () => {
            tabs.forEach(t => t.classList.remove('active'));
            tab.classList.add('active');

            const tabContents = document.querySelectorAll('.tab-content');
            tabContents.forEach(tc => tc.classList.remove('active'));

            const tabId = tab.dataset.tab + '-tab';
            document.getElementById(tabId).classList.add('active');

            if (tab.dataset.tab === 'rules') {
                loadRules();
            } else if (tab.dataset.tab === 'settings') {
                loadStats();
            }
        });
    });
}

initViewTabs function · javascript · L42-L61 (20 LOC)

static/app.js

function initViewTabs() {
    const viewTabs = document.querySelectorAll('.view-tab');
    viewTabs.forEach(tab => {
        tab.addEventListener('click', () => {
            viewTabs.forEach(t => t.classList.remove('active'));
            tab.classList.add('active');

            currentView = tab.dataset.view;

            const viewContainers = document.querySelectorAll('.view-container');
            viewContainers.forEach(vc => vc.classList.remove('active'));

            document.getElementById(`${currentView}-view`).classList.add('active');

            if (currentView === 'tree') {
                renderTreeView();
            }
        });
    });
}

‹ prevpage 2 / 3next ›