├── .gitignore
├── keymaps
    └── magic-reflow.cson
├── menus
    └── magic-reflow.cson
├── package.json
├── CHANGELOG.md
├── LICENSE.md
├── README.md
├── spec
    └── magic-reflow-spec.js
└── lib
    └── magic-reflow.js


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | npm-debug.log
3 | node_modules
4 | 


--------------------------------------------------------------------------------
/keymaps/magic-reflow.cson:
--------------------------------------------------------------------------------
1 | "atom-workspace atom-text-editor":
2 |     "alt-q": "magic-reflow:reflow"
3 | 


--------------------------------------------------------------------------------
/menus/magic-reflow.cson:
--------------------------------------------------------------------------------
 1 | "context-menu":
 2 |     "atom-text-editor": [
 3 |         {
 4 |             "label": "Reflow Selection Magically"
 5 |             "command": "magic-reflow:reflow"
 6 |         }
 7 |     ]
 8 | 
 9 | "menu": [
10 |     {
11 |         "label": "Edit"
12 |         "submenu": [
13 |             {
14 |                 "label": "Reflow Selection Magically"
15 |                 "command": "magic-reflow:reflow"
16 |             }
17 |         ]
18 |     }
19 | ]
20 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "magic-reflow",
 3 |   "main": "./lib/magic-reflow",
 4 |   "version": "0.3.0",
 5 |   "description": "Re-flow/re-wrap text in a variety of situations (comments, lists, etc.)",
 6 |   "keywords": [
 7 |     "wrap",
 8 |     "reflow",
 9 |     "rewrap",
10 |     "hard wrap",
11 |     "hard-wrap",
12 |     "format"
13 |   ],
14 |   "activationCommands": {
15 |     "atom-text-editor": "magic-reflow:reflow"
16 |   },
17 |   "repository": "https://github.com/josh-berry/magic-reflow",
18 |   "license": "MIT",
19 |   "engines": {
20 |     "atom": ">=1.8.0 <2.0.0"
21 |   },
22 |   "dependencies": {},
23 |   "devDependencies": {}
24 | }
25 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | ## 0.3.0 - Handle tab characters gracefully
 2 | 
 3 | Added:
 4 | 
 5 | - Detect and clean up inconsistent use of tab and space characters, according to
 6 |   editor settings.
 7 | - Reflow tab characters according to their proper visual width.
 8 | 
 9 | ## 0.2.0 - Fixes for various list issues
10 | 
11 | Fixed:
12 | 
13 | - Lots of corner cases related to lists, through an almost-complete rewrite.
14 | 
15 | Dropped:
16 | 
17 | - Support for paragraphs with leading indentation.  The new algorithm
18 |   unfortunately has lots of trouble with these, and they're not widely used.
19 | 
20 | ## 0.1.0 - First Release
21 | 
22 | Features:
23 | 
24 | - Wrap within common single-line and multi-line source code comments.
25 | - Wrap bulleted and ordered lists (with or without blank lines between each
26 |   item).  Recognizes numbered and lettered lists of the forms:
27 |   - 1., a., A.
28 |   - (2), (b), (B)
29 | - Wrap paragraphs with leading indentation
30 | - Wrap paragraphs with block indentation
31 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2016 Joshua J. Berry <des@condordes.net>
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | "Software"), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Magic Reflow
 2 | 
 3 | Magic Reflow will reflow or rewrap text in a variety of situations, ranging from
 4 | paragraphs, to comments, to bulleted and ordered lists (of the variety commonly
 5 | seen in Markdown and the like).
 6 | 
 7 | ## About
 8 | 
 9 | It is a replacement for the built-in autoflow package -- it handles many of the
10 | things that autoflow handles, and a lot more:
11 | 
12 | - Wrap within common single-line and multi-line source code comments.
13 | - Wrap bulleted and ordered lists (with or without blank lines between each
14 |   item).  Recognizes numbered and lettered lists of the forms:
15 |   - 1., a., A.
16 |   - (2), (b), (B)
17 | - Wrap nested lists intelligently.
18 | - Wrap paragraphs with block indentation
19 | 
20 | ...and various combinations of all of the above.
21 | 
22 | ## How to Use Magic Reflow
23 | 
24 | 1. Select the text you want to reflow, or put your cursor in the relevant
25 |    paragraph.
26 | 2. Hit Alt-Q.
27 | 
28 | Note that if you use one of the popular Emacs-emulation packages, you may have
29 | to add the following to your keymap.cson to make the keybinding work:
30 | 
31 |     'atom-workspace atom-text-editor':
32 |         'alt-q': 'magic-reflow:reflow'
33 | 
34 | You can also use the "Reflow Selection Magically" context menu option, or the
35 | "Edit > Reflow Selection Magically" menu bar option.
36 | 
37 | ## Future Work
38 | 
39 | - Support for paragraphs with leading indentation
40 | - Support for ASCII-art tables (a la org-mode)
41 | - Ignore code fences (a la Doxygen comments, markdown, etc.)
42 | 


