convenient utilities

Author: mightyaleksey

package.json

@@ -6,6 +6,12 @@
   "engines": {
     "node": ">=0.12"
   },
+  "dependencies": {
+    "lodash.identity": "^3.0.0",
+    "lodash.isarray": "^3.0.4",
+    "lodash.isfunction": "^3.0.6",
+    "lodash.isstring": "^3.0.1"
+  },
   "devDependencies": {
     "babel": "^5.8.20",
     "babel-eslint": "^4.0.5",

src/fn.js

@@ -1,7 +1,8 @@
 import hook from './hook';
 import { readFileSync } from 'fs';
 import { dirname, sep, relative, resolve } from 'path';
-import { identity, removeQuotes } from './fn';
+import { get, removeQuotes } from './utility';
+import identity from 'lodash.identity';
 import postcss from 'postcss';
 
 import ExtractImports from 'postcss-modules-extract-imports';
@@ -32,57 +33,30 @@ export default function setup(opts = {}) {
   importNr = 0;
   tokensByFile = {};
 
-  if (opts.processCss && typeof opts.processCss !== 'function') {
-    throw new Error('should specify function for processCss');
-  }
-
-  postProcess = opts.processCss || null;
-
-  if (opts.rootDir && typeof opts.rootDir !== 'string') {
-    throw new Error('should specify string for rootDir');
-  }
-
-  rootDir = opts.rootDir || process.cwd();
-
-  if (opts.use) {
-    if (!Array.isArray(opts.use)) {
-      throw new Error('should specify array for use');
-    }
+  postProcess = get('processCss', null, 'function', opts) || null;
+  rootDir = get('rootDir', ['root', 'd'], 'string', opts) || process.cwd();
 
-    return void (plugins = opts.use);
+  const customPlugins = get('use', ['u'], 'array', opts);
+  if (customPlugins) {
+    return void (plugins = customPlugins);
   }
 
   plugins = [];
 
-  if (opts.mode) {
-    if (typeof opts.mode !== 'string') {
-      throw new Error('should specify string for mode');
-    }
+  const mode = get('mode', null, 'string', opts);
+  plugins.push(mode
+    ? new LocalByDefault({mode: opts.mode})
+    : LocalByDefault);
 
-    plugins.push(new LocalByDefault({mode: opts.mode}));
-  } else {
-    plugins.push(LocalByDefault);
-  }
-
-  if (opts.createImportedName) {
-    if (typeof opts.createImportedName !== 'function') {
-      throw new Error('should specify function for createImportedName');
-    }
-
-    plugins.push(new ExtractImports({createImportedName: opts.createImportedName}));
-  } else {
-    plugins.push(ExtractImports);
-  }
-
-  if (opts.generateScopedName) {
-    if (typeof opts.generateScopedName !== 'function') {
-      throw new Error('should specify function for generateScopedName');
-    }
+  const createImportedName = get('createImportedName', null, 'function', opts);
+  plugins.push(createImportedName
+    ? new ExtractImports({createImportedName: opts.createImportedName})
+    : ExtractImports);
 
-    plugins.push(new Scope({generateScopedName: opts.generateScopedName}));
-  } else {
-    plugins.push(Scope);
-  }
+  const generateScopedName = get('generateScopedName', null, 'function', opts);
+  plugins.push(generateScopedName
+    ? new Scope({generateScopedName: opts.generateScopedName})
+    : Scope);
 }
 
 /**

src/index.js

@@ -0,0 +1,62 @@
+import isArray from 'lodash.isarray';
+import isFunction from 'lodash.isfunction';
+import isString from 'lodash.isstring';
+import { format } from 'util';
+
+const check = {
+  'array': isArray,
+  'function': isFunction,
+  'string': isString,
+};
+
+/**
+ * @param  {string} prop
+ * @param  {string[]} aliases
+ * @param  {string} type
+ * @param  {object} source
+ * @return {*}
+ */
+export function get(prop, aliases, type, source) {
+  if (source[prop]) {
+    if (!is(type, source[prop])) {
+      throw new Error(format('should specify %s for %s', type, prop));
+    }
+
+    return source[prop];
+  }
+
+  if (!isArray(aliases)) {
+    return null;
+  }
+
+  let deprecatedProp;
+  const match = aliases.some(alias => Boolean(source[(deprecatedProp = alias)]));
+
+  if (match) {
+    if (!is(type, source[deprecatedProp])) {
+      throw new Error(format('should specify %s for %s', type, deprecatedProp));
+    }
+
+    // deprecated message
+    return source[deprecatedProp];
+  }
+
+  return null;
+}
+
+/**
+ * @param  {string}  type
+ * @param  {*}       value
+ * @return {boolean}
+ */
+export function is(type, value) {
+  return check[type](value);
+}
+
+/**
+ * @param  {string} str
+ * @return {string}
+ */
+export function removeQuotes(str) {
+  return str.replace(/^["']|["']$/g, '');
+}

src/utility.js

@@ -0,0 +1,34 @@
+import { ok, equal, throws } from 'assert';
+import { get, is, removeQuotes } from '../src/utility';
+
+describe('utility', () => {
+  describe('get()', () => {
+    it('should return value for an existing property', () => equal(get('a', null, 'string', {a: 'val'}), 'val'));
+
+    it('should return value for an existing alias', () => equal(get('a', ['b'], 'string', {b: 'val'}), 'val'));
+
+    it('should return null for a non-existing property', () => equal(get('a', null, 'array', {}), null));
+
+    it('should throw an error for the specified key with wrong type of value', () => {
+      throws(() => get('a', null, 'string', {a: 5}));
+    });
+  });
+
+  describe('is()', () => {
+    it('should return true for an array', () => ok(is('array', [])));
+
+    it('should return false for not an array', () => ok(!is('array', null)));
+
+    it('should return true for a function', () => ok(is('function', () => {})));
+
+    it('should return false for not a function', () => ok(!is('function', null)));
+
+    it('should return true for a string', () => ok(is('string', '')));
+
+    it('should return false for not a string', () => ok(!is('string', null)));
+  });
+
+  describe('removeQuotes()', () => {
+    it('should remove quotes', () => equal(removeQuotes('"TEST"'), 'TEST'));
+  });
+});