flagon-io/automation-lab

cat test.js; cat math.js

const assert = require("node:assert");
const math = require("./math");

assert.strictEqual(math.add(2, 3), 5);
assert.strictEqual(math.multiply(4, 5), 20);
assert.strictEqual(math.power(2, 10), 1024);
assert.strictEqual(math.power(5, 0), 1);
assert.throws(() => math.power(2, -1), RangeError);
assert.strictEqual(math.mean([1, 2, 3, 4]), 2.5);
assert.strictEqual(math.median([3, 1, 2]), 2);
assert.strictEqual(math.median([4, 1, 3, 2]), 2.5);
assert.strictEqual(math.standard_deviation([2, 4, 4, 4, 5, 5, 7, 9]), 2);
for (const fn of [math.mean, math.median, math.standard_deviation]) {
  assert.throws(() => fn([]), TypeError);
}
console.log("all tests passed");
// Small helpers for numbers.
/** Returns the sum of a and b. */
function add(a, b) {
  return a + b;
}

/** Returns the product of a and b. */
function multiply(a, b) {
  return a * b;
}

/** Returns base raised to the whole-number exponent; throws a RangeError if exponent is negative. */
function power(base, exponent) {
  if (exponent < 0) {
    throw new RangeError("exponent must not be negative");
  }
  let result = 1;
  for (let i = 0; i < exponent; i++) {
    result *= base;
  }
  return result;
}

/** Returns the average of numbers; throws a TypeError if the array is empty. */
function mean(numbers) {
  if (numbers.length === 0) {
    throw new TypeError("numbers must not be empty");
  }
  return numbers.reduce((sum, n) => sum + n, 0) / numbers.length;
}

/** Returns the middle value of numbers (the average of the two middle values when the length is even); throws a TypeError if the array is empty. */
function median(numbers) {
  if (numbers.length === 0) {
    throw new TypeError("numbers must not be empty");
  }
  const sorted = [...numbers].sort((a, b) => a - b);
  const mid = Math.floor(sorted.length / 2);
  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
}

/** Returns the population standard deviation of numbers; throws a TypeError if the array is empty. */
function standard_deviation(numbers) {
  const avg = mean(numbers);
  const variance = numbers.reduce((sum, n) => sum + (n - avg) ** 2, 0) / numbers.length;
  return Math.sqrt(variance);
}

module.exports = { add, multiply, power, mean, median, standard_deviation };

sed -i 's|^assert.strictEqual(math.mean(\[1, 2, 3, 4\]), 2.5);|assert.strictEqual(math.mean([1, 2, 3]), 2);\n&|; s|^assert.strictEqual(math.median(\[3, 1, 2\]), 2);|assert.strictEqual(math.median([1, 2, 3]), 2);\n&|; s|^assert.strictEqual(math.standard_deviation(\[2, 4.*|assert.strictEqual(math.standard_deviation([1, 2, 3]), Math.sqrt(2 / 3));\n&|' test.js && node test.js && git commit -qam "Add simple-array tests for mean, median, and standard_deviation

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>" && git log --oneline | head -1

all tests passed
f6bca0c Add simple-array tests for mean, median, and standard_deviation

node test.js; git status --short; ls .g1t/workflows && cat .g1t/workflows/*

all tests passed
after-build.yml
build.yml
caller.yml
checks.yml
ci.yml
reusable-greet.yml
rust.yml
name: After build
on:
  workflow_run:
    workflows: [Build]
    types: [completed]
jobs:
  report:
    runs-on: ubuntu-latest
    steps:
      - run: echo "Build ${{ github.event.workflow_run.run_number }} finished with ${{ github.event.workflow_run.conclusion }} on ${{ github.event.workflow_run.head_branch }}"
name: Build
on:
  push:
    branches: [main]
  workflow_dispatch:
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - name: Restore the cache
        id: cache
        uses: actions/cache@v6
        with:
          path: .deps
          key: deps-${{ hashFiles('math.js') }}
          restore-keys: deps-
      - name: Fill the cache on a miss
        if: steps.cache.outputs.cache-hit != 'true'
        run: mkdir -p .deps && date > .deps/made-at && echo "cache was cold"
      - run: echo "cache hit=${{ steps.cache.outputs.cache-hit }}; deps made at $(cat .deps/made-at)"
      - run: mkdir -p dist && cp math.js dist/ && echo "built $(date)" > dist/BUILD
      - uses: actions/upload-artifact@v7
        with:
          name: dist
          path: dist/
  verify:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/download-artifact@v8
        with:
          name: dist
          path: out
      - run: ls -la out && cat out/BUILD && node -e "console.log(require('./out/math.js').add(2, 2))"
name: Caller
on:
  workflow_dispatch:
jobs:
  greet:
    uses: ./.github/workflows/reusable-greet.yml
    with:
      who: g1t
      loud: true
  report:
    needs: greet
    runs-on: ubuntu-latest
    steps:
      - run: echo "reusable said ${{ needs.greet.outputs.message }} (${{ needs.greet.result }})"
name: Checks
on:
  pull_request:
  merge_group:
  push:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - name: Unit tests
        run: node test.js
      - name: House style
        run: |
          # Every exported function is documented with a JSDoc block.
          for fn in $(grep -oE '^function [a-zA-Z]+' math.js | cut -d' ' -f2); do
            if ! grep -B1 "^function $fn" math.js | grep -q '^ \*/\|^\*/\|\*/$'; then
              echo "::error file=math.js,title=House style::$fn needs a /** JSDoc */ comment right above it"
              exit 1
            fi
          done
          echo "house style ok"
