DEV Community: Lance Pollard

Build, Install, and Publish a Local Choco Command (Chocolatey for Windows)

Lance Pollard — Tue, 23 Jan 2024 04:37:35 +0000

Create an org.repo.nuspec file, with this content:

<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2015/06/nuspec.xsd">
  <metadata>
    <id>org.repo</id>
    <title>Org Repo</title>
    <version>0.0.2</version>
    <authors>Name</authors>
    <description>Markdown description</description>
    <dependencies>
      <dependency id="imagemagick" />
      <dependency id="fontforge" />
    </dependencies>
  </metadata>
</package>

You can search packages on choco like ffmpeg, to see what the dependency names are.

The GitHub Action to publish this is:

on: push

jobs:
  test:
    # Windows Server 2022 (https://github.com/actions/runner-images)
    runs-on: windows-2022
    environment: build
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Install Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20.10.x
      - name: Set PACKAGE_VERSION
        id: version
        run: |
          echo "PACKAGE_VERSION=$(node -p "require('./package.json').version")" >> $env:GITHUB_ENV
      - name: Choco pack
        run: |
          choco pack org.repo.nuspec
      - name: Choco install
        run: |
          choco install -y org.repo --source "'.;chocolatey'"
      - name: Choco set api key
        env:
          CHOCOLATEY_API_KEY: ${{ secrets.CHOCOLATEY_API_KEY }}
        run:
          choco apikey --key $env:CHOCOLATEY_API_KEY --source https://push.chocolatey.org/
      - name: Choco publish
        env:
          PACKAGE_VERSION: "0.0.2"
        run:
          choco push org.repo.${{ env.PACKAGE_VERSION }}.nupkg --source https://push.chocolatey.org/

If you want to do more than this, like creating an executable, see this example chocolateyinstall.ps1 script, and follow the obscure directions for creating the chocolateyinstall.ps1 script. Here is another "default" script.

Cheers!

The only PostgreSQL schema you need, for Graph data.

Lance Pollard — Fri, 20 Aug 2021 03:30:01 +0000

Here is basically what I'm going to use.

SET client_encoding = 'UTF8';

CREATE TABLE link_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
);

CREATE TABLE base_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code BOOLEAN
);

CREATE TABLE code_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code BYTEA
);

CREATE TABLE date_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code DATE
);

CREATE TABLE fork_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code NUMERIC(8,2)
);

CREATE TABLE form_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code INTEGER
);

CREATE TABLE line_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code CHARACTER VARYING(255)
);

CREATE TABLE load_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code JSON
);

CREATE TABLE race_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code TIMESTAMP WITH TIME ZONE
);

CREATE TABLE text_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code TEXT
);

CREATE TABLE time_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code time without time zone
);

CREATE TABLE tune_list (
  mark BIGSERIAL PRIMARY KEY NOT NULL,
  home BIGINT,
  name CHARACTER VARYING(255),
  code REAL
);

CREATE INDEX base_code_index ON base_list USING btree (code);
CREATE INDEX base_home_name_index ON base_list USING btree (home, name);
CREATE INDEX code_code_index ON code_list USING btree (code);
CREATE INDEX code_home_name_index ON code_list USING btree (home, name);
CREATE INDEX date_code_index ON date_list USING btree (code);
CREATE INDEX date_home_name_index ON date_list USING btree (home, name);
CREATE INDEX fork_home_name_index ON fork_list USING btree (home, name);
CREATE INDEX form_code_index ON form_list USING btree (code);
CREATE INDEX form_home_name_index ON form_list USING btree (home, name);
CREATE INDEX line_code_index ON line_list USING btree (code);
CREATE INDEX line_home_name_index ON line_list USING btree (home, name);
CREATE INDEX link_code_index ON link_list USING btree (code);
CREATE INDEX link_home_name_index ON link_list USING btree (home, name);
CREATE INDEX load_home_name_index ON load_list USING btree (home, name);
CREATE INDEX race_code_index ON race_list USING btree (code);
CREATE INDEX race_home_name_index ON race_list USING btree (home, name);
CREATE INDEX text_home_name_index ON text_list USING btree (home, name);
CREATE INDEX time_code_index ON time_list USING btree (code);
CREATE INDEX time_home_name_index ON time_list USING btree (home, name);
CREATE INDEX tune_home_name_index ON tune_list USING btree (home, name);

One table per datatype, essentially, and one table for links. Everything has a name. BigInteger sequences for the IDs so they can grow pretty large. The queries are the hard part, trying to figure out how to serialize your standard JSON records from something like this.

Create seemingly random IDs from Big Integer Sequence in PostgreSQL

Lance Pollard — Fri, 20 Aug 2021 01:53:07 +0000

Here is a combination of cool code snippets I've received on StackOverflow over the years, to generate seemingly random IDs out of an incremental integer. You can use this to normalize your PostgreSQL BigInteger ID on a record table, so it doesn't appear, well, incremental. It is not for some security purpose, just for making the ID not feel like it's incremental.

