Use path.join instead of string joins for path construction. Move dynamic requires to boot time. Move formatted-data to the src directory.

chriseppstein · chriseppstein · commit ff4b706371ab · 2018-02-28T04:44:53.000-08:00
diff --git a/.gitignore b/.gitignore
@@ -4,7 +4,7 @@ node_modules
 .vscode
 
 # ignore generated grammars
-formatted-data
+src/formatted-data
 src/grammars/generated
 
 
diff --git a/package.json b/package.json
@@ -11,7 +11,7 @@
     "prepublish": "npm start",
     "test": "./node_modules/.bin/mocha --reporter spec --recursive",
     "start": "./updateCSSData.sh",
-    "clean": "rm -rf src/grammars/generated",
+    "clean": "rm -rf src/formatted-data src/grammars/generated",
     "benchmark": "node test/benchmark.js",
     "doctoc": "node ./node_modules/doctoc/doctoc.js README.md",
     "lint": "node node_modules/eslint/bin/eslint.js src/",
diff --git a/src/constants/paths.js b/src/constants/paths.js
@@ -1,12 +1,12 @@
 const path = require('path');
 
 module.exports = {
-  JSON_GRAMMAR_PATH: path.join(__dirname, '/../grammars/json/'),
-  NEARLEY_PROPERTY_GRAMMAR_PATH: path.join(__dirname, '/../grammars/nearley/properties/'),
-  GENERATED_JSON_GRAMMAR_PATH: path.join(__dirname, '/../grammars/generated/json/'),
-  GENERATED_NEARLEY_GRAMMAR_PATH: path.join(__dirname, '/../grammars/generated/nearley/'),
-  GENERATED_JS_GRAMMAR_PATH: path.join(__dirname, '/../grammars/generated/js/'),
-  FORMATTED_DATA_PATH: path.join(__dirname, '/../../formatted-data/'),
-  FORMAL_SYNTAX_GRAMMAR_PATH: path.join(__dirname, '/../grammars/'),
-  NEARLEY_BIN_ROOT: path.join(__dirname, '/../../node_modules/nearley/bin/'),
+  JSON_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars', 'json'),
+  NEARLEY_PROPERTY_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars', 'nearley', 'properties'),
+  GENERATED_JSON_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars', 'generated', 'json'),
+  GENERATED_NEARLEY_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars', 'generated', 'nearley'),
+  GENERATED_JS_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars', 'generated', 'js'),
+  FORMATTED_DATA_PATH: path.join(__dirname, '..', 'formatted-data'),
+  FORMAL_SYNTAX_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars'),
+  NEARLEY_BIN_ROOT: path.join(__dirname, '..', '..', 'node_modules', 'nearley', 'bin'),
 };
diff --git a/src/expandShorthandProperty.js b/src/expandShorthandProperty.js
@@ -1,8 +1,8 @@
 const nearley = require('nearley');
-const properties = require('../formatted-data/properties.json');
+const properties = require('./formatted-data/properties.json');
 const isShorthandProperty = require('./isShorthandProperty');
 const getShorthandComputedProperties = require('./getShorthandComputedProperties');
-const shorthandProperties = require('../formatted-data/shorthand-properties.json');
+const shorthandProperties = require('./formatted-data/shorthand-properties.json');
 const CSS_CONSTANTS = require('./constants/css');
 const { CLASSIFICATIONS } = require('./constants/shorthandProperties');
 const LocationIndexTracker = require('./utils/LocationIndexTracker');
@@ -18,6 +18,7 @@ const {
   UnorderedOptionalListPropertyFormatter,
 } = require('./formatters/shorthandPropertyTypeFormatters');
 const { initialValue, initialValues } = require('./initialValueMap');