--------------------------------------------------------------------------------
/spec/magic-reflow-spec.js:
--------------------------------------------------------------------------------
  1 | 'use babel';
  2 | 
  3 | import MagicReflow from '../lib/magic-reflow';
  4 | 
  5 | // Use the command `window:run-package-specs` (cmd-alt-ctrl-p) to run specs.
  6 | //
  7 | // To run a specific `it` or `describe` block add an `f` to the front (e.g.
  8 | // `fit` or `fdescribe`).  Remove the `f` to unfocus the block.
  9 | 
 10 | function test([input, line_vlen, tab_vlen, soft_tab], expected) {
 11 |     console.log(`BEGIN TEST:\n${input}`);
 12 |     let actual = MagicReflow.reflow(
 13 |         input, {line_vlen: line_vlen, tab_vlen: tab_vlen, soft_tab: soft_tab});
 14 |     console.log(`TEST EXPECTED:\n${expected}`);
 15 |     console.log(`TEST ACTUAL:\n${[actual]}`);
 16 |     expect(actual).toBe(expected);
 17 | };
 18 | 
 19 | function qcheck(what, args, expected) {
 20 |     it(`returns ${expected} for ${args}`, () => {
 21 |         let actual = what(...args);
 22 |         expect(actual).toBe(expected);
 23 |     });
 24 | }
 25 | 
 26 | function qcheckgen(gen, what, args, expected) {
 27 |     it(`${what}: returns ${expected} for ${args}`, () => {
 28 |         console.log(`BEGIN TEST ${what}:`, args);
 29 |         let actual = Array.from(gen(...args));
 30 |         console.log(`ACTUAL:  `, actual);
 31 |         console.log(`EXPECTED:`, [expected]);
 32 |         expect(actual[0]).toBe(expected);
 33 |     });
 34 | }
 35 | 
 36 | describe('MagicReflow', () => {
 37 |     describe('vlen', () => {
 38 |         let vlen = MagicReflow.vlen;
 39 |         describe('empty strings', () => {
 40 |             qcheck(vlen, ['', 0, 8], 0);
 41 |             qcheck(vlen, ['', 4, 8], 0);
 42 |         });
 43 | 
 44 |         describe('non-tab chars', () => {
 45 |             qcheck(vlen, ['  ', 0, 4], 2);
 46 |             qcheck(vlen, ['foo', 0, 4], 3);
 47 |         });
 48 | 
 49 |         describe('simple tabs', () => {
 50 |             qcheck(vlen, ['\t', 0, 8], 8);
 51 |             qcheck(vlen, ['\t', 4, 8], 4);
 52 |             qcheck(vlen, ['\t', 8, 8], 8);
 53 | 
 54 |             qcheck(vlen, ['\t', 0, 4], 4);
 55 |             qcheck(vlen, ['\t', 4, 4], 4);
 56 |         });
 57 | 
 58 |         describe('short text followed by tab', () => {
 59 |             qcheck(vlen, ['foo\t', 0, 8], 8);
 60 |             qcheck(vlen, ['foo\t', 4, 8], 4);
 61 |             qcheck(vlen, ['foo\t', 8, 8], 8);
 62 | 
 63 |             qcheck(vlen, ['foo\t', 0, 4], 4);
 64 |             qcheck(vlen, ['foo\t', 4, 4], 4);
 65 |         });
 66 | 
 67 |         describe('tab in middle', () => {
 68 |             qcheck(vlen, ['foo\tbar', 0, 8], 8+3);
 69 |             qcheck(vlen, ['foo\tbar', 4, 8], 4+3);
 70 |             qcheck(vlen, ['foo\tbar', 8, 8], 8+3);
 71 | 
 72 |             qcheck(vlen, ['foo\tbar', 0, 4], 4+3);
 73 |             qcheck(vlen, ['foo\tbar', 4, 4], 4+3);
 74 |         });
 75 | 
 76 |         describe('multiple tabs', () => {
 77 |             qcheck(vlen, ['foo\t\t', 0, 8], 8+8);
 78 |             qcheck(vlen, ['foo\t\t', 4, 8], 4+8);
 79 |             qcheck(vlen, ['foo\t\t', 8, 8], 8+8);
 80 | 
 81 |             qcheck(vlen, ['foo\t\t', 0, 4], 4+4);
 82 |             qcheck(vlen, ['foo\t\t', 4, 4], 4+4);
 83 |         });
 84 |     });
 85 | 
 86 |     describe('indent_with_tabs', () => {
 87 |         let iwt = MagicReflow.indent_with_tabs;
 88 | 
 89 |         qcheck(iwt, [0, 4], '');
 90 |         qcheck(iwt, [1, 4], ' ');
 91 |         qcheck(iwt, [4, 4], '\t');
 92 |         qcheck(iwt, [5, 4], '\t ');
 93 |         qcheck(iwt, [8, 4], '\t\t');
 94 |         qcheck(iwt, [10, 4], '\t\t  ');
 95 |     });
 96 | 
 97 |     describe('leading_tabs_to_spaces', () => {
 98 |         let gen = MagicReflow.leading_tabs_to_spaces;
 99 | 
100 |         qcheckgen(gen, 'tab', [['\tfoo'], 4], '    foo');
101 |         qcheckgen(gen, 'tab+spc', [['\t  foo'], 4], '      foo');
102 |         qcheckgen(gen, 'spc+tab+spc', [[' \t  foo'], 4], '      foo');
103 |         qcheckgen(gen, 'spc+tab+spc+tab', [[' \t \tfoo'], 4], '        foo');
104 |     });
105 | 
106 |     describe('leading_spaces_to_tabs', () => {
107 |         let gen = MagicReflow.leading_spaces_to_tabs;
108 | 
109 |         qcheckgen(gen, 'tab', [['    foo'], 4], '\tfoo');
110 |         qcheckgen(gen, 'tab+spc', [['      foo'], 4], '\t  foo');
111 |         qcheckgen(gen, 'spc+tab+spc', [['      foo'], 4], '\t  foo');
112 |         qcheckgen(gen, 'spc+tab+spc+tab', [['        foo'], 4], '\t\tfoo');
113 |     });
114 | 
115 |     describe('when reflowing a single paragraph', () => {
116 |         it('leaves short lines alone', () => test(
117 |             ['This is a short line.'],
118 |             'This is a short line.'
119 |         ));
120 | 
121 |         it('wraps long lines', () => test(
122 |             ['This is a much longer line, with more text.', 30],
123 |             'This is a much longer line,\nwith more text.'
124 |         ));
125 | 
126 |         it('leaves leading whitespace intact', () => test(
127 |             ['\nLeading whitespace.', 80],
128 |             '\nLeading whitespace.'
129 |         ));
130 | 
131 |         it('leaves more leading whitespace intact', () => test(
132 |             ['\n\nLeading whitespace.', 80],
133 |             '\n\nLeading whitespace.'
134 |         ));
135 | 
136 |         it('leaves trailing whitespace intact', () => test(
137 |             ['Trailing whitespace.\n', 80],
138 |             'Trailing whitespace.\n'
139 |         ));
140 | 
141 |         it('leaves more trailing whitespace intact', () => test(
142 |             ['Trailing whitespace.\n\n', 80],
143 |             'Trailing whitespace.\n\n'
144 |         ));
145 | 
146 |         it('lets long words overflow', () => test(
147 |             ['This IsAReallyLongWordThatDoesntFit in a single line.', 20],
148 |             'This\nIsAReallyLongWordThatDoesntFit\nin a single line.'
149 |         ));
150 | 
151 |         it('re-wraps multiple short lines', () => test(
152 |             ['This is a bunch\nof short lines,\nwith some text.', 30],
153 |             'This is a bunch of short\nlines, with some text.'
154 |         ));
155 | 
156 |         it('re-wraps multiple long lines', () => test(
157 |             ['This is a long line, followed by another long\nline.  This is another long line.', 30],
158 |             'This is a long line, followed\nby another long line.  This is\nanother long line.'
159 |         ));
160 | 
161 |         it('puts two spaces after a period at the end of a line', () => test(
162 |             ['This is a long line, followed by another long line.\nThis is another long line.', 30],
163 |             'This is a long line, followed\nby another long line.  This is\nanother long line.'
164 |         ));
165 | 
166 |         it('leaves leading and trailing blank lines alone', () => test(
167 |             ['This is a short line with some words.', 12],
168 |             'This is a\nshort line\nwith some\nwords.'
169 |         ));
170 |     });
171 | 
172 |     describe('when reflowing multiple paragraphs', () => {
173 |         it('wraps each paragraph independently', () => test(
174 |             ['First paragraph is this.\n\nSecond paragraph is this.', 16],
175 |             'First paragraph\nis this.\n\nSecond paragraph\nis this.'
176 |         ));
177 |         it('leaves leading and trailing blank lines alone', () => test(
178 |             ['\n\nThis is a short line.\n\nAnother paragraph.\n\n', 12],
179 |             '\n\nThis is a\nshort line.\n\nAnother\nparagraph.\n\n'
180 |         ));
181 |         it('re-wraps short lines within a paragraph', () => test(
182 |             ['First\nparagraph is this.\n\nSecond\nparagraph is this.', 16],
183 |             'First paragraph\nis this.\n\nSecond paragraph\nis this.'
184 |         ));
185 |     });
186 | 
187 |     // XXX not implemented in the new version
188 |     xdescribe('when dealing with leading space characters', () => {
189 |         it('wraps a single line in block style', () => test(
190 |             ['   This line should be wrapped in block style.', 12],
191 |             '   This line\n   should be\n   wrapped\n   in block\n   style.'
192 |         ));
193 | 
194 |         it('recognizes differing first-line indentation', () => test(
195 |             ['  This is the first line.\nThis is the second line.', 12],
196 |             '  This is\nthe first\nline.  This\nis the\nsecond line.'
197 |         ));
198 | 
199 |         it('recognizes block-style indentation', () => test(
200 |             ['  This is the first line.\n  This is the second line.', 14],
201 |             '  This is the\n  first line.\n  This is the\n  second line.'
202 |         ));
203 | 
204 |         it('recognizes combined first-line and block-style indentation', () => test(
205 |             ['    This is the first line.\n  This is the second line.', 14],
206 |             '    This is\n  the first\n  line.  This\n  is the\n  second line.'
207 |         ));
208 | 
209 |         it('converts spaces to tabs if appropriate', () => test(
210 |             ['    This is the first line.', 24, 4, false],
211 |             '\tThis is the first line.'
212 |         ));
213 | 
214 |         it('handles inconsistent use of tabs and spaces', () => test(
215 |             ['\tLeading tab.\n        Second line.', 40, 8, true],
216 |             '        Leading tab.  Second line.'
217 |         ));
218 | 
219 | 
220 |         it('fixes inconsistent indentation', () => test(
221 |             [`
222 |     This is the first line.
223 |   This is the second line.
224 |    This is the third line.
225 | `, 14],
226 |             `
227 |     This is
228 |   the first
229 |   line.  This
230 |   is the
231 |   second line.
232 |   This is the
233 |   third line.
234 | `
235 |         ));
236 |     });
237 | 
238 |     describe('when dealing with leading tab characters', () => {
239 |         it('preserves block style with tabs (one line)', () => test(
240 |             ['\tLeading tab.\n\tSecond line.', 40, 8, false],
241 |             '\tLeading tab.  Second line.'
242 |         ));
243 |         it('preserves block style with tabs (multi-line)', () => test(
244 |             ['\tLeading tab that is a long line.\n\tSecond line.', 24, 8, false],
245 |             '\tLeading tab that\n\tis a long line.\n\tSecond line.'
246 |         ));
247 |         it('uses the correct tab width for indentation', () => test(
248 |             ['\tLeading tab that is a long line.  Should be 24 cols.', 24, 4, false],
249 |             '\tLeading tab that is\n\ta long line.  Should\n\tbe 24 cols.',
250 |         ));
251 |         it('handles tabs after leading sigils', () => test(
252 |             ['1.\tThis is a numbered list item that needs wrapping.', 24, 4, false],
253 |             '1.\tThis is a numbered\n\tlist item that needs\n\twrapping.'
254 |         ));
255 | 
256 |         it('converts tabs to spaces if appropriate', () => test(
257 |             ['\tLeading tab.\n\tSecond line.', 40, 8, true],
258 |             '        Leading tab.  Second line.'
259 |         ));
260 | 
261 |         it('handles inconsistent use of tabs and spaces', () => test(
262 |             ['\tLeading tab.\n        Second line.', 40, 8, false],
263 |             '\tLeading tab.  Second line.'
264 |         ));
265 | 
266 |         // BEGIN: Leading indents are not supported currently.
267 |         xit('preserves leading indents with tabs (one line)', () => test(
268 |             ['\tLeading tab.\nSecond line.', 40],
269 |             '\tLeading tab.  Second line.'
270 |         ));
271 |         xit('preserves leading indents with tabs (multi-line)', () => test(
272 |             ['\tLeading tab.\nSecond line.', 40],
273 |             '\tLeading tab.  Second line.'
274 |         ));
275 |         // END: leading indents
276 |     });
277 | 
278 |     for (let sigil of ['#', '##', '//', '///', '--', ';', ';;', ';;;']) {
279 |         describe(`when dealing with ${sigil} comments`, () => {
280 |             it(`wraps one line of ${sigil} comments correctly`, () => test(
281 |                 [`${sigil} Hello, world!  Have another line.`, 24],
282 |                 `${sigil} Hello, world!  Have\n${sigil} another line.`
283 |             ));
284 |             it(`wraps many lines of ${sigil} comments correctly`, () => test(
285 |                 [`${sigil} Hello, world!\n${sigil} Have another line.`, 24],
286 |                 `${sigil} Hello, world!  Have\n${sigil} another line.`
287 |             ));
288 |             it('recognizes leading whitespace (one line)', () => test(
289 |                 [`    ${sigil} Hello, world!  Have another.`, 24],
290 |                 `    ${sigil} Hello, world!\n    ${sigil} Have another.`
291 | 
292 |             ));
293 |             it('recognizes leading whitespace (multi-line)', () => test(
294 |                 [`    ${sigil} Hello, world!  Have\n    ${sigil} another.`, 24],
295 |                 `    ${sigil} Hello, world!\n    ${sigil} Have another.`
296 | 
297 |             ));
298 |         });
299 |     }
300 | 
301 |     describe('when reflowing paragraphs with only a leading sigil', () => {
302 |         for (let sigil of ['-', '+', '*', '<!--', '/*', '/**', '1.', 'a.', '10.']) {
303 |             let spaces = ' '.repeat(sigil.length);
304 |             it(`recognizes single lines beginning with ${sigil}`, () => test(
305 |                 [`${sigil} effervescently excuplatory exploratory`, 24],
306 |                 `${sigil} effervescently\n${spaces} excuplatory\n${spaces} exploratory`
307 |             ));
308 |         }
309 | 
310 |         it('ignores leading sigils that are part of a paragraph', () => test(
311 |             ['1. this is a para\nitem broken up', 24],
312 |             '1. this is a para item\nbroken up'
313 |         ));
314 | 
315 |         it('ignores paragraphs with sigils in the middle', () => test(
316 |             [`
317 | This is a previously-wrapped paragraph
318 | - it has an unfortunate dash in it.
319 | That - shouldn't be a list.
320 | `, 40], `
321 | This is a previously-wrapped paragraph -
322 | it has an unfortunate dash in it.  That
323 | - shouldn't be a list.
324 | `
325 |         ));
326 | 
327 |         it('detects leading sigils with multiple lines', () => test(
328 |             ['.. this is a list\n item broken up', 24],
329 |             '.. this is a list item\n   broken up'
330 |         ));
331 | 
332 |         it('detects leading sigils with lots of lines', () => test(
333 |             ['.. This is a paragraph\n   with more than\n   two lines.', 24],
334 |             '.. This is a paragraph\n   with more than two\n   lines.'
335 |         ));
336 | 
337 |         it('detects leading sigils, multi-line, trailing .', () => test(
338 |             ['.. this is a list.\n item broken up', 24],
339 |             '.. this is a list.  item\n   broken up'
340 |         ));
341 |     });
342 | 
343 |     describe('when reflowing unordered lists', () => {
344 |         it('handles list items with blank lines between them', () => test(
345 |             [`
346 | - This is a short list item.
347 | 
348 | - This is a longer list item, which I expect to wrap across two lines.
349 | `, 40], `
350 | - This is a short list item.
351 | 
352 | - This is a longer list item, which I
353 |   expect to wrap across two lines.
354 | `
355 |         ));
356 | 
357 |         it('handles list items without blank lines between them', () => test(
358 |             [`
359 | - This is a short list item.
360 | - This is a longer list item, which I expect to wrap across two lines.
361 | `, 40], `
362 | - This is a short list item.
363 | - This is a longer list item, which I
364 |   expect to wrap across two lines.
365 | `
366 |         ));
367 | 
368 |         it('re-wraps list items that were poorly-wrapped', () => test(
369 |             [`
370 | - This is a list item.  It's wrapped in a
371 |  very strange way.
372 | - This is another list
373 |   item.  It's also wrapped
374 |   in a slightly different way.
375 | - This is a third list item.  Why are these
376 |     wrapped so strangely?
377 | `, 40], `
378 | - This is a list item.  It's wrapped in
379 |   a very strange way.
380 | - This is another list item.  It's also
381 |   wrapped in a slightly different way.
382 | - This is a third list item.  Why are
383 |   these wrapped so strangely?
384 | `
385 |         ));
386 | 
387 |         it('handles list items and paragraphs at the same time', () => test(
388 |             [`
389 | This is a short paragraph.
390 | 
391 | - This is a short list item.
392 | - This is a longer list item, which I expect to wrap across two lines.
393 | 
394 | This is a much longer paragraph, which should wrap (or so I hope).
395 | `, 40], `
396 | This is a short paragraph.
397 | 
398 | - This is a short list item.
399 | - This is a longer list item, which I
400 |   expect to wrap across two lines.
401 | 
402 | This is a much longer paragraph, which
403 | should wrap (or so I hope).
404 | `
405 |         ));
406 | 
407 |         it('handles nested list items gracefully', () => test(
408 |             [`
409 | - This is a short list item.
410 |   - This is a nested list item.
411 |   - This is another nested list item, which should wrap.
412 | - This is a longer list item, which I expect to wrap across two lines.
413 | `, 40], `
414 | - This is a short list item.
415 |   - This is a nested list item.
416 |   - This is another nested list item,
417 |     which should wrap.
418 | - This is a longer list item, which I
419 |   expect to wrap across two lines.
420 | `
421 |         ));
422 | 
423 |         it('handles list items that are cuddled up to the preceding paragraph', () => test(
424 |             [`
425 | This is a paragraph.
426 | It spans multiple lines.
427 | - This is the first list item.
428 | 2. This is the second list item.
429 |    It's inconsistent, but that's okay.
430 | `, 40], `
431 | This is a paragraph.  It spans multiple
432 | lines.
433 | - This is the first list item.
434 | 2. This is the second list item.  It's
435 |    inconsistent, but that's okay.
436 | `
437 |         ));
438 |     });
439 | 
440 |     describe('when reflowing ordered lists', () => {
441 |         for (let sigil of ['1.', '(1)', 'a.', 'A.', '(a)', '(A)']) {
442 |             let spaces = ' '.repeat(sigil.length);
443 |             it(`handles small lists that look like ${sigil}`, () => test(
444 |                 [`${sigil} foo\n${sigil} bar\n${sigil} baz`, 80],
445 |                 `${sigil} foo\n${sigil} bar\n${sigil} baz`
446 |             ));
447 |             it(`handles small nested lists that look like ${sigil}`, () => test(
448 |                 [`${sigil} foo\n${spaces} ${sigil} bar\n${sigil} baz`, 80],
449 |                 `${sigil} foo\n${spaces} ${sigil} bar\n${sigil} baz`
450 |             ));
451 |         }
452 | 
453 |         it('properly indents based on the length of the numeral', () => test(
454 |             ['1. Mary had a little lamb.\n10. Her fleece was white as snow.', 20],
455 |             '1. Mary had a little\n   lamb.\n10. Her fleece was\n    white as snow.'
456 |         ));
457 | 
458 |         it('handles nested lists of different varieties', () => test(
459 |             ['1. outer\n   - inner\n2. other outer\n   + other inner', 80],
460 |             '1. outer\n   - inner\n2. other outer\n   + other inner'
461 |         ));
462 | 
463 |         it('ignores the last number/word in a sentence (para context)', () => test(
464 |             ['This is a sentence\nend.  The beginning of this line looks odd.', 40],
465 |             'This is a sentence end.  The beginning\nof this line looks odd.'
466 |         ));
467 | 
468 |         it('properly reflows a list that ends in a single word', () => test(
469 |             ['1. This is a list item.\n   It ends with a\n   word.', 24],
470 |             '1. This is a list item.\n   It ends with a word.'
471 |         ));
472 | 
473 |         // NOTE: This is ambiguous even to humans, so this test is expected to
474 |         // fail.
475 |         xit('ignores the last number/word in a sentence (list context)', () => test(
476 |             ['1. This is a sentence\n   of.  The beginning of this line looks odd.', 40],
477 |             '1. This is a sentence of.  The beginning\n   of this line looks odd.'
478 |         ));
479 | 
480 |         it('ignores the last number/word in a sentence (list context, 2 lines)', () => test(
481 |             ['1. This is a sentence\n   of.  The beginning of\n   this line looks odd.', 40],
482 |             '1. This is a sentence of.  The beginning\n   of this line looks odd.'
483 |         ));
484 |         it('detects nested ordered lists that might be paragraphs', () => test(
485 |             ['1. This is a sentence\n   of.  The beginning of\n         this line looks odd.', 40],
486 |             '1. This is a sentence\n   of.  The beginning of this line looks\n        odd.'
487 |         ));
488 |     });
489 | 
490 |     describe('when reflowing comments', () => {
491 |         it('reflows paragraphs independently', () => test(
492 |             [`
493 | # This is a comment.  Here is the first paragraph.
494 | #
495 | # Here is the second paragraph.  These should be reflowed independently.
496 | `, 40], `
497 | # This is a comment.  Here is the first
498 | # paragraph.
499 | #
500 | # Here is the second paragraph.  These
501 | # should be reflowed independently.
502 | `
503 |         ));
504 | 
505 |         it('reflows lists independently', () => test(
506 |             [`
507 | # Here's a comment with a list embedded in it:
508 | #
509 | # 1. This is the first item.  It's pretty long.
510 | # 2. Second short item.
511 | # 3. Third, excessively long, extremely verbose and very redundant item.
512 | #
513 | # Another paragraph.
514 | `, 40], `
515 | # Here's a comment with a list embedded
516 | # in it:
517 | #
518 | # 1. This is the first item.  It's
519 | #    pretty long.
520 | # 2. Second short item.
521 | # 3. Third, excessively long, extremely
522 | #    verbose and very redundant item.
523 | #
524 | # Another paragraph.
525 | `
526 |         ));
527 | 
528 |         it('reflows lists that start on the same line as a comment', () => test(
529 |             [`
530 | // 1. This is the first item.  Look at how long it is.
531 | // 2. This is the second item.
532 | `, 40], `
533 | // 1. This is the first item.  Look at
534 | //    how long it is.
535 | // 2. This is the second item.
536 | `
537 |         ));
538 | 
539 |         it('reflows lists in block comments', () => test(
540 |             [`
541 | /* 1. This is the first item.  It's super long.
542 |    2. This is the second item.  Notice how it's longer. */
543 | `, 40], `
544 | /* 1. This is the first item.  It's
545 |       super long.
546 |    2. This is the second item.  Notice
547 |       how it's longer. */
548 | `
549 |         ));
550 |     });
551 | 
552 |     // XXX Not sure why the scaffolding isn't working here. :/
553 |     xdescribe('when invoked by the user', () => {
554 |         let editor, editor_view;
555 | 
556 |         beforeEach(() => {
557 |             let activationPromise = null;
558 |             waitsForPromise(() => atom.workspace.open());
559 | 
560 |             runs(() => {
561 |                 editor = atom.workspace.getActiveTextEditor();
562 |                 editor_view = atom.views.getView(editor);
563 | 
564 |                 activationPromise = atom.packages.activatePackage('magic-reflow');
565 |             });
566 | 
567 |             waitsForPromise(() => activationPromise);
568 |         });
569 | 
570 |         it('respects the preferred line length', () => {
571 |             atom.config.set('editor.preferredLineLength', 4,
572 |                             {scopeSelector: '.text.plain.null-grammar'});
573 |             editor.setText("foo bar");
574 |             editor.selectAll();
575 |             atom.commands.dispatch(editor_view, 'magic-reflow:reflow');
576 | 
577 |             expect(editor.getText()).toBe("foo\nbar");
578 |         });
579 |     });
580 | 
581 | });
582 | 


