.flake8

@@ -1,2 +0,0 @@
-[flake8]
-max-line-length = 88

Makefile

@@ -1,13 +1,34 @@
 ARGS ?= -c
+OK_TYPES := otf ttf woff woff2
+NF_SRC := $(shell find src -type f)
+ML_TYPES := $(shell find ./MonoLisa \
+						-mindepth 1 \
+						-maxdepth 1 \
+						-not -empty \
+						-type d \
+						-exec basename {} \;)
 
-NF_SRC := $(shell ./bin/get-font-files src)
-FONT_SRC := $(shell ./bin/get-font-files MonoLisa 'otf,ttf,woff,woff2')
+UNKNOWN := $(filter-out $(OK_TYPES),$(ML_TYPES))
+$(if $(UNKNOWN),$(error unknown font type in ./MonoLisa: $(UNKNOWN)))
 
-## patch | apply nerd fonts patch
-patch: ./bin/font-patcher
-	@./bin/patch-monolisa \
-		$(foreach f,$(FONT_SRC),-f '$(f)') \
-		$(ARGS)
+msg = $(call tprint,{a.bold}==>{a.end} {a.b_magenta}$(1){a.end} {a.bold}<=={a.end})
+
+## patch | add nerd fonts to MonoLisa
+ifdef DOCKER
+.PHONY: patch
+patch: $(foreach ml-type,$(ML_TYPES),patch-$(ml-type)-docker)
+else
+.PHONY: patch
+patch: $(addprefix patch-,$(ML_TYPES))
+endif
+
+patch-%: ./bin/font-patcher
+	$(call msg, Patching MonoLisa $* Files)
+	@./bin/patch-monolisa $* $(ARGS)
+
+patch-%-docker: ./bin/font-patcher
+	$(call msg, Patching Monolisa $* Files w/Docker)
+	@./bin/patch-monolisa-docker $* $(ARGS)
 
 ## update-fonts | move fonts and update fc-cache
 .PHONY: update-fonts
@@ -38,6 +59,5 @@ lint:
 clean:
 	@rm -r patched/*
 
-msg = $(call tprint,{a.bold}==>{a.end} {a.b_magenta}$(1){a.end} {a.bold}<=={a.end})
 USAGE = {a.b_green}Update MonoLisa with Nerd Fonts! {a.end}\n\n{a.header}usage{a.end}:\n	make <recipe>\n
 -include .task.mk

README.md

@@ -1,6 +1,6 @@
 # MonoLisa NF
 
-_Most_ Batteries included repo to patch MonoLisa with Nerd Fonts glyphs
+*Most* Batteries included repo to patch MonoLisa with Nerd Fonts glyphs
 
 tested w/ MonoLisa v1.808
 
@@ -22,7 +22,7 @@ sudo pacman -S fontforge
 
 You can also download the version for your system from the releases in the fontforge [repo](https://github.com/fontforge/fontforge).
 
-If you prefer to use `docker` rather than install `fontforge` you can add `ARGS='--docker'` to calls to `make patch`.
+If you prefer to use `docker` rather than install `fontforge` you can just add `DOCKER=1` to calls to `make patch`.
 
 ## Downloading MonoLisa
 
@@ -54,18 +54,16 @@ make
 By default the complete (`-c`) flag is passed to the font-patcher script to include all icons/symbols.
 You can change this by specifying the `ARGS` at runtime.
 
+
 ```bash
 ARGS="-c -w" make patch
 ```
 
-See `./bin/patch-monolisa --help` and `./bin/font-patcher --help` for available `ARGS`.
-
 You can find your patched fonts in the `patched/` directory
 
 If like me you want to place your patched fonts in a standard location on your Unix system you can move them to `~/.local/share/fonts/MonoLisa` with the `bin/update-fonts` script.
 
 Or for simplicity you can copy the fonts and update the cache with:
-
 ```bash
 make update-fonts
 ```

bin/get-font-files

@@ -1,28 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-from pathlib import Path
-
-
-def find_files(search_path, exts=None):
-    return (
-        [f for ext in exts for f in search_path.glob(f"**/*.{ext}")]
-        if exts
-        else [f for f in search_path.rglob("*") if f.is_file()]
-    )
-
-
-def main():
-    if len(sys.argv) == 1:
-        print("please specify directory to search")
-        exit(1)
-
-    search_path = Path(sys.argv[1])
-    exts = sys.argv[2].split(",") if len(sys.argv) == 3 else None
-
-    for f in find_files(search_path, exts):
-        print(f)
-
-
-if __name__ == "__main__":
-    main()