+const grammars = require('./grammars/generated');
 
 const shorthandPropertyTypeToActionDictionaryFactoryMap = {
   [CLASSIFICATIONS.TRBL]: TrblPropertyFormatter,
@@ -88,7 +89,7 @@ module.exports = function expandShorthandProperty(propertyName,
   }
 
   // get the compiled grammar file for this property
-  const grammar = require('./grammars/generated')[propertyName];
+  const grammar = grammars[propertyName];
   // remove any block style comments and extra whitespace
   const formattedPropertyValue = propertyValue.replace(R_BLOCK_COMMENT, ' ').replace(/\s+/g, ' ').trim();
   let parser;
diff --git a/src/formatters/grammarFormatters/NearleyGrammarFormatter.js b/src/formatters/grammarFormatters/NearleyGrammarFormatter.js
@@ -1,5 +1,6 @@
 const CaseConverterUtils = require('../../utils/CaseConverterUtils');
 const fs = require('fs-extra');
+const path = require('path');
 const PATHS = require('../../constants/paths');
 const GRAMMAR_CONSTANTS = require('../../constants/grammars');
 const shorthandIdentToLongHandPropertyMap = require('../../constants/shorthandIdentToLonghandPropertyMap.json');
@@ -36,7 +37,7 @@ module.exports = class NearleyGrammarFormatter {
       ._getGrammarsToResolve(jsonGrammar)
       .map(fileToResolve => [
         fileToResolve,
-        fs.readJsonSync(`${PATHS.GENERATED_JSON_GRAMMAR_PATH}${fileToResolve}.json`),
+        fs.readJsonSync(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, `${fileToResolve}.json`)),
       ])
       .filter(([, json]) => NearleyGrammarFormatter._isGrammarValid(json))
       .map(([grammarName, jsonGrammar]) => (
@@ -122,7 +123,7 @@ module.exports = class NearleyGrammarFormatter {
 
     return [...new Set(resolutions.concat(
       ...resolutions
-        .map(file => fs.readJsonSync(`${PATHS.GENERATED_JSON_GRAMMAR_PATH}${file}.json`))
+        .map(file => fs.readJsonSync(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, `${file}.json`)))
         .map(grammar => NearleyGrammarFormatter._getGrammarsToResolve(grammar, resolved.concat(resolutions)))))];
   }
 
diff --git a/src/getShorthandComputedProperties.js b/src/getShorthandComputedProperties.js
@@ -1,4 +1,4 @@
-const properties = require('../formatted-data/properties.json');
+const properties = require('./formatted-data/properties.json');
 
 /**
  * Given a shorthand property, returns an array of the computed properties for that shorthand property. If given
diff --git a/src/getShorthandsForProperty.js b/src/getShorthandsForProperty.js
@@ -1,5 +1,5 @@
-const shortHandProperties = require('../formatted-data/shorthand-properties.json');
-const properties = require('../formatted-data/properties.json');
+const shortHandProperties = require('./formatted-data/shorthand-properties.json');
+const properties = require('./formatted-data/properties.json');
 
 /**
  * @type {Object}
diff --git a/src/initialValueMap.js b/src/initialValueMap.js
@@ -1,4 +1,4 @@
-const properties = require('../formatted-data/properties.json');
+const properties = require('./formatted-data/properties.json');
 const getShorthandComputedProperties = require('./getShorthandComputedProperties');
 const isShorthandProperty = require('./isShorthandProperty');
 
diff --git a/src/isShorthandProperty.js b/src/isShorthandProperty.js
@@ -1,4 +1,4 @@
-const shortHandProperties = require('../formatted-data/shorthand-properties.json');
+const shortHandProperties = require('./formatted-data/shorthand-properties.json');
 
 /**
  * Checks if a given property is a shorthand property
diff --git a/src/isValidDeclaration.js b/src/isValidDeclaration.js
@@ -1,6 +1,7 @@
 const nearley = require('nearley');
-const properties = require('../formatted-data/properties.json');
+const properties = require('./formatted-data/properties.json');
 const { CSS } = require('./constants');
+const grammars = require('./grammars/generated');
 
 /**
  * Checks if the given property, value pair is valid.
@@ -16,7 +17,7 @@ module.exports = function isValidDeclaration(property, value) {
     return true;
   }
 
-  const propertyGrammar = require('./grammars/generated')[property];
+  const propertyGrammar = grammars[property];
 
   try {
     const parser = new nearley.Parser(nearley.Grammar.fromCompiled(propertyGrammar)).feed(value);
diff --git a/src/scripts/extractProperties.js b/src/scripts/extractProperties.js
@@ -3,11 +3,12 @@
  * Writes the formatted data to FORMATTED_DATA_PATH.
  */
 const fs = require('fs-extra');
+const path = require('path');
 const { css: { properties } } = require('mdn-data');
 const PATHS = require('../constants/paths');
 
 const ALL_PROPERTIES_DATA_FILE_NAME = 'properties.json';
-const OUTPUT_FILE = `${PATHS.FORMATTED_DATA_PATH}${ALL_PROPERTIES_DATA_FILE_NAME}`;
+const OUTPUT_FILE = path.join(PATHS.FORMATTED_DATA_PATH, ALL_PROPERTIES_DATA_FILE_NAME);
 fs.writeJson(OUTPUT_FILE, properties, { spaces: 2 })
   .then(() => (
     console.log(`Successfully extracted properties to ${OUTPUT_FILE}`)
diff --git a/src/scripts/formatData.js b/src/scripts/formatData.js
@@ -3,6 +3,7 @@
  * Writes the formatted data to FORMATTED_DATA_PATH.
  */
 const fs = require('fs-extra');
+const path = require('path');
 const { css: { properties } } = require('mdn-data');
 const ShorthandPropertyClassifierUtils = require('../utils/ShorthandPropertyClassifierUtils');
 const PATHS = require('../constants/paths');
@@ -21,7 +22,8 @@ const formattedData = Object.entries(properties)
   // reduce it down to an object again so we can write it to a file
   .reduce((propertyMap, [property, data]) => Object.assign({ [property]: data }, propertyMap), {});
 
-fs.writeJson(`${PATHS.FORMATTED_DATA_PATH}${SHORTHAND_FORMATTED_DATA_FILE_NAME}`, formattedData, { spaces: 2 })
-  .then(() => (
-    console.log(`Successfully formatted data to ${PATHS.FORMATTED_DATA_PATH}${SHORTHAND_FORMATTED_DATA_FILE_NAME}`)
-  ));
+fs.writeJson(path.join(PATHS.FORMATTED_DATA_PATH, SHORTHAND_FORMATTED_DATA_FILE_NAME), formattedData, { spaces: 2 })
+  .then(() => {
+    const fdPath = path.join(PATHS.FORMATTED_DATA_PATH, SHORTHAND_FORMATTED_DATA_FILE_NAME);
+    console.log(`Successfully formatted data to ${fdPath}`);
+  });
diff --git a/src/scripts/formatFormalSyntaxes.js b/src/scripts/formatFormalSyntaxes.js
@@ -2,6 +2,7 @@
  * Format each formal syntax into a json grammar
  */
 const fs = require('fs-extra');
+const path = require('path');
 const { css: { properties, syntaxes } } = require('mdn-data');
 const { PATHS, SYNTAX_OVERRIDES } = require('../constants/index');
 const JsonGrammarFormatter = require('../formatters/grammarFormatters/JsonGrammarFormatter');
@@ -30,18 +31,19 @@ const syntaxesSyntaxMap = Object.entries(syntaxes)
 const propertySyntaxMap = Object.entries(properties).reduce((syntaxMap, [propertyName, { syntax }]) => (
   Object.assign({ [propertyName]: syntax }, syntaxMap)
 ), syntaxesSyntaxMap);
-const overridenPropertySyntaxMap = Object.assign(propertySyntaxMap, SYNTAX_OVERRIDES);
+const overriddenPropertySyntaxMap = Object.assign(propertySyntaxMap, SYNTAX_OVERRIDES);
 
 // make the json grammar directory if needed
 if (!fs.existsSync(PATHS.GENERATED_JSON_GRAMMAR_PATH)) {
   fs.mkdirSync(PATHS.GENERATED_JSON_GRAMMAR_PATH);
 }
 
-Object.entries(overridenPropertySyntaxMap)
+Object.entries(overriddenPropertySyntaxMap)
 // filter out any entries that we need to do manually
   .filter(([grammarName]) => !manualSyntaxes.includes(grammarName))
   .forEach(([grammarName, formalSyntax]) => {
-    console.log(`creating ${PATHS.GENERATED_JSON_GRAMMAR_PATH}${grammarName}.json`);
+    const filename = path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, `${grammarName}.json`);
+    console.log(`creating ${filename}`);
     const jsonGrammar = JsonGrammarFormatter.format(formalSyntax);
-    fs.writeJson(`${PATHS.GENERATED_JSON_GRAMMAR_PATH}${grammarName}.json`, jsonGrammar, { spaces: 2 });
+    fs.writeJson(filename, jsonGrammar, { spaces: 2 });
   });
diff --git a/src/scripts/formatGrammars.js b/src/scripts/formatGrammars.js
@@ -24,33 +24,34 @@ if (!fs.existsSync(PATHS.GENERATED_JS_GRAMMAR_PATH)) {
 }
 
 // move manual json grammars into generated folder for grammar resolution
-fs.readdirSync(`${PATHS.JSON_GRAMMAR_PATH}`)
-  .forEach(fileName => (
-    fs.copySync(`${PATHS.JSON_GRAMMAR_PATH}${fileName}`, `${PATHS.GENERATED_JSON_GRAMMAR_PATH}${fileName}`))
-  );
+fs.readdirSync(PATHS.JSON_GRAMMAR_PATH)
+  .forEach((fileName) => {
+    const fullSrc = path.join(PATHS.JSON_GRAMMAR_PATH, fileName);
+    const fullDest = path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, fileName);
+    fs.copySync(fullSrc, fullDest);
+  });
 
 // read each json grammar and format it into an nearley grammar
 fs.readdirSync(PATHS.GENERATED_JSON_GRAMMAR_PATH)
-  .map(fileName => [fileName, fs.readJsonSync(`${PATHS.GENERATED_JSON_GRAMMAR_PATH}${fileName}`)])
+  .map(fileName => [fileName, fs.readJsonSync(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, fileName))])
   .forEach(([fileName, jsonGrammar]) => {
     console.log(`creating ${fileName}`);
 
     const grammarName = fileName.replace('.json', '');
     const nearleyGrammar = NearleyGrammarFormatter.format(jsonGrammar, grammarName);
-    const fileToWrite = `${PATHS.GENERATED_NEARLEY_GRAMMAR_PATH}${fileName.replace('.json', `.${GRAMMAR_CONSTANTS.GRAMMAR_FILE_EXTENSION}`)}`;
+    const fileToWrite = path.join(PATHS.GENERATED_NEARLEY_GRAMMAR_PATH, fileName.replace('.json', `.${GRAMMAR_CONSTANTS.GRAMMAR_FILE_EXTENSION}`));
 
     fs.createFileSync(fileToWrite);
     fs.writeFileSync(fileToWrite, nearleyGrammar);
   });
 
 // copy over overridden grammars
 fs.readdirSync(PATHS.NEARLEY_PROPERTY_GRAMMAR_PATH)
-  .forEach(fileName => (
-    fs.copySync(
-      `${PATHS.NEARLEY_PROPERTY_GRAMMAR_PATH}${fileName}`,
-      `${PATHS.GENERATED_NEARLEY_GRAMMAR_PATH}${fileName}`
-    )
-  ));
+  .forEach((fileName) => {
+    const fullSrc = path.join(PATHS.NEARLEY_PROPERTY_GRAMMAR_PATH, fileName);
+    const fullDest = path.join(PATHS.GENERATED_NEARLEY_GRAMMAR_PATH, fileName);
+    fs.copySync(fullSrc, fullDest);
+  });
 
 console.log('...Successfully created nearley grammars...');
 
@@ -65,19 +66,19 @@ const compilationCommands = fs.readdirSync(PATHS.GENERATED_NEARLEY_GRAMMAR_PATH)
   .map((fileName) => {
     const propName = fileName.replace(`.${GRAMMAR_CONSTANTS.GRAMMAR_FILE_EXTENSION}`, '');
     const jsFileName = `${propName}.${JAVASCRIPT_FILE_EXTENSION}`;
-    const nearleyFilePath = JSON.stringify(`${PATHS.GENERATED_NEARLEY_GRAMMAR_PATH}${fileName}`);
+    const nearleyFilePath = JSON.stringify(path.join(PATHS.GENERATED_NEARLEY_GRAMMAR_PATH, fileName));
     const jsFilePath = JSON.stringify(
       path.join(PATHS.GENERATED_JS_GRAMMAR_PATH, jsFileName)
     );
 
     jsModules.push(`  '${propName}': require('./js/${jsFileName}')`);
 
-    return `node ${PATHS.NEARLEY_BIN_ROOT}${NEARLEY_COMPILER_FILE_NAME} ${nearleyFilePath} > ${jsFilePath}`;
+    return `node ${path.join(PATHS.NEARLEY_BIN_ROOT, NEARLEY_COMPILER_FILE_NAME)} ${nearleyFilePath} > ${jsFilePath}`;
   });
 
 const jsExportsFile = `module.exports = {\n${jsModules.join(',\n')}\n}`;
 
-fs.writeFileSync(path.join(PATHS.GENERATED_JS_GRAMMAR_PATH, '../index.js'), jsExportsFile);
+fs.writeFileSync(path.resolve(PATHS.GENERATED_JS_GRAMMAR_PATH, '..', 'index.js'), jsExportsFile);
 
 compilationQueue.push(compilationCommands, (err) => {
   if (err) {
diff --git a/src/scripts/updateBasicDataUnits.js b/src/scripts/updateBasicDataUnits.js
@@ -5,6 +5,7 @@
  */
 const { css: { units } } = require('mdn-data');
 const fs = require('fs-extra');
+const path = require('path');
 const PATHS = require('../constants/paths');
 const GRAMMAR_CONSTANTS = require('../constants/grammars');
 
@@ -28,7 +29,7 @@ const unitToTypesMap = Object.entries(units).reduce((unitMap, [unit, { groups }]
 
 Promise.all(
   Object.entries(unitToTypesMap).map(([fileName, unitList]) => (
-    fs.writeJson(`${PATHS.GENERATED_JSON_GRAMMAR_PATH}${fileName}.json`, [
+    fs.writeJson(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, `${fileName}.json`), [
       [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, `( ${unitList.map(unit => `"${unit}"`).join(' | ')} )`],
     ], { spaces: 2 })
   )))
diff --git a/test/InitialValuesTest.js b/test/InitialValuesTest.js
@@ -1,5 +1,5 @@
 const { assert } = require('chai');
-const properties = require('../formatted-data/properties.json');
+const properties = require('../src/formatted-data/properties.json');
 const {
    initialValue,
    initialValues,
diff --git a/test/formatters/NearleyGrammarFormatterTest.js b/test/formatters/NearleyGrammarFormatterTest.js
@@ -1,5 +1,6 @@
 const sinon = require('sinon');
 const fs = require('fs-extra');
+const path = require('path');
 const { assert } = require('chai');
 const PATHS = require('../../src/constants/paths');
 const GRAMMAR_CONSTANTS = require('../../src/constants/grammars');
@@ -58,17 +59,17 @@ describe('NearleyGrammarFormatter#format', function () {
   describe('recursive cases', function () {
     it('should handle deeply recursive cases', function () {
       sandbox.stub(fs, 'readJsonSync')
-        .withArgs(`${PATHS.GENERATED_JSON_GRAMMAR_PATH}ra.json`)
+        .withArgs(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, 'ra.json'))
         .returns([
           [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '<rb>'],
           ['<rb>'],
         ])
-        .withArgs(`${PATHS.GENERATED_JSON_GRAMMAR_PATH}rb.json`)
+        .withArgs(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, 'rb.json'))
         .returns([
           [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '<rc>'],
           ['<rc>'],
         ])
-        .withArgs(`${PATHS.GENERATED_JSON_GRAMMAR_PATH}rc.json`)
+        .withArgs(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, 'rc.json'))
         .returns([
           [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '"d"'],
         ]);
diff --git a/updateCSSData.sh b/updateCSSData.sh
@@ -13,8 +13,8 @@ function realpath()
     echo "$dir$base"
 }
 cd "$(dirname "$(realpath "$0")")";
-rm -rf formatted-data src/grammars/generated/json
-mkdir -p formatted-data src/grammars/generated/json
+rm -rf src/formatted-data src/grammars/generated/json
+mkdir -p src/formatted-data src/grammars/generated/json
 node ./node_modules/nearley/bin/nearleyc.js ./src/grammars/nearley/formalSyntax.ne > ./src/grammars/js/formalSyntax.js || exit 1
 node ./src/scripts/updateBasicDataUnits.js || exit 1
 node ./src/scripts/formatData.js || exit 1

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-const properties = require('../formatted-data/properties.json');`
	`1`	`+const properties = require('./formatted-data/properties.json');`
`2`	`2`
`3`	`3`	`/**`
`4`	`4`	`* Given a shorthand property, returns an array of the computed properties for that shorthand property. If given`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-const shortHandProperties = require('../formatted-data/shorthand-properties.json');`
	`1`	`+const shortHandProperties = require('./formatted-data/shorthand-properties.json');`
`2`	`2`
`3`	`3`	`/**`
`4`	`4`	`* Checks if a given property is a shorthand property`