tools: modernize license2rtf
PR-URL: https://github.com/nodejs/node/pull/16220 Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Luigi Pinca <luigipinca@gmail.com> Reviewed-By: Michaël Zasso <targos@protonmail.com>
This commit is contained in:
Tobias Nießen
Родитель
9d768504d2
Коммит
e2ce1307ed
|
|
@ -2,112 +2,105 @@
|
|||
|
||||
const assert = require('assert');
|
||||
const Stream = require('stream');
|
||||
const inherits = require('util').inherits;
|
||||
|
||||
|
||||
/*
|
||||
* This filter consumes a stream of characters and emits one string per line.
|
||||
*/
|
||||
function LineSplitter() {
|
||||
const self = this;
|
||||
var buffer = '';
|
||||
class LineSplitter extends Stream {
|
||||
constructor() {
|
||||
super();
|
||||
this.buffer = '';
|
||||
this.writable = true;
|
||||
}
|
||||
|
||||
Stream.call(this);
|
||||
this.writable = true;
|
||||
|
||||
this.write = function(data) {
|
||||
const lines = (buffer + data).split(/\r\n|\n\r|\n|\r/);
|
||||
for (var i = 0; i < lines.length - 1; i++) {
|
||||
self.emit('data', lines[i]);
|
||||
write(data) {
|
||||
const lines = (this.buffer + data).split(/\r\n|\n\r|\n|\r/);
|
||||
for (let i = 0; i < lines.length - 1; i++) {
|
||||
this.emit('data', lines[i]);
|
||||
}
|
||||
buffer = lines[lines.length - 1];
|
||||
this.buffer = lines[lines.length - 1];
|
||||
return true;
|
||||
};
|
||||
}
|
||||
|
||||
this.end = function(data) {
|
||||
end(data) {
|
||||
this.write(data || '');
|
||||
if (buffer) {
|
||||
self.emit('data', buffer);
|
||||
if (this.buffer) {
|
||||
this.emit('data', this.buffer);
|
||||
}
|
||||
self.emit('end');
|
||||
};
|
||||
this.emit('end');
|
||||
}
|
||||
}
|
||||
inherits(LineSplitter, Stream);
|
||||
|
||||
|
||||
/*
|
||||
* This filter consumes lines and emits paragraph objects.
|
||||
*/
|
||||
function ParagraphParser() {
|
||||
const self = this;
|
||||
var block_is_license_block = false;
|
||||
var block_has_c_style_comment;
|
||||
var paragraph_line_indent;
|
||||
var paragraph;
|
||||
class ParagraphParser extends Stream {
|
||||
constructor() {
|
||||
super();
|
||||
this.blockIsLicenseBlock = false;
|
||||
this.writable = true;
|
||||
this.resetBlock(false);
|
||||
}
|
||||
|
||||
Stream.call(this);
|
||||
this.writable = true;
|
||||
|
||||
resetBlock(false);
|
||||
|
||||
this.write = function(data) {
|
||||
parseLine(data + '');
|
||||
write(data) {
|
||||
this.parseLine(data + '');
|
||||
return true;
|
||||
};
|
||||
}
|
||||
|
||||
this.end = function(data) {
|
||||
if (data) {
|
||||
parseLine(data + '');
|
||||
}
|
||||
flushParagraph();
|
||||
self.emit('end');
|
||||
};
|
||||
end(data) {
|
||||
if (data)
|
||||
this.parseLine(data + '');
|
||||
this.flushParagraph();
|
||||
this.emit('end');
|
||||
}
|
||||
|
||||
function resetParagraph() {
|
||||
paragraph_line_indent = -1;
|
||||
resetParagraph() {
|
||||
this.paragraphLineIndent = -1;
|
||||
|
||||
paragraph = {
|
||||
this.paragraph = {
|
||||
li: '',
|
||||
in_license_block: block_is_license_block,
|
||||
inLicenseBlock: this.blockIsLicenseBlock,
|
||||
lines: []
|
||||
};
|
||||
}
|
||||
|
||||
function resetBlock(is_license_block) {
|
||||
block_is_license_block = is_license_block;
|
||||
block_has_c_style_comment = false;
|
||||
resetParagraph();
|
||||
resetBlock(isLicenseBlock) {
|
||||
this.blockIsLicenseBlock = isLicenseBlock;
|
||||
this.blockHasCStyleComment = false;
|
||||
this.resetParagraph();
|
||||
}
|
||||
|
||||
function flushParagraph() {
|
||||
if (paragraph.lines.length || paragraph.li) {
|
||||
self.emit('data', paragraph);
|
||||
flushParagraph() {
|
||||
if (this.paragraph.lines.length || this.paragraph.li) {
|
||||
this.emit('data', this.paragraph);
|
||||
}
|
||||
resetParagraph();
|
||||
this.resetParagraph();
|
||||
}
|
||||
|
||||
function parseLine(line) {
|
||||
parseLine(line) {
|
||||
// Strip trailing whitespace
|
||||
line = line.replace(/\s*$/, '');
|
||||
line = line.trimRight();
|
||||
|
||||
// Detect block separator
|
||||
if (/^\s*(=|"){3,}\s*$/.test(line)) {
|
||||
flushParagraph();
|
||||
resetBlock(!block_is_license_block);
|
||||
this.flushParagraph();
|
||||
this.resetBlock(!this.blockIsLicenseBlock);
|
||||
return;
|
||||
}
|
||||
|
||||
// Strip comments around block
|
||||
if (block_is_license_block) {
|
||||
if (!block_has_c_style_comment)
|
||||
block_has_c_style_comment = /^\s*(\/\*)/.test(line);
|
||||
if (block_has_c_style_comment) {
|
||||
var prev = line;
|
||||
if (this.blockIsLicenseBlock) {
|
||||
if (!this.blockHasCStyleComment)
|
||||
this.blockHasCStyleComment = /^\s*(\/\*)/.test(line);
|
||||
if (this.blockHasCStyleComment) {
|
||||
const prev = line;
|
||||
line = line.replace(/^(\s*?)(?:\s?\*\/|\/\*\s|\s\*\s?)/, '$1');
|
||||
if (prev === line)
|
||||
line = line.replace(/^\s{2}/, '');
|
||||
if (/\*\//.test(prev))
|
||||
block_has_c_style_comment = false;
|
||||
this.blockHasCStyleComment = false;
|
||||
} else {
|
||||
// Strip C++ and perl style comments.
|
||||
line = line.replace(/^(\s*)(?:\/\/\s?|#\s?)/, '$1');
|
||||
|
|
@ -116,14 +109,14 @@ function ParagraphParser() {
|
|||
|
||||
// Detect blank line (paragraph separator)
|
||||
if (!/\S/.test(line)) {
|
||||
flushParagraph();
|
||||
this.flushParagraph();
|
||||
return;
|
||||
}
|
||||
|
||||
// Detect separator "lines" within a block. These mark a paragraph break
|
||||
// and are stripped from the output.
|
||||
if (/^\s*[=*-]{5,}\s*$/.test(line)) {
|
||||
flushParagraph();
|
||||
this.flushParagraph();
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -132,41 +125,40 @@ function ParagraphParser() {
|
|||
assert.ok(result);
|
||||
// The number of characters that will be stripped from the beginning of
|
||||
// the line.
|
||||
const line_strip_length = result[0].length;
|
||||
const lineStripLength = result[0].length;
|
||||
// The indentation size that will be used to detect indentation jumps.
|
||||
// Fudge by 1 space.
|
||||
const line_indent = Math.floor(line_strip_length / 2) * 2;
|
||||
const lineIndent = Math.floor(lineStripLength / 2) * 2;
|
||||
// The indentation level that will be exported
|
||||
const level = Math.floor(result[1].length / 2);
|
||||
// The list indicator that precedes the actual content, if any.
|
||||
const line_li = result[2];
|
||||
const lineLi = result[2];
|
||||
|
||||
// Flush the paragraph when there is a li or an indentation jump
|
||||
if (line_li || (line_indent !== paragraph_line_indent &&
|
||||
paragraph_line_indent !== -1)) {
|
||||
flushParagraph();
|
||||
paragraph.li = line_li;
|
||||
if (lineLi || (lineIndent !== this.paragraphLineIndent &&
|
||||
this.paragraphLineIndent !== -1)) {
|
||||
this.flushParagraph();
|
||||
this.paragraph.li = lineLi;
|
||||
}
|
||||
|
||||
// Set the paragraph indent that we use to detect indentation jumps. When
|
||||
// we just detected a list indicator, wait
|
||||
// for the next line to arrive before setting this.
|
||||
if (!line_li && paragraph_line_indent !== -1) {
|
||||
paragraph_line_indent = line_indent;
|
||||
if (!lineLi && this.paragraphLineIndent !== -1) {
|
||||
this.paragraphLineIndent = lineIndent;
|
||||
}
|
||||
|
||||
// Set the output indent level if it has not been set yet.
|
||||
if (paragraph.level === undefined)
|
||||
paragraph.level = level;
|
||||
if (this.paragraph.level === undefined)
|
||||
this.paragraph.level = level;
|
||||
|
||||
// Strip leading whitespace and li.
|
||||
line = line.slice(line_strip_length);
|
||||
line = line.slice(lineStripLength);
|
||||
|
||||
if (line)
|
||||
paragraph.lines.push(line);
|
||||
this.paragraph.lines.push(line);
|
||||
}
|
||||
}
|
||||
inherits(ParagraphParser, Stream);
|
||||
|
||||
|
||||
/*
|
||||
|
|
@ -174,35 +166,35 @@ inherits(ParagraphParser, Stream);
|
|||
* The lines within the paragraph are unwrapped where appropriate. It also
|
||||
* replaces multiple consecutive whitespace characters by a single one.
|
||||
*/
|
||||
function Unwrapper() {
|
||||
const self = this;
|
||||
class Unwrapper extends Stream {
|
||||
constructor() {
|
||||
super();
|
||||
this.writable = true;
|
||||
}
|
||||
|
||||
Stream.call(this);
|
||||
this.writable = true;
|
||||
|
||||
this.write = function(paragraph) {
|
||||
write(paragraph) {
|
||||
const lines = paragraph.lines;
|
||||
const break_after = [];
|
||||
var i;
|
||||
const breakAfter = [];
|
||||
let i;
|
||||
|
||||
for (i = 0; i < lines.length - 1; i++) {
|
||||
var line = lines[i];
|
||||
const line = lines[i];
|
||||
|
||||
// When a line is really short, the line was probably kept separate for a
|
||||
// reason.
|
||||
if (line.length < 50) {
|
||||
// If the first word on the next line really didn't fit after the line,
|
||||
// it probably was just ordinary wrapping after all.
|
||||
var next_first_word_length = lines[i + 1].replace(/\s.*$/, '').length;
|
||||
if (line.length + next_first_word_length < 60) {
|
||||
break_after[i] = true;
|
||||
const nextFirstWordLength = lines[i + 1].replace(/\s.*$/, '').length;
|
||||
if (line.length + nextFirstWordLength < 60) {
|
||||
breakAfter[i] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < lines.length - 1;) {
|
||||
if (!break_after[i]) {
|
||||
lines[i] += ' ' + lines.splice(i + 1, 1)[0];
|
||||
if (!breakAfter[i]) {
|
||||
lines[i] += ` ${lines.splice(i + 1, 1)[0]}`;
|
||||
} else {
|
||||
i++;
|
||||
}
|
||||
|
|
@ -214,43 +206,62 @@ function Unwrapper() {
|
|||
lines[i] = lines[i].replace(/\s+/g, ' ').replace(/\s+$/, '');
|
||||
}
|
||||
|
||||
self.emit('data', paragraph);
|
||||
};
|
||||
this.emit('data', paragraph);
|
||||
}
|
||||
|
||||
this.end = function(data) {
|
||||
end(data) {
|
||||
if (data)
|
||||
self.write(data);
|
||||
self.emit('end');
|
||||
};
|
||||
this.write(data);
|
||||
this.emit('end');
|
||||
}
|
||||
}
|
||||
inherits(Unwrapper, Stream);
|
||||
|
||||
function rtfEscape(string) {
|
||||
function toHex(number, length) {
|
||||
return (~~number).toString(16).padStart(length, '0');
|
||||
}
|
||||
|
||||
return string
|
||||
.replace(/[\\{}]/g, function(m) {
|
||||
return `\\${m}`;
|
||||
})
|
||||
.replace(/\t/g, function() {
|
||||
return '\\tab ';
|
||||
})
|
||||
// eslint-disable-next-line no-control-regex
|
||||
.replace(/[\x00-\x1f\x7f-\xff]/g, function(m) {
|
||||
return `\\'${toHex(m.charCodeAt(0), 2)}`;
|
||||
})
|
||||
.replace(/\ufeff/g, '')
|
||||
.replace(/[\u0100-\uffff]/g, function(m) {
|
||||
return `\\u${toHex(m.charCodeAt(0), 4)}?`;
|
||||
});
|
||||
}
|
||||
|
||||
/*
|
||||
* This filter generates an rtf document from a stream of paragraph objects.
|
||||
*/
|
||||
function RtfGenerator() {
|
||||
const self = this;
|
||||
var did_write_anything = false;
|
||||
class RtfGenerator extends Stream {
|
||||
constructor() {
|
||||
super();
|
||||
this.didWriteAnything = false;
|
||||
this.writable = true;
|
||||
}
|
||||
|
||||
Stream.call(this);
|
||||
this.writable = true;
|
||||
|
||||
this.write = function({ li, level, lines, in_license_block: lic }) {
|
||||
if (!did_write_anything) {
|
||||
emitHeader();
|
||||
did_write_anything = true;
|
||||
write({ li, level, lines, inLicenseBlock: lic }) {
|
||||
if (!this.didWriteAnything) {
|
||||
this.emitHeader();
|
||||
this.didWriteAnything = true;
|
||||
}
|
||||
|
||||
if (li)
|
||||
level++;
|
||||
|
||||
var rtf = '\\pard\\sa150\\sl300\\slmult1';
|
||||
let rtf = '\\pard\\sa150\\sl300\\slmult1';
|
||||
if (level > 0)
|
||||
rtf += `\\li${level * 240}`;
|
||||
if (li) {
|
||||
if (li)
|
||||
rtf += `\\tx${level * 240}\\fi-240`;
|
||||
}
|
||||
if (lic)
|
||||
rtf += '\\ri240';
|
||||
if (!lic)
|
||||
|
|
@ -262,64 +273,41 @@ function RtfGenerator() {
|
|||
rtf += '\\b0';
|
||||
rtf += '\\par\n';
|
||||
|
||||
self.emit('data', rtf);
|
||||
};
|
||||
this.emit('data', rtf);
|
||||
}
|
||||
|
||||
this.end = function(data) {
|
||||
end(data) {
|
||||
if (data)
|
||||
self.write(data);
|
||||
if (did_write_anything)
|
||||
emitFooter();
|
||||
self.emit('end');
|
||||
};
|
||||
|
||||
function toHex(number, length) {
|
||||
return (~~number).toString(16).padStart(length, '0');
|
||||
this.write(data);
|
||||
if (this.didWriteAnything)
|
||||
this.emitFooter();
|
||||
this.emit('end');
|
||||
}
|
||||
|
||||
function rtfEscape(string) {
|
||||
return string
|
||||
.replace(/[\\{}]/g, function(m) {
|
||||
return `\\${m}`;
|
||||
})
|
||||
.replace(/\t/g, function() {
|
||||
return '\\tab ';
|
||||
})
|
||||
// eslint-disable-next-line no-control-regex
|
||||
.replace(/[\x00-\x1f\x7f-\xff]/g, function(m) {
|
||||
return `\\'${toHex(m.charCodeAt(0), 2)}`;
|
||||
})
|
||||
.replace(/\ufeff/g, '')
|
||||
.replace(/[\u0100-\uffff]/g, function(m) {
|
||||
return `\\u${toHex(m.charCodeAt(0), 4)}?`;
|
||||
});
|
||||
}
|
||||
|
||||
function emitHeader() {
|
||||
self.emit('data', '{\\rtf1\\ansi\\ansicpg1252\\uc1\\deff0\\deflang1033' +
|
||||
emitHeader() {
|
||||
this.emit('data', '{\\rtf1\\ansi\\ansicpg1252\\uc1\\deff0\\deflang1033' +
|
||||
'{\\fonttbl{\\f0\\fswiss\\fcharset0 Tahoma;}}\\fs20\n' +
|
||||
'{\\*\\generator txt2rtf 0.0.1;}\n');
|
||||
}
|
||||
|
||||
function emitFooter() {
|
||||
self.emit('data', '}');
|
||||
emitFooter() {
|
||||
this.emit('data', '}');
|
||||
}
|
||||
}
|
||||
inherits(RtfGenerator, Stream);
|
||||
|
||||
|
||||
const stdin = process.stdin;
|
||||
const stdout = process.stdout;
|
||||
const line_splitter = new LineSplitter();
|
||||
const paragraph_parser = new ParagraphParser();
|
||||
const lineSplitter = new LineSplitter();
|
||||
const paragraphParser = new ParagraphParser();
|
||||
const unwrapper = new Unwrapper();
|
||||
const rtf_generator = new RtfGenerator();
|
||||
const rtfGenerator = new RtfGenerator();
|
||||
|
||||
stdin.setEncoding('utf-8');
|
||||
stdin.resume();
|
||||
|
||||
stdin.pipe(line_splitter);
|
||||
line_splitter.pipe(paragraph_parser);
|
||||
paragraph_parser.pipe(unwrapper);
|
||||
unwrapper.pipe(rtf_generator);
|
||||
rtf_generator.pipe(stdout);
|
||||
stdin.pipe(lineSplitter);
|
||||
lineSplitter.pipe(paragraphParser);
|
||||
paragraphParser.pipe(unwrapper);
|
||||
unwrapper.pipe(rtfGenerator);
|
||||
rtfGenerator.pipe(stdout);
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче