celq 0.1.1__tar.gz

celq-0.1.1/.github/scripts/publish-npm-binary.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Usage: publish-npm-binary.sh <build-name> <build-os> <target>
+# Example: publish-npm-binary.sh linux-x64-glibc ubuntu-24.04 x86_64-unknown-linux-gnu
+
+BUILD_NAME="$1"
+BUILD_OS="$2"
+TARGET="$3"
+
+BIN="celq"
+NPM_DIR="npm"
+
+# Read release version from package.json using celq
+RELEASE_VERSION=$(cargo run -- "this.version" < "${NPM_DIR}/celq/package.json")
+RELEASE_VERSION=${RELEASE_VERSION#\"}
+RELEASE_VERSION=${RELEASE_VERSION%\"}
+
+# Derive OS and architecture from build name
+# Format: os-arch-variant (e.g., linux-x64-glibc, darwin-arm64)
+node_os=$(echo "$BUILD_NAME" | cut -d '-' -f1)
+node_arch=$(echo "$BUILD_NAME" | cut -d '-' -f2)
+
+# Set package name (use 'windows' instead of 'win32')
+if [[ "$BUILD_OS" == windows-* ]]; then
+  node_pkg="${BIN}-windows-${node_arch}"
+else
+  node_pkg="${BIN}-${node_os}-${node_arch}"
+fi
+
+
+echo "Publishing ${node_pkg} version ${RELEASE_VERSION}"
+
+# Create package directory
+mkdir -p "${NPM_DIR}/${node_pkg}/bin"
+
+# Generate package.json using celq
+cargo run -- \
+  -n \
+  -p \
+  -S \
+  --from-file "${NPM_DIR}/package.json.cel" \
+  --arg="node_os:string=${node_os}" \
+  --arg="node_arch:string=${node_arch}" \
+  --arg="node_version:string=${RELEASE_VERSION}" \
+  --arg="node_pkg:string=${node_pkg}" \
+  > "${NPM_DIR}/${node_pkg}/package.json"
+
+# Copy binary (add .exe extension for Windows)
+binary_name="$BIN"
+if [[ "$BUILD_OS" == windows-* ]]; then
+  binary_name="${BIN}.exe"
+fi
+
+cp "target/${TARGET}/release/${binary_name}" "${NPM_DIR}/${node_pkg}/bin/"
+cp "LICENSE-MIT" "${NPM_DIR}/${node_pkg}/"
+cp "LICENSE-APACHE" "${NPM_DIR}/${node_pkg}/"
+cp "README.md" "${NPM_DIR}/${node_pkg}/"
+
+# Publish package
+cd "${NPM_DIR}/${node_pkg}"
+npm publish --access public
+
+echo "Successfully published ${node_pkg}"

celq-0.1.1/.github/scripts/stable_or_not.cel

@@ -0,0 +1,3 @@
+(this.version.contains("beta") 
+    || this.version.contains("alpha") 
+    || this.version.contains("rc") ) ? "prerelease" : "stable"

celq-0.1.1/.github/workflows/main.yml

@@ -0,0 +1,108 @@
+name: CI
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+concurrency:
+  group: ${{ github.repository }}-${{ github.ref }}-${{ github.head_ref }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+    name: Build (Linux x86-64)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Install Rust 1.90.0
+        uses: dtolnay/rust-toolchain@1.90.0
+      
+      - name: Build with locked dependencies
+        run: cargo build --locked
+
+  format:
+    name: Format Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Install Rust stable
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+      
+      - name: Check formatting
+        run: cargo fmt --all -- --check
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Install Rust 1.90.0
+        uses: dtolnay/rust-toolchain@1.90.0
+        with:
+          components: clippy
+      
+      - name: Run Clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+  test:
+    name: Test
+    needs: [build, format, clippy]
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            rust: stable
+          - os: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
+            rust: stable
+          - os: macos-latest
+            target: aarch64-apple-darwin
+            rust: stable
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+            rust: stable
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Install Rust ${{ matrix.rust }}
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ matrix.rust }}
+          targets: ${{ matrix.target }}
+      
+      - name: Run tests
+        run: cargo test --target ${{ matrix.target }}
+
+  docs:
+    name: Documentation
+    needs: [build, format, clippy]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Install Rust stable
+        uses: dtolnay/rust-toolchain@stable
+      
+      - name: Build documentation
+        run: cargo doc --no-deps --all-features
+        env:
+          RUSTDOCFLAGS: "-D warnings"
+      
+      - name: Upload documentation
+        uses: actions/upload-artifact@v4
+        with:
+          name: documentation
+          path: target/doc/
+          retention-days: 1

celq-0.1.1/.github/workflows/release_crates_io.yml

@@ -0,0 +1,28 @@
+name: Publish to crates.io
+
+on:
+  workflow_dispatch:  # Manual trigger only
+  push:
+    tags:
+      - "v[0-9]*"      # Trigger on version tags like v1.0.0
+
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: crates_io_release
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Run tests
+        run: cargo test
+
+      - name: Publish to crates.io
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}
+        run: cargo publish

