Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/ascoders/syntax-parser
Light and fast 🚀parser! With zero dependents. - Sql Parser Demo added!
https://github.com/ascoders/syntax-parser
lexer parser sql sql-parser
Last synced: 4 days ago
JSON representation
Light and fast 🚀parser! With zero dependents. - Sql Parser Demo added!
- Host: GitHub
- URL: https://github.com/ascoders/syntax-parser
- Owner: ascoders
- License: mit
- Created: 2018-07-04T02:33:31.000Z (over 6 years ago)
- Default Branch: master
- Last Pushed: 2023-10-28T04:37:05.000Z (about 1 year ago)
- Last Synced: 2024-03-15T11:02:25.976Z (8 months ago)
- Topics: lexer, parser, sql, sql-parser
- Language: TypeScript
- Homepage:
- Size: 1.27 MB
- Stars: 455
- Watchers: 16
- Forks: 47
- Open Issues: 12
-
Metadata Files:
- Readme: readme.md
Awesome Lists containing this project
README
syntax-parser
syntax-parser is a parser using pure javascript, so it can both run in browser and nodejs.
[syntax-parser](https://www.npmjs.com/package/syntax-parser) supports:
- lexer.
- parser.
## Lexer
`createLexer` can help you create a lexer.
### Example
```typescript
import { createLexer } from 'syntax-parser';
const myLexer = createLexer([
{
type: 'whitespace',
regexes: [/^(\s+)/],
ignore: true
},
{
type: 'word',
regexes: [/^([a-zA-Z0-9]+)/]
},
{
type: 'operator',
regexes: [/^(\+)/]
}
]);
myLexer('a + b');
// [
// { "type": "word", "value": "a", "position": [0, 1] },
// { "type": "operator", "value": "+", "position": [2, 3] },
// { "type": "word", "value": "b", "position": [4, 5] }
// ]
```
**type**
`Token` type name, you can use any value here, and you will use it in the parser stage.
**regexes**
Regexes that use to be matched for each `Token` type.
**ignore**
The matching `Token` will not be added to the `Token` result queue.
In general, whitespace can be ignored in syntax parsing.
## Parser
`createParser` can help you create a parser. Parser requires a lexer.
```typescript
import { createParser, chain, matchTokenType, many } from 'syntax-parser';
const root = () => chain(addExpr)(ast => ast[0]);
const addExpr = () =>
chain(matchTokenType('word'), many(addPlus))(ast => ({
left: ast[0].value,
operator: ast[1] && ast[1][0].operator,
right: ast[1] && ast[1][0].term
}));
const addPlus = () =>
chain('+', root)(ast => ({
operator: ast[0].value,
term: ast[1]
}));
const myParser = createParser(
root, // Root grammar.
myLexer // Created in lexer example.
);
myParser('a + b');
// ast:
// [{
// "left": "a",
// "operator": "+",
// "right": {
// "left": "b",
// "operator": null,
// "right": null
// }
// }]
```
### chain
Basic grammatical element, support four parameters:
#### string
String means match token:
```typescript
chain('select', 'table'); // Match 'select table'
```
#### array
Array means 'or':
```typescript
chain('select', ['table', 'chart']); // Match both 'select table' and 'select chart'
```
#### matchTokenType
`matchTokenType` allow you match `Token` type defined in lexer.
```typescript
chain('select', matchTokenType('word')); // Match 'select [any word!]'
```
#### function
It's easy to call another chain function:
```typescript
const a = () => chain('select', b);
const b = () => chain('table');
```
### many/optional
Just as literal meaning:
```typescript
const a = () => chain('select', optional('table')); // Match both 'select' and 'select table'
const b = () => chain('select', many(',', matchTokenType('word'))); // Match both 'select' and 'select a' and 'select a, b' .. and so on.
```
> `optional` `many` can also use `chain` as parameter. `many(chain(..))`
The last callback allow partial redefin of local ast:
```typescript
chain('select', 'table')(
ast => ast[0] // return 'select'
);
```
## Tests
```bash
npm test
```
## Monaco Editor Sql Editor
If you want to see this demo, run this command:
```bash
npm run docs
```
Then select demo `Monaco Editor`.