tarsec 0.0.1 → 0.0.2

package/README.md

@@ -13,7 +13,7 @@ A parser combinator library for TypeScript, inspired by Parsec.
 ## Install
 
 ```
-npm install egonSchiele/tarsec
+npm install tarsec
 ```
 
 ## Hello world

package/dist/combinators.d.ts

@@ -0,0 +1,15 @@
+import { Parser } from "./types";
+export declare function many<T>(parser: Parser<T>): Parser<T[]>;
+export declare function many1<T>(parser: Parser<T>): Parser<T[]>;
+export declare function manyWithJoin(parser: Parser<string>): Parser<string>;
+export declare function many1WithJoin(parser: Parser<string>): Parser<string>;
+export declare function or<T>(parsers: Parser<T>[], name?: string): Parser<T>;
+export declare function optional<T>(parser: Parser<T>): Parser<T | null>;
+export declare function not(parser: Parser<any>): Parser<null>;
+export declare function between<O, C, P>(open: Parser<O>, close: Parser<C>, parser: Parser<P>): Parser<P>;
+export declare function sepBy<S, P>(separator: Parser<S>, parser: Parser<P>): Parser<P[]>;
+export declare function seq<M, C extends string>(parsers: Parser<M>[], name?: string): Parser<M[], C>;
+export declare function capture<M, C extends string>(parser: Parser<M>, name: string): Parser<M, C>;
+export declare function captureCaptures<M, C extends string>(parser: Parser<M>, name: string): Parser<M, C>;
+export declare function shapeCaptures<M, C extends string>(parser: Parser<M>, func: (captures: Record<string, any>) => Record<string, any>, name: string): Parser<M, C>;
+export declare function transform<T, X>(parser: Parser<T>, transformerFunc: (x: T) => X): Parser<X>;

