Add capacitorjs runtime
This commit is contained in:
parent
d0ece489ee
commit
f90c0e6c40
8362 changed files with 1502407 additions and 1 deletions
674
node_modules/gradle-to-js/lib/parser.js
generated
vendored
Normal file
674
node_modules/gradle-to-js/lib/parser.js
generated
vendored
Normal file
|
|
@ -0,0 +1,674 @@
|
|||
/* jshint node: true */
|
||||
'use strict';
|
||||
var stream = require('stream');
|
||||
var fs = require('fs');
|
||||
var deepAssign = require('lodash.merge')
|
||||
|
||||
var exports = module.exports = {};
|
||||
|
||||
var CHAR_TAB = 9;
|
||||
var CHAR_NEWLINE = 10;
|
||||
var CHAR_CARRIAGE_RETURN = 13;
|
||||
var CHAR_SPACE = 32;
|
||||
var CHAR_LEFT_PARENTHESIS = 40;
|
||||
var CHAR_RIGHT_PARENTHESIS = 41;
|
||||
var CHAR_PERIOD = 46;
|
||||
var CHAR_SLASH = 47;
|
||||
var CHAR_EQUALS = 61;
|
||||
var CHAR_ARRAY_START = 91;
|
||||
var CHAR_ARRAY_END = 93;
|
||||
var CHAR_BLOCK_START = 123;
|
||||
var CHAR_BLOCK_END = 125;
|
||||
|
||||
var KEYWORD_DEF = 'def';
|
||||
var KEYWORD_IF = 'if';
|
||||
|
||||
var WHITESPACE_CHARACTERS = {};
|
||||
WHITESPACE_CHARACTERS[CHAR_TAB] = true;
|
||||
WHITESPACE_CHARACTERS[CHAR_NEWLINE] = true;
|
||||
WHITESPACE_CHARACTERS[CHAR_CARRIAGE_RETURN] = true;
|
||||
WHITESPACE_CHARACTERS[CHAR_SPACE] = true;
|
||||
|
||||
var SINGLE_LINE_COMMENT_START = '//';
|
||||
var BLOCK_COMMENT_START = '/*';
|
||||
var BLOCK_COMMENT_END = '*/';
|
||||
|
||||
var SPECIAL_KEYS = {
|
||||
repositories: parseRepositoryClosure,
|
||||
dependencies: parseDependencyClosure,
|
||||
plugins: parsePluginsClosure
|
||||
};
|
||||
|
||||
var DEPS_KEYWORD_STRING_PATTERN = '[ \\t]*([A-Za-z0-9_-]+)[ \\t]*';
|
||||
var DEPS_KEYWORD_STRING_REGEX = RegExp(DEPS_KEYWORD_STRING_PATTERN);
|
||||
var DEPS_EASY_GAV_STRING_REGEX = RegExp('(["\']?)([\\w.-]+):([\\w.-]+):([\\w\\[\\]\\(\\),+.-]+)\\1');
|
||||
var DEPS_HARD_GAV_STRING_REGEX = RegExp(DEPS_KEYWORD_STRING_PATTERN + '(?:\\((.*)\\)|(.*))');
|
||||
var DEPS_ITEM_BLOCK_REGEX = RegExp(DEPS_KEYWORD_STRING_PATTERN + '\\(((["\']?)(.*)\\3)\\)[ \\t]*\\{');
|
||||
var DEPS_EXCLUDE_LINE_REGEX = RegExp('exclude[ \\t]+([^\\n]+)', 'g');
|
||||
var PLUGINS_LINE_PATTERN = RegExp('(id|version)[ \\t]*\\(?(["\']?)([A-Za-z0-9._-]+)\\2\\)?', 'g');
|
||||
|
||||
|
||||
function deepParse(chunk, state, keepFunctionCalls, skipEmptyValues) {
|
||||
var out = {};
|
||||
|
||||
var chunkLength = chunk.length;
|
||||
var character = 0;
|
||||
var tempString = '';
|
||||
var commentText = '';
|
||||
|
||||
var currentKey = '';
|
||||
var parsingKey = true;
|
||||
var isBeginningOfLine = true;
|
||||
|
||||
if (typeof skipEmptyValues === 'undefined') {
|
||||
skipEmptyValues = true;
|
||||
}
|
||||
|
||||
for (; state.index < chunkLength; state.index++) {
|
||||
character = chunk[state.index];
|
||||
|
||||
if (isBeginningOfLine && isWhitespace(character)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!state.comment.parsing && isBeginningOfLine && isStartOfComment(tempString)) {
|
||||
isBeginningOfLine = false;
|
||||
if (isSingleLineComment(tempString)) {
|
||||
state.comment.setSingleLine();
|
||||
} else {
|
||||
state.comment.setMultiLine();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (state.comment.multiLine && isEndOfMultiLineComment(commentText)) {
|
||||
state.comment.reset();
|
||||
|
||||
isBeginningOfLine = true;
|
||||
tempString = '';
|
||||
commentText = '';
|
||||
continue;
|
||||
}
|
||||
|
||||
if (state.comment.parsing && character != CHAR_NEWLINE) {
|
||||
commentText += String.fromCharCode(character);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (state.comment.parsing && isLineBreakCharacter(character)) {
|
||||
if (state.comment.singleLine) {
|
||||
state.comment.reset();
|
||||
isBeginningOfLine = true;
|
||||
|
||||
currentKey = '';
|
||||
tempString = '';
|
||||
commentText = '';
|
||||
continue;
|
||||
} else {
|
||||
// NO-OP
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (parsingKey && !keepFunctionCalls && character === CHAR_LEFT_PARENTHESIS) {
|
||||
skipFunctionCall(chunk, state);
|
||||
currentKey = '';
|
||||
tempString = '';
|
||||
isBeginningOfLine = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (isLineBreakCharacter(character)) {
|
||||
if (!currentKey && tempString) {
|
||||
if (parsingKey) {
|
||||
if (isFunctionCall(tempString) && !keepFunctionCalls) {
|
||||
continue;
|
||||
} else {
|
||||
currentKey = tempString.trim();
|
||||
tempString = '';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (tempString || (currentKey && !skipEmptyValues)) {
|
||||
addValueToStructure(out, currentKey, trimWrappingQuotes(tempString));
|
||||
|
||||
currentKey = '';
|
||||
tempString = '';
|
||||
}
|
||||
|
||||
parsingKey = true;
|
||||
isBeginningOfLine = true;
|
||||
|
||||
state.comment.reset();
|
||||
continue;
|
||||
}
|
||||
|
||||
// Only parse as an array if the first *real* char is a [
|
||||
if (!parsingKey && !tempString && character === CHAR_ARRAY_START) {
|
||||
out[currentKey] = parseArray(chunk, state);
|
||||
currentKey = '';
|
||||
tempString = '';
|
||||
continue;
|
||||
}
|
||||
|
||||
if (character === CHAR_BLOCK_START) {
|
||||
// We need to skip the current (=start) character so that we literally "step into" the next closure/block
|
||||
state.index++;
|
||||
|
||||
if (SPECIAL_KEYS.hasOwnProperty(currentKey)) {
|
||||
out[currentKey] = SPECIAL_KEYS[currentKey](chunk, state);
|
||||
} else if (out[currentKey]) {
|
||||
out[currentKey] = deepAssign({}, out[currentKey], deepParse(chunk, state, keepFunctionCalls, skipEmptyValues));
|
||||
} else {
|
||||
out[currentKey] = deepParse(chunk, state, keepFunctionCalls, skipEmptyValues);
|
||||
}
|
||||
currentKey = '';
|
||||
} else if (character === CHAR_BLOCK_END) {
|
||||
currentKey = '';
|
||||
tempString = '';
|
||||
break;
|
||||
} else if (isDelimiter(character) && parsingKey) {
|
||||
if (isKeyword(tempString)) {
|
||||
if (tempString === KEYWORD_DEF) {
|
||||
tempString = fetchDefinedNameOrSkipFunctionDefinition(chunk, state);
|
||||
} else if (tempString === KEYWORD_IF) {
|
||||
skipIfStatement(chunk, state);
|
||||
currentKey = '';
|
||||
tempString = '';
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
currentKey = tempString;
|
||||
tempString = '';
|
||||
parsingKey = false;
|
||||
if (!currentKey) {
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
if (!tempString && isDelimiter(character)) {
|
||||
continue;
|
||||
}
|
||||
tempString += String.fromCharCode(character);
|
||||
isBeginningOfLine = isBeginningOfLine && (character === CHAR_SLASH || isStartOfComment(tempString));
|
||||
}
|
||||
}
|
||||
|
||||
// Add the last value to the structure
|
||||
addValueToStructure(out, currentKey, trimWrappingQuotes(tempString));
|
||||
return out;
|
||||
}
|
||||
|
||||
function skipIfStatement(chunk, state) {
|
||||
skipFunctionCall(chunk, state);
|
||||
|
||||
var character = '';
|
||||
var hasFoundTheCurlyBraces = false;
|
||||
var hasFoundAStatementWithoutBraces = false;
|
||||
var curlyBraceCount = 0;
|
||||
|
||||
for (var max = chunk.length; state.index < max; state.index++) {
|
||||
character = chunk[state.index];
|
||||
|
||||
if (hasFoundAStatementWithoutBraces) {
|
||||
if (isLineBreakCharacter(character)) {
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (character === CHAR_BLOCK_START) {
|
||||
hasFoundTheCurlyBraces = true;
|
||||
curlyBraceCount++;
|
||||
} else if (character === CHAR_BLOCK_END) {
|
||||
curlyBraceCount--;
|
||||
} else if (!hasFoundTheCurlyBraces && !isWhitespace(character)) {
|
||||
hasFoundAStatementWithoutBraces = true;
|
||||
}
|
||||
|
||||
if ((hasFoundTheCurlyBraces && curlyBraceCount === 0)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return curlyBraceCount === 0;
|
||||
}
|
||||
|
||||
function skipFunctionDefinition(chunk, state) {
|
||||
var start = state.index;
|
||||
var parenthesisNest = 1;
|
||||
var character = chunk[++state.index];
|
||||
while (character !== undefined && parenthesisNest) {
|
||||
if (character === CHAR_LEFT_PARENTHESIS) {
|
||||
parenthesisNest++;
|
||||
} else if (character === CHAR_RIGHT_PARENTHESIS) {
|
||||
parenthesisNest--;
|
||||
}
|
||||
|
||||
character = chunk[++state.index];
|
||||
}
|
||||
|
||||
while (character && character !== CHAR_BLOCK_START) {
|
||||
character = chunk[++state.index];
|
||||
}
|
||||
|
||||
character = chunk[++state.index];
|
||||
var blockNest = 1;
|
||||
while (character !== undefined && blockNest) {
|
||||
if (character === CHAR_BLOCK_START) {
|
||||
blockNest++;
|
||||
} else if (character === CHAR_BLOCK_END) {
|
||||
blockNest--;
|
||||
}
|
||||
|
||||
character = chunk[++state.index];
|
||||
}
|
||||
|
||||
state.index--;
|
||||
}
|
||||
|
||||
function parseDependencyClosure(chunk, state) {
|
||||
return parseSpecialClosure(chunk, state, createStructureForDependencyItem);
|
||||
}
|
||||
|
||||
function createStructureForDependencyItem(data) {
|
||||
var out = { group: '', name: '', version: '', type: '' };
|
||||
var compileBlockInfo = findDependencyItemBlock(data);
|
||||
if (compileBlockInfo['gav']) {
|
||||
out = parseGavString(compileBlockInfo['gav']);
|
||||
out['type'] = compileBlockInfo['type'];
|
||||
out['excludes'] = compileBlockInfo['excludes'];
|
||||
} else {
|
||||
out = parseGavString(data);
|
||||
var parsed = DEPS_KEYWORD_STRING_REGEX.exec(data);
|
||||
out['type'] = (parsed && parsed[1]) || '';
|
||||
out['excludes'] = [];
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function parsePluginsClosure(chunk, state) {
|
||||
return parseSpecialClosure(chunk, state, createStructureForPlugin);
|
||||
}
|
||||
|
||||
function createStructureForPlugin(pluginRow) {
|
||||
var out = {};
|
||||
|
||||
var match;
|
||||
while(match = PLUGINS_LINE_PATTERN.exec(pluginRow)) {
|
||||
if (match && match[1]) {
|
||||
out[match[1]] = match[3];
|
||||
}
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
function findFirstSpaceOrTabPosition(input) {
|
||||
var position = input.indexOf(' ');
|
||||
if (position === -1) {
|
||||
position = input.indexOf('\t');
|
||||
}
|
||||
return position;
|
||||
}
|
||||
|
||||
function findDependencyItemBlock(data) {
|
||||
var matches = DEPS_ITEM_BLOCK_REGEX.exec(data);
|
||||
if (matches && matches[2]) {
|
||||
var excludes = [];
|
||||
|
||||
var match;
|
||||
while((match = DEPS_EXCLUDE_LINE_REGEX.exec(data))) {
|
||||
excludes.push(parseMapNotation(match[0].substring(findFirstSpaceOrTabPosition(match[0]))));
|
||||
}
|
||||
|
||||
return { gav: matches[2], type: matches[1], excludes: excludes };
|
||||
}
|
||||
return [];
|
||||
}
|
||||
|
||||
function parseGavString(gavString) {
|
||||
var out = { group: '', name: '', version: '' };
|
||||
var easyGavStringMatches = DEPS_EASY_GAV_STRING_REGEX.exec(gavString);
|
||||
if (easyGavStringMatches) {
|
||||
out['group'] = easyGavStringMatches[2];
|
||||
out['name'] = easyGavStringMatches[3];
|
||||
out['version'] = easyGavStringMatches[4];
|
||||
} else if (gavString.indexOf('project(') !== -1) {
|
||||
out['name'] = gavString.match(/(project\([^\)]+\))/g)[0];
|
||||
} else {
|
||||
var hardGavMatches = DEPS_HARD_GAV_STRING_REGEX.exec(gavString);
|
||||
if (hardGavMatches && (hardGavMatches[3] || hardGavMatches[2])) {
|
||||
out = parseMapNotationWithFallback(out, hardGavMatches[3] || hardGavMatches[2]);
|
||||
} else {
|
||||
out = parseMapNotationWithFallback(out, gavString, gavString.slice(findFirstSpaceOrTabPosition(gavString)));
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function parseMapNotationWithFallback(out, string, name) {
|
||||
var outFromMapNotation = parseMapNotation(string);
|
||||
if (outFromMapNotation['name']) {
|
||||
out = outFromMapNotation;
|
||||
} else {
|
||||
out['name'] = name ? name : string;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function parseMapNotation(input) {
|
||||
var out = {};
|
||||
var currentKey = '';
|
||||
var quotation = '';
|
||||
|
||||
for (var i = 0, max = input.length; i < max; i++) {
|
||||
if (input[i] === ':') {
|
||||
currentKey = currentKey.trim();
|
||||
out[currentKey] = '';
|
||||
|
||||
for (var innerLoop = 0, i = i + 1; i < max; i++) {
|
||||
if (innerLoop === 0) {
|
||||
// Skip any leading spaces before the actual value
|
||||
if (isWhitespaceLiteral(input[i])) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// We just take note of what the "latest" quote was so that we can
|
||||
if (input[i] === '"' || input[i] === "'") {
|
||||
quotation = input[i];
|
||||
continue;
|
||||
}
|
||||
|
||||
// Moving on to the next value if we find a comma
|
||||
if (input[i] === ',') {
|
||||
out[currentKey] = out[currentKey].trim();
|
||||
currentKey = '';
|
||||
break;
|
||||
}
|
||||
|
||||
out[currentKey] += input[i];
|
||||
innerLoop++;
|
||||
}
|
||||
} else {
|
||||
currentKey += input[i];
|
||||
}
|
||||
}
|
||||
|
||||
// If the last character contains a quotation mark, we remove it
|
||||
if (out[currentKey]) {
|
||||
out[currentKey] = out[currentKey].trim();
|
||||
if (out[currentKey].slice(-1) === quotation) {
|
||||
out[currentKey] = out[currentKey].slice(0, -1);
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function parseRepositoryClosure(chunk, state) {
|
||||
var out = [];
|
||||
var repository = deepParse(chunk, state, true, false);
|
||||
Object.keys(repository).map(function(item) {
|
||||
if (repository[item]) {
|
||||
out.push({type: item, data: repository[item]});
|
||||
} else {
|
||||
out.push({type: 'unknown', data: {name: item}});
|
||||
}
|
||||
});
|
||||
return out;
|
||||
}
|
||||
|
||||
function parseSpecialClosure(chunk, state, mapFunction) {
|
||||
var out = [];
|
||||
// openBlockCount starts at 1 due to us entering after "<key> {"
|
||||
var openBlockCount = 1;
|
||||
var currentKey = '';
|
||||
var currentValue = '';
|
||||
|
||||
var isInItemBlock = false;
|
||||
for (; state.index < chunk.length; state.index++) {
|
||||
if (chunk[state.index] === CHAR_BLOCK_START) {
|
||||
openBlockCount++;
|
||||
} else if (chunk[state.index] === CHAR_BLOCK_END) {
|
||||
openBlockCount--;
|
||||
} else {
|
||||
currentKey += String.fromCharCode(chunk[state.index]);
|
||||
}
|
||||
|
||||
// Keys shouldn't have any leading nor trailing whitespace
|
||||
currentKey = currentKey.trim();
|
||||
|
||||
if (isStartOfComment(currentKey)) {
|
||||
var commentText = currentKey;
|
||||
for (state.index = state.index + 1; state.index < chunk.length; state.index++) {
|
||||
if (isCommentComplete(commentText, chunk[state.index])) {
|
||||
currentKey = '';
|
||||
break;
|
||||
}
|
||||
commentText += String.fromCharCode(chunk[state.index]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (currentKey && isWhitespace(chunk[state.index])) {
|
||||
var character = '';
|
||||
for (state.index = state.index + 1; state.index < chunk.length; state.index++) {
|
||||
character = chunk[state.index];
|
||||
currentValue += String.fromCharCode(character);
|
||||
|
||||
if (character === CHAR_BLOCK_START) {
|
||||
isInItemBlock = true;
|
||||
} else if (isInItemBlock && character === CHAR_BLOCK_END) {
|
||||
isInItemBlock = false;
|
||||
} else if (!isInItemBlock) {
|
||||
if (isLineBreakCharacter(character) && currentValue) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
out.push(mapFunction(currentKey + ' ' + currentValue));
|
||||
currentKey = '';
|
||||
currentValue = '';
|
||||
}
|
||||
|
||||
if (openBlockCount == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function fetchDefinedNameOrSkipFunctionDefinition(chunk, state) {
|
||||
var character = 0;
|
||||
var temp = '';
|
||||
var isVariableDefinition = true;
|
||||
for (var max = chunk.length; state.index < max; state.index++) {
|
||||
character = chunk[state.index];
|
||||
|
||||
if (character === CHAR_EQUALS) {
|
||||
// Variable definition, break and return name
|
||||
break;
|
||||
} else if (character === CHAR_LEFT_PARENTHESIS) {
|
||||
// Function definition, skip parsing
|
||||
isVariableDefinition = false;
|
||||
skipFunctionDefinition(chunk, state);
|
||||
break;
|
||||
}
|
||||
|
||||
temp += String.fromCharCode(character);
|
||||
}
|
||||
|
||||
if (isVariableDefinition) {
|
||||
var values = temp.trim().split(' ');
|
||||
return values[values.length - 1];
|
||||
} else {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
function parseArray(chunk, state) {
|
||||
var character = 0;
|
||||
var temp = '';
|
||||
for (var max = chunk.length; state.index < max; state.index++) {
|
||||
character = chunk[state.index];
|
||||
if (character === CHAR_ARRAY_START) {
|
||||
continue;
|
||||
} else if (character === CHAR_ARRAY_END) {
|
||||
break;
|
||||
}
|
||||
temp += String.fromCharCode(character);
|
||||
}
|
||||
|
||||
return temp.split(',').map(function(item) {
|
||||
return trimWrappingQuotes(item.trim());
|
||||
});
|
||||
}
|
||||
|
||||
function skipFunctionCall(chunk, state) {
|
||||
var openParenthesisCount = 0;
|
||||
var character = '';
|
||||
for (var max = chunk.length; state.index < max; state.index++) {
|
||||
character = chunk[state.index];
|
||||
if (character === CHAR_LEFT_PARENTHESIS) {
|
||||
openParenthesisCount++;
|
||||
} else if (character === CHAR_RIGHT_PARENTHESIS) {
|
||||
openParenthesisCount--;
|
||||
}
|
||||
if (openParenthesisCount === 0 && !isWhitespace(character)) {
|
||||
state.index++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return openParenthesisCount === 0;
|
||||
}
|
||||
|
||||
function addValueToStructure(structure, currentKey, value) {
|
||||
if (currentKey) {
|
||||
if (structure.hasOwnProperty(currentKey)) {
|
||||
if (structure[currentKey].constructor === Array) {
|
||||
structure[currentKey].push(getRealValue(value));
|
||||
} else {
|
||||
var oldValue = structure[currentKey];
|
||||
structure[currentKey] = [oldValue, getRealValue(value)];
|
||||
}
|
||||
} else {
|
||||
structure[currentKey] = getRealValue(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function getRealValue(value) {
|
||||
if (value === 'true' || value === 'false') { // booleans
|
||||
return value === 'true';
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
function trimWrappingQuotes(string) {
|
||||
var firstCharacter = string.slice(0, 1);
|
||||
if (firstCharacter === '"') {
|
||||
return string.replace(/^"([^"]+)"$/g, '$1');
|
||||
} else if (firstCharacter === '\'') {
|
||||
return string.replace(/^'([^']+)'$/g, '$1');
|
||||
}
|
||||
return string;
|
||||
}
|
||||
|
||||
function isDelimiter(character) {
|
||||
return character === CHAR_SPACE || character === CHAR_EQUALS;
|
||||
}
|
||||
|
||||
function isWhitespace(character) {
|
||||
return WHITESPACE_CHARACTERS.hasOwnProperty(character);
|
||||
}
|
||||
|
||||
function isWhitespaceLiteral(character) {
|
||||
return isWhitespace(character.charCodeAt(0));
|
||||
}
|
||||
|
||||
function isLineBreakCharacter(character) {
|
||||
return character == CHAR_CARRIAGE_RETURN || character == CHAR_NEWLINE
|
||||
}
|
||||
|
||||
function isKeyword(string) {
|
||||
return string === KEYWORD_DEF || string === KEYWORD_IF;
|
||||
}
|
||||
|
||||
function isSingleLineComment(comment) {
|
||||
return comment.slice(0, 2) === SINGLE_LINE_COMMENT_START;
|
||||
}
|
||||
|
||||
function isStartOfComment(snippet) {
|
||||
return snippet === BLOCK_COMMENT_START || snippet === SINGLE_LINE_COMMENT_START;
|
||||
}
|
||||
|
||||
function isCommentComplete(text, next) {
|
||||
return (isLineBreakCharacter(next) && isSingleLineComment(text)) || (isWhitespace(next) && isEndOfMultiLineComment(text));
|
||||
}
|
||||
|
||||
function isEndOfMultiLineComment(comment) {
|
||||
return comment.slice(-2) === BLOCK_COMMENT_END;
|
||||
}
|
||||
|
||||
function isFunctionCall(string) {
|
||||
return string.match(/\w+\(.*\);?$/) !== null;
|
||||
}
|
||||
|
||||
function parse(readableStream) {
|
||||
return new Promise(function(resolve, reject) {
|
||||
var out = {};
|
||||
readableStream.on('data', function(chunk) {
|
||||
var state = {
|
||||
index: 0,
|
||||
comment: {
|
||||
parsing: false,
|
||||
singleLine: false,
|
||||
multiLine: false,
|
||||
|
||||
setSingleLine: function() {
|
||||
this._setCommentState(true, false);
|
||||
},
|
||||
setMultiLine: function() {
|
||||
this._setCommentState(false, true);
|
||||
},
|
||||
reset: function() {
|
||||
this._setCommentState(false, false);
|
||||
},
|
||||
_setCommentState: function(singleLine, multiLine) {
|
||||
this.singleLine = singleLine;
|
||||
this.multiLine = multiLine;
|
||||
this.parsing = singleLine || multiLine;
|
||||
}
|
||||
}
|
||||
};
|
||||
out = deepParse(chunk, state, false, undefined);
|
||||
});
|
||||
|
||||
readableStream.on('end', function() {
|
||||
resolve(out);
|
||||
});
|
||||
readableStream.on('error', function(error) {
|
||||
reject('Error parsing stream: ' + error);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function parseText(text) {
|
||||
var textAsStream = new stream.Readable();
|
||||
textAsStream._read = function noop() {};
|
||||
textAsStream.push(text);
|
||||
textAsStream.push(null);
|
||||
return parse(textAsStream);
|
||||
}
|
||||
|
||||
function parseFile(path) {
|
||||
var stream = fs.createReadStream(path);
|
||||
return parse(stream);
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
parseText: parseText,
|
||||
parseFile: parseFile
|
||||
};
|
||||
Loading…
Add table
Add a link
Reference in a new issue