celq-0.1.1/.github/workflows/release_github.yml

@@ -0,0 +1,100 @@
+# Release workflow for celq binaries
+# Credit: Inspired by https://github.com/01mf02/jaq/blob/main/.github/workflows/release.yml
+# Also see: https://github.com/BurntSushi/ripgrep/blob/61733f6378b62fa2dc2e7f3eff2f2e7182069ca9/.github/workflows/release.yml
+
+
+name: GitHub Release
+
+on:
+  workflow_dispatch:  # Manual trigger only
+  push:
+    tags:
+      - "v[0-9]*"      # Trigger on version tags like v1.0.0
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  NAME: celq
+  VERSION: ${{ github.ref_name }}
+
+# Required for gh release upload
+permissions:
+  contents: write
+
+jobs:
+  build:
+    name: ${{ matrix.target }}
+    runs-on: ${{ matrix.os }}
+    environment: github_release
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # macOS ARM64 (native)
+          - { target: aarch64-apple-darwin, os: macos-15 }
+          
+          # Windows x86-64 (native)
+          - { target: x86_64-pc-windows-msvc, os: windows-2025 }
+          
+          # Linux x86-64 (native - glibc)
+          - { target: x86_64-unknown-linux-gnu, os: ubuntu-24.04 }
+          
+          # Linux x86-64 (native - musl static binary)
+          - { target: x86_64-unknown-linux-musl, os: ubuntu-24.04 }
+          
+          # Linux ARM64 (native)
+          - { target: aarch64-unknown-linux-gnu, os: ubuntu-24.04-arm }
+
+          # Linux ARM64 (native - musl static binary)
+          - { target: aarch64-unknown-linux-musl, os: ubuntu-24.04-arm }
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Install musl tools (for musl targets)
+        if: contains(matrix.target, 'musl')
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y musl-tools
+
+      - name: Build
+        run: cargo build --locked --release --target ${{ matrix.target }}
+
+      - name: Create release archive
+        id: archive
+        run: |
+          EXE_suffix="" 
+          case ${{ matrix.target }} in 
+            *-pc-windows-*) EXE_suffix=".exe" ;; 
+          esac
+          
+          BIN_PATH="target/${{ matrix.target }}/release/${NAME}${EXE_suffix}"
+          BIN_NAME="${NAME}${EXE_suffix}"
+          
+          # Determine archive format based on platform
+          case ${{ matrix.target }} in
+            *-pc-windows-*)
+              # Windows: create .zip archive
+              ARCHIVE_NAME="${NAME}-${{ matrix.target }}.zip"
+              7z a "${ARCHIVE_NAME}" "${BIN_PATH}"
+              ;;
+            *)
+              # Linux/macOS: create .tar.gz archive
+              ARCHIVE_NAME="${NAME}-${{ matrix.target }}.tar.gz"
+              tar czf "${ARCHIVE_NAME}" -C "target/${{ matrix.target }}/release" "${BIN_NAME}"
+              ;;
+          esac
+          
+          echo "ARCHIVE_NAME=${ARCHIVE_NAME}" >> $GITHUB_OUTPUT
+
+      - name: Upload release archive
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: gh release upload ${VERSION} ${{ steps.archive.outputs.ARCHIVE_NAME }}

celq-0.1.1/.github/workflows/release_npm.yml