package/dist/combinators.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = exports.shapeCaptures = exports.captureCaptures = exports.capture = exports.seq = exports.sepBy = exports.between = exports.not = exports.optional = exports.or = exports.many1WithJoin = exports.manyWithJoin = exports.many1 = exports.many = void 0;
+const trace_1 = require("./trace");
+const utils_1 = require("./utils");
+function many(parser) {
+    return (0, trace_1.trace)("many", (input) => {
+        let match = [];
+        let rest = input;
+        while (true) {
+            let result = parser(rest);
+            if (!result.success) {
+                return { success: true, match, rest };
+            }
+            match.push(result.match);
+            rest = result.rest;
+        }
+    });
+}
+exports.many = many;
+function many1(parser) {
+    return (0, trace_1.trace)(`many1`, (input) => {
+        let result = many(parser)(input);
+        // this logic doesn't work with optional and not
+        if (result.rest !== input) {
+            return result;
+        }
+        return {
+            success: false,
+            rest: input,
+            message: "expected at least one match",
+        };
+    });
+}
+exports.many1 = many1;
+function manyWithJoin(parser) {
+    return transform(many(parser), (x) => x.join(""));
+}
+exports.manyWithJoin = manyWithJoin;
+function many1WithJoin(parser) {
+    return transform(many1(parser), (x) => x.join(""));
+}
+exports.many1WithJoin = many1WithJoin;
+function or(parsers, name = "") {
+    return (0, trace_1.trace)(`or(${name})`, (input) => {
+        for (let parser of parsers) {
+            let result = parser(input);
+            if (result.success) {
+                return result;
+            }
+        }
+        return {
+            success: false,
+            rest: input,
+            message: "all parsers failed",
+        };
+    });
+}
+exports.or = or;
+function optional(parser) {
+    return (0, trace_1.trace)("optional", (input) => {
+        let result = parser(input);
+        if (result.success) {
+            return result;
+        }
+        return { success: true, match: null, rest: input };
+    });
+}
+exports.optional = optional;
+function not(parser) {
+    return (0, trace_1.trace)("not", (input) => {
+        let result = parser(input);
+        if (result.success) {
+            return {
+                success: false,
+                rest: input,
+                message: "unexpected match",
+            };
+        }
+        return { success: true, match: null, rest: input };
+    });
+}
+exports.not = not;
+function between(open, close, parser) {
+    return (input) => {
+        const result1 = open(input);
+        if (!result1.success) {
+            return result1;
+        }
+        const parserResult = parser(result1.rest);
+        if (!parserResult.success) {
+            return parserResult;
+        }
+        const result2 = close(parserResult.rest);
+        if (!result2.success) {
+            return result2;
+        }
+        return { success: true, match: parserResult.match, rest: result2.rest };
+    };
+}
+exports.between = between;
+function sepBy(separator, parser) {
+    return (input) => {
+        let match = [];
+        let rest = input;
+        while (true) {
+            const result = parser(rest);
+            if (!result.success) {
+                return { success: true, match, rest };
+            }
+            match.push(result.match);
+            rest = result.rest;
+            const sepResult = separator(rest);
+            if (!sepResult.success) {
+                return { success: true, match, rest };
+            }
+            rest = sepResult.rest;
+        }
+    };
+}
+exports.sepBy = sepBy;
+function seq(parsers, name = "") {
+    return (0, trace_1.trace)(`seq(${name})`, (input) => {
+        let match = [];
+        let rest = input;
+        // @ts-ignore
+        let captures = {};
+        for (let parser of parsers) {
+            let result = parser(rest);
+            if (!result.success) {
+                return result;
+            }
+            match.push(result.match);
+            rest = result.rest;
+            if (result.captures) {
+                captures = (0, utils_1.mergeCaptures)(captures, result.captures);
+            }
+        }
+        return { success: true, match, rest, captures };
+    });
+}
+exports.seq = seq;
+function capture(parser, name) {
+    return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
+        let result = parser(input);
+        if (result.success) {
+            const captures = {
+                [name]: result.match,
+            };
+            return Object.assign(Object.assign({}, result), { captures: (0, utils_1.mergeCaptures)(result.captures || {}, captures) });
+        }
+        return result;
+    });
+}
+exports.capture = capture;
+function captureCaptures(parser, name) {
+    return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
+        let result = parser(input);
+        if (result.success) {
+            const captures = {
+                [name]: result.captures,
+            };
+            return Object.assign(Object.assign({}, result), { captures: (0, utils_1.mergeCaptures)(result.captures || {}, captures) });
+        }
+        return result;
+    });
+}
+exports.captureCaptures = captureCaptures;
+function shapeCaptures(parser, func, name) {
+    return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
+        let result = parser(input);
+        if (result.success) {
+            const captures = result.captures || {};
+            return Object.assign(Object.assign({}, result), { captures: func(captures) });
+        }
+        return result;
+    });
+}
+exports.shapeCaptures = shapeCaptures;
+function transform(parser, transformerFunc) {
+    return (0, trace_1.trace)(`transform(${transformerFunc})`, (input) => {
+        let result = parser(input);
+        if (result.success) {
+            return Object.assign(Object.assign({}, result), { match: transformerFunc(result.match) });
+        }
+        return result;
+    });
+}
+exports.transform = transform;

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parsers"), exports);
+__exportStar(require("./combinators"), exports);
+__exportStar(require("./trace"), exports);

package/dist/parsers.d.ts

@@ -0,0 +1,17 @@
+import { Parser } from "./types";
+export declare function char(c: string): Parser<string>;
+export declare function str(s: string): Parser<string>;
+export declare function oneOf(chars: string): Parser<string>;
+export declare function noneOf(chars: string): Parser<string>;
+export declare function anyChar(input: string): Parser<string>;
+export declare const space: Parser<string>;
+export declare const spaces: Parser<string>;
+export declare const digit: Parser<string>;
+export declare const letter: Parser<string>;
+export declare const alphanum: Parser<string>;
+export declare const word: Parser<string>;
+export declare const num: Parser<string>;
+export declare const quote: Parser<string>;
+export declare const tab: Parser<string>;
+export declare const newline: Parser<string>;
+export declare const quotedString: Parser<string, string>;