name: CI
on:
  push:
    branches: [main]
  workflow_dispatch:
    inputs:
      greeting:
        description: What to say
        default: hi
env:
  WORKFLOW_LEVEL: from-the-workflow
jobs:
  setup:
    runs-on: ubuntu-latest
    outputs:
      version: ${{ steps.version.outputs.value }}
      matrix: ${{ steps.matrix.outputs.json }}
    steps:
      - uses: actions/checkout@v7
      - id: version
        run: echo "value=1.2.$GITHUB_RUN_NUMBER" >> "$GITHUB_OUTPUT"
      - id: matrix
        run: echo 'json={"node":[24,26]}' >> "$GITHUB_OUTPUT"
      - name: Show the context
        run: |
          echo "::group::Context"
          echo "repo=${{ github.repository }} ref=${{ github.ref_name }} sha=${{ github.sha }}"
          echo "event=${{ github.event_name }} actor=${{ github.actor }}"
          echo "var=${{ vars.GREETING }} secret=${{ secrets.DEMO_SECRET }}"
          echo "workflow env=$WORKFLOW_LEVEL"
          echo "::endgroup::"
          echo "::notice title=Version::Building ${{ steps.version.outputs.value }}"
          ls -la
  test:
    needs: setup
    runs-on: ${{ matrix.os || 'ubuntu-latest' }}
    strategy:
      matrix: ${{ fromJSON(needs.setup.outputs.matrix) }}
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v7
        with:
          node-version: ${{ matrix.node }}
      - run: node --version
      - name: Pass state between steps
        run: echo "FROM_EARLIER=set by step one" >> "$GITHUB_ENV"
      - run: echo "Reading it back -> $FROM_EARLIER (version ${{ needs.setup.outputs.version }})"
      - name: Allowed to fail
        continue-on-error: true
        run: exit 3
      - name: Only on Node 22
        if: matrix.node == 24
        run: echo "hash=${{ hashFiles('**/*.yml') }}"
  report:
    needs: [setup, test]
    if: always()
    runs-on: ubuntu-latest
    steps:
      - run: echo "test result was ${{ needs.test.result }}"
      - shell: python
        run: |
          import os
          print("python says", os.environ["GITHUB_REPOSITORY"])
name: Greet (reusable)
on:
  workflow_call:
    inputs:
      who:
        type: string
        required: true
      loud:
        type: boolean
        default: false
    outputs:
      message:
        description: What was said
        value: ${{ jobs.say.outputs.said }}
jobs:
  say:
    runs-on: ubuntu-latest
    outputs:
      said: ${{ steps.greet.outputs.said }}
    steps:
      - id: greet
        run: |
          msg="hello, ${{ inputs.who }}"
          if [ "${{ inputs.loud }}" = "true" ]; then msg="${msg^^}!"; fi
          echo "$msg"
          echo "said=$msg" >> "$GITHUB_OUTPUT"
  after:
    needs: say
    runs-on: ubuntu-latest
    steps:
      - run: echo "the greeting was ${{ needs.say.outputs.said }}"
name: Rust toolchain
on:
  workflow_dispatch:
jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: dtolnay/rust-toolchain@stable
        with:
          components: rustfmt, clippy
      - uses: actions/cache@v6
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
          key: cargo-${{ runner.os }}-demo
      - run: |
          cargo new --quiet /tmp/demo
          cd /tmp/demo
          cargo fmt --check
          cargo clippy --quiet -- -D warnings
          cargo test --quiet
          rustc --version

for fn in $(grep -oE '^function [a-zA-Z_]+' math.js | cut -d' ' -f2); do grep -B1 "^function $fn" math.js | grep -q '\*/$' && echo "ok $fn" || echo "MISSING $fn"; done

ok add
ok multiply
ok power
ok mean
ok median
ok standard_deviation