madden-franchise 2.4.2 → 2.5.3

package/FranchiseFile.js

@@ -175,30 +175,20 @@ class FranchiseFile extends EventEmitter {
     });
   };
 
-  save(outputFilePath) {
-    return this.packFile(outputFilePath);
+  save(outputFilePath, options) {
+    return this.packFile(outputFilePath, options);
   };
 
-  packFile(outputFilePath) {
+  packFile(outputFilePath, options) {
     const that = this;
     this.emit('saving');
 
     return new Promise((resolve, reject) => {
       this.unpackedFileContents = this.strategy.file.generateUnpackedContents(this.tables, this.unpackedFileContents);
-      // const changedTables = this.tables.filter((table) => { return table.isChanged; });
-  
-      //   for (let i = 0; i < changedTables.length; i++) {
-      //     let table = changedTables[i];
-      //     const header = that.unpackedFileContents.slice(0, table.offset);
-      //     const trailer = that.unpackedFileContents.slice(table.offset + table.data.length);
-      //     that.unpackedFileContents = Buffer.concat([header, table.hexData, trailer]);
-
-      //     table.isChanged = false;
-      //   }
 
       let destination = outputFilePath ? outputFilePath : this.filePath;
   
-      _packFile(this.unpackedFileContents).then((data) => {
+      _packFile(this.unpackedFileContents, options).then((data) => {
         const dataToSave = this.strategy.file.postPackFile(this.packedFileContents, data);
         _save(destination, dataToSave, (err) => {
           if (err) {
@@ -346,15 +336,24 @@ function unpackFile (data, type) {
   return zlib.inflateSync(data.slice(offset));
 };
 
-function _packFile (data) {
+function _packFile (data, options) {
   return new Promise((resolve, reject) => {
-    zlib.deflate(data, {
-      windowBits: 15
-    }, function (err, newData) {
-      if (err) reject(err);
-
+    if (options && options.sync) {
+      const newData = zlib.deflateSync(data, {
+        windowBits: 15
+      });
+      
       resolve(newData);
-    });
+    }
+    else {
+      zlib.deflate(data, {
+        windowBits: 15
+      }, function (err, newData) {
+        if (err) reject(err);
+  
+        resolve(newData);
+      });
+    }
   });
 };
 

package/FranchiseSchema.js

@@ -46,6 +46,7 @@ class FranchiseSchema extends EventEmitter {
     this.meta = this.schema.meta;
     this.schemas = this.schema.schemas;
     this.schemaMap = {};
+    this.enumMap = {};
   
     for (let i = 0; i < this.schemas.length; i++) {
       const schema = this.schemas[i];
@@ -56,6 +57,7 @@ class FranchiseSchema extends EventEmitter {
   
         if (attribute.enum) {
           attribute.enum = new FranchiseEnum(attribute.enum);
+          this.enumMap[attribute.enum.name] = attribute.enum;
         } 
       }
     }
@@ -64,6 +66,11 @@ class FranchiseSchema extends EventEmitter {
     const extraSchemas = schemaGenerator.getExtraSchemas();
     extraSchemas.forEach((schema) => {
       if (!this.schemaMap[schema.name]) {
+        schema.attributes.forEach((attrib) => {
+          if (attrib.enum) {
+            attrib.enum = new FranchiseEnum(this.enumMap[attrib.enum]);
+          }
+        })
         this.schemas.unshift(schema);
         this.schemaMap[schema.name] = schema;
         addedExtraSchema = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "madden-franchise",
-  "version": "2.4.2",
+  "version": "2.5.3",
   "description": "Tools to read a madden franchise file and get data from it",
   "main": "FranchiseFile.js",
   "scripts": {
@@ -13,7 +13,7 @@
   "author": "matthewpanetta",
   "license": "MIT",
   "dependencies": {
-    "xml-stream": "^0.4.5"
+    "node-xml-stream-parser": "^1.0.12"
   },
   "repository": {
     "type": "git",
@@ -22,7 +22,7 @@
   "devDependencies": {
     "chai": "^4.2.0",
     "chai-eventemitter": "^1.1.1",
-    "mocha": "^6.2.2",
+    "mocha": "^9.1.4",
     "proxyquire": "^2.1.3",
     "sinon": "^7.5.0"
   }

package/services/schemaGenerator.js

@@ -1,14 +1,11 @@
-// USAGE:
-//  node schema-generator.js [input file path] [output file folder]
-
 const fs = require('fs');
 const path = require('path');
 const zlib = require('zlib');
-const XmlStream = require('xml-stream');
+const { pipeline } = require('stream');
 const utilService = require('./utilService');
 const FranchiseEnum = require('../FranchiseEnum');
+const XmlParser = require('node-xml-stream-parser');
 const EventEmitter = require('events').EventEmitter;
-const extraSchemas = require('../data/schemas/extra-schemas.json');
 
 let schemaGenerator = {};
 schemaGenerator.eventEmitter = new EventEmitter();
@@ -22,103 +19,147 @@ schemaGenerator.generateFromStream = (stream, showOutput, outputFile) => {
   schemaGenerator.root = {}
   schemaGenerator.schemas = [];
   schemaGenerator.schemaMap = {};
+  schemaGenerator.schemaMeta = {};
   schemaGenerator.enums = [];
+  const extraSchemas = schemaGenerator.getExtraSchemas();
 
-  schemaGenerator.xml = new XmlStream(stream);
+  schemaGenerator.xml = new XmlParser();
 
-  schemaGenerator.xml.collect('attribute');
+  pipeline(
+    stream,
+    schemaGenerator.xml,
+    (err) => {
+      if (err) {
+        console.error(err);
+        throw err;
+      }
+      
+      schemaGenerator.enums.forEach((theEnum) => {
+        theEnum.setMemberLength();
+      });
 
-  schemaGenerator.xml.on('endElement: FranTkData', function (data) {
-    const majorVersion = data.$.dataMajorVersion;
-    const minorVersion = data.$.dataMinorVersion;
-    const databaseName = data.$.databaseName;
-    const gameYear = /Madden(\d{2})/.exec(databaseName)[1];
+      const majorVersion = schemaGenerator.schemaMeta.dataMajorVersion;
+      const minorVersion = schemaGenerator.schemaMeta.dataMinorVersion;
+      const databaseName = schemaGenerator.schemaMeta.databaseName;
 
-    addExtraSchemas();
-    calculateInheritedSchemas();
+      const gameYear = /Madden(\d{2})/.exec(databaseName)[1];
 
-    schemaGenerator.root = {
-      'meta': {
-        'major': parseInt(majorVersion),
-        'minor': parseInt(minorVersion),
-        'gameYear': parseInt(gameYear)
-      },
-      'schemas': schemaGenerator.schemas,
-      'schemaMap': schemaGenerator.schemaMap
-    };
+      addExtraSchemas();
+      calculateInheritedSchemas();
 
-    if (outputFile) {
-      zlib.gzip(JSON.stringify(schemaGenerator.root), function (_, data) {
-        fs.writeFileSync(`${outputFile}\\${majorVersion}_${minorVersion}.gz`, data);
-      });
+      schemaGenerator.root = {
+        'meta': {
+          'major': parseInt(majorVersion),
+          'minor': parseInt(minorVersion),
+          'gameYear': parseInt(gameYear)
+        },
+        'schemas': schemaGenerator.schemas,
+        'schemaMap': schemaGenerator.schemaMap
+      };
+
+      if (outputFile) {
+        zlib.gzip(JSON.stringify(schemaGenerator.root), function (_, data) {
+          fs.writeFileSync(`${outputFile}\\${majorVersion}_${minorVersion}.gz`, data);
+        });
+      }
+
+      schemaGenerator.eventEmitter.emit('schemas:done', schemaGenerator.root);
     }
+  );
 
-    schemaGenerator.eventEmitter.emit('schemas:done', schemaGenerator.root);
-  });
+  let currentParent = {
+    type: '',
+    ref: null
+  };
 
-  schemaGenerator.xml.on('endElement: enum', function (theEnum) {
-    if (showOutput) console.log(`Adding enum ${theEnum.$.name}`);
+  schemaGenerator.xml.on('opentag', (name, attrs) => {
+    if (name === 'FranTkData') {
+      schemaGenerator.schemaMeta.databaseName = attrs.databaseName;
+      schemaGenerator.schemaMeta.dataMajorVersion = attrs.dataMajorVersion;
+      schemaGenerator.schemaMeta.dataMinorVersion = attrs.dataMinorVersion;
+    }
 
-    let newEnum = new FranchiseEnum(theEnum.$.name, theEnum.$.assetId, theEnum.$.isRecordPersistent);
+    else if (name === 'enum') {
+      let theEnum = parseEnum(attrs);
+      schemaGenerator.enums.push(theEnum);
 
-    if (theEnum.attribute) {
-      theEnum.attribute.forEach((attribute) => {
-        newEnum.addMember(attribute.$.name, attribute.$.idx, attribute.$.value);
-      });
+      currentParent = {
+        type: 'enum',
+        ref: theEnum
+      }
     }
 
-    newEnum.setMemberLength();
-    schemaGenerator.enums.push(newEnum);
-  });
+    else if (name === 'schema') {
+      let schema = parseSchema(attrs);
+      schema.attributes = [];
 
-  schemaGenerator.xml.on('endElement: schema', function (schema) {
-    if (showOutput) console.log(`Adding schema ${schema.$.name}`);
-    let attributes = [];
-    
-    if (schema.attribute) {
-      attributes = schema.attribute.map((attribute) => {
-        return {
-          'index': attribute.$.idx,
-          'name': attribute.$.name,
-          'type': attribute.$.type,
-          'minValue': attribute.$.minValue,
-          'maxValue': attribute.$.maxValue,
-          'maxLength': attribute.$.maxLen,
-          'default': attribute.$.default,
-          'final': attribute.$.final,
-          'enum': getEnum(attribute.$.type),
-          'const': attribute.$.const
-        }
-      });
+      schemaGenerator.schemas.push(schema);
+      schemaGenerator.schemaMap[schema.name] = schema;
+      
+      currentParent = {
+        type: 'schema',
+        ref: schema
+      }
+    }
+
+    else if (name === 'attribute') {
+      if (currentParent.type === 'enum') {
+        currentParent.ref.addMember(attrs.name, attrs.idx, attrs.value);
+      }
+      else {
+        const attribute = parseAttribute(attrs);
+        currentParent.ref.attributes.push(attribute);
+      }
     }
+  });
 
-    const element = {
-      'assetId': schema.$.assetId,
-      'ownerAssetId': schema.$.ownerAssetId,
-      'numMembers': schema.$.numMembers,
-      'name': schema.$.name,
-      'base': schema.$.base,
-      'attributes': attributes
+  function parseEnum(enumAttributes) {
+    return new FranchiseEnum(enumAttributes.name, enumAttributes.assetId, enumAttributes.isRecordPersistent);
+  };
+
+  function parseSchema(schemaAttributes) {
+    return {
+      'assetId': schemaAttributes.assetId,
+      'ownerAssetId': schemaAttributes.ownerAssetId,
+      'numMembers': schemaAttributes.numMembers,
+      'name': schemaAttributes.name,
+      'base': schemaAttributes.base
     };
+  };
+
+  function parseAttribute(attributeAttributes) {
+    return {
+      'index': attributeAttributes.idx,
+      'name': attributeAttributes.name,
+      'type': attributeAttributes.type,
+      'minValue': attributeAttributes.minValue,
+      'maxValue': attributeAttributes.maxValue,
+      'maxLength': attributeAttributes.maxLen,
+      'default': getDefaultValue(attributeAttributes.default),
+      'final': attributeAttributes.final,
+      'enum': getEnum(attributeAttributes.type),
+      'const': attributeAttributes.const
+    }
 
-    schemaGenerator.schemas.push(element);
-    schemaGenerator.schemaMap[element.name] = element;
+    function getDefaultValue(defaultVal) {
+      if (!defaultVal) { return undefined; }
 
-    if (element.name === 'WinLossStreakPlayerGoal') {
-      // calculateInheritedSchemas();
-      // // fs.writeFileSync(outputFile, JSON.stringify(schemaGenerator.schemas));
-      // zlib.gzip(JSON.stringify(schemaGenerator.schemas), function (_, data) {
-      //   fs.writeFileSync(outputFile, data);
-      // });
-      // schemaGenerator.emit('schemas:done', schemaGenerator.schemas);
+      defaultVal = defaultVal
+        .replace(new RegExp('
', 'g'), '\r')
+        .replace(new RegExp('
', 'g'), '\n')
+        .replace(new RegExp('&', 'g'), '&')
+        .replace(new RegExp('>', 'g'), '>')
+        .replace(new RegExp('&lt;', 'g'), '<')
+        .replace(new RegExp('&quot;', 'g'), '\"')
+
+      return defaultVal;
     }
-  });
+  };
 
   function addExtraSchemas() {
     extraSchemas.forEach((schema) => {
-
       if (!schemaGenerator.schemaMap[schema.name]) {
-        schema.attributes.filter((attrib) => { 
+        schema.attributes.filter((attrib) => {
           return attrib.enum && !(attrib.enum instanceof FranchiseEnum);
         }).forEach((attrib) => {
           attrib.enum = getEnum(attrib.enum);
@@ -143,19 +184,7 @@ schemaGenerator.generateFromStream = (stream, showOutput, outputFile) => {
 };
 
 schemaGenerator.getExtraSchemas = () => {
-  let newSchemas = [];
-
-  extraSchemas.forEach((schema) => {
-    schema.attributes.filter((attrib) => { 
-      return attrib.enum && !(attrib.enum instanceof FranchiseEnum);
-    }).forEach((attrib) => {
-      attrib.enum = new FranchiseEnum(attrib.enum);
-    });
-
-    newSchemas.push(schema);
-  });
-
-  return newSchemas;
+  return JSON.parse(JSON.stringify(require(path.join(__dirname, '../data/schemas/extra-schemas.json'))));
 };
 
 schemaGenerator.calculateInheritedSchemas = (schemaList) => {