Use tape for tests

Add tests section to readme.

Author: bas080

.gitignore

@@ -1 +1,2 @@
 node_modules
+.nyc_output

README.md

@@ -1,7 +1,5 @@
 # Lucene Query String Builder
 
-[![Tests](https://github.com/bas080/lucene-query-string-builder/workflows/Node.js%20CI/badge.svg)](https://github.com/bas080/lucene-query-string-builder/actions)
-
 Easily build your lucene string queries using small and pure functions.
 
 Imagine having an API that leverages lucene for performing queries on the
@@ -131,6 +129,86 @@ https://lucene.apache.org/core/2_9_4/queryparsersyntax.html#Terms
 
 ```
 
+## Tests
+
+```bash bash
+set -eo pipefail
+
+npm i
+npm prune
+
+npx standard --fix
+npx nyc npm t
+```
+```
+
+up to date, audited 72 packages in 604ms
+
+44 packages are looking for funding
+  run `npm fund` for details
+
+found 0 vulnerabilities
+
+up to date, audited 72 packages in 553ms
+
+44 packages are looking for funding
+  run `npm fund` for details
+
+found 0 vulnerabilities
+
+> lucene-query-string-builder@1.0.5 test
+> tape ./test/index.js
+
+TAP version 13
+# builder
+ok 1 should be strictly equal
+# range
+ok 2 should be strictly equal
+ok 3 should be strictly equal
+ok 4 should be strictly equal
+ok 5 should be strictly equal
+# group
+ok 6 should be strictly equal
+# term
+ok 7 should be strictly equal
+ok 8 should be strictly equal
+# fuzzy
+ok 9 should throw
+ok 10 should be strictly equal
+ok 11 should be strictly equal
+ok 12 should be strictly equal
+ok 13 should be strictly equal
+ok 14 should be strictly equal
+ok 15 should be strictly equal
+# proximity
+ok 16 should be strictly equal
+ok 17 should throw
+ok 18 should throw
+ok 19 should throw
+ok 20 should throw
+ok 21 should throw
+# or/and/not
+ok 22 should be strictly equal
+ok 23 should be strictly equal
+ok 24 should be strictly equal
+ok 25 should be strictly equal
+ok 26 should be strictly equal
+ok 27 should be strictly equal
+
+1..27
+# tests 27
+# pass  27
+
+# ok
+
+----------|---------|----------|---------|---------|-------------------
+File      | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
+----------|---------|----------|---------|---------|-------------------
+All files |   90.32 |    94.44 |   88.24 |   90.91 |                   
+ index.js |   90.32 |    94.44 |   88.24 |   90.91 | 69-72,165-167     
+----------|---------|----------|---------|---------|-------------------
+```
+
 ## Contributing
 
 I have not gotten the chance to use this lib in my own projects. Please share

README.mz

@@ -0,0 +1,173 @@
+# Lucene Query String Builder
+
+Easily build your lucene string queries using small and pure functions.
+
+Imagine having an API that leverages lucene for performing queries on the
+(indexed) database. In that case you might want to generate lucene query strings on
+the client/front end.
+
+The usage section shows how you can leverage this lib for your purposes.
+
+## Setup
+
+```bash
+npm install lucene-query-string-builder --save
+```
+
+## Features
+
+- escapes lucene special chars when creating a term string
+- contains all the operators lucene uses
+- simple lucene.builder function for defining a lucene query builder
+
+## Usage
+
+Let's see how you can use lucene query string builder to define lucene query
+strings with simple JavaScript functions.
+
+Assuming that the lucene global variable contains the lucene functions. This
+would be the default when loaded into a browser.
+
+```JavaScript
+
+var findUserLuceneQueryString = lucene.builder(function(data){
+
+  // just to make the example more readable;
+  var _ = lucene;
+
+  return _.group(_.and(
+    _.field('eye-color', _.term(data.eye.color)),
+    _.field('age', _.range(data.age.min, data.age.max))
+  ));
+
+});
+
+var luceneQueryString = findUserLuceneQueryString({
+  eye: { color: 'brown'},
+  age: {
+    min: 10,
+    max: 20
+  }
+});
+
+luceneQueryString === '( eye-color: "brown" AND age:{ 10 TO 20 } )' // => true
+
+```
+The functions are based on the lucene specifications found here:
+https://lucene.apache.org/core/2_9_4/queryparsersyntax.html#Terms
+
+```JavaScript
+
+  var _ = lucene;
+
+  /***
+   * terms or term
+   */
+
+  _.term('hello'); // => '"hello"'
+
+  _.terms('hello world'); // => '"hello world"'
+
+
+  /***
+   * field
+   */
+
+  _.field('hello', _.term('world')); // => 'hello: "world"'
+
+
+  /***
+   * or/and/not
+   *
+   * These functions are variadic and all work the same way. This example only
+     shows the or but ot works similar with and and not
+   */
+
+  _.or(_.term('hello'), _.term('world')); // => '"hello" OR "world"'
+
+  _.or(_.term('hello'), _.term('you'), _.term('world')); // => '"hello" OR "you" OR "world"'
+
+
+  /***
+   * group
+   *
+   * Is a variadic function too
+   */
+
+  _.group(_.term('hello'), _.term('you'), _.term('world')); // => '( "hello" "you" "world" )'
+
+
+  /***
+   * range
+   *
+   * Takes two strings and 2 booleans.
+   */
+
+  /* combined with the field function to query for ages between 10 and 20 */
+  _.field('age', _.range(10, 20)); // => 'age: { 10 TO 20 }'
+
+
+  /***
+   * fuzzy
+   */
+
+  _.fuzzy(_.term('hello'), 0.2); // => '"hello"~0.2'
+
+
+  /***
+   * proximity
+   */
+
+  _.proximity("a", "c", 2); // => '"a b"'~2
+
+
+  /***
+   * required
+   */
+
+  _.required(_.term('required')); // => '+"required"'
+
+```
+
+## Tests
+
+```bash bash
+set -eo pipefail
+
+npm i
+npm prune
+
+npx standard --fix
+npx nyc npm t
+```
+
+## Contributing
+
+I have not gotten the chance to use this lib in my own projects. Please share
+your thoughts, issues and improvements.
+
+- Make sure your dependencies are installed by running: `npm run-script setup`
+- Then start editing the index.js
+- You should add and/or edit the tests in test/index.js
+- Run your tests and see what happens
+
+When performing pull request make sure to not add the **dist** files. This is left
+to the maintainers(s) of the library. They are responsible to version and avoid
+code breakages.
+
+You can perform your own build with `npm run-script` build to make a *lucine.js* and
+a *lucine.min.js*
+
+**notice**
+
+I am currently not using this repository in any of my projects. Therefore I am looking
+for people that are able to make LQSB more useful for them and others.
+
+## Road map
+
+- split all functions into separate files
+- tasks for running tests on dist/lucene.js and dist/lucene.min.js
+
+## License
+
+The MIT License (MIT)

package-lock.json

@@ -1,15 +1,14 @@
 {
   "name": "lucene-query-string-builder",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Build Lucene queries by defining lucene query builders",
   "main": "index.js",
   "repository": {
     "type": "git",
     "url": "https://github.com/bas080/lucene-query-string-builder.git"
   },
   "scripts": {
-    "test": "mocha -b",
-    "posttest": "standard"
+    "test": "tape ./test/index.js"
   },
   "keywords": [
     "lucene",
@@ -19,9 +18,7 @@
   "author": "Bas Huis <bas080@hotmail.com>",
   "license": "MIT",
   "devDependencies": {
-    "chai": "~4.3.0",
-    "mocha": "^8.3.0",
-    "standard": "^16.0.3"
+    "tape": "^5.3.1"
   },
   "standard": {
     "env": [

package.json

@@ -1,111 +1,79 @@
 'use strict'
 
-const expect = require('chai').expect
+const test = require('tape')
 const l = require('../index.js')
 
-describe('builder', () => {
-  it('generates a string', () => {
-    const helloWorldQuery = l.builder((data) => {
-      return l.field(data.hello, l.term(data.world))
-    })
-
-    expect(helloWorldQuery({
-      hello: 'hello',
-      world: 'world'
-    })).to.equal('hello: "world"')
+test('builder', t => {
+  const helloWorldQuery = l.builder((data) => {
+    return l.field(data.hello, l.term(data.world))
   })
+  t.equal(helloWorldQuery({
+    hello: 'hello',
+    world: 'world'
+  }), 'hello: "world"')
+  t.end()
 })
 
-describe('range', () => {
-  it('includes both the left and right equal cases', () => {
-    expect(l.range('a', 'b', true, true)).to.equal('[ a TO b ]')
-  })
-
-  it('includes the left equal case', () => {
-    expect(l.range('a', 'b', true)).to.equal('[ a TO b }')
-  })
-
-  it('includes the left equal case', () => {
-    expect(l.range('a', 'b', false, true)).to.equal('{ a TO b ]')
-  })
-
-  it('excludes the equal cases by default', () => {
-    expect(l.range('a', 'b')).to.equal('{ a TO b }')
-  })
+test('range', t => {
+  t.equal(l.range('a', 'b', true, true), '[ a TO b ]')
+  t.equal(l.range('a', 'b', true), '[ a TO b }')
+  t.equal(l.range('a', 'b', false, true), '{ a TO b ]')
+  t.equal(l.range('a', 'b'), '{ a TO b }')
+  t.end()
 })
 
-describe('group', () => {
-  it('group', () => {
-    expect(l.group.apply(null, ['red', 'white', 'blue'].map(l.term)))
-      .to.equal('( "red" "white" "blue" )')
-  })
+test('group', t => {
+  t.equal(
+    l.group.apply(null, ['red', 'white', 'blue'].map(l.term)),
+    '( "red" "white" "blue" )')
+  t.end()
 })
 
-describe('term', () => {
-  it('creates a term query', function () {
-    expect(l.terms('hello world')).to.equal('"hello world"')
-  })
-
-  it('escapes query syntax characters', function () {
-    expect(l.terms('()')).to.equal('"\\(\\)"')
-  })
+test('term', t => {
+  t.equal(l.terms('hello world'), '"hello world"')
+  t.equal(l.terms('()'), '"\\(\\)"')
+  t.end()
 })
 
-describe('fuzzy', () => {
-  it('throws a RangeError when similarity is out of range', () => {
-    expect(
-      l.fuzzy.bind(null, l.term('lucene'), 200)
-    ).to.throw(RangeError)
-  })
-
-  it('returns a valid fuzzy search when similarity is not defined', () => {
-    expect(l.fuzzy('hello')).to.equal('hello~')
-    expect(l.fuzzy('hello')).to.equal('hello~')
-    expect(l.fuzzy('hello')).to.equal('hello~')
-  })
-
-  it('returns a valid fuzzy search when similarity param is passed', () => {
-    expect(l.fuzzy('hello', 1)).to.equal('hello~1')
-    expect(l.fuzzy('hello', 0)).to.equal('hello~0')
-    expect(l.fuzzy('hello', 0.5)).to.equal('hello~0.5')
-  })
+test('fuzzy', t => {
+  t.throws(l.fuzzy.bind(null, l.term('lucene'), 200), RangeError)
+  t.equal(l.fuzzy('hello'), 'hello~')
+  t.equal(l.fuzzy('hello'), 'hello~')
+  t.equal(l.fuzzy('hello'), 'hello~')
+  t.equal(l.fuzzy('hello', 1), 'hello~1')
+  t.equal(l.fuzzy('hello', 0), 'hello~0')
+  t.equal(l.fuzzy('hello', 0.5), 'hello~0.5')
+  t.end()
 })
 
-describe('proximity', () => {
-  it('returns a valid proximity query', () => {
-    expect(l.proximity('hello', 'world', 10)).to.equal('"hello world"~10')
-    // expect(l.proximity('hello', 'world', Infinity)).to.equal('"hello world"~Infinity');
-  })
+test('proximity', t => {
+  t.equal(l.proximity('hello', 'world', 10), '"hello world"~10')
 
-  it('throw when arguments are invalid', () => {
-    expect(l.proximity.bind(null, 'lucene')).to.throw(TypeError)
-    expect(l.proximity.bind(null, 'lucene', 'hello')).to.throw(TypeError)
-    expect(l.proximity.bind(null, 'lucene', 'hello', Infinity)).to.throw(RangeError)
-    expect(l.proximity.bind(null, 'lucene', 'hello', -1)).to.throw(RangeError)
-    expect(l.proximity.bind(null, 'lucene', 'hello', -Infinity)).to.throw(RangeError)
-  })
+  t.throws(l.proximity.bind(null, 'lucene'), TypeError)
+  t.throws(l.proximity.bind(null, 'lucene', 'hello'), TypeError)
+  t.throws(l.proximity.bind(null, 'lucene', 'hello', Infinity), RangeError)
+  t.throws(l.proximity.bind(null, 'lucene', 'hello', -1), RangeError)
+  t.throws(l.proximity.bind(null, 'lucene', 'hello', -Infinity), RangeError)
+  t.end()
 })
 
 /***
  * These are combined as they use the same function to be bootstrapped
  */
-describe('or/and/not', () => {
+test('or/and/not', t => {
   ['or', 'and', 'not'].forEach(function (operator) {
     const uppered = operator.toUpperCase()
 
-    it('places the operator in the middle of the other operators', () => {
-      expect(l[operator](
-        l.terms('hello'),
-        l.terms('world')
-      )).to.equal(`"hello" ${uppered} "world"`)
-    })
+    t.equal(l[operator](
+      l.terms('hello'),
+      l.terms('world')
+    ), `"hello" ${uppered} "world"`)
 
-    it('takes a variadic amount of args', () => {
-      expect(l[operator](
-        l.terms('hello'),
-        l.terms('world'),
-        l.terms('red')
-      )).to.equal(`"hello" ${uppered} "world" ${uppered} "red"`)
-    })
+    t.equal(l[operator](
+      l.terms('hello'),
+      l.terms('world'),
+      l.terms('red')
+    ), `"hello" ${uppered} "world" ${uppered} "red"`)
   })
+  t.end()
 })