Implementing Pattern with RegExp in Dart - regex

Question

I wanted to have a Pattern where I could easily get the base path of the pattern, for use with routing, like this:
var route = new Pattern('/user');
print(route.path)
would give '/user', but the pattern would match r'/user/.*'.
I pictured this would suffice:
class Path extends RegExp {
String _path;
Path(this._path): super(path.join(_path, '.*'));
}
However, RegExp is abstract, so it cannot work. But RegExp is still instantiable because it's constructor is declared with factory. Therefore, I find the only / best solution is to keep a RegExp object as a member:
class Path implements Pattern {
String _path;
RegExp _r;
Path(this._path) {
_r = new RegExp(join(_path, '.*'));
}
Match matchAsPrefix(String string, [int start=0]) {
return _r.matchAsPrefix(string, start);
}
Iterable<Match> allMatches(String str) {
return _r.allMatches(str);
}
}
But the definition of RegExp lists only allMatches, as specified by Pattern. But doesn't all of Patterns method need to be implemented if RegExp is to support Pattern?
I wanted to look at the implementation of RegExp's constructor, but it's defined as external, and I can't find the correct file.
So properly formulate my question, is there any way for me to do what I originally intended, to inherit from a non-abstract class implementing Pattern?

Answer 1

I would recommend that you look at the Uri class or Path package, and see if it can't help you with what you want (and if it can't, file a feature request). Working with paths or URIs as strings is likely to be fragile.
Anyway, if I understand you correctly, you want the input x to be match "$x/" and everything after that. That sounds fairly simple - since it matches to the end of the string, there can only ever be one match per string.
You can write your own Pattern implementation:
class MyPattern implements Pattern {
final String _pattern;
MyPattern(String prefix) : _pattern = "$prefix/";
Iterable<Match> allMatches(String input) {
int index = input.indexOf(_pattern);
if (index < 0) return null;
return [new _MyMatch(input, this, index)];
}
Match matchAsPrefix(String input, [int start = 0]) {
if (input.startsWith(_pattern, start)) {
return new _MyMatch(input, this, start);
}
return null;
}
}
class _MyMatch implements Match {
final String input;
final Pattern pattern;
final int start;
_MyMatch(this.input, this.pattern, this.start);
int get end => input.length;
int get groupCount => 0;
List<String> groups(Iterable<int> indices) {
var result = <String>[];
for (int i in indices) result.add(group(i));
return result;
}
String group(int index) {
if (index == 0) return input.substring(start);
throw new RangeError.value(index);
}
String operator[](int index) => group(index);
}

Answer 2

I think it is fine how you did it (RegExp as member).
The abstract class with the factory constructor is a construct to prevent deriving from RegExp.
The external keyword is a trick to bind to a concrete implementation from somewhere else later (VM or JS, see https://www.dartlang.org/docs/spec/latest/dart-language-specification.html#h.lkkt75qhbiwh).
This is the reason why the abstract class can be instantiated and why RegExp doesn't have to implement all methods in the regexp.dart file.