--------------------------------------------------------------------------------
/lib/magic-reflow.js:
--------------------------------------------------------------------------------
  1 | 'use babel';
  2 | 
  3 | const debug = false
  4 |             ? (...args) => (console.log(...args))
  5 |             : undefined;
  6 | 
  7 | // Things that look like list bullets or numbers.
  8 | const LIST_STYLES = [
  9 |     /^-$/,
 10 |     /^\+$/,
 11 |     /^\*$/,
 12 |     /^[0-9]{1,3}\.$/,
 13 |     /^[a-z]{1,2}\.$/,
 14 |     /^[A-Z]{1,2}\.$/,
 15 |     /^\([0-9]{1,3}\)$/,
 16 |     /^\([a-z]{1,2}\)$/,
 17 |     /^\([A-Z]{1,2}\)$/,
 18 | ];
 19 | 
 20 | // If we see a sigil that begins with any of these prefixes, don't extend it
 21 | // when wrapping onto multiple lines.  Treat it as something that should only
 22 | // appear on the first line.
 23 | //
 24 | // (Note that this is distinct from the set of list styles, which are checked
 25 | // first.)
 26 | const DONT_EXTEND_PREFIXES = ['<!--', '/*', '(*'];
 27 | 
 28 | // If we see a sigil that begins with any of these prefixes, assume it should be
 29 | // extended.  This is checked after DONT_EXTEND_PREFIXES.
 30 | const EXTEND_PREFIXES = ['#', '//', ';', '--'];
 31 | 
 32 | // How to match a line with (possibly) a sigil, list bullet, etc. at the
 33 | // beginning.
 34 | const LINE_PATT = /^((\s*)(\S+)(\s+))(.*)$/;
 35 | 
 36 | // How to match punctuation.
 37 | const SIGIL_PATT = /^[`"'\[\](){}:;=+!@#$%^&*_~,.<>?/\\|-]+$/;
 38 | 
 39 | // How to match leading whitespace.
 40 | const LEADING_WS_PATT = /^(\s+)(.*)/;
 41 | 
 42 | 
 43 | 
 44 | // Some useful text and array-processing utility functions.
 45 | function is_blank_line(text) {
 46 |     return text.search(/^\s*$/) !== -1;
 47 | }
 48 | 
 49 | function first_in_range(array, start, end, cb) {
 50 |     for (let i = start; i < end; ++i) {
 51 |         if (cb(array[i], i, array)) return i;
 52 |     }
 53 |     return end;
 54 | }
 55 | 
 56 | function last_in_range(array, start, end, cb) {
 57 |     for (let i = end - 1; i >= start; --i) {
 58 |         if (cb(array[i], i, array)) return i;
 59 |     }
 60 |     return start - 1;
 61 | }
 62 | 
 63 | function vlen_of_tab_at(start_col, tab_vlen) {
 64 |     // Returns the visual length of a tab character, if that tab character
 65 |     // appears at the specified /start_col/.  The /tab_vlen/ parameter indicates
 66 |     // the visual length of tab characters generally (e.g. 1 tab = 8 spaces).
 67 | 
 68 |     return tab_vlen - (start_col % tab_vlen);
 69 | }
 70 | 
 71 | function vlen(text, start_col, tab_vlen) {
 72 |     // Compute the visual length of /text/, assuming (for the purposes of tab
 73 |     // alignment) it starts at column /start_col/.  The /text/ should not
 74 |     // contain any newlines.
 75 | 
 76 |     let vl = start_col;
 77 | 
 78 |     let re = /([^\t\r\n]+|[\t\r\n])/gm;
 79 |     let m;
 80 |     while (m = re.exec(text)) {
 81 |         switch (m[1]) {
 82 |             case '\t':
 83 |                 vl += vlen_of_tab_at(vl, tab_vlen);
 84 |                 break;
 85 |             case '\n':
 86 |             case '\r':
 87 |                 throw "Text contains newlines";
 88 |             default:
 89 |                 vl += m[1].length;
 90 |                 break;
 91 |         }
 92 |     }
 93 | 
 94 |     return vl - start_col;
 95 | }
 96 | 
 97 | function indent_with_tabs(vlen, tab_vlen) {
 98 |     // Return a sequence of tab and space characters long enough to visually
 99 |     // indent from column 0 to /vlen/, assuming tab characters are /tab_vlen/
100 |     // columns wide.
101 | 
102 |     let i = '';
103 |     if (vlen >= tab_vlen) {
104 |         let tabs = (vlen/tab_vlen)|0;
105 |         i = i.concat('\t'.repeat(tabs));
106 |         vlen -= tabs * tab_vlen;
107 |     }
108 |     return i.concat(' '.repeat(vlen));
109 | }
110 | 
111 | function* leading_tabs_to_spaces(lines, tab_vlen) {
112 |     // Replaces leading tab characters in each line of /lines/ with a
113 |     // visually-appropriate number of spaces.  Assumes that tab characters are
114 |     // typically /tab_vlen/ columns wide.
115 | 
116 |     // This is O(n^2) becuase of the vlen() call, but that should be fine since
117 |     // we're only operating on a single line.
118 |     for (let line of lines) {
119 |         // Fixup all leading whitespace, to catch weird corner cases like
120 |         // " \t \tThe rest of the line"
121 |         yield line.replace(/^\s+/, (ws) => {
122 |             return ws.replace(/\t/g, (m, off, t) => {
123 |                 let vl = vlen(t.substr(0, off), 0, tab_vlen);
124 |                 return ' '.repeat(vlen_of_tab_at(vl, tab_vlen));
125 |             });
126 |         });
127 |     }
128 | }
129 | 
130 | function* leading_spaces_to_tabs(lines, tab_vlen) {
131 |     // Undoes what leading_tabs_to_spaces does -- replaces runs of space
132 |     // characters with an appropriate number of tabs.
133 | 
134 |     for (let line of lines) {
135 |         yield line.replace(/^\s+/, (ws) => {
136 |             return indent_with_tabs(vlen(ws, 0, tab_vlen), tab_vlen);
137 |         });
138 |     }
139 | }
140 | 
141 | 
142 | 
143 | // Match a line with LINE_PATT and build an object describing what's in it.
144 | function match_line(text) {
145 |     let obj = {
146 |         // The original line.
147 |         line: text,
148 | 
149 |         // 'none' if there is no sigil.
150 |         // 'leading' if the sigil we found should appear only on the first line.
151 |         // 'extend' if the sigil we found should appear on every line.
152 |         sigil: 'none',
153 | 
154 |         // .first is the sigil mentioned above, or '' if none was found.  ws_pre
155 |         // and ws_post are the whitespace before/after .first.  If .first is
156 |         // empty, all the whitespace shows up in .ws_pre.
157 |         ws_pre: '',
158 |         first: '',
159 |         ws_post: '',
160 | 
161 |         // The same as ws_pre + first + ws_post.
162 |         leading: '',
163 | 
164 |         // The remaining text (not including the sigil or surrounding
165 |         // whitespace)
166 |         text: text,
167 |     };
168 | 
169 |     let m = text.match(LINE_PATT);
170 |     if (! m) {
171 |         m = text.match(LEADING_WS_PATT);
172 |         if (m) {
173 |             obj.leading = m[1];
174 |             obj.ws_pre = m[1];
175 |             obj.text = m[2];
176 |         }
177 |         return obj;
178 |     }
179 | 
180 |     obj.leading = m[1];
181 |     obj.ws_pre = m[2];
182 |     obj.first = m[3];
183 |     obj.ws_post = m[4];
184 |     obj.text = m[5];
185 | 
186 |     for (let s of LIST_STYLES) {
187 |         if (obj.first.search(s) !== -1) {
188 |             obj.sigil = 'leading';
189 |             return obj;
190 |         }
191 |     }
192 | 
193 |     if (obj.first.search(SIGIL_PATT) !== -1) {
194 |         let matching_prefix = (p, i, a) => obj.first.substr(0, p.length) === p;
195 | 
196 |         if (DONT_EXTEND_PREFIXES.findIndex(matching_prefix) !== -1) {
197 |             obj.sigil = 'leading';
198 |             return obj;
199 |         }
200 | 
201 |         if (EXTEND_PREFIXES.findIndex(matching_prefix) !== -1) {
202 |             obj.sigil = 'extend';
203 |             return obj;
204 |         }
205 | 
206 |         obj.sigil = obj.first.length == 1 ? 'extend' : 'leading';
207 |         return obj;
208 |     }
209 | 
210 |     // First word doesn't match anything like what we're looking for; put it
211 |     // back into text.
212 |     obj.text = obj.first.concat(obj.ws_post, obj.text);
213 |     obj.first = '';
214 |     obj.ws_post = '';
215 |     obj.leading = obj.ws_pre;
216 |     return obj;
217 | }
218 | 
219 | 
220 | 
221 | export default {
222 | 
223 |     activate(state) {
224 |         // Register command that toggles this view
225 |         atom.commands.add('atom-text-editor', {
226 |             'magic-reflow:reflow': (event) => this.invoke(event)
227 |         });
228 |     },
229 | 
230 |     deactivate() {
231 |     },
232 | 
233 |     serialize() {
234 |         return null;
235 |     },
236 | 
237 |     invoke(event) {
238 |         let editor = event.currentTarget.getModel();
239 |         let range = editor.getSelectedBufferRange();
240 | 
241 |         // XXX need to deal with leading sigils as appropriate; means we
242 |         // probably need to do some scanning in this neighborhood rather than
243 |         // relying on the editor's notion of a paragraph
244 |         if (range.isEmpty()) range = editor.getCurrentParagraphBufferRange();
245 |         if (! range) return;
246 | 
247 |         // The reflow state object.  This is modified (or copies are
248 |         // created) and passed around as the reflow algorithm does its work.
249 |         let state = {
250 |             // How long is a tab character, visually?
251 |             tab_vlen: atom.config.get('editor.tabLength',
252 |                 {scope: editor.getRootScopeDescriptor()}),
253 | 
254 |             // How long should a line be, overall?
255 |             line_vlen: atom.config.get('editor.preferredLineLength',
256 |                 {scope: editor.getRootScopeDescriptor()}),
257 | 
258 |             // What is the starting (visual) column?  We will assume that there
259 |             // is a prefix that is this many columns wide, so we'll wrap the
260 |             // text to fit in (line_vlen - start_col).
261 |             //
262 |             // We need both start_col and line_vlen so we can tell how much
263 |             // visual space a leading tab takes up.  If we simply subtracted
264 |             // from line_vlen as we process indented text, we wouldn't be able
265 |             // to compute the visual length of tab characters correctly.
266 |             start_col: 0,
267 | 
268 |             // When adding leading whitespace, should we use spaces or tabs?
269 |             soft_tab: atom.config.get('editor.softTabs',
270 |                 {scope: editor.getRootScopeDescriptor()}),
271 |         };
272 | 
273 |         let text = this.reflow(editor.getTextInRange(range), state);
274 | 
275 |         editor.getBuffer().setTextInRange(range, text);
276 |     },
277 | 
278 |     reflow(text, state) {
279 |         // Reflow a block of text, and return the reflowed text.
280 |         //
281 |         // The state object is as described above in invoke().
282 | 
283 |         if (! state.line_vlen) state.line_vlen = 80;
284 |         if (! state.tab_vlen) state.tab_vlen = 8;
285 |         if (! state.start_col) state.start_col = 0;
286 |         if (state.soft_tab === undefined) state.soft_tab = true;
287 | 
288 |         let [head, body, tail] = this.head_body_tail(text);
289 |         let useTabs = body.indexOf('\t') != -1;
290 | 
291 |         let lines = body.split(/\r\n|\r|\n/);
292 |         let out = this.reflow_lines(
293 |             leading_tabs_to_spaces(lines, state.tab_vlen),
294 |             state);
295 | 
296 |         if (! state.soft_tab) {
297 |             out = leading_spaces_to_tabs(out, state.tab_vlen);
298 |         }
299 | 
300 |         return head.concat(Array.from(out).join('\n'), tail);
301 |     },
302 | 
303 |     reflow_lines: function*(lines, state) {
304 |         lines = Array.from(lines);
305 | 
306 |         if (debug) debug('reflowing:', state, lines);
307 | 
308 |         // Break the text into blocks, and reflow each block separately.
309 |         for (let i = 0; i < lines.length; ) {
310 |             // Blank lines always break blocks.  We must handle them specially
311 |             // here since they will get swallowed by the rewrap logic otherwise.
312 |             if (is_blank_line(lines[i])) {
313 |                 yield lines[i];
314 |                 ++i;
315 |                 continue;
316 |             }
317 | 
318 |             let [ni, out_lines] = this.consume_block(lines, i, state);
319 |             if (ni < i + 1) {
320 |                 throw `consume didn't advance (from ${i}) target ${ni}`;
321 |             }
322 |             i = ni;
323 |             yield* out_lines;
324 |         }
325 | 
326 |         if (debug) debug('done reflowing');
327 |     },
328 | 
329 |     retry_without_prefix: function*(prefix, lines, state) {
330 |         if (debug) debug(`retrying without prefix: ${prefix}`);
331 | 
332 |         let reflowed = this.remove_and_reflow(prefix, lines, state);
333 | 
334 |         for (let line of reflowed) {
335 |             line = prefix.concat(line);
336 |             yield line;
337 |         }
338 |     },
339 | 
340 |     retry_without_leading: function*(leading, lines, state) {
341 |         if (debug) debug(`retrying without leading: ${leading}`);
342 | 
343 |         let reflowed = this.remove_and_reflow(leading, lines, state);
344 |         let ilen = vlen(leading, state.start_col, state.tab_vlen);
345 |         let indent = ' '.repeat(ilen);
346 | 
347 |         let first = true;
348 |         for (let line of reflowed) {
349 |             line = (first ? leading : indent).concat(line);
350 |             yield line;
351 |             first = false;
352 |         }
353 |     },
354 | 
355 |     remove_and_reflow(prefix, lines, state) {
356 |         return this.reflow_lines(Array.from(
357 |             this.remove_prefix_and_ws(prefix, lines)), {
358 |                 line_vlen: state.line_vlen,
359 |                 tab_vlen: state.tab_vlen,
360 |                 start_col: state.start_col
361 |                     + vlen(prefix, state.start_col, state.tab_vlen),
362 |                 soft_tab: state.soft_tab,
363 |             });
364 |     },
365 | 
366 |     remove_prefix_and_ws: function*(prefix, lines) {
367 |         let remove_re = new RegExp(`^\\s{0,${prefix.length}}`);
368 |         for (line of lines) {
369 |             let pf = line.substr(0, prefix.length);
370 |             if (pf === prefix) {
371 |                 yield line.substr(prefix.length);
372 |             } else {
373 |                 yield line.replace(remove_re, '');
374 |             }
375 |         }
376 |     },
377 | 
378 |     consume_block(lines, start, state) {
379 |         // Find the end of the next block.  Return the line number and a
380 |         // generator that yields the reflowed lines for the block.
381 |         //
382 |         // ARGUMENTS:
383 |         //
384 |         // lines: The array of lines we are operating on currently
385 |         //
386 |         // start: The index of the first line in the array that we should be
387 |         // concerned with.  Prior lines have already been reflowed.
388 |         //
389 |         // state: A state object, as described in invoke() above.
390 |         //
391 |         // ALGORITHM:
392 |         //
393 |         // When looking for and reflowing blocks, here are the main cases we
394 |         // need to handle:
395 |         //
396 |         // Case 0 -- only one line.  There are a number of variants of this
397 |         // case, but we basically look at the beginning of the line and guess.
398 |         // It degenerates into one of: case 1a, case 2a.
399 |         //
400 |         // Case 1a -- paragraph:
401 |         //
402 |         //     This is a paragraph.  We need to preserve any block-style indent
403 |         //     when wrapping.
404 |         //
405 |         // Case 1b -- paragraph that looks deceptively like a list:
406 |         //
407 |         //     This is a paragraph that might contain a list,
408 |         //     because it has a sentence that ends with the number
409 |         //     1.  If the 1 lands at the beginning of a line, the
410 |         //     rest of the paragraph might get reflowed incorrectly.
411 |         //
412 |         // Case 1c -- paragraph that looks like a list in a different way:
413 |         //
414 |         //     I.  Like.  Green.  Eggs.  And.  Ham.
415 |         //     No, seriously, they're delicious.
416 |         //
417 |         // Case 2a -- a list:
418 |         //
419 |         //     1. This is a list broken by blank spaces -- we'll only see
420 |         //        one list item at a time.
421 |         //
422 |         // Case 2b -- multiple list items, one per line:
423 |         //
424 |         //     1. This is a list, but there is one list item per line.
425 |         //     2. Sort of like this.
426 |         //     3. Another list item.
427 |         //
428 |         // Case 3x -- a paragraph followed by a list (where the paragraph is one
429 |         // of the 1x cases):
430 |         //
431 |         //     This is not a list, it's just a paragraph. All lines have the
432 |         //     same indentation.
433 |         //     1. This is a list.
434 |         //     2. It is not part of the paragraph above.
435 |         //
436 |         // CASES NOT HANDLED:
437 |         //
438 |         // Case 4a -- paragraph with leading indent:
439 |         //
440 |         //         This is a paragraph with a leading indent.
441 |         //     Notice how the second line has less indent than
442 |         //     the first.
443 |         //
444 |         // Case 4b -- paragraph with leading indent (mistaken for a list):
445 |         //
446 |         //         I.  This is a paragraph with a leading indent.
447 |         //     Notice how the second line has less indent than
448 |         //     the first.
449 |         //
450 |         // Case 4c -- paragraph with leading indent (mistaken for a list):
451 |         //
452 |         //         I.  This is a paragraph with a leading indent.
453 |         //     A.  Notice how the second line has less indent than
454 |         //     the first.
455 |         //
456 |         // Note that any of the list cases might have sub-lists inside of them,
457 |         // which could lead to case 4 happening as a sub-list (where the
458 |         // paragraph is actually the enclosing list item).  We don't need to
459 |         // handle sub-lists here; we can handle them by treating each list item
460 |         // (sans leading sigil) as its own block.
461 | 
462 |         // Never go beyond a blank line; that should be considered a hard-stop
463 |         // on any block.
464 |         let blank_end = first_in_range(lines, start, lines.length,
465 |             (l, i, a) => is_blank_line(l));
466 | 
467 |         if (debug) debug(`block <= [${start},${blank_end}): `, lines[start]);
468 | 
469 |         let startm = match_line(lines[start]);
470 |         let start_indent = startm.ws_pre.length;
471 | 
472 |         // Check if we only have one line before the next blank line.  If so,
473 |         // just treat the single line as its own block.
474 |         if (start + 1 == blank_end) {
475 |             if (debug) debug('= single line only');
476 |             return this.consume_single_line(lines, start, startm, state);
477 |         }
478 | 
479 |         // Else this block may extend beyond a single line.
480 | 
481 |         if (startm.sigil === 'leading') {
482 |             // The first line has a leading sigil; we need to figure out if it's
483 |             // actually leading or if it might be a false positive (e.g. case
484 |             // 1c).
485 |             let end = first_in_range(lines, start + 1, blank_end,
486 |                 (l, i, a) => match_line(l).ws_pre.length <= start_indent);
487 | 
488 |             if (end > start + 1) {
489 |                 // Looks like nested indentation -- must be 2a.
490 |                 if (debug) debug(`= preformatted leading [${start}, ${end})`);
491 |                 return [end, this.retry_without_leading(
492 |                     startm.leading, lines.slice(start, end), state)];
493 |             }
494 | 
495 |             // Check if it's case 1c or 2b.
496 |             //
497 |             // For 1c, look for following non-sigil lines at the same
498 |             // indentation level.  We ignore things that look like they're
499 |             // indented; if we see a non-sigil line after this, we assume
500 |             // everything in between falls under 1c.
501 |             //
502 |             // Anything that looks like this will get treated as a single
503 |             // paragraph, but that's okay since people usually parse it as an
504 |             // unreadable mess anyway:
505 |             //
506 |             //     This is a paragraph.  It might
507 |             //     span multiple lines.
508 |             //     1. This is a list.
509 |             //     2. This is another list item.
510 |             //     This is another paragraph, that
511 |             //     also spans multiple lines.
512 |             //
513 |             let para_end = 1 + last_in_range(lines, start, blank_end,
514 |                 (l, i, a) => {
515 |                     let m = match_line(l);
516 |                     return m.ws_pre.length <= start_indent
517 |                         && m.sigil !== 'leading';
518 |                 });
519 | 
520 |             if (para_end == start) {
521 |                 // If there is no non-sigil line, this is a case 2b list.  Tear
522 |                 // off the first item and reflow it.
523 |                 if (debug) debug(`= single-line list item`);
524 |                 return [start + 1, this.retry_without_leading(
525 |                     startm.leading, [lines[start]], state)];
526 |             }
527 | 
528 |             // Could be 1c or 3c.  Handle 1c and advance; we'll pick up the list
529 |             // portions of 3c later.
530 |             if (debug) debug(`= paragraph w/leading [${start}, ${para_end})`);
531 |             return this.consume_para(lines, start, para_end, state);
532 |         }
533 | 
534 |         // Could be 1a/1b, or 3a/3b.
535 |         //
536 |         // Same as above; find the last non-indented, non-sigil line, and tear
537 |         // it off as a paragraph.
538 | 
539 |         let maybe_end = 1 + last_in_range(lines, start, blank_end,
540 |             (l, i, a) => {
541 |                 let m = match_line(l);
542 |                 return m.ws_pre.length <= start_indent && m.sigil !== 'leading';
543 |             });
544 | 
545 |         // maybe_end will be pointing to a line that is indented, has a sigil,
546 |         // or both.  If the line has a sigil, assume this really is the end of
547 |         // the paragraph.  Otherwise, this is just hanging/messed-up indentation
548 |         // of the form:
549 |         //
550 |         // Hello, world!  This is a paragraph
551 |         //   with weird indentation.
552 |         //
553 |         // Include any such lines in the current paragraph.
554 | 
555 |         let para_end = first_in_range(lines, maybe_end, blank_end,
556 |             (l, i, a) => {
557 |                 let m = match_line(l);
558 |                 return m.sigil !== 'none';
559 |             });
560 | 
561 |         if (debug) debug(`= paragraph [${start}, ${para_end})`)
562 |         return this.consume_para(lines, start, para_end, state);
563 |     },
564 | 
565 |     consume_para(lines, start, end, state) {
566 |         let para = lines.slice(start, end);
567 | 
568 |         // The "paragraph" might actually be a succession of single-line
569 |         // comments which contain their own set of blocks.  If so, we need to
570 |         // strip and reflow within the comment block.
571 |         let prefix = this.common_prefix(para);
572 |         if (prefix !== '') {
573 |             return [end, this.retry_without_prefix(prefix, para, state)];
574 |         }
575 | 
576 |         // This is a garden-variety paragraph.  Wrap it accordingly.
577 |         return [end, this.wrap_para(para.join('\n'), state)];
578 |     },
579 | 
580 |     consume_single_line(lines, start, startm, state) {
581 |         let gen;
582 | 
583 |         if (startm.sigil == 'leading') {
584 |             gen = this.retry_without_leading(
585 |                 startm.leading, [lines[start]], state);
586 | 
587 |         } else if (startm.leading !== '') {
588 |             gen = this.retry_without_prefix(
589 |                 startm.leading, [lines[start]], state);
590 | 
591 |         } else {
592 |             // Garden-variety paragraph, no whitespace; reflow it.
593 |             gen = this.wrap_para(lines[start], state);
594 |         }
595 | 
596 |         return [start + 1, gen];
597 |     },
598 | 
599 |     wrap_para: function*(text, state) {
600 |         // Wrap /text/ as a single paragraph, yielding lines of wrapped text
601 |         // that are no longer than /fill/.
602 | 
603 |         if (debug) debug('wrapping paragraph:', text, state);
604 | 
605 |         // XXX firstFill isn't used anymore, with the support for leading
606 |         // indents gone.
607 |         text = text
608 |             // SPECIAL CASE: Sentences that end at the end of a line should have
609 |             // two spaces after them.
610 |             .replace(/([.!?])\s*\n\s*/gm, '$1  ')
611 |             .replace(/\n\s*/gm, ' ');
612 | 
613 |         let res = [];
614 |         let start = 0;
615 |         let end = start;
616 |         let vl = state.start_col;
617 | 
618 |         for (let [run, ws, word] of this.segments_of(text)) {
619 |             let newend = end + ws.length + word.length;
620 |             let newvl = vl + vlen(run, vl, state.tab_vlen);
621 | 
622 |             if (end == start) {
623 |                 // Current line is empty. Skip over leading whitespace that
624 |                 // would otherwise get put at the beginning of the line.
625 |                 start += ws.length;
626 |                 newvl = vl + vlen(word, vl, state.tab_vlen);
627 | 
628 |             } else if (newvl > state.line_vlen) {
629 |                 // Current line is full.  Emit what we have and start the next
630 |                 // line.
631 |                 yield text.substr(start, end - start);
632 | 
633 |                 // Skip leading whitespace on the next line, and start the line
634 |                 // with the current word.
635 |                 start = end + ws.length;
636 |                 newvl = state.start_col + vlen(word, vl, state.tab_vlen);
637 |             }
638 | 
639 |             end = newend;
640 |             vl = newvl;
641 |         }
642 | 
643 |         if (start != end) {
644 |             yield text.substr(start, end - start);
645 |         }
646 |     },
647 | 
648 |     common_prefix(lines) {
649 |         // Finds and returns any non-alphanumeric prefix that is common to all
650 |         // the lines.  If there are 0 or 1 lines, we assume there is no common
651 |         // prefix.
652 | 
653 |         if (lines.length < 2) return '';
654 | 
655 |         let pf = '';
656 |         let testpf = '';
657 | 
658 |         while (testpf.length < lines[0].length) {
659 |             pf = testpf;
660 |             testpf = lines[0].substr(0, testpf.length + 1);
661 | 
662 |             // Letters/numbers/etc. cannot be part of a prefix.
663 |             if (testpf.search(/\w/) !== -1) return pf;
664 | 
665 |             // Check if any line doesn't match the test prefix.
666 |             for (line of lines) {
667 |                 if (testpf.length > line.length) return pf;
668 |                 if (line.substr(0, testpf.length) !== testpf) return pf;
669 |             }
670 |         }
671 | 
672 |         return testpf;
673 |     },
674 | 
675 |     head_body_tail: function(text) {
676 |         // Split text into:
677 |         // [leading whitespace, everything else, trailing whitespace]
678 | 
679 |         let head = (text.match(/^\s*\n/) || [''])[0];
680 |         let tail = (text.match(/\n\s*$/) || [''])[0];
681 |         let body = text.substr(head.length,
682 |                 text.length - head.length - tail.length);
683 |         return [head, body, tail];
684 |     },
685 | 
686 |     segments_of: function*(text) {
687 |         // Split /text/ at word boundaries, yielding [run, ws, word] tuples
688 |         // where /ws/ is the whitespace that appears before /word/, and /run/ is
689 |         // ws.concat(word).
690 | 
691 |         let span = /(\s*)(\S+)/gm;
692 |         let m;
693 |         while (m = span.exec(text)) {
694 |             yield m;
695 |         }
696 |     },
697 | 
698 |     // Exports for testing purposes, used in the spec file
699 |     vlen: vlen,
700 |     indent_with_tabs: indent_with_tabs,
701 |     leading_tabs_to_spaces: leading_tabs_to_spaces,
702 |     leading_spaces_to_tabs: leading_spaces_to_tabs,
703 | };
704 | 


--------------------------------------------------------------------------------