bin/patch-monolisa

@@ -1,221 +1,28 @@
-#!/usr/bin/env python3
+#!/usr/bin/env bash
+set -e
 
-import argparse
-import itertools
-import os
-import shlex
-import subprocess
-import sys
-import threading
-import time
-from pathlib import Path
-from typing import List, Set
+exts=(otf ttf woff woff2)
+ext=$1
+shift
+fp_args=$@
 
-# EXTS = ["otf", "ttf", "woff", "woff2"]
+if [[ -z $ext ]]; then
+	echo "please provide an extension"
+	exit 1
+fi
 
+if [[ ! " ${exts[@]} " =~ " ${ext} " ]]; then
+	echo "$ext is not a valid extension"
+	echo "Please choose one of the below:"
+	printf '%s\n' "${exts[@]}"
+	exit 1
+fi
 
-class Color:
-    def __init__(self):
-        self.red = "\033[1;31m"
-        self.green = "\033[1;32m"
-        self.yellow = "\033[1;33m"
-        self.magenta = "\033[1;35m"
-        self.cyan = "\033[1;36m"
-        self.end = "\033[0m"
+echo "Patching all fonts with ext -> $ext"
+echo "Using the following arguments for font-patcher $fp_args"
 
-        if os.getenv("NO_COLOR"):
-            for attr in self.__dict__:
-                setattr(self, attr, "")
+for fontfile in MonoLisa/$ext/*.$ext; do
 
+	fontforge -script ./bin/font-patcher $fontfile --glyphdir ./src/glyphs/ -o ./patched/$ext $fp_args
 
-class Spinner:
-    # https://raw.githubusercontent.com/Tagar/stuff/master/spinner.py
-    def __init__(self, message, delay=0.1):
-        # self.spinner = itertools.cycle(["-", "/", "|", "\\"])
-        self.spinner = itertools.cycle([f"{c}  " for c in "⣾⣽⣻⢿⡿⣟⣯⣷"])
-
-        self.delay = delay
-        self.busy = False
-        self.spinner_visible = False
-        sys.stdout.write(message)
-
-    def write_next(self):
-        with self._screen_lock:
-            if not self.spinner_visible:
-                sys.stdout.write(next(self.spinner))
-                self.spinner_visible = True
-                sys.stdout.flush()
-
-    def remove_spinner(self, cleanup=False):
-        with self._screen_lock:
-            if self.spinner_visible:
-                # sys.stdout.write("\b")
-                sys.stdout.write("\b\b\b")
-                self.spinner_visible = False
-                if cleanup:
-                    sys.stdout.write(" ")  # overwrite spinner with blank
-                    # sys.stdout.write("\r")  # move to next line
-                    sys.stdout.write("\r\033[K")
-                sys.stdout.flush()
-
-    def spinner_task(self):
-        while self.busy:
-            self.write_next()
-            time.sleep(self.delay)
-            self.remove_spinner()
-
-    def __enter__(self):
-        if sys.stdout.isatty():
-            self._screen_lock = threading.Lock()
-            self.busy = True
-            self.thread = threading.Thread(target=self.spinner_task)
-            self.thread.start()
-
-    def __exit__(self, exc_type, exc_val, exc_traceback):
-        if sys.stdout.isatty():
-            self.busy = False
-            self.remove_spinner(cleanup=True)
-        else:
-            sys.stdout.write("\r")
-
-
-def run_cmd(
-    command: str, fontfile: Path, verbose: bool, ignore_error: bool = False
-) -> None:
-    """run a subcommand
-    Args:
-        command: Subcommand to be run in subprocess.
-        fontfile: Path to font file that will be patched
-        verbose: If true, print subcommand output.
-    """
-
-    p = subprocess.run(
-        shlex.split(command),
-        stdout=None if verbose else subprocess.PIPE,
-        stderr=None if verbose else subprocess.STDOUT,
-        universal_newlines=True,
-    )
-
-    if p.returncode != 0 and not ignore_error:
-        print()
-        print(p.stdout)
-        err_msg = (
-            f"{color.red}ERROR{color.end}: patching font file "
-            f"{fontfile.name} see above for font-patcher output"
-        )
-        echo(err_msg, hue="red")
-        sys.exit(1)
-
-
-def get_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "-f",
-        "--font-path",
-        help="path to font files",
-        action="append",
-        type=Path,
-        required=True,
-    )
-    parser.add_argument(
-        "-o", "--output", help="target output directory", default="patched", type=Path
-    )
-    parser.add_argument(
-        "-d", "--docker", help="use nerdfonts/patcher docker image", action="store_true"
-    )
-    parser.add_argument(
-        "-v", "--verbose", help="show subprocess output", action="store_true"
-    )
-    return parser.parse_known_args()
-
-
-def patch_single_font(
-    font_path: Path, output_dir: Path, fp_args: str, verbose: bool
-) -> None:
-    display_name = f"{font_path.parent.name}/{font_path.name}"
-    output_path = output_dir / font_path.parent.name.replace("MonoLisa/", "")
-    output_path.mkdir(exist_ok=True)
-
-    cmd = (
-        "fontforge -script "
-        f"./bin/font-patcher {font_path} "
-        "--glyphdir ./src/glyphs/ "
-        f"-o {output_path} "
-        f"{fp_args}"
-    )
-
-    if verbose:
-        echo(f"cmd: {cmd}")
-        run_cmd(cmd, font_path, verbose)
-    else:
-        with Spinner(f"{color.yellow}:::{color.end} Patching {display_name}... "):
-            run_cmd(cmd, font_path, verbose)
-
-    echo(f"{display_name} patched!", hue="green")
-
-
-def collect_files_by_dir(fontfiles: List[Path]) -> Set[Path]:
-    return set([f.parent for f in fontfiles])
-
-
-def patch_font_dir_docker(
-    font_dir_path: Path, output_dir: Path, fp_args: str, verbose: bool
-) -> None:
-    font_dir_path = font_dir_path.resolve()
-    output_path = (output_dir / font_dir_path.name).resolve()
-    output_path.mkdir(exist_ok=True)
-
-    cmd = (
-        "docker run --rm "
-        f"-v '{font_dir_path}:/in' "
-        f"-v '{output_path}:/out' "
-        f" -u '{os.getuid()}:{os.getegid()}' "
-        "nerdfonts/patcher "
-        f"{fp_args}"
-    )
-
-    # ignoring the fact that docker exits with code 1
-    if verbose:
-        echo(f"cmd: {cmd}")
-        run_cmd(cmd, font_dir_path, verbose, ignore_error=True)
-    else:
-        with Spinner(
-            f"{color.yellow}:::{color.end} Patching fonts in {font_dir_path.name}... "
-        ):
-            run_cmd(cmd, font_dir_path, verbose, ignore_error=True)
-
-    echo(f"{font_dir_path.name}/ fonts patched!", hue="green")
-
-
-def echo(msg: str, header=False, hue="cyan") -> None:
-    if header:
-        print(f"==>{color.magenta} {msg} {color.end}<==")
-    else:
-        print(f"{color.__dict__[hue]}::{color.end} {msg}")
-
-
-def main():
-
-    echo("MonoLisa NerdFont Patcher", header=True)
-    args, fp_args = get_args()
-    fp_args = " ".join(fp_args)
-    if fp_args:
-        echo(f"Flags passed to font-patcher: {fp_args}")
-
-    if args.docker:
-        echo("==> DOCKER MODE ENABLED")
-        for font_dir in collect_files_by_dir(args.font_path):
-            patch_font_dir_docker(font_dir, args.output, fp_args, args.verbose)
-    else:
-        for fontfile in args.font_path:
-            patch_single_font(Path(fontfile), args.output,
-                              fp_args, args.verbose)
-
-    echo("fonts are patched", hue="green")
-    echo("Happy typing!", hue="green")
-
-
-if __name__ == "__main__":
-
-    color = Color()
-    main()
+done

bin/patch-monolisa-docker

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# set -e
+# docker exits with code 1?
+
+exts=(otf ttf woff woff2)
+ext=$1
+shift
+fp_args=$@
+
+if [[ -z $ext ]]; then
+	echo "please provide an extension"
+	exit 1
+fi
+
+if [[ ! " ${exts[@]} " =~ " ${ext} " ]]; then
+	echo "$ext is not a valid extension"
+	echo "Please choose one of the below:"
+	printf '%s\n' "${exts[@]}"
+	exit 1
+fi
+
+echo "Patching all fonts with ext -> $ext"
+echo "Using the following arguments for font-patcher $fp_args"
+
+docker run \
+	--rm \
+	-v "$(pwd)/MonoLisa/$ext:/in" \
+	-v "$(pwd)/patched/$ext:/out" \
+	-u "$(id -u):$(id -g)" \
+	nerdfonts/patcher \
+	$fp_arg
+
+exit 0