final glob

Author: SydneyBao

packages/flutter_tools/lib/src/web/devfs_proxy.dart

@@ -2,16 +2,22 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import 'package:glob/glob.dart';
 import 'package:yaml/yaml.dart';
 import '../base/logger.dart';
 
+bool _twoCanHandle(bool a, bool b, bool c) {
+  return (a && b) || (a && c) || (b && c);
+}
+
 /// Represents a rule for proxying requests based on a specific pattern.
 /// Subclasses must implement the [matches], [replace], and [getTargetUri] methods.
 sealed class ProxyRule {
   static const _kLogEntryPrefix = '[ProxyRule]';
   static const _kTarget = 'target';
   static const _kRegex = 'regex';
   static const _kPrefix = 'prefix';
+  static const _kSource = 'source';
   static const _kReplace = 'replace';
 
   /// Checks if the given [path] matches the rule's pattern.
@@ -27,16 +33,22 @@ sealed class ProxyRule {
   /// If both or neither 'prefix' and 'regex' are defined, it logs an error and returns null.
   /// Otherwise, it tries to create a [PrefixProxyRule] or [RegexProxyRule] based on the [yaml] keys.
   static ProxyRule? fromYaml(YamlMap yaml, Logger logger) {
-    if (PrefixProxyRule.canHandle(yaml) && RegexProxyRule.canHandle(yaml)) {
+    if (_twoCanHandle(
+      PrefixProxyRule.canHandle(yaml),
+      RegexProxyRule.canHandle(yaml),
+      SourceProxyRule.canHandle(yaml),
+    )) {
       logger.printError(
-        '$_kLogEntryPrefix Both $_kPrefix and $_kRegex are defined in the proxy rule YAML.'
+        '$_kLogEntryPrefix Multiple patterns ($_kPrefix, $_kRegex, $_kSource) are defined in the proxy rule YAML.'
         ' Only one should be used.',
       );
       return null;
     } else if (PrefixProxyRule.canHandle(yaml)) {
       return PrefixProxyRule.fromYaml(yaml, logger);
     } else if (RegexProxyRule.canHandle(yaml)) {
       return RegexProxyRule.fromYaml(yaml, logger);
+    } else if (SourceProxyRule.canHandle(yaml)) {
+      return SourceProxyRule.fromYaml(yaml, logger);
     } else {
       logger.printError('$_kLogEntryPrefix Invalid proxy rule in YAML: $yaml');
       return null;
@@ -172,3 +184,54 @@ class PrefixProxyRule extends RegexProxyRule {
     return PrefixProxyRule(prefix: prefix, target: target, replacement: replacement?.trim());
   }
 }
+
+/// A [ProxyRule] implementation that uses glob syntax for matching and
+/// replacement.
+///
+/// This rule matches paths against a provided glob syntax [_source].
+/// If a [_replacement] string is provided, it replaces parts of the matched
+/// path based on regex group capturing.
+class SourceProxyRule extends RegexProxyRule {
+  /// Creates a [SourceProxyRule] with the given glob [source],
+  /// [target] URI base, and optional [replacement] string.
+  SourceProxyRule({required Glob source, required super.target, super.replacement})
+    : _source = source,
+      super(pattern: RegExp(RegExp.escape(source.pattern)));
+  final Glob _source;
+
+  @override
+  bool matches(String path) {
+    return _source.matches(path);
+  }
+
+  @override
+  String toString() {
+    return '{${ProxyRule._kSource}: ${_source.pattern}, ${ProxyRule._kTarget}: $_target, ${ProxyRule._kReplace}: ${_replacement ?? 'null'}}';
+  }
+
+  /// Checks if the given [yaml] can be handled by this rule.
+  /// It requires the 'source' key to be present and non-empty.
+  static bool canHandle(YamlMap yaml) {
+    return yaml.containsKey(ProxyRule._kSource) &&
+        yaml[ProxyRule._kSource] is String &&
+        (yaml[ProxyRule._kSource] as String).isNotEmpty;
+  }
+
+  /// Attempts to create a [SourceProxyRule] from the provided [yaml] map.
+  /// If the 'source' or 'target' keys are missing or invalid, it logs an error
+  /// and returns null.
+  static SourceProxyRule? fromYaml(YamlMap yaml, Logger effectiveLogger) {
+    final source = yaml[ProxyRule._kSource] as String?;
+    final target = yaml[ProxyRule._kTarget] as String?;
+    final replacement = yaml[ProxyRule._kReplace] as String?;
+    if (source == null || source.isEmpty) {
+      return null;
+    } else if (target == null || target.isEmpty) {
+      effectiveLogger.printError(
+        '${ProxyRule._kLogEntryPrefix} Invalid ${ProxyRule._kTarget} for ${ProxyRule._kSource}: $source. ${ProxyRule._kTarget} cannot be null',
+      );
+      return null;
+    }
+    return SourceProxyRule(source: Glob(source), target: target, replacement: replacement?.trim());
+  }
+}

packages/flutter_tools/test/general.shard/web/proxy_test.dart

@@ -6,6 +6,7 @@ import 'dart:async';
 import 'package:flutter_tools/src/base/logger.dart';
 import 'package:flutter_tools/src/isolated/proxy_middleware.dart';
 import 'package:flutter_tools/src/web/devfs_proxy.dart';
+import 'package:glob/glob.dart';
 import 'package:shelf/shelf.dart';
 import 'package:test/test.dart';
 import 'package:yaml/yaml.dart';
@@ -291,6 +292,81 @@ void main() {
     });
   });
 
+  group('SourceProxyRule', () {
+    test('canHandle returns true for valid source', () {
+      final yaml = YamlMap.wrap(<String, String>{
+        'source': '/assets/**',
+        'target': 'http://localhost:8080',
+      });
+      expect(SourceProxyRule.canHandle(yaml), isTrue);
+    });
+
+    test('canHandle returns false for missing source', () {
+      final yaml = YamlMap.wrap(<String, String>{'target': 'http://localhost:8080'});
+      expect(SourceProxyRule.canHandle(yaml), isFalse);
+    });
+
+    test('canHandle returns false for empty source', () {
+      final yaml = YamlMap.wrap(<String, String>{'source': '', 'target': 'http://localhost:8080'});
+      expect(SourceProxyRule.canHandle(yaml), isFalse);
+    });
+
+    test('fromYaml creates a SourceProxyRule', () {
+      final yaml = YamlMap.wrap(<String, String>{
+        'source': '/assets/**',
+        'target': 'http://localhost:8080/data',
+        'replace': '/static_files',
+      });
+      final SourceProxyRule? rule = SourceProxyRule.fromYaml(yaml, logger);
+      expect(rule, isNotNull);
+      expect(
+        rule.toString(),
+        '{source: /assets/**, target: http://localhost:8080/data, replace: /static_files}',
+      );
+    });
+
+    test('fromYaml returns null if target is missing', () {
+      final yaml = YamlMap.wrap(<String, String>{'source': '/assets/**'});
+      final SourceProxyRule? rule = SourceProxyRule.fromYaml(yaml, logger);
+      expect(rule, isNull);
+      expect(
+        logger.errorText,
+        contains('[ProxyRule] Invalid target for source: /assets/**. target cannot be null'),
+      );
+    });
+
+    test('matches returns true when glob matches path', () {
+      final rule = SourceProxyRule(source: Glob('/assets/**.jpg'), target: 'http://localhost:8080');
+      expect(rule.matches('/assets/images/cat.jpg'), isTrue);
+      expect(rule.matches('/assets/cat.jpg'), isTrue);
+      expect(rule.matches('/assets/images/subfolder/cat.jpg'), isTrue);
+    });
+
+    test('matches returns false when glob does not match path', () {
+      final rule = SourceProxyRule(
+        source: Glob('/assets/**/*.jpg'),
+        target: 'http://localhost:8080',
+      );
+      expect(rule.matches('/assets/images/dog.png'), isFalse);
+      expect(rule.matches('/assets/images/dog'), isFalse);
+      expect(rule.matches('/style.css'), isFalse);
+    });
+
+    test('replace correctly replaces with replacement string', () {
+      final rule = SourceProxyRule(
+        source: Glob('/assets/**'),
+        target: 'http://localhost:8080',
+        replacement: '/static',
+      );
+      expect(rule.replace('/assets/images/image.jpg'), '/static');
+    });
+
+    test('replace returns original path for no replacement', () {
+      final rule = SourceProxyRule(source: Glob('/assets/**'), target: 'http://localhost:8080');
+      expect(rule.replace('/assets/images/image.jpg'), '/assets/images/image.jpg');
+    });
+  });
+
   group('proxyRequest', () {
     test('should correctly proxy all request elements', () async {
       final Uri originalUrl = Uri.parse('http://original.example.com/path');