source: trip-planner-front/node_modules/snapdragon-util/README.md@ 8d391a1

Last change on this file since 8d391a1 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 20.9 KB
Line 
1# snapdragon-util [![NPM version](https://img.shields.io/npm/v/snapdragon-util.svg?style=flat)](https://www.npmjs.com/package/snapdragon-util) [![NPM monthly downloads](https://img.shields.io/npm/dm/snapdragon-util.svg?style=flat)](https://npmjs.org/package/snapdragon-util) [![NPM total downloads](https://img.shields.io/npm/dt/snapdragon-util.svg?style=flat)](https://npmjs.org/package/snapdragon-util) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/snapdragon-util.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/snapdragon-util)
2
3> Utilities for the snapdragon parser/compiler.
4
5<details>
6<summary><strong>Table of Contents</strong></summary>
7
8- [Install](#install)
9- [Usage](#usage)
10- [API](#api)
11- [Release history](#release-history)
12 * [[3.0.0] - 2017-05-01](#300---2017-05-01)
13 * [[0.1.0]](#010)
14- [About](#about)
15
16</details>
17
18## Install
19
20Install with [npm](https://www.npmjs.com/):
21
22```sh
23$ npm install --save snapdragon-util
24```
25
26Install with [yarn](https://yarnpkg.com):
27
28```sh
29$ yarn add snapdragon-util
30```
31
32## Usage
33
34```js
35var util = require('snapdragon-util');
36```
37
38## API
39
40### [.isNode](index.js#L21)
41
42Returns true if the given value is a node.
43
44**Params**
45
46* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
47* `returns` **{Boolean}**
48
49**Example**
50
51```js
52var Node = require('snapdragon-node');
53var node = new Node({type: 'foo'});
54console.log(utils.isNode(node)); //=> true
55console.log(utils.isNode({})); //=> false
56```
57
58### [.noop](index.js#L37)
59
60Emit an empty string for the given `node`.
61
62**Params**
63
64* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
65* `returns` **{undefined}**
66
67**Example**
68
69```js
70// do nothing for beginning-of-string
71snapdragon.compiler.set('bos', utils.noop);
72```
73
74### [.identity](index.js#L53)
75
76Appdend `node.val` to `compiler.output`, exactly as it was created by the parser.
77
78**Params**
79
80* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
81* `returns` **{undefined}**
82
83**Example**
84
85```js
86snapdragon.compiler.set('text', utils.identity);
87```
88
89### [.append](index.js#L76)
90
91Previously named `.emit`, this method appends the given `val` to `compiler.output` for the given node. Useful when you know what value should be appended advance, regardless of the actual value of `node.val`.
92
93**Params**
94
95* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
96* `returns` **{Function}**: Returns a compiler middleware function.
97
98**Example**
99
100```js
101snapdragon.compiler
102 .set('i', function(node) {
103 this.mapVisit(node);
104 })
105 .set('i.open', utils.append('<i>'))
106 .set('i.close', utils.append('</i>'))
107```
108
109### [.toNoop](index.js#L99)
110
111Used in compiler middleware, this onverts an AST node into an empty `text` node and deletes `node.nodes` if it exists. The advantage of this method is that, as opposed to completely removing the node, indices will not need to be re-calculated in sibling nodes, and nothing is appended to the output.
112
113**Params**
114
115* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
116* `nodes` **{Array}**: Optionally pass a new `nodes` value, to replace the existing `node.nodes` array.
117
118**Example**
119
120```js
121utils.toNoop(node);
122// convert `node.nodes` to the given value instead of deleting it
123utils.toNoop(node, []);
124```
125
126### [.visit](index.js#L128)
127
128Visit `node` with the given `fn`. The built-in `.visit` method in snapdragon automatically calls registered compilers, this allows you to pass a visitor function.
129
130**Params**
131
132* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
133* `fn` **{Function}**
134* `returns` **{Object}**: returns the node after recursively visiting all child nodes.
135
136**Example**
137
138```js
139snapdragon.compiler.set('i', function(node) {
140 utils.visit(node, function(childNode) {
141 // do stuff with "childNode"
142 return childNode;
143 });
144});
145```
146
147### [.mapVisit](index.js#L155)
148
149Map [visit](#visit) the given `fn` over `node.nodes`. This is called by [visit](#visit), use this method if you do not want `fn` to be called on the first node.
150
151**Params**
152
153* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
154* `options` **{Object}**
155* `fn` **{Function}**
156* `returns` **{Object}**: returns the node
157
158**Example**
159
160```js
161snapdragon.compiler.set('i', function(node) {
162 utils.mapVisit(node, function(childNode) {
163 // do stuff with "childNode"
164 return childNode;
165 });
166});
167```
168
169### [.addOpen](index.js#L194)
170
171Unshift an `*.open` node onto `node.nodes`.
172
173**Params**
174
175* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
176* `Node` **{Function}**: (required) Node constructor function from [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node).
177* `filter` **{Function}**: Optionaly specify a filter function to exclude the node.
178* `returns` **{Object}**: Returns the created opening node.
179
180**Example**
181
182```js
183var Node = require('snapdragon-node');
184snapdragon.parser.set('brace', function(node) {
185 var match = this.match(/^{/);
186 if (match) {
187 var parent = new Node({type: 'brace'});
188 utils.addOpen(parent, Node);
189 console.log(parent.nodes[0]):
190 // { type: 'brace.open', val: '' };
191
192 // push the parent "brace" node onto the stack
193 this.push(parent);
194
195 // return the parent node, so it's also added to the AST
196 return brace;
197 }
198});
199```
200
201### [.addClose](index.js#L244)
202
203Push a `*.close` node onto `node.nodes`.
204
205**Params**
206
207* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
208* `Node` **{Function}**: (required) Node constructor function from [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node).
209* `filter` **{Function}**: Optionaly specify a filter function to exclude the node.
210* `returns` **{Object}**: Returns the created closing node.
211
212**Example**
213
214```js
215var Node = require('snapdragon-node');
216snapdragon.parser.set('brace', function(node) {
217 var match = this.match(/^}/);
218 if (match) {
219 var parent = this.parent();
220 if (parent.type !== 'brace') {
221 throw new Error('missing opening: ' + '}');
222 }
223
224 utils.addClose(parent, Node);
225 console.log(parent.nodes[parent.nodes.length - 1]):
226 // { type: 'brace.close', val: '' };
227
228 // no need to return a node, since the parent
229 // was already added to the AST
230 return;
231 }
232});
233```
234
235### [.wrapNodes](index.js#L274)
236
237Wraps the given `node` with `*.open` and `*.close` nodes.
238
239**Params**
240
241* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
242* `Node` **{Function}**: (required) Node constructor function from [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node).
243* `filter` **{Function}**: Optionaly specify a filter function to exclude the node.
244* `returns` **{Object}**: Returns the node
245
246### [.pushNode](index.js#L299)
247
248Push the given `node` onto `parent.nodes`, and set `parent` as `node.parent.
249
250**Params**
251
252* `parent` **{Object}**
253* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
254* `returns` **{Object}**: Returns the child node
255
256**Example**
257
258```js
259var parent = new Node({type: 'foo'});
260var node = new Node({type: 'bar'});
261utils.pushNode(parent, node);
262console.log(parent.nodes[0].type) // 'bar'
263console.log(node.parent.type) // 'foo'
264```
265
266### [.unshiftNode](index.js#L325)
267
268Unshift `node` onto `parent.nodes`, and set `parent` as `node.parent.
269
270**Params**
271
272* `parent` **{Object}**
273* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
274* `returns` **{undefined}**
275
276**Example**
277
278```js
279var parent = new Node({type: 'foo'});
280var node = new Node({type: 'bar'});
281utils.unshiftNode(parent, node);
282console.log(parent.nodes[0].type) // 'bar'
283console.log(node.parent.type) // 'foo'
284```
285
286### [.popNode](index.js#L354)
287
288Pop the last `node` off of `parent.nodes`. The advantage of using this method is that it checks for `node.nodes` and works with any version of `snapdragon-node`.
289
290**Params**
291
292* `parent` **{Object}**
293* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
294* `returns` **{Number|Undefined}**: Returns the length of `node.nodes` or undefined.
295
296**Example**
297
298```js
299var parent = new Node({type: 'foo'});
300utils.pushNode(parent, new Node({type: 'foo'}));
301utils.pushNode(parent, new Node({type: 'bar'}));
302utils.pushNode(parent, new Node({type: 'baz'}));
303console.log(parent.nodes.length); //=> 3
304utils.popNode(parent);
305console.log(parent.nodes.length); //=> 2
306```
307
308### [.shiftNode](index.js#L382)
309
310Shift the first `node` off of `parent.nodes`. The advantage of using this method is that it checks for `node.nodes` and works with any version of `snapdragon-node`.
311
312**Params**
313
314* `parent` **{Object}**
315* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
316* `returns` **{Number|Undefined}**: Returns the length of `node.nodes` or undefined.
317
318**Example**
319
320```js
321var parent = new Node({type: 'foo'});
322utils.pushNode(parent, new Node({type: 'foo'}));
323utils.pushNode(parent, new Node({type: 'bar'}));
324utils.pushNode(parent, new Node({type: 'baz'}));
325console.log(parent.nodes.length); //=> 3
326utils.shiftNode(parent);
327console.log(parent.nodes.length); //=> 2
328```
329
330### [.removeNode](index.js#L409)
331
332Remove the specified `node` from `parent.nodes`.
333
334**Params**
335
336* `parent` **{Object}**
337* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
338* `returns` **{Object|undefined}**: Returns the removed node, if successful, or undefined if it does not exist on `parent.nodes`.
339
340**Example**
341
342```js
343var parent = new Node({type: 'abc'});
344var foo = new Node({type: 'foo'});
345utils.pushNode(parent, foo);
346utils.pushNode(parent, new Node({type: 'bar'}));
347utils.pushNode(parent, new Node({type: 'baz'}));
348console.log(parent.nodes.length); //=> 3
349utils.removeNode(parent, foo);
350console.log(parent.nodes.length); //=> 2
351```
352
353### [.isType](index.js#L443)
354
355Returns true if `node.type` matches the given `type`. Throws a `TypeError` if `node` is not an instance of `Node`.
356
357**Params**
358
359* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
360* `type` **{String}**
361* `returns` **{Boolean}**
362
363**Example**
364
365```js
366var Node = require('snapdragon-node');
367var node = new Node({type: 'foo'});
368console.log(utils.isType(node, 'foo')); // false
369console.log(utils.isType(node, 'bar')); // true
370```
371
372### [.hasType](index.js#L486)
373
374Returns true if the given `node` has the given `type` in `node.nodes`. Throws a `TypeError` if `node` is not an instance of `Node`.
375
376**Params**
377
378* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
379* `type` **{String}**
380* `returns` **{Boolean}**
381
382**Example**
383
384```js
385var Node = require('snapdragon-node');
386var node = new Node({
387 type: 'foo',
388 nodes: [
389 new Node({type: 'bar'}),
390 new Node({type: 'baz'})
391 ]
392});
393console.log(utils.hasType(node, 'xyz')); // false
394console.log(utils.hasType(node, 'baz')); // true
395```
396
397### [.firstOfType](index.js#L519)
398
399Returns the first node from `node.nodes` of the given `type`
400
401**Params**
402
403* `nodes` **{Array}**
404* `type` **{String}**
405* `returns` **{Object|undefined}**: Returns the first matching node or undefined.
406
407**Example**
408
409```js
410var node = new Node({
411 type: 'foo',
412 nodes: [
413 new Node({type: 'text', val: 'abc'}),
414 new Node({type: 'text', val: 'xyz'})
415 ]
416});
417
418var textNode = utils.firstOfType(node.nodes, 'text');
419console.log(textNode.val);
420//=> 'abc'
421```
422
423### [.findNode](index.js#L556)
424
425Returns the node at the specified index, or the first node of the given `type` from `node.nodes`.
426
427**Params**
428
429* `nodes` **{Array}**
430* `type` **{String|Number}**: Node type or index.
431* `returns` **{Object}**: Returns a node or undefined.
432
433**Example**
434
435```js
436var node = new Node({
437 type: 'foo',
438 nodes: [
439 new Node({type: 'text', val: 'abc'}),
440 new Node({type: 'text', val: 'xyz'})
441 ]
442});
443
444var nodeOne = utils.findNode(node.nodes, 'text');
445console.log(nodeOne.val);
446//=> 'abc'
447
448var nodeTwo = utils.findNode(node.nodes, 1);
449console.log(nodeTwo.val);
450//=> 'xyz'
451```
452
453### [.isOpen](index.js#L584)
454
455Returns true if the given node is an "*.open" node.
456
457**Params**
458
459* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
460* `returns` **{Boolean}**
461
462**Example**
463
464```js
465var Node = require('snapdragon-node');
466var brace = new Node({type: 'brace'});
467var open = new Node({type: 'brace.open'});
468var close = new Node({type: 'brace.close'});
469
470console.log(utils.isOpen(brace)); // false
471console.log(utils.isOpen(open)); // true
472console.log(utils.isOpen(close)); // false
473```
474
475### [.isClose](index.js#L607)
476
477Returns true if the given node is a "*.close" node.
478
479**Params**
480
481* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
482* `returns` **{Boolean}**
483
484**Example**
485
486```js
487var Node = require('snapdragon-node');
488var brace = new Node({type: 'brace'});
489var open = new Node({type: 'brace.open'});
490var close = new Node({type: 'brace.close'});
491
492console.log(utils.isClose(brace)); // false
493console.log(utils.isClose(open)); // false
494console.log(utils.isClose(close)); // true
495```
496
497### [.hasOpen](index.js#L633)
498
499Returns true if `node.nodes` **has** an `.open` node
500
501**Params**
502
503* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
504* `returns` **{Boolean}**
505
506**Example**
507
508```js
509var Node = require('snapdragon-node');
510var brace = new Node({
511 type: 'brace',
512 nodes: []
513});
514
515var open = new Node({type: 'brace.open'});
516console.log(utils.hasOpen(brace)); // false
517
518brace.pushNode(open);
519console.log(utils.hasOpen(brace)); // true
520```
521
522### [.hasClose](index.js#L663)
523
524Returns true if `node.nodes` **has** a `.close` node
525
526**Params**
527
528* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
529* `returns` **{Boolean}**
530
531**Example**
532
533```js
534var Node = require('snapdragon-node');
535var brace = new Node({
536 type: 'brace',
537 nodes: []
538});
539
540var close = new Node({type: 'brace.close'});
541console.log(utils.hasClose(brace)); // false
542
543brace.pushNode(close);
544console.log(utils.hasClose(brace)); // true
545```
546
547### [.hasOpenAndClose](index.js#L697)
548
549Returns true if `node.nodes` has both `.open` and `.close` nodes
550
551**Params**
552
553* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
554* `returns` **{Boolean}**
555
556**Example**
557
558```js
559var Node = require('snapdragon-node');
560var brace = new Node({
561 type: 'brace',
562 nodes: []
563});
564
565var open = new Node({type: 'brace.open'});
566var close = new Node({type: 'brace.close'});
567console.log(utils.hasOpen(brace)); // false
568console.log(utils.hasClose(brace)); // false
569
570brace.pushNode(open);
571brace.pushNode(close);
572console.log(utils.hasOpen(brace)); // true
573console.log(utils.hasClose(brace)); // true
574```
575
576### [.addType](index.js#L719)
577
578Push the given `node` onto the `state.inside` array for the given type. This array is used as a specialized "stack" for only the given `node.type`.
579
580**Params**
581
582* `state` **{Object}**: The `compiler.state` object or custom state object.
583* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
584* `returns` **{Array}**: Returns the `state.inside` stack for the given type.
585
586**Example**
587
588```js
589var state = { inside: {}};
590var node = new Node({type: 'brace'});
591utils.addType(state, node);
592console.log(state.inside);
593//=> { brace: [{type: 'brace'}] }
594```
595
596### [.removeType](index.js#L759)
597
598Remove the given `node` from the `state.inside` array for the given type. This array is used as a specialized "stack" for only the given `node.type`.
599
600**Params**
601
602* `state` **{Object}**: The `compiler.state` object or custom state object.
603* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
604* `returns` **{Array}**: Returns the `state.inside` stack for the given type.
605
606**Example**
607
608```js
609var state = { inside: {}};
610var node = new Node({type: 'brace'});
611utils.addType(state, node);
612console.log(state.inside);
613//=> { brace: [{type: 'brace'}] }
614utils.removeType(state, node);
615//=> { brace: [] }
616```
617
618### [.isEmpty](index.js#L788)
619
620Returns true if `node.val` is an empty string, or `node.nodes` does not contain any non-empty text nodes.
621
622**Params**
623
624* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
625* `fn` **{Function}**
626* `returns` **{Boolean}**
627
628**Example**
629
630```js
631var node = new Node({type: 'text'});
632utils.isEmpty(node); //=> true
633node.val = 'foo';
634utils.isEmpty(node); //=> false
635```
636
637### [.isInsideType](index.js#L833)
638
639Returns true if the `state.inside` stack for the given type exists and has one or more nodes on it.
640
641**Params**
642
643* `state` **{Object}**
644* `type` **{String}**
645* `returns` **{Boolean}**
646
647**Example**
648
649```js
650var state = { inside: {}};
651var node = new Node({type: 'brace'});
652console.log(utils.isInsideType(state, 'brace')); //=> false
653utils.addType(state, node);
654console.log(utils.isInsideType(state, 'brace')); //=> true
655utils.removeType(state, node);
656console.log(utils.isInsideType(state, 'brace')); //=> false
657```
658
659### [.isInside](index.js#L867)
660
661Returns true if `node` is either a child or grand-child of the given `type`, or `state.inside[type]` is a non-empty array.
662
663**Params**
664
665* `state` **{Object}**: Either the `compiler.state` object, if it exists, or a user-supplied state object.
666* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
667* `type` **{String}**: The `node.type` to check for.
668* `returns` **{Boolean}**
669
670**Example**
671
672```js
673var state = { inside: {}};
674var node = new Node({type: 'brace'});
675var open = new Node({type: 'brace.open'});
676console.log(utils.isInside(state, open, 'brace')); //=> false
677utils.pushNode(node, open);
678console.log(utils.isInside(state, open, 'brace')); //=> true
679```
680
681### [.last](index.js#L915)
682
683Get the last `n` element from the given `array`. Used for getting
684a node from `node.nodes.`
685
686**Params**
687
688* `array` **{Array}**
689* `n` **{Number}**
690* `returns` **{undefined}**
691
692### [.arrayify](index.js#L935)
693
694Cast the given `val` to an array.
695
696**Params**
697
698* `val` **{any}**
699* `returns` **{Array}**
700
701**Example**
702
703```js
704console.log(utils.arraify(''));
705//=> []
706console.log(utils.arraify('foo'));
707//=> ['foo']
708console.log(utils.arraify(['foo']));
709//=> ['foo']
710```
711
712### [.stringify](index.js#L948)
713
714Convert the given `val` to a string by joining with `,`. Useful
715for creating a cheerio/CSS/DOM-style selector from a list of strings.
716
717**Params**
718
719* `val` **{any}**
720* `returns` **{Array}**
721
722### [.trim](index.js#L961)
723
724Ensure that the given value is a string and call `.trim()` on it,
725or return an empty string.
726
727**Params**
728
729* `str` **{String}**
730* `returns` **{String}**
731
732## Release history
733
734Changelog entries are classified using the following labels from [keep-a-changelog](https://github.com/olivierlacan/keep-a-changelog):
735
736* `added`: for new features
737* `changed`: for changes in existing functionality
738* `deprecated`: for once-stable features removed in upcoming releases
739* `removed`: for deprecated features removed in this release
740* `fixed`: for any bug fixes
741
742Custom labels used in this changelog:
743
744* `dependencies`: bumps dependencies
745* `housekeeping`: code re-organization, minor edits, or other changes that don't fit in one of the other categories.
746
747### [3.0.0] - 2017-05-01
748
749**Changed**
750
751* `.emit` was renamed to [.append](#append)
752* `.addNode` was renamed to [.pushNode](#pushNode)
753* `.getNode` was renamed to [.findNode](#findNode)
754* `.isEmptyNodes` was renamed to [.isEmpty](#isEmpty): also now works with `node.nodes` and/or `node.val`
755
756**Added**
757
758* [.identity](#identity)
759* [.removeNode](#removeNode)
760* [.shiftNode](#shiftNode)
761* [.popNode](#popNode)
762
763### [0.1.0]
764
765First release.
766
767## About
768
769### Contributing
770
771Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
772
773Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
774
775### Building docs
776
777_(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.)_
778
779To generate the readme, run the following command:
780
781```sh
782$ npm install -g verbose/verb#dev verb-generate-readme && verb
783```
784
785### Running tests
786
787Running 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:
788
789```sh
790$ npm install && npm test
791```
792
793### Author
794
795**Jon Schlinkert**
796
797* [github/jonschlinkert](https://github.com/jonschlinkert)
798* [twitter/jonschlinkert](https://twitter.com/jonschlinkert)
799
800### License
801
802Copyright © 2017, [Jon Schlinkert](https://github.com/jonschlinkert).
803Released under the [MIT License](LICENSE).
804
805***
806
807_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on May 01, 2017._
Note: See TracBrowser for help on using the repository browser.