not-locale 0.0.19 → 0.0.22

package/index.js

@@ -1,20 +1,28 @@
 const {
-	getMiddleware,
-	fromJSON,
-	fromDir,
-	say,
-	sayForModule,
-	modulePhrase,
-	vocabulary,
-	OPTS
-} = require('./src/common/lib.js');
+    getMiddleware,
+    fromJSON,
+    fromDir,
+    say,
+    sayForModule,
+    modulePhrase,
+    vocabulary,
+    OPTS,
+} = require("./src/common/lib.js");
 
 module.exports = {
-	name: 'not-locale',
-	paths:{
-		controllers:  __dirname + '/src/controllers',
-    logics:  __dirname + '/src/logics',
-		routes:  __dirname + '/src/routes',
-	},
-	getMiddleware, fromJSON, fromDir, say, sayForModule, modulePhrase, vocabulary, OPTS
+    name: "not-locale",
+    paths: {
+        controllers: __dirname + "/src/controllers",
+        logics: __dirname + "/src/logics",
+        locales: __dirname + "/src/locales",
+        routes: __dirname + "/src/routes",
+    },
+    getMiddleware,
+    fromJSON,
+    fromDir,
+    say,
+    sayForModule,
+    modulePhrase,
+    vocabulary,
+    OPTS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "not-locale",
-	"version": "0.0.19",
+	"version": "0.0.22",
 	"description": "not-* family module for localization in not- environment",
 	"main": "index.js",
 	"scripts": {
@@ -14,6 +14,7 @@
 		"url": "git+https://github.com/interrupter/not-locale.git"
 	},
 	"keywords": [
+		"not-bulma",
 		"not-node",
 		"locale"
 	],
@@ -24,13 +25,13 @@
 	},
 	"homepage": "https://github.com/interrupter/not-locale#readme",
 	"dependencies": {
-		"not-log": "^0.0.18",
+		"not-log": "^0.0.20",
 		"not-path": "^1.0.1"
 	},
 	"devDependencies": {
 		"chai": "*",
 		"chai-as-promised": "*",
-		"eslint": "^8.0.1",
+		"eslint": "^8.3.0",
 		"ink-docstrap": "^1.3.2",
 		"jsdoc": "^3.6.7",
 		"mocha": "*",

package/src/common/lib.js

@@ -9,43 +9,43 @@ const //loadJsonFile = require('load-json-file'),
 	notPath = require('not-path'),
 	path = require('path');
 
-var store = {},
+let store = {},
 	OPTS = {
 		default: 'en',
 		getter: null
 	};
 
-	/**
-	* Express middleware, to determine in which locale should we process response
-	*/
+/**
+ * Express middleware, to determine in which locale should we process response
+ */
 
-	function detect( req, res, next ){
-		let reqLang;
-		if (OPTS.getter){
-			reqLang = OPTS.getter(req);
-		}else{
-			reqLang = req.get('Accept-Language');
-		}
-		if (Object.prototype.hasOwnProperty.call(store, reqLang)){
-			res.locals.locale = reqLang;
-		}else{
-			res.locals.locale = OPTS.default;
-		}
-		next();
+function detect(req, res, next) {
+	let reqLang;
+	if (OPTS.getter) {
+		reqLang = OPTS.getter(req);
+	} else {
+		reqLang = req.get('Accept-Language');
+	}
+	if (Object.prototype.hasOwnProperty.call(store, reqLang)) {
+		res.locals.locale = reqLang;
+	} else {
+		res.locals.locale = OPTS.default;
 	}
+	next();
+}
 
-	/**
-	* Express middleware initializer, to determine in which locale should we process response
-	* @param {object} options - object with `deafult` {string}, `getter` {function} redefined
-	* @return {function} function wich will accept three params (req, res, next) and run as express middleware
-	*/
+/**
+ * Express middleware initializer, to determine in which locale should we process response
+ * @param {object} options - object with `deafult` {string}, `getter` {function} redefined
+ * @return {function} function wich will accept three params (req, res, next) and run as express middleware
+ */
 
-exports.getMiddleware = (options)=>{
-	if (options){
-		if (options.default && options.default.length > 1){
+exports.getMiddleware = (options) => {
+	if (options) {
+		if (options.default && options.default.length > 1) {
 			OPTS.default = options.default;
 		}
-		if (options.getter && typeof options.getter === 'function'){
+		if (options.getter && typeof options.getter === 'function') {
 			OPTS.getter = options.getter;
 		}
 	}
@@ -54,12 +54,12 @@ exports.getMiddleware = (options)=>{
 
 
 /**
-  * Add locale by json object
-  * @param {string} locale - name of locale
-  * @param {json} json - json object
-  */
-exports.fromJSON = (locale, json, prefix = '')=>{
-	if(prefix){
+ * Add locale by json object
+ * @param {string} locale - name of locale
+ * @param {json} json - json object
+ */
+exports.fromJSON = (locale, json, prefix = '') => {
+	if (prefix) {
 		let tmp = {};
 		const keys = Object.keys(json);
 		keys.forEach((key) => {
@@ -67,36 +67,36 @@ exports.fromJSON = (locale, json, prefix = '')=>{
 		});
 		json = tmp;
 	}
-	if (typeof store[locale] !== 'undefined'){
+	if (typeof store[locale] !== 'undefined') {
 		store[locale] = Object.assign(store[locale], json);
-	}else{
+	} else {
 		store[locale] = Object.assign({}, json);
 	}
 };
 
 /**
-  * Load locales from directory, with json files, names as [locale_name].json
-  * @param {number} pathToLocales - absolute path to directory
-  * @return {Promise}
-  */
-exports.fromDir = (pathToLocales, prefix = '')=>{
-	return new Promise((resolve, reject)=>{
+ * Load locales from directory, with json files, names as [locale_name].json
+ * @param {number} pathToLocales - absolute path to directory
+ * @return {Promise}
+ */
+exports.fromDir = (pathToLocales, prefix = '') => {
+	return new Promise((resolve, reject) => {
 		fs.readdir(pathToLocales, (err, items) => {
-			if (err){
+			if (err) {
 				reject(err);
-			}else{
-				for(let i = 0; i < items.length; i++) {
+			} else {
+				for (let i = 0; i < items.length; i++) {
 					let filename = path.join(pathToLocales, items[i]),
 						stats = fs.lstatSync(filename);
-					if (stats.isFile()){
-						try{
+					if (stats.isFile()) {
+						try {
 							let file = require(filename),
 								[localeName] = items[i].split('.');
 							exports.fromJSON(localeName, file, prefix);
-						}catch(e){
+						} catch (e) {
 							Log.error(e);
 						}
-					}else{
+					} else {
 						continue;
 					}
 				}
@@ -107,56 +107,63 @@ exports.fromDir = (pathToLocales, prefix = '')=>{
 };
 
 /**
-  * Returns localized variant of code phrase
-  * @param {string} phrase - code phrase
-  * @param {array|object} params - array or hash with params for template parser
-  * @return {string} localized variant
-  */
-function say(phrase, params = {}, locale = OPTS.default){
-	try{
+ * Returns localized variant of code phrase
+ * @param {string} phrase - code phrase
+ * @param {array|object} params - array or hash with params for template parser
+ * @return {string} localized variant
+ */
+function say(phrase, params = {}, locale = OPTS.default) {
+	try {
 		let tmpl = store[locale][phrase],
 			result = '';
-		if (params){
+		if (typeof tmpl === 'undefined') {
+			return phrase;
+		}
+		if (params) {
 			return notPath.parseSubs(tmpl, params, {});
-		}else{
+		} else {
 			result = tmpl;
 		}
 		return result;
-	}catch(e){
+	} catch (e) {
 		Log.error(e);
 	}
-};
+}
 
-exports.say = say
+exports.say = say;
 
 /**
-  * Getter for stores of all locales
-  * @return {objects} all locales
-  */
-exports.vocabulary = () => {return store;};
+ * Getter for stores of all locales
+ * @return {objects} all locales
+ */
+exports.vocabulary = () => {
+	return store;
+};
 
 /**
-  * Getter for OPTS variable
-  * @return {object} copy of OPTS object
-  */
-exports.OPTS = () => { return Object.assign({}, OPTS);};
+ * Getter for OPTS variable
+ * @return {object} copy of OPTS object
+ */
+exports.OPTS = () => {
+	return Object.assign({}, OPTS);
+};
 
 
-exports.get = (locale)=>{
-	if(Object.prototype.hasOwnProperty.call(store, locale)){
+exports.get = (locale) => {
+	if (Object.prototype.hasOwnProperty.call(store, locale)) {
 		return store[locale];
-	}else{
+	} else {
 		return {};
 	}
 };
 
 
-exports.available = ()=>{
+exports.available = () => {
 	return Object.keys(store);
 };
 
 
-function modulePhrase(moduleName = ''){
+function modulePhrase(moduleName = '') {
 	return (phrase) => [moduleName, phrase].join(':');
 }
 
@@ -169,5 +176,5 @@ exports.sayForModule = (moduleName = '') => {
 			params,
 			locale
 		);
-	}
+	};
 };

package/src/controllers/common/nsLocale.js

@@ -1,164 +1,168 @@
 /**
-* detects current locale, loads dictionary from server
-*
-**/
-
-const SECTION_ID = 'locale';
-
-import {notCommon, notLocale, TopMenu} from 'not-bulma';
-
-class nsLocale{
-  constructor(app){
-    this.app = app;
-    this.locales = [];
-    this.failures = 0;
-    this.app.on('wsClient:main:connected', this.update.bind(this));
-    notLocale.on('change', ()=>{
-      this.app.emit('locale');
-    });
-  }
-
-  /**
-  * Creates network interface for this service
-  */
-  interface(data){
-    return this.app.getInterface('locale')(data);
-  }
-
-  /**
-  * Retrieves dictionary for current locale
-  * sets dictionary in notLocale object
-  */
-  async update(){
-    try{
-      await this.updateAvailable();
-      let res = await this.interface({locale: this.getCurrentLocale()}).$get({});
-      if(res.status === 'ok' && res.result){
-        notLocale.set(res.result);
-      }else{
-        this.scheduleUpdate();
-      }
-    }catch(e){
-      notCommon.error(e);
-      this.scheduleUpdate();
+ * detects current locale, loads dictionary from server
+ *
+ **/
+
+const SECTION_ID = "locale";
+
+import { notCommon, notLocale, Frame } from "not-bulma";
+
+const { notTopMenu } = Frame;
+
+class nsLocale {
+    constructor(app) {
+        this.app = app;
+        this.locales = [];
+        this.failures = 0;
+        this.app.on("wsClient:main:connected", this.update.bind(this));
+        notLocale.on("change", () => {
+            this.app.emit("locale");
+        });
+    }
+
+    /**
+     * Creates network interface for this service
+     */
+    interface(data) {
+        return this.app.getInterface("locale")(data);
+    }
+
+    /**
+     * Retrieves dictionary for current locale
+     * sets dictionary in notLocale object
+     */
+    async update() {
+        try {
+            await this.updateAvailable();
+            let res = await this.interface({
+                locale: this.getCurrentLocale(),
+            }).$get({});
+            if (res.status === "ok" && res.result) {
+                notLocale.set(res.result);
+            } else {
+                this.scheduleUpdate();
+            }
+        } catch (e) {
+            notCommon.error(e);
+            this.scheduleUpdate();
+        }
     }
-  }
-
-  scheduleUpdate(){
-    this.failures++;
-    if(this.failures < 100){
-      setTimeout(this.update.bind(this), 1000 * this.failures);
-    }else{
-      notCommon.error('Too many failures of locale loading');
+
+    scheduleUpdate() {
+        this.failures++;
+        if (this.failures < 100) {
+            setTimeout(this.update.bind(this), 1000 * this.failures);
+        } else {
+            notCommon.error("Too many failures of locale loading");
+        }
     }
-  }
-
-  async updateAvailable(){
-    try{
-      let res = await this.interface({}).$available({});
-      if(res.status === 'ok' && res.result){
-        this.setAvailable(res.result);
-      }
-    }catch(e){
-      notCommon.error(e);
+
+    async updateAvailable() {
+        try {
+            let res = await this.interface({}).$available({});
+            if (res.status === "ok" && res.result) {
+                this.setAvailable(res.result);
+            }
+        } catch (e) {
+            notCommon.error(e);
+        }
     }
-  }
-
-  updateUI(list){
-    let menuItems = this.createMenuItems(list);
-    TopMenu.updateSectionItems(SECTION_ID, () => {
-      return menuItems;
-    });
-    setTimeout(()=>{
-      this.app.emit(`tag-${SECTION_ID}:update`, {
-        title: this.getCurrentLocale()
-      });
-    }, 1000);
-  }
-
-  createMenuItems(list) {
-    let items = list.map(this.createMenuItem.bind(this));
-    return items;
-  }
-
-  createMenuItem(item) {
-    return {
-      id: `${SECTION_ID}.${item}`,
-      section: SECTION_ID,
-      title: item,
-      classes: ' is-clickable ',
-      action: this.changeLocale.bind(this, item)
-    };
-  }
-
-  changeLocale(locale){
-    this.saveLocaleToStore(locale);
-    this.update();
-  }
-
-  /**
-  * @returns {string}   code of current locale
-  **/
-  getCurrentLocale(){
-    let stored = this.restoreLocaleFromStore();
-    if (stored){
-      if(this.locales.includes(stored)){
-        return stored;
-      }
+
+    updateUI(list) {
+        let menuItems = this.createMenuItems(list);
+        notTopMenu.updateSectionItems(SECTION_ID, () => {
+            return menuItems;
+        });
+        setTimeout(() => {
+            this.app.emit(`tag-${SECTION_ID}:update`, {
+                title: this.getCurrentLocale(),
+            });
+        }, 1000);
     }
-    return this.selectBest();
-  }
-
-  /**
-  * @returns {Promise<Array>}   of locales objects {code, title}
-  **/
-  getAvailable(){
-    return this.interface().$available({});
-  }
-
-
-  setAvailable(list){
-    this.locales = list;
-    this.updateUI(list);
-  }
-
-  restoreLocaleFromStore(){
-    if (window.localStorage) {
-    	try {
-    	  return window.localStorage.getItem('locale');
-      } catch (e) {
-        this.app.error(e);
-        return false;
-      }
+
+    createMenuItems(list) {
+        let items = list.map(this.createMenuItem.bind(this));
+        return items;
+    }
+
+    createMenuItem(item) {
+        return {
+            id: `${SECTION_ID}.${item}`,
+            section: SECTION_ID,
+            title: item,
+            classes: " is-clickable ",
+            action: this.changeLocale.bind(this, item),
+        };
+    }
+
+    changeLocale(locale) {
+        this.saveLocaleToStore(locale);
+        this.update();
+    }
+
+    /**
+     * @returns {string}   code of current locale
+     **/
+    getCurrentLocale() {
+        let stored = this.restoreLocaleFromStore();
+        if (stored) {
+            if (this.locales.includes(stored)) {
+                return stored;
+            }
+        }
+        return this.selectBest();
+    }
+
+    /**
+     * @returns {Promise<Array>}   of locales objects {code, title}
+     **/
+    getAvailable() {
+        return this.interface().$available({});
     }
-    return false;
-  }
-
-  saveLocaleToStore(locale){
-    if (window.localStorage) {
-    	try {
-    	  return window.localStorage.setItem('locale', locale);
-      } catch (e) {
-        this.app.error(e);
+
+    setAvailable(list) {
+        this.locales = list;
+        this.updateUI(list);
+    }
+
+    restoreLocaleFromStore() {
+        if (window.localStorage) {
+            try {
+                return window.localStorage.getItem("locale");
+            } catch (e) {
+                this.app.error(e);
+                return false;
+            }
+        }
         return false;
-      }
     }
-    return false;
-  }
-
-  selectBest(){
-    if(navigator.languages){
-      let locale = navigator.languages.find((itm) => {
-        return this.locales.includes(itm);
-      });
-      if(locale){
-        return locale;
-      }
+
+    saveLocaleToStore(locale) {
+        if (window.localStorage) {
+            try {
+                return window.localStorage.setItem("locale", locale);
+            } catch (e) {
+                this.app.error(e);
+                return false;
+            }
+        }
+        return false;
     }
-    return this.app.getWorking('locale', this.app.getOptions('modules.locale.default', 'ru'));
-  }
 
+    selectBest() {
+        if (navigator.languages) {
+            let locale = navigator.languages.find((itm) => {
+                return this.locales.includes(itm);
+            });
+            if (locale) {
+                return locale;
+            }
+        }
+        return this.app.getWorking(
+            "locale",
+            this.app.getOptions("modules.locale.default", "ru")
+        );
+    }
 }
 
-
 export default nsLocale;

package/src/exceptions.js

@@ -0,0 +1,17 @@
+const { notError } = require("not-error");
+
+class LocaleExceptionGetError extends notError {
+    constructor(params = {}, cause) {
+        super(`not-locale:exception_logic_get`, params, cause);
+    }
+}
+
+module.exports.LocaleExceptionGetError = LocaleExceptionGetError;
+
+class LocaleExceptionAvailableError extends notError {
+    constructor(params = {}, cause) {
+        super(`not-locale:exception_logic_available`, params, cause);
+    }
+}
+
+module.exports.LocaleExceptionAvailableError = LocaleExceptionAvailableError;

package/src/locales/en.json

@@ -0,0 +1,4 @@
+{
+    "exception_logic_available": "Exception while listing available locales",
+    "exception_logic_get": "Exception while retrieving locale library"
+}

package/src/locales/ru.json

@@ -0,0 +1,4 @@
+{
+    "exception_logic_available": "Исключение при листинге доступных локалей",
+    "exception_logic_get": "Исключение при получении локали"
+}

package/src/logics/locale.js

@@ -1,63 +1,29 @@
-const notNode = require('not-node');
-const Log = require('not-log')(module, 'locale:logics');
+const notLocale = require("../common/lib.js");
 const {
-	notError
-} = require('not-error');
-
-const notLocale = require('../common/lib.js');
-
-const MODEL_NAME = 'Locale';
+    LocaleExceptionGetError,
+    LocaleExceptionAvailableError,
+} = require("../exceptions");
+const MODEL_NAME = "Locale";
 exports.thisLogicName = MODEL_NAME;
 
 class LocaleLogic {
-	static async get({
-		locale
-	}){
-		try{
-			let result = notLocale.get(locale);
-			return {
-				status: 'ok',
-				result
-			};
-		}catch(err){
-			Log.error(err);
-			notNode.Application.report(
-				new notError(
-					`locale:logic.get`,
-					{locale},
-					err
-				)
-			);
-			return {
-				status: 'error',
-				error:  err.message
-			};
-		}
-	}
-
-	static async available() {
-		try{
-			let result = notLocale.available();
-			return {
-				status: 'ok',
-				result
-			};
-		}catch(err){
-			Log.error(err);
-			notNode.Application.report(
-				new notError(
-					`locale:logic.available`,
-					{},
-					err
-				)
-			);
-			return {
-				status: 'error',
-				error:  err.message
-			};
-		}
-	}
+    static async get({ locale }) {
+        try {
+            let result = notLocale.get(locale);
+            return result;
+        } catch (err) {
+            throw new LocaleExceptionGetError({ locale }, err);
+        }
+    }
 
+    static async available() {
+        try {
+            let result = notLocale.available();
+            return result;
+        } catch (err) {
+            throw new LocaleExceptionAvailableError({}, err);
+        }
+    }
 }
 
 exports[MODEL_NAME] = LocaleLogic;

package/src/routes/locale.manifest.js

@@ -1,4 +1,4 @@
-const Log = require('not-log')(module, 'locale:route');
+const {error} = require('not-log')(module, 'locale:route');
 
 try {
 	module.exports = {
@@ -33,5 +33,5 @@ try {
 		}
 	};
 } catch (e) {
-	Log.error(e);
+	error(e);
 }

package/src/routes/locale.ws.js

@@ -1,22 +1,25 @@
-const notNode = require('not-node');
+const notNode = require("not-node");
 
-async function get({data}){
-	let result = await notNode.Application.getLogic('Locale').get({locale: data.locale});
-	return result;
+async function get({ data }) {
+    return await notNode.Application.getLogic("Locale").get({
+        locale: data.locale,
+    });
 }
 
-async function available(){
-	let result = await notNode.Application.getLogic('Locale').available();
-	return result;
+async function available() {
+    return await notNode.Application.getLogic("Locale").available();
 }
 
 module.exports = {
-	servers:{
-		main:{
-			request: {
-				get,
-				available
-			}
-		}
-	}
+    servers: {
+        //collection type
+        main: {
+            //collection name
+            request: {
+                //routes(end-points) type
+                get, //end-points
+                available,
+            },
+        },
+    },
 };

package/test/index.js

@@ -71,7 +71,7 @@ describe("say", function() {
 	});
 
 	it("phrase not exists `like`", function() {
-		expect(locale.say('like')).to.be.undefined;
+		expect(locale.say('like_me')).to.be.equal('like_me');
 	});
 
 	it("locale not exists, should throw", function() {