Merge branch 'dev'

Author: Alexander Yukal

.github/workflows/node.js.yml

@@ -0,0 +1,28 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ master, dev ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x, 14.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm ci
+    - run: npm test

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Alexander
+Copyright (c) 2020 Alexander Yukal
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -140,10 +140,6 @@ $ gulp html
 $ npx gulp html
 ```
 
-### TODO
-To avoid collisions with the same file names, we should split the responsibility of pages 
-and libraries in the data directory using the nested paths cutting them with a dot symbol.
-
 ## Libraries Using `gulp-json-loader`
 
 - [gulp-data](https://www.npmjs.com/package/gulp-data)

changes.txt

@@ -22,3 +22,5 @@ v1.1.0:
 
 - Implemented data caching
   - The data that has already been loaded will be getting from the cache
+
+- Added tests

lib/gulp-json-loader.js

@@ -1,33 +1,30 @@
 'use strict';
 
+/**
+ * GulpJsonLoader
+ *
+ * @file
+ * @ingroup Plugins
+ * @version 1.2
+ * @license MIT
+ * @author Alexander Yukal <yukal@email.ua>
+ */
+
 const Util = require('util');
 const Path = require('path');
 const Fs = require('fs');
 
 const APP_PATH = process.cwd();
-const DEFAULT_SOURCE_PATH = './src';
+const DEFAULT_SOURCE_PATH = 'src';
 const BREAK_LINE = process.platform === 'win32' ? '\r\n' : '\n';
-const ERR_TOP_DIR = 'Working with top-level directories is prohibited!';
+const ERR_EXTERNAL_PATH = 'Working with external paths is prohibited!';
 
-const CachedData = {};
 const BrushColors = {
   red: 1,
   cyan: 6,
   grey: 8
 };
 
-const getAbsolutePath = (path, subdir = '') => {
-  if (path.startsWith('/')) {
-    path = '.' + path;
-  }
-
-  path = Path.join(APP_PATH, path);
-
-  return subdir
-    ? Path.join(path, subdir)
-    : path;
-}
-
 /**
  * brush
  * Adding the ANSI escape codes to a textual data
@@ -66,19 +63,36 @@ const reportAction = (ctx, pathJson, filename, action) => {
   process.stdout.write(message);
 }
 
-const loadImportsAsync = (ctx, imports) => {
+const loadImportsAsync = (ctx, imports, cachedData) => {
   return new Promise((resolve, reject) => {
     if (!Array.isArray(imports)) {
+
       reject(new Error('Imports should be an Array'));
+
     } else {
-      const storage = {};
-      loadImportsRecursively({ ctx, imports, storage, resolve, reject });
+
+      if (imports.length < 1) {
+        resolve({});
+        return;
+      }
+
+      const options = { ctx, imports, cachedData, pocket: {} };
+
+      loadImportsRecursively(options, (error, pocket) => {
+        if (error !== null) {
+          reject(error);
+          return;
+        }
+
+        resolve(pocket);
+      });
+
     }
   });
 };
 
-const loadImportsRecursively = async (options) => {
-  const { ctx, imports, storage, resolve, reject, idx = 0 } = options;
+const loadImportsRecursively = async (options, callback) => {
+  const { ctx, imports, cachedData, pocket, idx = 0 } = options;
   const { report, pathData } = ctx;
 
   if (idx < imports.length) {
@@ -87,78 +101,78 @@ const loadImportsRecursively = async (options) => {
     const jsonRelativePath = imports[idx] + '.json';
     const jsonFullPath = Path.join(pathData, 'imports', jsonRelativePath);
     const jsonFilename = Path.basename(jsonFullPath, '.json');
-    const cacheKey = 'imports:' + jsonFullPath.replace(APP_PATH, '');
+    const cacheKey = jsonFullPath.replace(`${APP_PATH}/`, '');
 
     if (!jsonFullPath.startsWith(APP_PATH)) {
-      reject(new Error(ERR_TOP_DIR));
+      callback(new Error(ERR_EXTERNAL_PATH), null);
       return;
     }
 
-    if (!CachedData.hasOwnProperty(cacheKey)) {
+    if (!cachedData.hasOwnProperty(cacheKey)) {
       try {
 
         const jsonData = await Fs.promises.readFile(jsonFullPath, 'utf8');
 
-        CachedData[cacheKey] = JSON.parse(jsonData);
+        cachedData[cacheKey] = JSON.parse(jsonData);
         action = 'Loaded';
 
       } catch (error) {
 
-        reject(error);
+        callback(error, null);
         return;
 
       }
     }
 
     report && reportAction(ctx, jsonFullPath, jsonFilename, action);
 
-    Object.defineProperty(storage, jsonFilename, {
-      value: CachedData[cacheKey],
+    Object.defineProperty(pocket, jsonFilename, {
+      value: cachedData[cacheKey],
       enumerable: true
     });
 
     options.idx = idx + 1;
-    loadImportsRecursively(options);
+    loadImportsRecursively(options, callback);
 
-  } else {
-    resolve(storage);
+  } else if (callback !== undefined) {
+    callback(null, pocket);
   }
 }
 
 async function loadJsonData(file) {
-  const { report, pathHtml, pathData, dataEntry } = this;
+  const { report, pathHtml, pathData, dataEntry, cachedData } = this;
 
-  const pathJson = file.path
+  const jsonFullPath = file.path
     .replace(pathHtml, `${pathData}/pages`)
     .slice(0, -3) + 'json';
 
-  const cacheKey = 'data:' + pathJson.replace(APP_PATH, '');
+  const cacheKey = jsonFullPath.replace(`${APP_PATH}/`, '');
 
   const filename = Path.basename(file.path, '.pug');
   const pocket = { filename };
 
-  if (CachedData.hasOwnProperty(pathJson)) {
-    report && reportAction(this, pathJson, filename, 'Cached');
-    return CachedData[cacheKey];
+  if (cachedData.hasOwnProperty(cacheKey)) {
+    report && reportAction(this, jsonFullPath, filename, 'Cached');
+    return cachedData[cacheKey];
   }
 
   let jsonData = '';
 
   try {
-    jsonData = await Fs.promises.readFile(pathJson, 'utf8');
+    jsonData = await Fs.promises.readFile(jsonFullPath, 'utf8');
     jsonData = JSON.parse(jsonData);
   } catch (err) {
     return pocket;
   }
 
-  report && reportAction(this, pathJson, filename, 'Loaded');
+  report && reportAction(this, jsonFullPath, filename, 'Loaded');
 
   if (jsonData.hasOwnProperty('imports')) {
     const { data = {}, imports = [] } = jsonData;
 
     try {
 
-      const importedData = await loadImportsAsync(this, imports);
+      const importedData = await loadImportsAsync(this, imports, cachedData);
 
       Object.defineProperty(data, 'imports', {
         value: importedData,
@@ -170,7 +184,7 @@ async function loadJsonData(file) {
       const coloredErrorMesage = brush('red', err.message);
       process.stderr.write(coloredErrorMesage + BREAK_LINE);
 
-      return;
+      return pocket;
 
     }
 
@@ -180,13 +194,13 @@ async function loadJsonData(file) {
     });
   }
 
-  CachedData[cacheKey] = pocket;
+  cachedData[cacheKey] = pocket;
 
   return pocket;
 }
 
-const factory = (options) => {
-  if (options === undefined) {
+const factory = (options, testMode = false) => {
+  if (!options) {
     const packagePath = Path.join(APP_PATH, 'package.json');
     const Package = require(packagePath);
 
@@ -202,25 +216,57 @@ const factory = (options) => {
     : DEFAULT_SOURCE_PATH;
 
   const pathHtml = options.hasOwnProperty('pathHtml')
-    ? getAbsolutePath(options.pathHtml)
-    : getAbsolutePath(sourcePath, 'html');
+    ? Path.join(APP_PATH, options.pathHtml)
+    : Path.join(APP_PATH, sourcePath, 'html');
 
   const pathData = options.hasOwnProperty('pathData')
-    ? getAbsolutePath(options.pathData)
-    : getAbsolutePath(sourcePath, 'data');
+    ? Path.join(APP_PATH, options.pathData)
+    : Path.join(APP_PATH, sourcePath, 'data');
 
   if (!pathHtml.startsWith(APP_PATH) || !pathData.startsWith(APP_PATH)) {
     // Please put your source files into your project directory.
-    throw new Error(ERR_TOP_DIR);
+    throw new Error(ERR_EXTERNAL_PATH);
   }
 
-  return loadJsonData.bind({
+  const context = {
+    sourcePath,
     pathHtml,
     pathData,
     dataEntry,
     locales,
     report,
-  });
+    cachedData: {}
+  };
+
+  if (testMode) {
+    return {
+      context,
+      loader: loadJsonData.bind(context),
+    }
+  }
+
+  return loadJsonData.bind(context);
+}
+
+factory.forTest = () => {
+  return {
+    // Package,
+    // BrushColors,
+
+    constants: {
+      APP_PATH,
+      DEFAULT_SOURCE_PATH,
+      BREAK_LINE,
+      ERR_EXTERNAL_PATH,
+    },
+
+    brush,
+    reportAction,
+    loadImportsAsync,
+    loadImportsRecursively,
+    loadJsonData,
+    // factory,
+  };
 }
 
 module.exports = factory;