1 var concatMap = require('concat-map');
2 var balanced = require('balanced-match');
4 module.exports = expandTop;
6 var escSlash = '\0SLASH'+Math.random()+'\0';
7 var escOpen = '\0OPEN'+Math.random()+'\0';
8 var escClose = '\0CLOSE'+Math.random()+'\0';
9 var escComma = '\0COMMA'+Math.random()+'\0';
10 var escPeriod = '\0PERIOD'+Math.random()+'\0';
12 function numeric(str) {
13 return parseInt(str, 10) == str
18 function escapeBraces(str) {
19 return str.split('\\\\').join(escSlash)
20 .split('\\{').join(escOpen)
21 .split('\\}').join(escClose)
22 .split('\\,').join(escComma)
23 .split('\\.').join(escPeriod);
26 function unescapeBraces(str) {
27 return str.split(escSlash).join('\\')
28 .split(escOpen).join('{')
29 .split(escClose).join('}')
30 .split(escComma).join(',')
31 .split(escPeriod).join('.');
35 // Basically just str.split(","), but handling cases
36 // where we have nested braced sections, which should be
37 // treated as individual members, like {a,{b,c},d}
38 function parseCommaParts(str) {
43 var m = balanced('{', '}', str);
46 return str.split(',');
51 var p = pre.split(',');
53 p[p.length-1] += '{' + body + '}';
54 var postParts = parseCommaParts(post);
56 p[p.length-1] += postParts.shift();
57 p.push.apply(p, postParts);
60 parts.push.apply(parts, p);
65 function expandTop(str) {
69 // I don't know why Bash 4.3 does this, but it does.
70 // Anything starting with {} will have the first two bytes preserved
71 // but *only* at the top level, so {},a}b will not expand to anything,
72 // but a{},b}c will be expanded to [a}c,abc].
73 // One could argue that this is a bug in Bash, but since the goal of
74 // this module is to match Bash's rules, we escape a leading {}
75 if (str.substr(0, 2) === '{}') {
76 str = '\\{\\}' + str.substr(2);
79 return expand(escapeBraces(str), true).map(unescapeBraces);
82 function identity(e) {
86 function embrace(str) {
87 return '{' + str + '}';
89 function isPadded(el) {
90 return /^-?0\d/.test(el);
100 function expand(str, isTop) {
103 var m = balanced('{', '}', str);
104 if (!m || /\$$/.test(m.pre)) return [str];
106 var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
107 var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
108 var isSequence = isNumericSequence || isAlphaSequence;
109 var isOptions = /^(.*,)+(.+)?$/.test(m.body);
110 if (!isSequence && !isOptions) {
112 if (m.post.match(/,.*\}/)) {
113 str = m.pre + '{' + m.body + escClose + m.post;
121 n = m.body.split(/\.\./);
123 n = parseCommaParts(m.body);
124 if (n.length === 1) {
125 // x{{a,b}}y ==> x{a}y x{b}y
126 n = expand(n[0], false).map(embrace);
127 if (n.length === 1) {
128 var post = m.post.length
129 ? expand(m.post, false)
131 return post.map(function(p) {
132 return m.pre + n[0] + p;
138 // at this point, n is the parts, and we know it's not a comma set
139 // with a single entry.
141 // no need to expand pre, since it is guaranteed to be free of brace-sets
143 var post = m.post.length
144 ? expand(m.post, false)
150 var x = numeric(n[0]);
151 var y = numeric(n[1]);
152 var width = Math.max(n[0].length, n[1].length)
153 var incr = n.length == 3
154 ? Math.abs(numeric(n[2]))
162 var pad = n.some(isPadded);
166 for (var i = x; test(i, y); i += incr) {
168 if (isAlphaSequence) {
169 c = String.fromCharCode(i);
175 var need = width - c.length;
177 var z = new Array(need + 1).join('0');
179 c = '-' + z + c.slice(1);
188 N = concatMap(n, function(el) { return expand(el, false) });
191 for (var j = 0; j < N.length; j++) {
192 for (var k = 0; k < post.length; k++) {
193 var expansion = pre + N[j] + post[k];
194 if (!isTop || isSequence || expansion)
195 expansions.push(expansion);