package/dist/parsers.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quotedString = exports.newline = exports.tab = exports.quote = exports.num = exports.word = exports.alphanum = exports.letter = exports.digit = exports.spaces = exports.space = exports.anyChar = exports.noneOf = exports.oneOf = exports.str = exports.char = void 0;
+const combinators_1 = require("./combinators");
+const trace_1 = require("./trace");
+const utils_1 = require("./utils");
+function char(c) {
+    return (0, trace_1.trace)(`char(${(0, utils_1.escape)(c)})`, (input) => {
+        if (input.length === 0) {
+            return {
+                success: false,
+                rest: input,
+                message: "unexpected end of input",
+            };
+        }
+        if (input[0] === c) {
+            return { success: true, match: c, rest: input.slice(1) };
+        }
+        return {
+            success: false,
+            rest: input,
+            message: `expected ${c}, got ${input[0]}`,
+        };
+    });
+}
+exports.char = char;
+function str(s) {
+    return (0, trace_1.trace)(`str(${(0, utils_1.escape)(s)})`, (input) => {
+        if (input.substring(0, s.length) === s) {
+            return { success: true, match: s, rest: input.slice(s.length) };
+        }
+        return {
+            success: false,
+            rest: input,
+            message: `expected ${s}, got ${input.substring(0, s.length)}`,
+        };
+    });
+}
+exports.str = str;
+function oneOf(chars) {
+    return (0, trace_1.trace)(`oneOf(${(0, utils_1.escape)(chars)})`, (input) => {
+        if (input.length === 0) {
+            return {
+                success: false,
+                rest: input,
+                message: "unexpected end of input",
+            };
+        }
+        const c = input[0];
+        if (chars.includes(c)) {
+            return char(c)(input);
+        }
+        return {
+            success: false,
+            rest: input,
+            message: `expected one of ${(0, utils_1.escape)(chars)}, got ${c}`,
+        };
+    });
+}
+exports.oneOf = oneOf;
+function noneOf(chars) {
+    return (0, trace_1.trace)(`noneOf(${(0, utils_1.escape)(chars)})`, (input) => {
+        if (input.length === 0) {
+            return {
+                success: false,
+                rest: input,
+                message: "unexpected end of input",
+            };
+        }
+        if (chars.includes(input[0])) {
+            return {
+                success: false,
+                rest: input,
+                message: `expected none of ${chars}`,
+            };
+        }
+        return char(input[0])(input);
+    });
+}
+exports.noneOf = noneOf;
+function anyChar(input) {
+    return (0, trace_1.trace)("anyChar", (input) => {
+        if (input.length === 0) {
+            return {
+                success: false,
+                rest: input,
+                message: "unexpected end of input",
+            };
+        }
+        return { success: true, match: input[0], rest: input.slice(1) };
+    });
+}
+exports.anyChar = anyChar;
+exports.space = oneOf(" \t\n\r");
+exports.spaces = (0, combinators_1.many1WithJoin)(exports.space);
+exports.digit = oneOf("0123456789");
+exports.letter = oneOf("abcdefghijklmnopqrstuvwxyz");
+exports.alphanum = oneOf("abcdefghijklmnopqrstuvwxyz0123456789");
+exports.word = (0, combinators_1.many1WithJoin)(exports.letter);
+exports.num = (0, combinators_1.many1WithJoin)(exports.digit);
+exports.quote = oneOf(`'"`);
+exports.tab = char("\t");
+exports.newline = char("\n");
+exports.quotedString = (0, combinators_1.transform)((0, combinators_1.seq)([exports.quote, exports.word, exports.quote], "quotedString"), (x) => x.join(""));

package/dist/trace.d.ts

@@ -0,0 +1,3 @@
+import { ParserResult, Parser } from "./types";
+export declare function resultToString<T>(name: string, result: ParserResult<T, string>): string;
+export declare function trace<T>(name: string, parser: Parser<T>): Parser<T>;

package/dist/trace.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trace = exports.resultToString = void 0;
+const utils_1 = require("./utils");
+const STEP = 2;
+function resultToString(name, result) {
+    if (result.success) {
+        return `✅ ${name} -- match: ${(0, utils_1.escape)(result.match)}, rest: ${(0, utils_1.escape)(result.rest)}`;
+    }
+    return `❌ ${name} -- message: ${(0, utils_1.escape)(result.message)}, rest: ${(0, utils_1.escape)(result.rest)}`;
+}
+exports.resultToString = resultToString;
+let level = 0;
+function trace(name, parser) {
+    return (input) => {
+        if (process.env.DEBUG) {
+            console.log(" ".repeat(level) + `🔍 ${name} -- input: ${(0, utils_1.escape)(input)}`);
+        }
+        level += STEP;
+        const result = parser(input);
+        level -= STEP;
+        if (process.env.DEBUG) {
+            console.log(" ".repeat(level) + resultToString(name, result));
+            if (result.success && result.captures) {
+                console.log(" ".repeat(level) +
+                    `⭐ ${name} -- captures: ${JSON.stringify(result.captures)}`);
+            }
+        }
+        return result;
+    };
+}
+exports.trace = trace;

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+export type Object = Record<string, string>;
+export type ParserSuccess<M, C extends string> = {
+    success: true;
+    match: M;
+    captures?: Record<C, any>;
+    rest: string;
+};
+export type ParserFailure = {
+    success: false;
+    rest: string;
+    message: string;
+};
+export type ParserOptions = {
+    capture: string;
+};
+export type ParserResult<M, C extends string> = ParserSuccess<M, C> | ParserFailure;
+export type Parser<M, C extends string = string> = (input: string) => ParserResult<M, C>;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function escape(str: any): string;
+export declare function merge(a: any | any[], b: any | any[]): any[];
+export declare function mergeCaptures(a: Record<string, any>, b: Record<string, any>): Record<string, any>;

