将JavaScript RegEx转换为JSON格式

Question

I'm currently developing a Safari Extension which will make use of the new webkit-content-blocker feature available in Safari 9. Now, the rules of such blockers need to be written in JSON.

The background script of my soon-to-be extension generates such JSON rules. The issue I have is that I cannot properly format a regex, whose role is to filter URLs, to be JSON compatible.

Say I need to block all images whose URL contains either "banana", "orange", or "apple". My regex would be something like:

var url-filter = /banana|orange|apple/g;

Now the blocker's rule in JSON, missing the url filtering part:

"action": {
   "type": "block"
    },
"trigger": {
   "url-filter": <JSON regex here>,
   "resource-type": ["image"],
   "load-type": ["third-party"]
    }

[UPDATED]

How can I rewrite my regex to be JSON compatible/ready, knowing that alternations are not supported ?

The Regular expression format

Triggers support filtering the URLs of each resource based on regular expression.

The following features are supported:

• Matching any character with “.”.
• Matching ranges with the range syntax [ab].
• Quantifying expressions with “?”, “+” and “*”.
• Groups with parenthesis.

It is possible to use the beginning of line (“^”) and end of line (“$”) marker but they are restricted to be the first and last character of the expression. For example, a pattern like “^bar$” is perfectly valid, while “(foo)?^bar$” causes a syntax error.

[UPDATED BIS]

Given the strict CSP policy implemented by Safari and the lack of support for alternations, I finally converted my original regex into an array and then dynamically generated the JSON rules via a loop.

var regex = 'banana|orange|apple',
    filters = regex.split('|'),
    json_rules = [];

var Blocker = {
        build: function() {

            filters.forEach( function(filter) {
                var rule = {
                    action: {
                        'type': 'block'
                    },
                    trigger: {
                        'url-filter': filter,
                        'resource-type': ['image'],
                        'load-type': ['third-party']
                    }
                };
                json_rules.push(rule);
            });

            Blocker.set(JSON.stringify(json_rules));
        },
        init: function() {
            Blocker.build();
        },
        set: function (rule) {
            safari.extension.setContentBlocker(rule);
        }

};

Answer 1

According to the documentation you linked, the values of the filters are treated as regular expressions (for example, they show "url-filter": "evil-tracker\\\\.js" and "url-filter": ".*" ).

The documentation also says that url-filter is case-insensitive, so you don't have to worry about the i flag you might otherwise want to use. But if you wanted a case-sensitive one, you'd add "url-filter-is-case-sensitive": true .

That being the case, you just put your regular expression in quotes, being sure to escape any characters that need to be escaped within a string literal (for instance, note how they used two backslashes in their "evil-tracker\\\\.js" string, in order for the regex to be evil-tracker\\.js ).

However : The problem with your expression is that they don't support alternations. Again, from the documentation you linked:

The format is a strict subset of JavaScript regular expressions. Syntactically, everything supported by JavaScript is reserved but only a subset will be accepted by the parser. An unsupported expression results in a parse error.

The following features are supported:

• Matching any character with “.”.
• Matching ranges with the range syntax [ab].
• Quantifying expressions with “?”, “+” and “*”.
• Groups with parenthesis.

It is possible to use the beginning of line (“^”) and end of line (“$”) marker but they are restricted to be the first and last character of the expression. For example, a pattern like “^bar$” is perfectly valid, while “(foo)?^bar$” causes a syntax error.

Note that they don't accept | (alternation).

That tells me you'll need three rules: One for banana , one for orange , and one for apple .