Refactoring and CI

.

.

.

Author: vladimir-popov

.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+name: parcom ci
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    paths-ignore:
+      - 'LICENSE'
+      - 'README.md'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    name: Build and Test
+    steps:
+      - uses: actions/checkout@v3
+      - uses: mlugg/setup-zig@v1
+      - run: zig build test --summary all

README.md

@@ -1,8 +1,13 @@
 # parcom
 
+[![parcom ci](https://github.com/dokwork/parcom/actions/workflows/ci.yml/badge.svg)](https://github.com/dokwork/parcom/actions/workflows/ci.yml)
+
 > [!WARNING]  
 > Required version of zig is 0.13.0
 
 Parser combinators for Zig. 
 
-Read documentation here: [https://dokwork.github.io/parcom/index.html](https://dokwork.github.io/parcom/index.html)
+Documentation: [https://dokwork.github.io/parcom/index.html](https://dokwork.github.io/parcom/index.html)
+
+Examples:
+ - [The parser of a math expression](examples/expression.zig)

build.zig

@@ -31,24 +31,24 @@ pub fn build(b: *std.Build) void {
     // to handle many examples see
     // https://github.com/zigzap/zap/blob/master/build.zig#L49
 
-    const example = b.addExecutable(.{
-        .name = "expression",
-        .root_source_file = b.path("example/expression.zig"),
+    const examples = b.addExecutable(.{
+        .name = "examples",
+        .root_source_file = b.path("examples/expression.zig"),
         .target = target,
         .optimize = optimize,
     });
 
-    example.root_module.addImport("parcom", parcom);
+    examples.root_module.addImport("parcom", parcom);
 
-    b.installArtifact(example);
+    b.installArtifact(examples);
 
-    const run_example = b.addRunArtifact(example);
+    const run_examples = b.addRunArtifact(examples);
     if (b.args) |args| {
-        run_example.addArgs(args);
+        run_examples.addArgs(args);
     }
 
-    const run_step = b.step("example", "Run example of parsing an expression");
-    run_step.dependOn(&run_example.step);
+    const run_step = b.step("expression", "Run example of parsing a math expression");
+    run_step.dependOn(&run_examples.step);
 
     // ----- Unit tests -----
     const test_filters = b.option([]const []const u8, "test-filter", "Skip tests that do not match any filter") orelse &[0][]const u8{};
@@ -63,17 +63,17 @@ pub fn build(b: *std.Build) void {
     const run_parcom_tests = b.addRunArtifact(parcom_tests);
 
     const example_tests = b.addTest(.{
-        .root_source_file = b.path("example/expression.zig"),
+        .root_source_file = b.path("examples/expression.zig"),
         .target = target,
         .optimize = optimize,
         .filters = test_filters,
     });
 
     example_tests.root_module.addImport("parcom", parcom);
 
-    const run_example_tests = b.addRunArtifact(example_tests);
+    const run_examples_tests = b.addRunArtifact(example_tests);
 
     const test_step = b.step("test", "Run unit tests");
     test_step.dependOn(&run_parcom_tests.step);
-    test_step.dependOn(&run_example_tests.step);
+    test_step.dependOn(&run_examples_tests.step);
 }

example/expression.zig examples/expression.zigexample/expression.zig renamed to examples/expression.zig

@@ -1,15 +1,13 @@
-//! This is a small example of the mathematics expression parser,
+//! This is a small example of a math expression parser,
 //! which parse only unsigned integers, brackets, [+-*/] operations,
 //! and no spaces.
 //!
 //! This example can be run with expression at first argument:
 //! ```
-//! zig build example -- "1+1"
+//! zig build expression -- "1+1"
 //! ```
 const std = @import("std");
-const parcom = @import("parcom");
-
-const P = parcom.Parsers;
+const p = @import("parcom");
 
 const Value = i8;
 
@@ -47,7 +45,7 @@ const Operation = enum {
 /// Product ← Value (('*' / '/') Value)*
 /// Value   ← [0-9]+ / '(' Expr ')'
 /// ```
-fn expr(alloc: std.mem.Allocator) !parcom.TaggedParser(Value) {
+fn expr(alloc: std.mem.Allocator) !p.TaggedParser(Value) {
     // functions to transform parsers results
     const fns = struct {
         fn parseInt(_: void, str: [10:0]u8) anyerror!Value {
@@ -57,7 +55,7 @@ fn expr(alloc: std.mem.Allocator) !parcom.TaggedParser(Value) {
         fn valueFromParens(_: void, result: struct { u8, Value, u8 }) anyerror!Value {
             return result[1];
         }
-        fn valueFromEither(_: void, result: parcom.Either(Value, Value)) anyerror!Value {
+        fn valueFromEither(_: void, result: p.Either(Value, Value)) anyerror!Value {
             return switch (result) {
                 .left => result.left,
                 .right => result.right,
@@ -79,12 +77,12 @@ fn expr(alloc: std.mem.Allocator) !parcom.TaggedParser(Value) {
     };
 
     // brackets: Int <- (<exp>)
-    const brackets = P.tuple(.{ P.char('('), P.lazy(Value, alloc, expr), P.char(')') })
+    const brackets = p.tuple(.{ p.char('('), p.lazy(Value, alloc, expr), p.char(')') })
         .transform(Value, {}, fns.valueFromParens);
 
     // we can't use Parsers.int to parse numbers here to avoid consumption of the '-' and '+'
     // number: Int <- \d+
-    const number = P.range('0', '9').repeatToSentinelArray(1, 10)
+    const number = p.range('0', '9').repeatToSentinelArray(1, 10)
         .transform(Value, {}, fns.parseInt);
 
     // value: Int <- <number>|<brackets>
@@ -93,14 +91,14 @@ fn expr(alloc: std.mem.Allocator) !parcom.TaggedParser(Value) {
 
     // product: Int <- <value>([*/]<value>)*
     const product = blk: {
-        const operation = P.oneCharOf("*/").transform(Operation, {}, Operation.parse);
+        const operation = p.oneCharOf("*/").transform(Operation, {}, Operation.parse);
         break :blk value.andThen(operation.andThen(value).repeat(alloc))
             .transform(Value, alloc, fns.calculate);
     };
 
     // sum: Int <- <product>([+-]<product>)*
     const sum = blk: {
-        const operation = P.oneCharOf("+-").transform(Operation, {}, Operation.parse);
+        const operation = p.oneCharOf("+-").transform(Operation, {}, Operation.parse);
         break :blk product.andThen(operation.andThen(product).repeat(alloc))
             .transform(Value, alloc, fns.calculate);
     };
@@ -109,9 +107,9 @@ fn expr(alloc: std.mem.Allocator) !parcom.TaggedParser(Value) {
 }
 
 fn evaluate(alloc: std.mem.Allocator, expression: []const u8) !?Value {
-    const p = try expr(alloc);
-    defer p.deinit();
-    return try p.parseString(alloc, expression);
+    const parser = try expr(alloc);
+    defer parser.deinit();
+    return try parser.parseString(alloc, expression);
 }
 
 test "1+1" {