package/dist/utils.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeCaptures = exports.merge = exports.escape = void 0;
+function escape(str) {
+    return JSON.stringify(str);
+}
+exports.escape = escape;
+function merge(a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return [...a, ...b];
+    }
+    else if (Array.isArray(a)) {
+        return [...a, b];
+    }
+    else if (Array.isArray(b)) {
+        return [a, ...b];
+    }
+    else {
+        return [a, b];
+    }
+}
+exports.merge = merge;
+function mergeCaptures(a, b) {
+    const result = {};
+    Object.keys(a).forEach((key) => {
+        result[key] = a[key];
+    });
+    Object.keys(b).forEach((key) => {
+        if (result[key]) {
+            result[key] = merge(result[key], b[key]);
+        }
+        else {
+            result[key] = b[key];
+        }
+    });
+    return result;
+}
+exports.mergeCaptures = mergeCaptures;

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "tarsec",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
+  "homepage": "https://github.com/egonSchiele/tarsec",
   "scripts": {
     "test": "vitest",
     "build": "tsc",
     "start": "cd dist && node index.js"
   },
+  "files": ["./dist"],
   "keywords": [],
   "author": "",
   "license": "ISC",

package/.github/workflows/node.js.yml

@@ -1,31 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [16.x, 18.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v3
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm install
-    - run: npm run build --if-present
-    - run: npm test

package/TODOS.md

@@ -1,5 +0,0 @@
-- tests
-- docs
-- ci
-- better perf
-- package for npm

package/index.ts

@@ -1,105 +0,0 @@
-import {
-  seq,
-  capture,
-  many1WithJoin,
-  many,
-  optional,
-  or,
-  manyWithJoin,
-  transform,
-  many1,
-  captureCaptures,
-  shapeCaptures,
-} from "./lib/combinators.js";
-import {
-  noneOf,
-  space,
-  str,
-  char,
-  quote,
-  word,
-  quotedString,
-} from "./lib/parsers.js";
-/* 
-const helloParser = seq<any, "name">([
-  str("hello"),
-  space,
-  capture<string, "name">(many1WithJoin(noneOf("!")), "name"),
-  char("!"),
-]);
-
-const questionParser = seq<any, "question">([
-  capture<string, "question">(many1WithJoin(noneOf("?")), "question"),
-  char("?"),
-]);
-
-const parser = seq<any, "name" | "question">([
-  helloParser,
-  space,
-  questionParser,
-]);
-
-const result = parser("hello adit! how are you?");
-console.log(result); */
-
-/* 
-if (result.success) {
-  console.log(result.captures?.name);
-}  */
-
-const input = `terraform {
-    required_providers {
-      aws = {
-        source = "hashicorp"
-      }
-    }
-  }`;
-
-const line = seq<any, string>(
-  [
-    many(space),
-    capture(word, "key"),
-    many(space),
-    char("="),
-    many(space),
-    capture(quotedString, "value"),
-  ],
-  "line"
-);
-
-let block: any = char("{");
-block = shapeCaptures(
-  seq<any, string>(
-    [
-      manyWithJoin(space),
-      capture(
-        or(
-          [str("terraform"), str("required_providers"), str("aws")],
-          "blockName"
-        ),
-        "blockName"
-      ),
-      space,
-      optional(str("= ")),
-      char("{"),
-      manyWithJoin(space),
-      // this works
-      or([line, (x) => block(x)], "line or block"),
-      // but this doesnt
-      // many(or([line, (x) => block(x)], "line or block")),
-      // nor this
-      // many1(or([line, (x) => block(x)], "line or block")),
-      manyWithJoin(space),
-      char("}"),
-    ],
-    "block"
-  ),
-  ({ blockName }) => ({ blockName }),
-  "block"
-);
-
-const result2 = block(input);
-console.log(result2);
-if (result2.success) {
-  console.log(JSON.stringify(result2.captures, null, 2));
-}