The fact you can't come up with a regex and be sure it's correct answers your first two questions.
Regexes are incredibly useful, but the syntax is just a bunch of noise. This library turns it into self-docummenting code, which is incredibly valuable. Novices might prefer showing their regex-fu, but after you've spent a good chunk of your life reading and writing code, you value clear code more.
The problem is that for anyone who knows how regexps work, this library provides an obfuscation layer. I personally prefer the free-spacing regexp support[1] found in a number of popular parsers. It lets you write a complicated regexp in small and/or indented chunks across multiple lines, including comments. This provides as much or more documentation than this "self-documenting" form and allows the full power of the regexp engine (which big regexps often seem to need). I've occasionally had to work out some pretty gnarly regexps, but when written in two-column code/comments form they end up being pretty understandable and maintainable.
[1] Example from the Ruby docs. IIRC, Python and a few other parsers have similar support: http://www.ruby-doc.org/core-1.9.3/Regexp.html#label-Free-Sp...
He's arguing that the nicer syntax is a valuable abstraction over regex's overly-complicated syntax, not that the syntax will be 100% the same as regex 100% of the time.
Apparently, we can't. So, you really want to improve your odds of writing correct code at the first attempt by making the language work with you rather than against.
Replacing a bunch punctuation with code that reads like prose is one way.
I'm a huge fan of regular expressions and I love to discover new ones, try to improve my own, etc. But, it does not mean there isn't place for a human readable regex syntax, and I will definitely give it a try.
Not unnecessary, “useless”, “kidding” are more appropriate words IMHO.
Where is named captures? Oh, you cannot. Well, ordinary $1 $2 $3? Oh, you cannot capture at all! How do you use back refs? Oh, you cannot? Wait, why the heck then you even need regexps?
There are problems with complex regexes, yes. But this silly toy is not the solution. For solutions look at Perl6's “regexps”, Perl6's Grammars (example down the thread), Perl5's Regexp::Grammars, look how Haskell do it with parser combinators. They are all light years ahead.
But yes, 1.2 will likely have named captures and back refs. It's a regex, so $1 etc come with turning it into a regex and doing matching.
Perl5's R::Grammars is doing it the same way you do — it generates one-big-scary regex. But this lib is nowhere close to what it can do.
For idea: it will provide fully parsed struct like {proto: 'http', domain: { all: 'www.exampe.com', subdomains: ['www','example'], tld: 'ord', ... }
So, no, you cannot. And there're many more cool things you cannot
If we could come up with some sort of high-level API for regexes we might end up in a better situation, given that this would make them effectively language agnostic.
And you could always revert to your platform's native option if there are some missing features on the API (Given that those type of things generally end up with a least-common-denominator approach)
I've generally found that my practice is basically "try regex; if it doesn't work after ten minutes of effort, abandon regex completely".
> Am I the only person who thinks that things like this are totally unnecessary?
No, it's been made clear to me that my library is totally unnecessary by quite a few developers. I like it though.
> ^(-|+)?[0-9]*\.[0-9]+$
exp.float, and you only have to define it once.
I only use regex occasionally and, as such, typically need to refresh each time I go back to it.
Obviously you should choose the level of abstraction that fits your needs but I would love something like this if I did any ruby.
No, you're not the only one. I have a feeling that things like that massive regular expression that is meant to match RFC822 email addresses is part of the reason for the focus on this kind of "easy to use, human" regular expression interfaces. The problem is that that email matching regular expression is an extreme case that matches a whole bunch of things that MTAs/MUAs need to know about, but that most people, who are accepting email addresses in web forms, don't need to know about, like "email comments", the real name fields, bang paths, etc. 99.999% of email addresses are going to match something simple like ^\S+@[\w-.]+\.[\w-]+$, and you're going to pass that off to the MTA to parse and validate and bounce anyway. For example, most people should be more concerned with having decent bounce processing support rather than trying to make email address matching regular expressions.
I'm not sure the "builder pattern" in the OP does this well though...
Macros! https://github.com/wyantb/js-regex#macros
Given some named macro, whenever the user wants to use it, they use addMacro (or some analogous method).
Regular expressions are a pain, but I strongly believe that you shouldn't use abstractions unless you have at least a functional understanding of what you're abstracting.
Here's the subset of regular expressions that has gotten me through nearly all of the regular expressions I've ever needed to write. As a plus, it has no dependencies!
* - zero or more of the preceding character/group
+ - one or more of the preceding character/group
? - zero or one of the preceding character/group
$ - end of line
^ - beginning of line
. - one of any one character
\ - escape the following character (for a literal '$' or '.', for example)
[<some characters>] - one of the given characters
[a-zA-Z0-9] - letters and numbers inside a group can have ranges!
(<something>) - capturing group (anything that matches inside it will be accessible in the match object)
<thing1>|<thing2> - either the first thing, or the second thing (or the third, or the fourth...)
This isn't a complete, or even precise, definition, but knowing those things will get you to the point where you can read and write expressions like this:
^(-|+)?[0-9]*\.[0-9]+$
which matches things like -.2, 0.123, +0.1, etc. (floating point numbers, basically). This likely has bugs, since I haven't tested it ;)