First, we want to generate a random list of bytes. We then take that list of bytes and create a second list, mapping the output (array value) to the input (index). This essentially creates a two-way mapping function, but a random one. Then we do this as many times as we want, so each table has a different randomness feeling when generating the IDs. Here is that code.

import fs from 'fs'

const json = [
  [],
  []
]

let i = 0
let a = []
while (i < 256) {
  a[i] = i
  i++
}

i = 0
while (i < 256) {
  json[0][i] = shuffle(a.concat())
  i++
}

json[0].forEach(a => {
  let o = new Array(256)
  a.forEach((x, i) => {
    o[x] = i
  })
  json[1].push(o)
})

fs.writeFileSync('seeds/id-generator.json', JSON.stringify(json))

function shuffle(array) {
  for (var i = array.length - 1; i > 0; i--) {
    var j = Math.floor(Math.random() * (i + 1));
    var temp = array[i];
    array[i] = array[j];
    array[j] = temp;
  }
  return array
}

We then want to create a mapping from a BigInteger from PostgreSQL (or anywhere), and a custom ID string, and back.

Here is the code:

import ID_SEED from './seeds/id-generator.json'

const CODE = `abcdefghzyxwvust`

function toPublic(id, salt) {
  const byteArray = bnToBuf(id)
  const eightArray = new Array(8)
  byteArray.forEach((x, i) => eightArray[i] = x)
  const n = 8 - byteArray.length
  let i = 0
  while (i < n) {
    eightArray[i] = 0
    i++
  }
  let j = 0
  while (i < 8) {
    eightArray[i] = byteArray[j]
    j++
    i++
  }

  let string = eightArray
    .map((x, i) => ID_SEED[0][salt + i][x])

  string = string
    .map((x, i) => {
      let v = toStringRadix(x, CODE).padStart(4, toStringRadix(0, CODE))
      return v
    })
    .join('')
  return string
}

function toPrivate(string, salt) {
  let byteArray = chunkSubstr(string, 4)
    .map(x => parseIntRadix(x, CODE))
    .map((x, i) => ID_SEED[1][salt + i][x])
  return bufToBn(byteArray).toString()
}

function bnToBuf(bn) {
  let hex = BigInt(bn).toString(16)
  if (hex.length % 2) {
    hex = '0' + hex
  }

  const len = hex.length / 2
  const u8 = new Uint8Array(len)

  let i = 0
  let j = 0
  while (i < len) {
    u8[i] = parseInt(hex.slice(j, j+2), 16)
    i += 1
    j += 2
  }

  return u8
}

function bufToBn(buf) {
  const hex = []
  const u8 = Uint8Array.from(buf)

  u8.forEach(function (i) {
    let h = i.toString(16)
    if (h.length % 2) {
      h = '0' + h
    }
    hex.push(h)
  })

  return BigInt('0x' + hex.join(''))
}

function parseIntRadix(value, code) {
  return [...value].reduce((r, a) => r * code.length + code.indexOf(a), 0)
}

function toStringRadix(value, code) {
  var digit
  var radix = code.length
  var result = ''

  do {
    digit = value % radix
    result = code[digit] + result
    value = Math.floor(value / radix)
  } while (value)

  return result
}

function chunkSubstr(str, size) {
  const numChunks = Math.ceil(str.length / size)
  const chunks = new Array(numChunks)

  for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
    chunks[i] = str.substr(o, size)
  }

  return chunks
}

export default {
  toPrivate,
  toPublic,
}

First, we have to define the "code" we want to use for the ID string. We make it using an "alphabet" of a multiple-of-8 characters, so we chose 16 characters. There is this great function using radix math to convert an integer to a string using a code, and back. It works with any number of characters, but we choose multiple of 8 so it maps to bytes in a reversible way.

console.log(toStringRadix(72, CODE)) // => ez
console.log(toStringRadix(102, CODE)) // => gg

It is reversible too:

console.log(parseIntRadix('ez', CODE)) // => 72
console.log(parseIntRadix('gg', CODE)) // => 102

So that's a pretty nifty function.

Then the next thing to do is convert the bigint string from the database to our custom ID format. That is what toPublic does. It also takes a "salt", an offset for the random array to use in generating the string.

console.log(toPublic(72, 0)) // => aaaaaatsaabbaayxaahyaafvaacaaavc
console.log(toPublic(102, 0)) // => aaaaaatsaabbaayxaahyaafvaacaaasx

Now, given an ID like this (which we may get as a parameter from the URL path), you can convert it back.

console.log(toPrivate('aaaaaatsaabbaayxaahyaafvaacaaavc', 0)) // => 72
console.log(toPrivate('aaaaaatsaabbaayxaahyaafvaacaaasx', 0)) // => 102

That's about it! Code is messy, but hey. Not spending the time refactoring it just yet!

Hanákana: A Cross-Cultural Writing and Pronunciation System

Lance Pollard — Fri, 19 Mar 2021 09:41:05 +0000

Hanákana is a Universal Writing System, backed by a JavaScript library installable through NPM, to transform an ASCII representation of text into the native font.

If you learn this set of 30 or so symbols (70 or so with sound tones and slight sound variants), you can read and write in any language. It also serves as a translation framework for any app.