open-index/open-npm huggingface dataset:
npm package: @mfl/jasmine-n-matchers
Description: A set of matchers to assert a spy was called n times
Author: MFL Team
Latest version: 2.1.1

jasmine-n-matchers
==================

[![Build Status](https://travis-ci.org/intel-hpdd/jasmine-n-matchers.svg?branch=master)](https://travis-ci.org/intel-hpdd/jasmine-n-matchers)

A set of matchers to assert a spy was called n times

The 2.0.0 release supports Jasmine 2.0. Everything earlier is for Jasmine 1.3.

## Usage

Make sure the jasmine-n-matchers.js file is executed early in your tests, it uses `beforeEach` to register the matchers.

## Example

```javascript
var spy = jasmine.createSpy('spy');

expect(spy).toHaveBeenCalledNTimes(0);

spy('foo', 'bar');

expect(spy).toHaveBeenCalledNTimes(1);
expect(spy).toHaveBeenCalledOnce();
expect(spy).toHaveBeenCalledOnceWith('foo', 'bar');

spy('foo', 'bar');

expect(spy).toHaveBeenCalledNTimes(2);
expect(spy).toHaveBeenCalledTwice();
expect(spy).toHaveBeenCalledTwiceWith('foo', 'bar');

spy('bar', 'baz');

expect(spy).toHaveBeenCalledNTimes(3);
expect(spy).toHaveBeenCalledThrice();
expect(spy).toHaveBeenCalledTwiceWith('foo', 'bar');
expect(spy).toHaveBeenCalledOnceWith('bar', 'baz');

spy('foo', 'bar');
spy('foo', 'bar');

expect(spy).toHaveBeenCalledNTimes(5);
expect(spy).toHaveBeenCalledNTimesWith(4, 'foo', 'bar');
npm package: @mfl/line-delimited-json-stream
Description: A Transform stream that buffers JSON objects. It will emit a completed object on a newline.
Author: MFL Team
Latest version: 1.0.0

# line-delimited-json-stream

A Transform stream that buffers JSON objects. It will emit a completed object on a newline.

Useful for sending messages over a bi-directional stream (socket) between server and clients.

## Overview

Messages will be buffered by this stream until a full JSON object has been received terminated by a newline.

Consider if someone emits a partial object (or one comes over the stream):

```
                     ┌─────────────────────────────┐
                     │        {"foo": "bar"        │
┌───────────────┐    └─────────────────────────────┘     ┌───────────────┐
│    Client     │ ────────────────────────────────────▶  │    Server     │
└───────────────┘                                        └───────────────┘
```

At this point, the stream is holding a partial object and will not emit.
Now consider what happens when the rest is sent:

```
                     ┌─────────────────────────────┐
                     │       , "bar": "baz"}\n     │
┌───────────────┐    └─────────────────────────────┘     ┌───────────────┐
│    Client     │ ────────────────────────────────────▶  │    Server     │
└───────────────┘                                        └───────────────┘
```

Now we have received a full JSON object terminated by a newline.
The stream will emit the completed and parsed object:

`{"foo": "bar", "bar": "baz"}`
npm package: @mfl/lodash-mixins
Description: Mixins for Lo-Dash we find useful.
Author: MFL Team
Latest version: 1.0.4

# lodash-mixins

[![Build Status](https://travis-ci.org/intel-hpdd/lodash-mixins.svg?branch=master)](https://travis-ci.org/intel-hpdd/lodash-mixins)
npm package: @mfl/math
Description: Functional Math
Author: MFL Team
Latest version: 6.0.1

# math

This module provides a stdlib of math methods.

[![Build Status](https://travis-ci.org/intel-hpdd/math.svg?branch=master)](https://travis-ci.org/intel-hpdd/math)

## Methods

### math.lte

```
(number -> number) -> boolean
```

### math.lt

```
(number -> number) -> boolean
```

### math.gt

```
(number -> number) -> boolean
```

### math.gte

```
(number -> number) -> boolean
```

### math.add

```
(number -> number) -> number
```

### math.minus

```
(number -> number) -> number
```

### math.times

```
(number -> number) -> number
```

### math.div

```
(number -> number) -> number|Infinity
```
npm package: @mfl/maybe
Description: The Maybe datatype
Author: MFL Team
Latest version: 3.1.0

## Maybe

[![Build Status](https://travis-ci.org/intel-hpdd/maybe.svg?branch=master)](https://travis-ci.org/intel-hpdd/maybe)

`Maybe` is a datatype that represents a value that may or may not be there. It is useful to explicitly model where a possible null type may occur. Once we wrap a value in `Maybe`, all future computations will be skipped if they are `null` (or `undefined`).
npm package: @mfl/parsely
Description: Parser combinators
Author: MFL Team
Latest version: 4.0.1

# parsely

[![Build Status](https://travis-ci.org/intel-hpdd/parsely.svg?branch=master)](https://travis-ci.org/intel-hpdd/parsely)
[![Greenkeeper badge](https://badges.greenkeeper.io/intel-hpdd/parsely.svg)](https://greenkeeper.io/)

Generic parser combinator loosely based on parsec
npm package: @mfl/pdsh-parser
Description: PDSH module for parsing pdsh queries
Author: MFL Team
Latest version: 1.0.5

# pdsh-parser

[![Build Status](https://travis-ci.org/intel-hpdd/pdsh-parser.svg?branch=master)](https://travis-ci.org/intel-hpdd/pdsh-parser)
[![Greenkeeper badge](https://badges.greenkeeper.io/intel-hpdd/pdsh-parser.svg)](https://greenkeeper.io/)
npm package: @mfl/qs-parsers
Description: A set of parsers useful for parsing input <-> qs
Author: MFL Team
Latest version: 4.0.1

# qs-parsers

A set of parsers useful for parsing input <-> qs

[![Greenkeeper badge](https://badges.greenkeeper.io/intel-hpdd/qs-parsers.svg)](https://greenkeeper.io/)
[![Build Status](https://travis-ci.org/intel-hpdd/qs-parsers.svg?branch=master)](https://travis-ci.org/intel-hpdd/qs-parsers)
npm package: @mfl/req
Description: A module used to make a request and apply a json mask if necessary.
Author: MFL Team
Latest version: 3.0.4

# req

[![Build Status](https://travis-ci.org/intel-hpdd/req.svg?branch=master)](https://travis-ci.org/intel-hpdd/req)

[![Greenkeeper badge](https://badges.greenkeeper.io/intel-hpdd/req.svg)](https://greenkeeper.io/)
npm package: @mfl/xml-2-json
Description: parses simple xml to JSON output
Author: MFL Team
Latest version: 1.0.2

# xml-2-json

[![Build Status](https://travis-ci.org/intel-hpdd/xml-2-json.svg?branch=master)](https://travis-ci.org/intel-hpdd/xml-2-json)

parses simple XML input to JSON output