@@ -0,0 +1,116 @@
+# Release workflow to publish NPM packages
+# Courtesy of: https://github.com/orhun/packaging-rust-for-npm/blob/4640d8a33491cc68cddc257b5966c8caa3b4e8c8/.github/workflows/cd.yml#L1
+name: Publish to NPM
+
+on:
+  workflow_dispatch:  # Manual trigger only
+  push:
+    tags:
+      - "v[0-9]*"      # Trigger on version tags like v1.0.0
+
+permissions:
+  # IMPORTANT: this permission is mandatory for Trusted Publishing
+  id-token: write
+  contents: read
+
+jobs:
+  publish-npm-binaries:
+    name: Publish NPM packages
+    runs-on: ${{ matrix.build.os }}
+    environment: npm_release
+    strategy:
+      fail-fast: false
+      matrix:
+        build:
+          - {
+              NAME: linux-x64-glibc,
+              OS: ubuntu-24.04,
+              TOOLCHAIN: stable,
+              TARGET: x86_64-unknown-linux-gnu,
+            }
+          - {
+              NAME: linux-arm64-glibc,
+              OS: ubuntu-24.04-arm,
+              TOOLCHAIN: stable,
+              TARGET: aarch64-unknown-linux-gnu,
+            }
+          - {
+              NAME: win32-x64-msvc,
+              OS: windows-2025,
+              TOOLCHAIN: stable,
+              TARGET: x86_64-pc-windows-msvc,
+            }
+          - {
+              NAME: win32-arm64-msvc,
+              OS: windows-2025,
+              TOOLCHAIN: stable,
+              TARGET: aarch64-pc-windows-msvc,
+            }
+          - {
+              NAME: darwin-x64,
+              OS: macos-15,
+              TOOLCHAIN: stable,
+              TARGET: x86_64-apple-darwin,
+            }
+          - {
+              NAME: darwin-arm64,
+              OS: macos-15,
+              TOOLCHAIN: stable,
+              TARGET: aarch64-apple-darwin,
+            }
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.build.TARGET }}
+
+      - name: Build
+        run: cargo build --release --locked --target ${{ matrix.build.TARGET }}
+
+      - name: Install node
+        uses: actions/setup-node@v6
+        with:
+          node-version: "24"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Make publish script executable
+        shell: bash
+        run: chmod +xw ./.github/scripts/publish-npm-binary.sh
+
+      - name: Publish to NPM
+        shell: bash
+        run: |
+          ./.github/scripts/publish-npm-binary.sh \
+            "${{ matrix.build.NAME }}" \
+            "${{ matrix.build.OS }}" \
+            "${{ matrix.build.TARGET }}"
+
+  publish-npm-base:
+    name: Publish the base NPM package
+    needs: publish-npm-binaries
+    environment: npm_release
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install node
+        uses: actions/setup-node@v6
+        with:
+          node-version: "24"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Publish the package
+        continue-on-error: true
+        shell: bash
+        run: |
+          STABLE_OR_NOT=$(cargo run -- --from-file ./.github/scripts/stable_or_not.cel  < "npm/celq/package.json")
+          STABLE_OR_NOT=${STABLE_OR_NOT#\"}
+          STABLE_OR_NOT=${STABLE_OR_NOT%\"}
+          cd npm/celq
+          yarn install # requires optional dependencies to be present in the registry
+          yarn build
+          npm publish --access public --tag "$STABLE_OR_NOT"

celq-0.1.1/.github/workflows/release_pypi.yml

@@ -0,0 +1,87 @@
+name: Release to PyPI
+
+on:
+  workflow_dispatch:  # Manual trigger only
+  push:
+    tags:
+      - "v[0-9]*"      # Trigger on version tags like v1.0.0
+
+permissions:
+  # IMPORTANT: this permission is mandatory for Trusted Publishing
+  id-token: write
+  contents: read
+
+jobs:
+  publish-binaries:
+    name: Publish binaries
+    runs-on: ${{ matrix.build.os }}
+    environment: pypi_release
+    strategy:
+      fail-fast: false
+      matrix:
+        build:
+          - {
+              NAME: linux-x64,
+              OS: ubuntu-24.04,
+              TOOLCHAIN: stable,
+              TARGET: x86_64-unknown-linux-gnu,
+            }
+          - {
+              NAME: linux-arm64,
+              OS: ubuntu-24.04-arm,
+              TOOLCHAIN: stable,
+              TARGET: aarch64-unknown-linux-gnu,
+            }
+          - {
+              NAME: win32-x64-msvc,
+              OS: windows-2025,
+              TOOLCHAIN: stable,
+              TARGET: x86_64-pc-windows-msvc,
+            }
+          - {
+              NAME: darwin-arm64,
+              OS: macos-15,
+              TOOLCHAIN: stable,
+              TARGET: aarch64-apple-darwin,
+            }
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Rust ${{ matrix.build.TOOLCHAIN }}
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.build.TOOLCHAIN }}
+          targets: ${{ matrix.build.TARGET }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          version: "0.9.22"
+
+      - name: Install Python 3.12
+        run: uv python install 3.12
+
+      - name: Build Python wheels (Linux with cibuildwheel)
+        if: runner.os == 'Linux'
+        run: |
+          uvx cibuildwheel@3.3.1  --output-dir pypi/dist pypi
+
+      - name: Build Python wheels (Windows/macOS)
+        if: runner.os != 'Linux'
+        working-directory: pypi
+        run: |
+          uv build --wheel --out-dir dist
+
+      - name: Publish wheels to PyPI
+        run: uv publish --trusted-publishing always pypi/dist/*.whl
+
+      - name: Build source distribution
+        if: matrix.build.TARGET == 'x86_64-unknown-linux-gnu'
+        working-directory: pypi
+        run: |
+          uv build --sdist --out-dir dist
+
+      - name: Publish source distribution to PyPI
+        if: matrix.build.TARGET == 'x86_64-unknown-linux-gnu'
+        run: uv publish --trusted-publishing always pypi/dist/*.tar.gz

celq-0.1.1/.gitignore

@@ -0,0 +1,27 @@
+# Generated by Cargo
+# will have compiled files and executables
+debug
+target
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# Generated by cargo mutants
+# Contains mutation testing data
+**/mutants.out*/
+
+# RustRover
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+
+# Added by cargo
+
+/target
+.DS_Store

celq-0.1.1/CONTRIBUTING.md

@@ -0,0 +1,55 @@
+# Contributing
+
+## Building
+
+`celq` is built with Rust. To contribute, you'll need to have `cargo` installed. If you don't, check
+[rustup](https://rustup.rs/) for the most popular way of installing.
+
+Once you have `cargo`, simply run:
+
+```bash
+cargo build
+```
+
+To use the local binary, `cargo run -- <ARGS>` is your friend.
+
+## Bug Fixes and Features
+
+If `celq` has a bug or is missing a feature, please:
+1. Open an issue
+2. Discuss the proposed bug fix/ feature design
+3. Send a PR with tests
+
+## Tests
+
+To run the tests:
+
+```bash
+cargo test
+```
+
+`celq` has two kind of tests: unit tests and integration tests.
+
+Unit tests live very close to the implementation. Next to the `mod.rs`, there's generally a `module_test.rs`. It's fine to use unit tests for smaller details.
+
+Integration tests live in the `test/` folder, mostly in `tests/golden.rs`. When fixing a bug or adding a feature, please try to add a test covering multiple combinations to that file.
+
+## Documentation
+
+The `celq` manual lives in docs.rs. To build it locally, run:
+
+```bash
+cargo doc --open --no-deps
+```
+
+Despite `celq` being a binary, docs.rs reads from `src/lib.rs`. Our current documentation lives in the `docs/` folder, so `src/lib.rs` should exclusively include the markdown from the docs folder.
+
+## Packaging
+
+Packaging `celq` for Linux, macOS, and Windows is a welcome contribution. If you add `celq` to a packaging repository, feel free to send a Pull Request updating the README to list that installation method.
+
+## MSRV
+
+The Minimum Supported Rust Version (MSRV) of `celq` trys to align with the MSRV of Debian stable. To see their current MSRV, search for [rustc](https://packages.debian.org/search?keywords=rustc) and see the version listed for testing.
+
+Notice that eventually that may lag behind the latest of rustc by a considerable margin. However, that guarantees that `celq` can be packaged by many Linux distributions.