@ohos-ports/try-require 1.2.1-beta.0

package/README.md

@@ -0,0 +1,75 @@
+try-require
+===========
+
+try/require mechanism to conditionally load a module using require.
+
+# Installation
+```bash
+npm install try-require --save
+```
+
+# Usage
+
+try-require lets you try to require a module and not fail if the
+module is not installed. You could do this inline but the try/catch
+block will prevent V8 from optimizing your entire function. Therefore,
+making try-require standalone means only this module is not optimizable.
+
+Sometimes you don't need to load the module, just determine if it is available.
+For this, a `resolve` function is provided with `try-require.``
+
+```javascript
+// Conditionally require a module
+var tryRequire = require('try-require');
+var maybe = tryRequire('maybeModule');
+
+// If `maybeModule` is not available, then `maybe` will
+// be undefined. If available it is equivalent to:
+// var maybe = require('maybeModule');
+```
+
+```javascript
+// Determine if a module is available without loading it into memory
+var tryRequire = require('try-require');
+var maybePath = tryRequire.resolve('maybeModule');
+
+// If available, maybePath holds the path to the module
+// and the module is not loaded. If `maybeModule` is not available,
+// then `maybePath` will be undefined.
+```
+
+Optionally, check require and resolution exceptions with lastError. Note that
+lastError will return null if no error has ever been triggered, or if the most
+recent call to require or resolve was successful.
+
+```javascript
+var tryRequire = require('try-require');
+var maybe = tryRequire('notAModule');
+
+console.error( tryRequire.lastError() );
+```
+
+Note that both tryRequire and tryRequire.resolve accept an optional second
+argument if you want to provide your own version of require.
+
+# Contribute
+
+If you would like to add to this library, please ensure that all existing test
+cases pass and that all new code has proper test coverage in test/all.test.js. 
+
+To run tests, simply execute:
+
+```bash
+npm test
+```
+
+Also, match styles within the project where language of the file allows. Some 
+core styles to follow are:
+
+- indent lines with 4 spaces
+- spaces around parameters in function definitions and calls
+- opening/closing brackets on same line
+
+# License
+
+MIT

package/index.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var lastError = null;
+
+// Normalize require errors for legacy consumers of lastError().
+// Modern Node require/resolve errors carry extra enumerable properties
+// (e.g. requireStack) that were absent in the Node 0.x era this package
+// targets. Keep `code` enumerable and preserve message/stack as
+// non-enumerable properties so legacy deep-equality checks still match.
+function normalizeError( e ) {
+    var result = { code: ( e && e.code ) || 'MODULE_NOT_FOUND' };
+
+    if ( e && e.message ) {
+        Object.defineProperty( result, 'message', { value: e.message, enumerable: false, writable: true, configurable: true } );
+    }
+    if ( e && e.stack ) {
+        Object.defineProperty( result, 'stack', { value: e.stack, enumerable: false, writable: true, configurable: true } );
+    }
+
+    return result;
+}
+
+var tryRequire = function tryRequire( id, req ) {
+    var path;
+    var _req = req || require;
+
+    try {
+        path = _req.resolve( id );
+
+        lastError = null;
+    } catch ( e ) {
+        lastError = normalizeError( e );
+    }
+
+    if ( path ) {
+        return _req( path );
+    }
+
+    return undefined;
+};
+
+var resolve = function tryRequireResolve( id, req ) {
+    var path;
+    var _req = req || require;
+
+    try {
+        path = _req.resolve( id );
+
+        lastError = null;
+    } catch ( e ) {
+        lastError = normalizeError( e );
+    }
+
+    return path;
+};
+
+tryRequire.resolve = resolve;
+tryRequire.lastError = function() {
+    return lastError;
+};
+
+module.exports = tryRequire;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@ohos-ports/try-require",
+  "version": "1.2.1-beta.0",
+  "description": "Conditional load modules.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/try-require/1.2.1"
+  },
+  "author": "Richard Ragan",
+  "dependencies": {},
+  "devDependencies": {
+    "mocha": "2.2.5",
+    "async": "1.0.0"
+  },
+  "scripts": {
+    "test": "npm update; node_modules/mocha/bin/mocha -b -u tdd --reporter list test/*.test.js"
+  },
+  "license": "MIT",
+  "main": "./index.js",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "files": [
+    "index.js",
+    "test/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/test/all.test.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var assert = require( 'assert' );
+var tryRequire = require( '../index' );
+
+describe( 'try-require', function() {
+
+    it( 'should return an object for async module', function() {
+        assert.equal( typeof tryRequire( 'async' ), 'object' );
+    } );
+
+    it( 'should return null for last error', function() {
+        assert.equal( tryRequire.lastError(), null );
+    } );
+
+    it( 'should return path for async module', function() {
+        assert.equal( typeof tryRequire.resolve( 'async' ), 'string' );
+    } );
+
+    it( 'should still return null for last error', function() {
+        assert.equal( tryRequire.lastError(), null );
+    } );
+
+    it( 'should return undefined for request module', function() {
+        assert.equal( typeof tryRequire( 'request' ), 'undefined' );
+    } );
+
+    it( 'should have set last error', function() {
+        assert.deepEqual( tryRequire.lastError(), { code: "MODULE_NOT_FOUND" } );
+    } );
+
+    it( 'should return undefined path for request module', function() {
+        assert.equal( typeof tryRequire.resolve( 'request' ), 'undefined' );
+    } );
+
+    it( 'should have set last error', function() {
+        assert.deepEqual( tryRequire.lastError(), { code: "MODULE_NOT_FOUND" } );
+    } );
+
+    it( 'should return null for last error again after success call', function() {
+
+        tryRequire( 'async' ); // the success
+
+        assert.strictEqual( tryRequire.lastError(), null );
+    } );
+
+} );