Multiple changes

README.md

@@ -29,39 +29,43 @@ Calculate logical expressions in string.
 ## Usage
 
 ```
-const L = require('logic-string');
+const logic = require('logic-string');
 
-L.eval('true && false');  // false
-L.eval('true || false');  // true
+logic('true && false');  // false
+logic('true || false');  // true
 
-L.eval('a && b', {        // false
+logic('{a} && {b}', {        // false
     a: true,
     b: false,
 });
-L.eval('a || b', {        // true
+logic('{a} || {b}', {        // true
     a: true,
     b: false,
 });
 
-L.eval('!false');         // true
-L.eval('!true');          // false
+logic('!false');         // true
+logic('!true');          // false
 
-L.eval('(a && b) || c', { // true
+logic('({a} && {b}) || {c}', { // true
     a: true,
     b: true,
     c: false,
 });
 
-L.eval('( a && b )||c', { // true
+logic('( {a} && {b} )||{c}', { // true
     a: true,
     b: true,
     c: false,
 });
+
+logic('{int} > 2', { // true
+    int: 5
+});
 ```
 
 ## API
 
-### L.eval(pattern, variables)
+### logic(pattern, variables)
 
 ```js
 /**

package.json

@@ -2,7 +2,7 @@
   "name": "logic-string",
   "version": "0.1.0",
   "description": "Calculate logical expressions in string.",
-  "main": "src/L.js",
+  "main": "src/logic.js",
   "scripts": {
     "lint": "npm-run-all lint-*",
     "lint-src": "eslint --quiet src",
@@ -30,7 +30,9 @@
   "bugs": {
     "url": "https://github.com/adoyle-h/logic-string/issues"
   },
-  "dependencies": {},
+  "dependencies": {
+    "string-template": "^1.0.0"
+  },
   "devDependencies": {
     "ava": "^0.17.0",
     "eslint": "^3.12.2",

src/logic.js

@@ -0,0 +1,12 @@
+const format = require('string-template');
+
+/**
+ * It is based on `eval` function. You should be in charge of the security with injection risks.
+ *
+ * @param {String} pattern
+ * @param {Object} [variables]
+ * @return {Boolean}
+ */
+module.exports = (pattern, variables) => {
+    return eval(format(pattern, variables));  // eslint-disable-line no-eval
+};

test/unit/eval.js

@@ -1,81 +1,81 @@
 import test from 'ava';
-import L from '../../src/L';
+import logic from '../../src/logic';
 
 test('true && false', (t) => {
-    t.is(L.eval('true && false'), false);
+    t.is(logic('true && false'), false);
 });
 
 test('true || false', (t) => {
-    t.is(L.eval('true || false'), true);
+    t.is(logic('true || false'), true);
 });
 
-test('a && b', (t) => {
-    const result = L.eval('a && b', {
+test('{a} && {b}', (t) => {
+    const result = logic('{a} && {b}', {
         a: true,
         b: false,
     });
     t.is(result, false);
 });
 
-test('a || b', (t) => {
-    const result = L.eval('a || b', {
+test('{a} || {b}', (t) => {
+    const result = logic('{a} || {b}', {
         a: true,
         b: false,
     });
     t.is(result, true);
 });
 
 test('!true', (t) => {
-    t.is(L.eval('!true'), false);
+    t.is(logic('!true'), false);
 });
 
 test('!false', (t) => {
-    t.is(L.eval('!false'), true);
+    t.is(logic('!false'), true);
 });
 
-test('!a', (t) => {
-    t.is(L.eval('!a', {a: false}), true);
-    t.is(L.eval('!a', {a: true}), false);
+test('!{a}', (t) => {
+    t.is(logic('!{a}', {a: false}), true);
+    t.is(logic('!{a}', {a: true}), false);
 });
 
-test('a && b || c', (t) => {
-    const result = L.eval('a && b || c', {
+test('{a} && {b} || {c}', (t) => {
+    const result = logic('{a} && {b} || {c}', {
         a: true,
         b: false,
         c: false,
     });
     t.is(result, false);
 });
 
-test('a && (b || c)', (t) => {
-    const result = L.eval('a && (b || c)', {
+test('{a} && ({b} || {c})', (t) => {
+    const result = logic('{a} && ({b} || {c})', {
         a: true,
         b: false,
         c: false,
     });
     t.is(result, false);
 });
 
-test('a && b || c', (t) => {
-    const result = L.eval('a && b || c', {
+test('{a} && {b} || {c}', (t) => {
+    const result = logic('{a} && {b} || {c}', {
         a: true,
         b: true,
         c: false,
     });
     t.is(result, true);
 });
 
-test('(a && b) || c', (t) => {
-    const result = L.eval('(a && b) || c', {
+test('({a} && {b}) || {c}', (t) => {
+    const result = logic('({a} && {b}) || {c}', {
         a: true,
         b: true,
         c: false,
     });
     t.is(result, true);
 });
 
-test('( a && b )||c', (t) => {
-    const result = L.eval('( a && b )||c', {
+test('( {a} && {b} )||{c}', (t) => {
+    const result = logic('( {a} && {b} )||{c}', {
         a: true,
         b: true,
         c: false,
@@ -84,7 +84,7 @@ test('( a && b )||c', (t) => {
 });
 
 test('throw error when no matched variable ', (t) => {
-    const error = t.throws(() => L.eval('!a', {ha: false}));
+    const error = t.throws(() => logic('!{a}', {ha: false}));
     t.is(error instanceof Error, true);
     t.is(error.message, 'No any matched variable for "a"');
 });