16 |
19 | 20 | This libary generates the `source` string to be passed to `new RegExp()` for matching a range of numbers. 21 | 22 | **Example** 23 | 24 | ```js 25 | const toRegexRange = require('to-regex-range'); 26 | const regex = new RegExp(toRegexRange('15', '95')); 27 | ``` 28 | 29 | A string is returned so that you can do whatever you need with it before passing it to `new RegExp()` (like adding `^` or `$` boundaries, defining flags, or combining it another string). 30 | 31 |
32 | 33 |
34 |
35 | What does this do?
17 | 18 |19 | 20 | This libary generates the `source` string to be passed to `new RegExp()` for matching a range of numbers. 21 | 22 | **Example** 23 | 24 | ```js 25 | const toRegexRange = require('to-regex-range'); 26 | const regex = new RegExp(toRegexRange('15', '95')); 27 | ``` 28 | 29 | A string is returned so that you can do whatever you need with it before passing it to `new RegExp()` (like adding `^` or `$` boundaries, defining flags, or combining it another string). 30 | 31 |
32 | 33 |
36 |
39 | 40 | ### Convenience 41 | 42 | Creating regular expressions for matching numbers gets deceptively complicated pretty fast. 43 | 44 | For example, let's say you need a validation regex for matching part of a user-id, postal code, social security number, tax id, etc: 45 | 46 | * regex for matching `1` => `/1/` (easy enough) 47 | * regex for matching `1` through `5` => `/[1-5]/` (not bad...) 48 | * regex for matching `1` or `5` => `/(1|5)/` (still easy...) 49 | * regex for matching `1` through `50` => `/([1-9]|[1-4][0-9]|50)/` (uh-oh...) 50 | * regex for matching `1` through `55` => `/([1-9]|[1-4][0-9]|5[0-5])/` (no prob, I can do this...) 51 | * regex for matching `1` through `555` => `/([1-9]|[1-9][0-9]|[1-4][0-9]{2}|5[0-4][0-9]|55[0-5])/` (maybe not...) 52 | * regex for matching `0001` through `5555` => `/(0{3}[1-9]|0{2}[1-9][0-9]|0[1-9][0-9]{2}|[1-4][0-9]{3}|5[0-4][0-9]{2}|55[0-4][0-9]|555[0-5])/` (okay, I get the point!) 53 | 54 | The numbers are contrived, but they're also really basic. In the real world you might need to generate a regex on-the-fly for validation. 55 | 56 | **Learn more** 57 | 58 | If you're interested in learning more about [character classes](http://www.regular-expressions.info/charclass.html) and other regex features, I personally have always found [regular-expressions.info](http://www.regular-expressions.info/charclass.html) to be pretty useful. 59 | 60 | ### Heavily tested 61 | 62 | As of April 07, 2019, this library runs [>1m test assertions](./test/test.js) against generated regex-ranges to provide brute-force verification that results are correct. 63 | 64 | Tests run in ~280ms on my MacBook Pro, 2.5 GHz Intel Core i7. 65 | 66 | ### Optimized 67 | 68 | Generated regular expressions are optimized: 69 | 70 | * duplicate sequences and character classes are reduced using quantifiers 71 | * smart enough to use `?` conditionals when number(s) or range(s) can be positive or negative 72 | * uses fragment caching to avoid processing the same exact string more than once 73 | 74 |
75 | 76 |
77 |
78 | ## Usage
79 |
80 | Add this library to your javascript application with the following line of code
81 |
82 | ```js
83 | const toRegexRange = require('to-regex-range');
84 | ```
85 |
86 | The main export is a function that takes two integers: the `min` value and `max` value (formatted as strings or numbers).
87 |
88 | ```js
89 | const source = toRegexRange('15', '95');
90 | //=> 1[5-9]|[2-8][0-9]|9[0-5]
91 |
92 | const regex = new RegExp(`^${source}$`);
93 | console.log(regex.test('14')); //=> false
94 | console.log(regex.test('50')); //=> true
95 | console.log(regex.test('94')); //=> true
96 | console.log(regex.test('96')); //=> false
97 | ```
98 |
99 | ## Options
100 |
101 | ### options.capture
102 |
103 | **Type**: `boolean`
104 |
105 | **Deafault**: `undefined`
106 |
107 | Wrap the returned value in parentheses when there is more than one regex condition. Useful when you're dynamically generating ranges.
108 |
109 | ```js
110 | console.log(toRegexRange('-10', '10'));
111 | //=> -[1-9]|-?10|[0-9]
112 |
113 | console.log(toRegexRange('-10', '10', { capture: true }));
114 | //=> (-[1-9]|-?10|[0-9])
115 | ```
116 |
117 | ### options.shorthand
118 |
119 | **Type**: `boolean`
120 |
121 | **Deafault**: `undefined`
122 |
123 | Use the regex shorthand for `[0-9]`:
124 |
125 | ```js
126 | console.log(toRegexRange('0', '999999'));
127 | //=> [0-9]|[1-9][0-9]{1,5}
128 |
129 | console.log(toRegexRange('0', '999999', { shorthand: true }));
130 | //=> \d|[1-9]\d{1,5}
131 | ```
132 |
133 | ### options.relaxZeros
134 |
135 | **Type**: `boolean`
136 |
137 | **Default**: `true`
138 |
139 | This option relaxes matching for leading zeros when when ranges are zero-padded.
140 |
141 | ```js
142 | const source = toRegexRange('-0010', '0010');
143 | const regex = new RegExp(`^${source}$`);
144 | console.log(regex.test('-10')); //=> true
145 | console.log(regex.test('-010')); //=> true
146 | console.log(regex.test('-0010')); //=> true
147 | console.log(regex.test('10')); //=> true
148 | console.log(regex.test('010')); //=> true
149 | console.log(regex.test('0010')); //=> true
150 | ```
151 |
152 | When `relaxZeros` is false, matching is strict:
153 |
154 | ```js
155 | const source = toRegexRange('-0010', '0010', { relaxZeros: false });
156 | const regex = new RegExp(`^${source}$`);
157 | console.log(regex.test('-10')); //=> false
158 | console.log(regex.test('-010')); //=> false
159 | console.log(regex.test('-0010')); //=> true
160 | console.log(regex.test('10')); //=> false
161 | console.log(regex.test('010')); //=> false
162 | console.log(regex.test('0010')); //=> true
163 | ```
164 |
165 | ## Examples
166 |
167 | | **Range** | **Result** | **Compile time** |
168 | | --- | --- | --- |
169 | | `toRegexRange(-10, 10)` | `-[1-9]\|-?10\|[0-9]` | _132μs_ |
170 | | `toRegexRange(-100, -10)` | `-1[0-9]\|-[2-9][0-9]\|-100` | _50μs_ |
171 | | `toRegexRange(-100, 100)` | `-[1-9]\|-?[1-9][0-9]\|-?100\|[0-9]` | _42μs_ |
172 | | `toRegexRange(001, 100)` | `0{0,2}[1-9]\|0?[1-9][0-9]\|100` | _109μs_ |
173 | | `toRegexRange(001, 555)` | `0{0,2}[1-9]\|0?[1-9][0-9]\|[1-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]` | _51μs_ |
174 | | `toRegexRange(0010, 1000)` | `0{0,2}1[0-9]\|0{0,2}[2-9][0-9]\|0?[1-9][0-9]{2}\|1000` | _31μs_ |
175 | | `toRegexRange(1, 50)` | `[1-9]\|[1-4][0-9]\|50` | _24μs_ |
176 | | `toRegexRange(1, 55)` | `[1-9]\|[1-4][0-9]\|5[0-5]` | _23μs_ |
177 | | `toRegexRange(1, 555)` | `[1-9]\|[1-9][0-9]\|[1-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]` | _30μs_ |
178 | | `toRegexRange(1, 5555)` | `[1-9]\|[1-9][0-9]{1,2}\|[1-4][0-9]{3}\|5[0-4][0-9]{2}\|55[0-4][0-9]\|555[0-5]` | _43μs_ |
179 | | `toRegexRange(111, 555)` | `11[1-9]\|1[2-9][0-9]\|[2-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]` | _38μs_ |
180 | | `toRegexRange(29, 51)` | `29\|[34][0-9]\|5[01]` | _24μs_ |
181 | | `toRegexRange(31, 877)` | `3[1-9]\|[4-9][0-9]\|[1-7][0-9]{2}\|8[0-6][0-9]\|87[0-7]` | _32μs_ |
182 | | `toRegexRange(5, 5)` | `5` | _8μs_ |
183 | | `toRegexRange(5, 6)` | `5\|6` | _11μs_ |
184 | | `toRegexRange(1, 2)` | `1\|2` | _6μs_ |
185 | | `toRegexRange(1, 5)` | `[1-5]` | _15μs_ |
186 | | `toRegexRange(1, 10)` | `[1-9]\|10` | _22μs_ |
187 | | `toRegexRange(1, 100)` | `[1-9]\|[1-9][0-9]\|100` | _25μs_ |
188 | | `toRegexRange(1, 1000)` | `[1-9]\|[1-9][0-9]{1,2}\|1000` | _31μs_ |
189 | | `toRegexRange(1, 10000)` | `[1-9]\|[1-9][0-9]{1,3}\|10000` | _34μs_ |
190 | | `toRegexRange(1, 100000)` | `[1-9]\|[1-9][0-9]{1,4}\|100000` | _36μs_ |
191 | | `toRegexRange(1, 1000000)` | `[1-9]\|[1-9][0-9]{1,5}\|1000000` | _42μs_ |
192 | | `toRegexRange(1, 10000000)` | `[1-9]\|[1-9][0-9]{1,6}\|10000000` | _42μs_ |
193 |
194 | ## Heads up!
195 |
196 | **Order of arguments**
197 |
198 | When the `min` is larger than the `max`, values will be flipped to create a valid range:
199 |
200 | ```js
201 | toRegexRange('51', '29');
202 | ```
203 |
204 | Is effectively flipped to:
205 |
206 | ```js
207 | toRegexRange('29', '51');
208 | //=> 29|[3-4][0-9]|5[0-1]
209 | ```
210 |
211 | **Steps / increments**
212 |
213 | This library does not support steps (increments). A pr to add support would be welcome.
214 |
215 | ## History
216 |
217 | ### v2.0.0 - 2017-04-21
218 |
219 | **New features**
220 |
221 | Adds support for zero-padding!
222 |
223 | ### v1.0.0
224 |
225 | **Optimizations**
226 |
227 | Repeating ranges are now grouped using quantifiers. rocessing time is roughly the same, but the generated regex is much smaller, which should result in faster matching.
228 |
229 | ## Attribution
230 |
231 | Inspired by the python library [range-regex](https://github.com/dimka665/range-regex).
232 |
233 | ## About
234 |
235 | Why use this library?
37 | 38 |39 | 40 | ### Convenience 41 | 42 | Creating regular expressions for matching numbers gets deceptively complicated pretty fast. 43 | 44 | For example, let's say you need a validation regex for matching part of a user-id, postal code, social security number, tax id, etc: 45 | 46 | * regex for matching `1` => `/1/` (easy enough) 47 | * regex for matching `1` through `5` => `/[1-5]/` (not bad...) 48 | * regex for matching `1` or `5` => `/(1|5)/` (still easy...) 49 | * regex for matching `1` through `50` => `/([1-9]|[1-4][0-9]|50)/` (uh-oh...) 50 | * regex for matching `1` through `55` => `/([1-9]|[1-4][0-9]|5[0-5])/` (no prob, I can do this...) 51 | * regex for matching `1` through `555` => `/([1-9]|[1-9][0-9]|[1-4][0-9]{2}|5[0-4][0-9]|55[0-5])/` (maybe not...) 52 | * regex for matching `0001` through `5555` => `/(0{3}[1-9]|0{2}[1-9][0-9]|0[1-9][0-9]{2}|[1-4][0-9]{3}|5[0-4][0-9]{2}|55[0-4][0-9]|555[0-5])/` (okay, I get the point!) 53 | 54 | The numbers are contrived, but they're also really basic. In the real world you might need to generate a regex on-the-fly for validation. 55 | 56 | **Learn more** 57 | 58 | If you're interested in learning more about [character classes](http://www.regular-expressions.info/charclass.html) and other regex features, I personally have always found [regular-expressions.info](http://www.regular-expressions.info/charclass.html) to be pretty useful. 59 | 60 | ### Heavily tested 61 | 62 | As of April 07, 2019, this library runs [>1m test assertions](./test/test.js) against generated regex-ranges to provide brute-force verification that results are correct. 63 | 64 | Tests run in ~280ms on my MacBook Pro, 2.5 GHz Intel Core i7. 65 | 66 | ### Optimized 67 | 68 | Generated regular expressions are optimized: 69 | 70 | * duplicate sequences and character classes are reduced using quantifiers 71 | * smart enough to use `?` conditionals when number(s) or range(s) can be positive or negative 72 | * uses fragment caching to avoid processing the same exact string more than once 73 | 74 |
75 | 76 |
236 |
241 |
242 | Contributing
237 | 238 | Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). 239 | 240 |
243 |
252 |
253 | Running Tests
244 | 245 | Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command: 246 | 247 | ```sh 248 | $ npm install && npm test 249 | ``` 250 | 251 |
254 |
265 |
266 | ### Related projects
267 |
268 | You might also be interested in these projects:
269 |
270 | * [expand-range](https://www.npmjs.com/package/expand-range): Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. Used… [more](https://github.com/jonschlinkert/expand-range) | [homepage](https://github.com/jonschlinkert/expand-range "Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. Used by micromatch.")
271 | * [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or `step` to… [more](https://github.com/jonschlinkert/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`")
272 | * [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | [homepage](https://github.com/micromatch/micromatch "Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.")
273 | * [repeat-element](https://www.npmjs.com/package/repeat-element): Create an array by repeating the given value n times. | [homepage](https://github.com/jonschlinkert/repeat-element "Create an array by repeating the given value n times.")
274 | * [repeat-string](https://www.npmjs.com/package/repeat-string): Repeat the given string n times. Fastest implementation for repeating a string. | [homepage](https://github.com/jonschlinkert/repeat-string "Repeat the given string n times. Fastest implementation for repeating a string.")
275 |
276 | ### Contributors
277 |
278 | | **Commits** | **Contributor** |
279 | | --- | --- |
280 | | 63 | [jonschlinkert](https://github.com/jonschlinkert) |
281 | | 3 | [doowb](https://github.com/doowb) |
282 | | 2 | [realityking](https://github.com/realityking) |
283 |
284 | ### Author
285 |
286 | **Jon Schlinkert**
287 |
288 | * [GitHub Profile](https://github.com/jonschlinkert)
289 | * [Twitter Profile](https://twitter.com/jonschlinkert)
290 | * [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
291 |
292 | Please consider supporting me on Patreon, or [start your own Patreon page](https://patreon.com/invite/bxpbvm)!
293 |
294 |
295 | Building docs
255 | 256 | _(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_ 257 | 258 | To generate the readme, run the following command: 259 | 260 | ```sh 261 | $ npm install -g verbose/verb#dev verb-generate-readme && verb 262 | ``` 263 | 264 |
296 |
297 |
298 | ### License
299 |
300 | Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
301 | Released under the [MIT License](LICENSE).
302 |
303 | ***
304 |
305 | _This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 07, 2019._
--------------------------------------------------------------------------------
/test/test.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | require('mocha');
4 | const assert = require('assert').strict;
5 | const fill = require('fill-range');
6 | const toRange = require('..');
7 | let count = 0;
8 |
9 | const inRange = (min, max, num) => min <= num && max >= num;
10 | const toRegex = str => new RegExp(`^${str}$`);
11 | const toRangeRegex = (min, max, options) => {
12 | return toRegex(toRange(min, max, { wrap: true, ...options }));
13 | };
14 |
15 | const matcher = (...args) => {
16 | const regex = toRangeRegex(...args);
17 | return num => regex.test(String(num));
18 | };
19 |
20 | const matchRange = (min, max, expected, match, notMatch) => {
21 | if (max - min >= 1000000) {
22 | throw new RangeError('range is too big');
23 | }
24 |
25 | let actual = toRange(min, max);
26 | let msg = actual + ' => ' + expected;
27 |
28 | // test expected string
29 | assert.equal(actual, expected, msg);
30 |
31 | let re = toRegex(actual);
32 | for (let i = 0; i < match.length; i++) {
33 | assert(re.test(match[i]), 'should match ' + msg);
34 | count++;
35 | }
36 |
37 | if (!Array.isArray(notMatch)) return;
38 | for (let j = 0; j < notMatch.length; j++) {
39 | assert(!re.test(notMatch[j]), 'should not match ' + msg);
40 | count++;
41 | }
42 | }
43 |
44 | const verifyRange = (min, max, from, to) => {
45 | let isMatch = matcher(min, max);
46 | let minNum = Math.min(min, max);
47 | let maxNum = Math.max(min, max);
48 | let num = from - 1;
49 |
50 | while (++num < to) {
51 | let n = Number(num);
52 | if (inRange(minNum, maxNum, n)) {
53 | assert(isMatch(num), `should match "${num}"`);
54 | } else {
55 | assert(!isMatch(num), `should not match "${num}"`);
56 | }
57 | count++;
58 | }
59 | };
60 |
61 | const verifyZeros = (min, max, from, to) => {
62 | let range = fill(from, to);
63 | let len = range.length;
64 | let idx = -1;
65 |
66 | let isMatch = matcher(min, max);
67 | let minNum = Math.min(min, max);
68 | let maxNum = Math.max(min, max);
69 |
70 | while (++idx < len) {
71 | let num = range[idx];
72 | let n = Number(num);
73 | if (inRange(minNum, maxNum, n)) {
74 | assert(isMatch(num), `should match "${num}"`);
75 | } else {
76 | assert(!isMatch(num), `should not match "${num}"`);
77 | }
78 | count++;
79 | }
80 | };
81 |
82 | describe('to-regex-range', () => {
83 | after(() => {
84 | console.log();
85 | console.log(' ', (+(+count.toFixed(2))).toLocaleString(), 'assertions');
86 | });
87 |
88 | describe('range', () => {
89 | it('should throw an error when the first arg is invalid:', () => {
90 | assert.throws(() => toRange(), /expected/);
91 | });
92 |
93 | it('should throw an error when the second arg is invalid:', () => {
94 | assert.throws(() => toRange(1, {}), /expected/);
95 | });
96 |
97 | it('should match the given numbers', () => {
98 | let oneFifty = toRegex(toRange(1, 150));
99 | assert(oneFifty.test('125'));
100 | assert(!oneFifty.test('0'));
101 | assert(oneFifty.test('1'));
102 | assert(oneFifty.test('126'));
103 | assert(oneFifty.test('150'));
104 | assert(!oneFifty.test('151'));
105 |
106 | let oneTwentyFive = toRegex(toRange(1, 125));
107 | assert(oneTwentyFive.test('125'));
108 | assert(!oneTwentyFive.test('0'));
109 | assert(oneTwentyFive.test('1'));
110 | assert(!oneTwentyFive.test('126'));
111 | assert(!oneTwentyFive.test('150'));
112 | assert(!oneTwentyFive.test('151'));
113 | });
114 | });
115 |
116 | describe('minimum / maximum', () => {
117 | it('should reverse `min/max` when the min is larger than the max:', () => {
118 | assert.equal(toRange(55, 10), '(?:1[0-9]|[2-4][0-9]|5[0-5])');
119 | });
120 | });
121 |
122 | describe('ranges', () => {
123 | it('should return the number when only one argument is passed:', () => {
124 | assert.equal(toRange(5), '5');
125 | });
126 |
127 | it('should return a single number when both numbers are equal', () => {
128 | assert.equal(toRange('1', '1'), '1');
129 | assert.equal(toRange('65443', '65443'), '65443');
130 | assert.equal(toRange('192', '192'), '192');
131 | verifyRange(1, 1, 0, 100);
132 | verifyRange(65443, 65443, 65000, 66000);
133 | verifyRange(192, 192, 0, 1000);
134 | });
135 |
136 | it('should not return a range when both numbers are the same:', () => {
137 | assert.equal(toRange(5, 5), '5');
138 | });
139 |
140 | it('should return regex character classes when both args are less than 10', () => {
141 | assert.equal(toRange(0, 9), '[0-9]');
142 | assert.equal(toRange(1, 5), '[1-5]');
143 | assert.equal(toRange(1, 7), '[1-7]');
144 | assert.equal(toRange(2, 6), '[2-6]');
145 | });
146 |
147 | it('should support string numbers', () => {
148 | assert.equal(toRange('1', '5'), '[1-5]');
149 | assert.equal(toRange('10', '50'), '(?:1[0-9]|[2-4][0-9]|50)');
150 | });
151 |
152 | it('should support padded ranges:', () => {
153 | assert.equal(toRange('001', '005'), '0{0,2}[1-5]');
154 | assert.equal(toRange('01', '05'), '0?[1-5]');
155 | assert.equal(toRange('001', '100'), '(?:0{0,2}[1-9]|0?[1-9][0-9]|100)');
156 | assert.equal(toRange('0001', '1000'), '(?:0{0,3}[1-9]|0{0,2}[1-9][0-9]|0?[1-9][0-9]{2}|1000)');
157 | });
158 |
159 | it('should work when padding is imbalanced:', () => {
160 | assert.equal(toRange('001', '105'), '(?:0{0,2}[1-9]|0?[1-9][0-9]|10[0-5])');
161 | assert.equal(toRange('01', '105'), '(?:0{0,2}[1-9]|0?[1-9][0-9]|10[0-5])');
162 | assert.equal(toRange('010', '105'), '(?:0?1[0-9]|0?[2-9][0-9]|10[0-5])');
163 | assert.equal(toRange('010', '1005'), '(?:0{0,2}1[0-9]|0{0,2}[2-9][0-9]|0?[1-9][0-9]{2}|100[0-5])');
164 | assert.equal(toRange('0001', '1000'), toRange('001', '1000'));
165 | assert.equal(toRange('0001', '1000'), toRange('01', '1000'));
166 | });
167 |
168 | it('should generate regex strings for negative patterns', () => {
169 | assert.equal(toRange(-1, 0), '(?:-1|0)');
170 | assert.equal(toRange(-1, 1), '(?:-1|[01])');
171 | assert.equal(toRange(-4, -2), '-[2-4]');
172 | assert.equal(toRange(-3, 1), '(?:-[1-3]|[01])');
173 | assert.equal(toRange(-2, 0), '(?:-[12]|0)');
174 | assert.equal(toRange(-1, 3), '(?:-1|[0-3])');
175 | matchRange(-1, -1, '-1', [-1], [-2, 0, 1]);
176 | matchRange(-1, -10, '(?:-[1-9]|-10)', [-1, -5, -10], [-11, 0]);
177 | matchRange(-1, 3, '(?:-1|[0-3])', [-1, 0, 1, 2, 3], [-2, 4]);
178 | });
179 |
180 | it('should wrap patterns when options.capture is true', () => {
181 | assert.equal(toRange(-1, 0, { capture: true }), '(-1|0)');
182 | assert.equal(toRange(-1, 1, { capture: true }), '(-1|[01])');
183 | assert.equal(toRange(-4, -2, { capture: true }), '(-[2-4])');
184 | assert.equal(toRange(-3, 1, { capture: true }), '(-[1-3]|[01])');
185 | assert.equal(toRange(-2, 0, { capture: true }), '(-[12]|0)');
186 | assert.equal(toRange(-1, 3, { capture: true }), '(-1|[0-3])');
187 | });
188 |
189 | it('should generate regex strings for positive patterns', () => {
190 | assert.equal(toRange(1, 1), '1');
191 | assert.equal(toRange(0, 1), '(?:0|1)');
192 | assert.equal(toRange(0, 2), '[0-2]');
193 | assert.equal(toRange(65666, 65667), '(?:65666|65667)');
194 | assert.equal(toRange(12, 3456), '(?:1[2-9]|[2-9][0-9]|[1-9][0-9]{2}|[12][0-9]{3}|3[0-3][0-9]{2}|34[0-4][0-9]|345[0-6])');
195 | assert.equal(toRange(1, 3456), '(?:[1-9]|[1-9][0-9]{1,2}|[12][0-9]{3}|3[0-3][0-9]{2}|34[0-4][0-9]|345[0-6])');
196 | assert.equal(toRange(1, 10), '(?:[1-9]|10)');
197 | assert.equal(toRange(1, 19), '(?:[1-9]|1[0-9])');
198 | assert.equal(toRange(1, 99), '(?:[1-9]|[1-9][0-9])');
199 | assert.equal(toRange(1, 100), '(?:[1-9]|[1-9][0-9]|100)');
200 | assert.equal(toRange(1, 1000), '(?:[1-9]|[1-9][0-9]{1,2}|1000)');
201 | assert.equal(toRange(1, 10000), '(?:[1-9]|[1-9][0-9]{1,3}|10000)');
202 | assert.equal(toRange(1, 100000), '(?:[1-9]|[1-9][0-9]{1,4}|100000)');
203 | assert.equal(toRange(1, 9999999), '(?:[1-9]|[1-9][0-9]{1,6})');
204 | assert.equal(toRange(99, 100000), '(?:99|[1-9][0-9]{2,4}|100000)');
205 |
206 | matchRange(99, 100000, '(?:99|[1-9][0-9]{2,4}|100000)', [99, 999, 989, 100, 9999, 9899, 10009, 10999, 100000], [0, 9, 100001, 100009]);
207 | });
208 |
209 | it('should optimize regexes', () => {
210 | assert.equal(toRange(-9, 9), '(?:-[1-9]|[0-9])');
211 | assert.equal(toRange(-19, 19), '(?:-[1-9]|-?1[0-9]|[0-9])');
212 | assert.equal(toRange(-29, 29), '(?:-[1-9]|-?[12][0-9]|[0-9])');
213 | assert.equal(toRange(-99, 99), '(?:-[1-9]|-?[1-9][0-9]|[0-9])');
214 | assert.equal(toRange(-999, 999), '(?:-[1-9]|-?[1-9][0-9]{1,2}|[0-9])');
215 | assert.equal(toRange(-9999, 9999), '(?:-[1-9]|-?[1-9][0-9]{1,3}|[0-9])');
216 | assert.equal(toRange(-99999, 99999), '(?:-[1-9]|-?[1-9][0-9]{1,4}|[0-9])');
217 | });
218 | });
219 |
220 | describe('validate ranges', () => {
221 | it('should match all numbers in the given range', () => {
222 | let isMatch = matcher(1, 59);
223 | for (let i = 0; i < 100; i++) {
224 | if (i >= 1 && i <= 59) {
225 | assert(isMatch(i));
226 | } else {
227 | assert(!isMatch(i));
228 | }
229 | }
230 | });
231 |
232 | it('should support negative ranges:', () => {
233 | verifyRange(-9, -1, -100, 100);
234 | verifyRange(-99, -1, -1000, 1000);
235 | verifyRange(-999, -1, -1000, 1000);
236 | verifyRange(-9999, -1, -10000, 10000);
237 | verifyRange(-99999, -1, -100999, 100999);
238 | });
239 |
240 | it('should support negative-to-positive ranges:', () => {
241 | verifyRange(-9, 9, -100, 100);
242 | verifyRange(-99, 99, -1000, 1000);
243 | verifyRange(-999, 999, -1000, 1000);
244 | verifyRange(-9999, 9999, -10000, 10000);
245 | verifyRange(-99999, 99999, -100999, 100999);
246 | });
247 |
248 | it('should support large numbers:', () => {
249 | verifyRange(100019999300000, 100020000300000, 1000199992999900, 100020000200000);
250 | });
251 |
252 | it('should support large ranges:', () => {
253 | verifyRange(1, 100000, 1, 1000);
254 | verifyRange(1, 100000, 10000, 11000);
255 | verifyRange(1, 100000, 99000, 100000);
256 | verifyRange(1, 100000, 1000, 2000);
257 | verifyRange(1, 100000, 10000, 12000);
258 | verifyRange(1, 100000, 50000, 60000);
259 | verifyRange(1, 100000, 99999, 101000);
260 | verifyRange(10331, 20381, 0, 99999);
261 | });
262 |
263 | it('should support repeated digits:', () => {
264 | verifyRange(111, 222, 0, 999);
265 | verifyRange(111, 333, 0, 999);
266 | verifyRange(111, 444, 0, 999);
267 | verifyRange(111, 555, 0, 999);
268 | verifyRange(111, 666, 0, 999);
269 | verifyRange(111, 777, 0, 999);
270 | verifyRange(111, 888, 0, 999);
271 | verifyRange(111, 999, 0, 999);
272 | verifyRange(0, 111, -99, 999);
273 | verifyRange(0, 222, -99, 999);
274 | verifyRange(0, 333, -99, 999);
275 | verifyRange(0, 444, -99, 999);
276 | verifyRange(0, 555, -99, 999);
277 | verifyRange(0, 666, -99, 999);
278 | verifyRange(0, 777, -99, 999);
279 | verifyRange(0, 888, -99, 999);
280 | verifyRange(0, 999, -99, 999);
281 | });
282 |
283 | it('should support repeated zeros:', () => {
284 | verifyRange(10031, 20081, 0, 59999);
285 | verifyRange(10000, 20000, 0, 59999);
286 | });
287 |
288 | it('should support zero one:', () => {
289 | verifyRange(10301, 20101, 0, 99999);
290 | verifyRange(101010, 101210, 101009, 101300);
291 | });
292 |
293 | it('should support repeated ones:', () => {
294 | verifyRange(1, 11111, 0, 1000);
295 | verifyRange(1, 1111, 0, 1000);
296 | verifyRange(1, 111, 0, 1000);
297 | verifyRange(1, 11, 0, 1000);
298 | verifyRange(1, 1, 0, 1000);
299 | });
300 |
301 | it('should support small diffs:', () => {
302 | verifyRange(102, 103, 0, 1000);
303 | verifyRange(102, 110, 0, 1000);
304 | verifyRange(102, 130, 0, 1000);
305 | });
306 |
307 | it('should support random ranges:', () => {
308 | verifyRange(4173, 7981, 0, 99999);
309 | });
310 |
311 | it('should support one digit numbers:', () => {
312 | verifyRange(3, 7, 0, 99);
313 | });
314 |
315 | it('should support one digit at bounds:', () => {
316 | verifyRange(1, 9, 0, 1000);
317 | });
318 |
319 | it('should support power of ten:', () => {
320 | verifyRange(1000, 8632, 0, 99999);
321 | });
322 |
323 | it('should not match the negative of the same number', () => {
324 | verifyRange(1, 1000, -1000, 1000);
325 | verifyRange(1, 1000, '-1000', '1000');
326 | });
327 |
328 | it('should work with numbers of varying lengths:', () => {
329 | verifyRange(1030, 20101, 0, 99999);
330 | verifyRange(13, 8632, 0, 10000);
331 | });
332 |
333 | it('should support small ranges:', () => {
334 | verifyRange(9, 11, 0, 100);
335 | verifyRange(19, 21, 0, 100);
336 | });
337 |
338 | it('should support big ranges:', () => {
339 | verifyRange(90, 98009, 0, 98999);
340 | verifyRange(999, 10000, 1, 20000);
341 | });
342 |
343 | it('should create valid regex ranges with zero-padding:', () => {
344 | verifyZeros('001', '100', '001', 100);
345 | verifyZeros('001', '100', '001', '100');
346 | verifyZeros('0001', '1000', '01', 1000);
347 | verifyZeros('0001', '1000', '-01', 1000);
348 | verifyZeros('0001', '1000', '-099', '1000');
349 | verifyZeros('0001', '1000', '-010', 1000);
350 | verifyZeros('0001', '1000', '-010', 1000);
351 | verifyZeros('0001', '1000', '0001', '1000');
352 | verifyZeros('01', '1000', '-01', '1000');
353 | verifyZeros('000000001', '1000', '-010', '1000');
354 | verifyZeros('00000001', '1000', '-010', '1000');
355 | verifyZeros('0000001', '1000', '-010', '1000');
356 | verifyZeros('000001', '1000', '-010', '1000');
357 | verifyZeros('00001', '1000', '-010', '1000');
358 | verifyZeros('0001', '1000', '-010', '1000');
359 | verifyZeros('001', '1000', '-010', '1000');
360 | verifyZeros('01', '1000', '-010', '1000');
361 | verifyZeros('0001', '1000', '-010', '1000');
362 | });
363 |
364 | it('should create valid regex ranges with negative padding:', () => {
365 | verifyZeros('-00001', '-1000', -1000, 1000);
366 | verifyZeros('-0001', '-1000', -1000, 1000);
367 | verifyZeros('-001', '-1000', -1000, 1000);
368 | verifyZeros('-01', '-1000', -1000, 1000);
369 | });
370 |
371 | it('should create valid ranges with neg && pos zero-padding:', () => {
372 | verifyZeros('-01', '10', '-1', '01');
373 | verifyZeros('-1000', '100', -1000, 1000);
374 | verifyZeros('-1000', '0100', '-010', '1000');
375 | verifyZeros('-0100', '100', '-01', '100');
376 | verifyZeros('-010', '100', '-01', '100');
377 | verifyZeros('-01', '100', '-01', '100');
378 | verifyZeros('-01000', '1000', '-010', '1000');
379 | verifyZeros('-0100', '1000', '-010', '1000');
380 | verifyZeros('-010', '1000', '-010', '1000');
381 | verifyZeros('-01', '1000', '-010', '1000');
382 | });
383 | });
384 | });
385 |
--------------------------------------------------------------------------------