gedcom.json 1.0.6 → 1.0.9

package/src/ToJSON/parsing/parseLine.ts

@@ -1,9 +1,9 @@
 import drop from 'lodash/drop';
 import join from 'lodash/join';
-import trim from "lodash/trim";
-import isEmpty from "lodash/isEmpty";
+import trim from 'lodash/trim';
+import isEmpty from 'lodash/isEmpty';
 
-import ParsedLine from "../models/ParsedLine";
+import ParsedLine from '../models/ParsedLine';
 
 import { GetLineLevel, GetReferenceId } from './lineHelper';
 
@@ -14,40 +14,40 @@ import { GetLineLevel, GetReferenceId } from './lineHelper';
  * @param lineNumber - The line number
  * @param lastLevel - The level of the last parent
  * @returns The ParsedLine object if it is a correct gedcom line else undefined
-*/
-export function ParseLine(line: string, lineNumber: number, lastLevel: number) : ParsedLine | undefined {
-    // level is max + 1 of last level
-    let level = GetLineLevel(line);
-    if (level !== 0 && level > lastLevel + 1){
-        return undefined;
+ */
+export function ParseLine(line: string, lineNumber: number, lastLevel: number): ParsedLine | undefined {
+  // level is max + 1 of last level
+  let level = GetLineLevel(line);
+  if (level !== 0 && level > lastLevel + 1) {
+    return undefined;
+  }
+
+  let splitWithDelimiter = line.split(' ');
+  let tagOrRef = trim(splitWithDelimiter[1]);
+  let valueOrTag = trim(splitWithDelimiter[2]);
+  let value: string | undefined = join(drop(splitWithDelimiter, 3), ' ');
+
+  let refId = GetReferenceId(tagOrRef);
+
+  if (refId !== undefined) {
+    if (refId.length > 23) {
+      return undefined;
     }
 
-    let splitWithDelimiter = line.split(' ');
-    let tagOrRef = trim(splitWithDelimiter[1]);
-    let valueOrTag = trim(splitWithDelimiter[2]);
-    let value: string | undefined = join(drop(splitWithDelimiter, 3), ' ');
+    return new ParsedLine(lineNumber, level, valueOrTag, value, refId);
+  }
 
-    let refId = GetReferenceId(tagOrRef);
+  let tag = tagOrRef;
 
-    if (refId !== undefined) {
-        if (refId.length > 23) {
-            return undefined;
-        }
+  if (tag.length > 31) {
+    return undefined;
+  }
 
-        return new ParsedLine(lineNumber, level, valueOrTag, value, refId);
-    }
-
-    let tag = tagOrRef;
-
-    if (tag.length > 31){
-        return undefined;
-    }
-
-    value = trim(`${valueOrTag} ${value}`);
+  value = trim(`${valueOrTag} ${value}`);
 
-    if (trim(value) === 'undefined' || isEmpty(trim(value))) {
-        value = undefined;
-    }
+  if (trim(value) === 'undefined' || isEmpty(trim(value))) {
+    value = undefined;
+  }
 
-    return new ParsedLine(lineNumber, level, tag, value);
-}
+  return new ParsedLine(lineNumber, level, tag, value);
+}

package/src/ToJSON/parsing/parsing.ts

@@ -2,7 +2,7 @@ import trimStart from 'lodash/trimStart';
 import forEach from 'lodash/forEach';
 import split from 'lodash/split';
 
-import ParsedLine from "../models/ParsedLine";
+import ParsedLine from '../models/ParsedLine';
 import Statistics from '../models/Statistics';
 import StatisticLine from '../models/StatisticLine';
 
@@ -16,57 +16,54 @@ const LineByLineReader = require('line-by-line');
 let stats = new Statistics();
 
 /**
- * Parses a text to an object 
+ * Parses a text to an object
  *
  * @param text - The text
  * @param parsingOptions - The parsing options
  * @param invokeProgressFunction - Set function that is called before each line, to show progress in some way
  * @returns An object which includes the parsed object and parsing statistics
-*/
-export function ParseText(
-    text?: string, 
-    parsingOptions?: string, 
-    invokeProgressFunction?: (linesCount: number, actualLine: number) => void): ParsingResult {
-
-    if (!text || !parsingOptions){
-        return new ParsingResult({});
-    }
+ */
+export function ParseText(text?: string, parsingOptions?: string, invokeProgressFunction?: (linesCount: number, actualLine: number) => void): ParsingResult {
+  stats = new Statistics();
 
-    ResetProcessing();
+  if (!text || !parsingOptions) {
+    return new ParsingResult({});
+  }
 
-    let lastLevel = 0;
-    let lineNumber = 1;
-    let lines = split(text, "\n");
-    let yamlOptions: string | object | undefined = {};
+  ResetProcessing();
 
-    try{
-        yamlOptions = yaml.safeLoad(parsingOptions);
-        SetParsingOptions(yamlOptions);
-    }
-    catch(e) {
-        ResetProcessing();
-        return new ParsingResult({});
+  let lastLevel = 0;
+  let lineNumber = 1;
+  let lines = split(text, '\n');
+  let yamlOptions: string | object | undefined = {};
+
+  try {
+    yamlOptions = yaml.safeLoad(parsingOptions);
+    SetParsingOptions(yamlOptions);
+  } catch (e) {
+    ResetProcessing();
+    return new ParsingResult({});
+  }
+
+  let nextLine = (lastLine: ParsedLine | undefined = undefined) => {
+    if (lastLine) {
+      lastLevel = lastLine.Level;
     }
 
-    let nextLine = (lastLine: ParsedLine | undefined = undefined) => {
-        if (lastLine){
-            lastLevel = lastLine.Level;
-        }
+    lineNumber++;
+  };
 
-        lineNumber++;
-    };
+  forEach(lines, (line, index) => {
+    if (invokeProgressFunction) {
+      invokeProgressFunction(lines.length, index);
+    }
 
-    forEach(lines, (line, index) => {
-      if (invokeProgressFunction) {
-        invokeProgressFunction(lines.length, index);
-      }
+    ProcessNewLine(lastLevel, lineNumber, line, nextLine);
+  });
 
-      ProcessNewLine(lastLevel, lineNumber, line, nextLine);
-    });
-    
-    let result = GetResult();
-    ResetProcessing();
-    return new ParsingResult(result, stats);
+  let result = GetResult();
+  ResetProcessing();
+  return new ParsingResult(result, stats);
 }
 
 /**
@@ -78,93 +75,93 @@ export function ParseText(
  * @param errorCallback - Returns file reading errors
  * @param invokeProgressFunction - Set function that is called before each line, to show progress in some way
  * @returns An object which includes the parsed object and parsing statistics
-*/
+ */
 
 /* istanbul ignore next */ // maybe later ;)
 export function ParseFile(
-  path: string, 
-  parsingOptions: string, 
-  doneCallback: (result: ParsingResult) => void, 
+  path: string,
+  parsingOptions: string,
+  doneCallback: (result: ParsingResult) => void,
   errorCallback: any,
-  invokeProgressFunction?: ((linesCount: number, actualLine: number) => void) | undefined) {
-
-    // if no progress should be shown, it is not necessary to get the line count of the file at first
-    if (!invokeProgressFunction) {
-      ExecuteParseFile(path, parsingOptions, doneCallback, errorCallback, 0);
-      return;
-    }
+  invokeProgressFunction?: ((linesCount: number, actualLine: number) => void) | undefined
+) {
+  // if no progress should be shown, it is not necessary to get the line count of the file at first
+  if (!invokeProgressFunction) {
+    ExecuteParseFile(path, parsingOptions, doneCallback, errorCallback, 0);
+    return;
+  }
 
-    // read first time to get lines count
-    let linesCountLr = new LineByLineReader(path);
-    let linesCount = 0;
-    linesCountLr.on('line', function (line: any) {
-      linesCountLr.pause();
-      linesCount++;
-      linesCountLr.resume();
-    });
-
-    linesCountLr.on('end', function () {
-      ExecuteParseFile(path, parsingOptions, doneCallback, errorCallback, linesCount, invokeProgressFunction);
-    });
+  // read first time to get lines count
+  let linesCountLr = new LineByLineReader(path);
+  let linesCount = 0;
+  linesCountLr.on('line', function (line: any) {
+    linesCountLr.pause();
+    linesCount++;
+    linesCountLr.resume();
+  });
+
+  linesCountLr.on('end', function () {
+    ExecuteParseFile(path, parsingOptions, doneCallback, errorCallback, linesCount, invokeProgressFunction);
+  });
 }
 
 /* istanbul ignore next */ // maybe later ;)
 function ExecuteParseFile(
-  path: string, 
-  parsingOptions: string, 
-  doneCallback: (result: ParsingResult) => void, 
+  path: string,
+  parsingOptions: string,
+  doneCallback: (result: ParsingResult) => void,
   errorCallback: any,
   linesCount: number,
-  invokeProgressFunction?: ((linesCount: number, actualLine: number) => void) | undefined) {
-    let lr = new LineByLineReader(path);
-    let lastLevel = 0;
-    let lineNumber = 1;
-    let yamlOptions: string | object | undefined = {};
-
-    try{
-        yamlOptions = yaml.safeLoad(parsingOptions);
-        SetParsingOptions(yamlOptions);
+  invokeProgressFunction?: ((linesCount: number, actualLine: number) => void) | undefined
+) {
+  let lr = new LineByLineReader(path);
+  let lastLevel = 0;
+  let lineNumber = 1;
+  let yamlOptions: string | object | undefined = {};
+
+  try {
+    yamlOptions = yaml.safeLoad(parsingOptions);
+    SetParsingOptions(yamlOptions);
+  } catch (e) {
+    errorCallback(e);
+    doneCallback(new ParsingResult({}));
+
+    ResetProcessing();
+    return;
+  }
+
+  let nextLine = (lastLine: ParsedLine | undefined = undefined) => {
+    if (lastLine) {
+      lastLevel = lastLine.Level;
     }
-    catch(e) {
-        errorCallback(e);
-        doneCallback(new ParsingResult({}));
 
-        ResetProcessing();
-        return;
+    if (invokeProgressFunction) {
+      invokeProgressFunction(linesCount, lineNumber);
     }
-    
-    let nextLine = (lastLine: ParsedLine | undefined = undefined) => {
-        if (lastLine){
-            lastLevel = lastLine.Level;
-        }
-
-        if (invokeProgressFunction) {
-          invokeProgressFunction(linesCount, lineNumber);
-        }
-
-        lineNumber++;
-        lr.resume();
-    };
-
-    lr.on('error', function (err: any) {
-        if (errorCallback) {
-            errorCallback(err);
-        }
-    });
-
-    lr.on('line', function (line: any) {
-        lr.pause();
-        ProcessNewLine(lastLevel, lineNumber, line, nextLine);
-    });
-    
-    lr.on('end', function () {
-        let result = GetResult();
-        ResetProcessing();
-
-        // All lines are read, file is closed now.
-        doneCallback(new ParsingResult(result, stats));
-    });
-  }
+
+    lineNumber++;
+    lr.resume();
+  };
+
+  lr.on('error', function (err: any) {
+    if (errorCallback) {
+      errorCallback(err);
+    }
+  });
+
+  lr.on('line', function (line: any) {
+    lr.pause();
+    ProcessNewLine(lastLevel, lineNumber, line, nextLine);
+  });
+
+  lr.on('end', function () {
+    let result = GetResult();
+    ResetProcessing();
+
+    // All lines are read, file is closed now.
+    doneCallback(new ParsingResult(result, stats));
+  });
+}
 
 /**
  * Function that processes a text line
@@ -175,36 +172,33 @@ function ExecuteParseFile(
  * @internal
  */
 export function ProcessNewLine(lastLevel: number, lineNumber: number, line: string, nextLine: Function) {
-    let actualLine = trimStart(line);
+  let actualLine = trimStart(line);
 
-    if (!IsValidLine(actualLine)) {
-        stats.IncorrectLines.push(new StatisticLine(lineNumber, actualLine));
-        nextLine();
-        return stats;
-    }
+  if (!IsValidLine(actualLine)) {
+    stats.IncorrectLines.push(new StatisticLine(lineNumber, actualLine));
+    nextLine();
+    return stats;
+  }
 
-    var parsedLine = ParseLine(actualLine, lineNumber, lastLevel);
+  var parsedLine = ParseLine(actualLine, lineNumber, lastLevel);
 
-    if (parsedLine === undefined) {
-        stats.IncorrectLines.push(new StatisticLine(lineNumber, actualLine));
-        nextLine();
-        return stats;
-    }
-   
-    let processingResult = ProcessLine(parsedLine, lastLevel);
-    if (processingResult.Parsed) {
-        stats.ParsedLines.push(new StatisticLine(lineNumber, actualLine));
-    }
-    else
-    {        
-        if (parsedLine.Tag && parsedLine.Tag[0] === '_') {
-            stats.NotParsedLinesWithoutGEDCOMTag.push(new StatisticLine(lineNumber, actualLine, processingResult.Reason));
-        }
-        else{
-            stats.NotParsedLines.push(new StatisticLine(lineNumber, actualLine, processingResult.Reason));
-        }
+  if (parsedLine === undefined) {
+    stats.IncorrectLines.push(new StatisticLine(lineNumber, actualLine));
+    nextLine();
+    return stats;
+  }
+
+  let processingResult = ProcessLine(parsedLine, lastLevel);
+  if (processingResult.Parsed) {
+    stats.ParsedLines.push(new StatisticLine(lineNumber, actualLine));
+  } else {
+    if (parsedLine.Tag && parsedLine.Tag[0] === '_') {
+      stats.NotParsedLinesWithoutGEDCOMTag.push(new StatisticLine(lineNumber, actualLine, processingResult.Reason));
+    } else {
+      stats.NotParsedLines.push(new StatisticLine(lineNumber, actualLine, processingResult.Reason));
     }
+  }
 
-    nextLine(parsedLine);
-    return stats;
-}
+  nextLine(parsedLine);
+  return stats;
+}