DEV Community: mtwtkman

I made a small script as distrobox thin wrapper

mtwtkman — Sat, 14 Jun 2025 05:44:03 +0000

TL;DR

I made a (very personally) light bash script named boxkit for setup routine of a development container created by distrobox to be more handy.
Please refer https://github.com/mtwtkman/boxkit

Why and what for

I love distrobox's approach to create new development environment, basically I create an indivisual development container against one project.
That works well, but I have to setup development configurations which are almost same tools like ripgrep and fzf, vim and different tools at different times.

boxkit provides those functionalities via generating a simple thin wrapper of distrobox and a configured distrobox manifest file.

I can say this script is jsut a cookiecutter for each environment.

Architecture

`boxkit` command

boxkit itself is a single script for installing main assets.

Once you run boxkit script then one executable bash script named box (default) and distrobox.ini in you current directory.

`box` command

box (default name) is an executable bash script for manipulating container via distrobox command.
box has three subcommands like below.

box enter equals to distrobox enter
box init is initial setup like creating symlink and envvars, .bashrc
box stop equals to distrobox stop

Why do I need box enter and box stop? Those commands look just aliases for distrobox.
Almost Yes. Short answer is just for unity.

Actually both commands are more conditional than distrobox enter because box enter detect current active development container name and changes behaviour by existance of the container.

Now box is very personally defined, so I recommend that you fork and custom it.

# How `box enter` do:
[ "${CONTAINER_ID}" ] && exit 0
[ ! "$(distrobox list | rg ${container_name})" ] && create_box
[ "$#" = 1 ] && [ "$1" = "-r" ] && create_box
distrobox enter "${container_name}"

# How `box stop` do:
[ "${CONTAINER_ID}" ] && exit 0
[ ! "$(distrobox list | rg ${container_name})" ] && exit 0
distrobox stop ${container_name}

Those conditional functionalities reduces little a bit annoying.

configured distrobox manifest file

boxkit generates a distrobox.ini. Which is one of core purpose.

This generated file (or boxkit's concept) regards the development container must be isolated environment from host machine's one.
So this file is configured home option.

Though home directory for the development container is separated, advantates of distrobox is not dead because box init provisioned symlinks for some configuration of my needed packages.

Conclusion

distrobox is so neat and powerful for me. But when I use heavily it, I notice that there are some routines and I'm bothered.
So I made a thin wrapper for distrobox setup to be happy development and this approach works well so far.

Rethink pattern matching in Ruby

mtwtkman — Fri, 14 Mar 2025 11:31:14 +0000

I'm working with ruby but I don't know about ruby well.

And I usually feel that ruby's case ... when never be able to be enough for me because it is soooo loose about data type domain.

I love ADT and its strictness, then I want to introduce strictness like ADT in ruby. Of course ruby doesn't has ADT type system, but has flexibility.

I made a prototype.

I'm sharing how I have made decision a design with ruby which is the programming language I'm not used to.

Decide interface or usage

This phase does'nt matter about what language I use.
Just think about HOW DO I WANT TO USE.

My first priority is strictness and completeness which means that there is a guarantee of a type guard at runtime.

So I made that like below.

# I need a something like some type to gather type constructors.
class Data < PseudoSumType; end 

# I can create any classes freely as product type.
class NoParam
end 

class SingleParam
  def initialize(x)
    @x = x
  end
end

class MultiParams
  def initialize(x, y)
    @x = x
    @y = y
  end
end

# Data is like a container. so now gathering.
Data.define_types(NoParam, SingleParam, MultiParams)

# Activate pattern matching.
# And this system is guard against incompleteness.
# Either lack of branch or lack of fallback shall occur runtime error.
matching = Data.match.of(NoParam).then(->(o) { o.do_something })
          .of(SingleParam).then(->(o) { o.do_something })
          .otherwise(->{ do_fallback }) # Fallback must be requried feature.

# Evaluate pattern matching and it enable to call defined callback. 
raise unless matching.eval(NoParam.new) == do_something_result

Ok, now interface is fixed.

...

Wait a minute. I consider about the key point is the chain of of and then methods. I must avoid to call like .of().of and then().then().

Finally I made a dicision about this structure like below.

All I need is just implementing that.

Implementing

My ruby ability maybe be a problem about this phase.

Basically there is no difficult but one thing had been difficut to me.

See the code.

class Data
  include Singleton

  def self.inherited(subclass)
    subclass.class_variable_set(:@@types, [])

    def subclass.define_type(type)
      raise Error::AlreadyDefinedError if has?(type)

      class_variable_set(:@@types, owned_types << type)
    end

    def subclass.define_types(*types)
      types.each { define_type(it) }
    end

    def subclass.owned_types
      class_variable_get(:@@types)
    end

    def subclass.match
      raise Error::NoDataDefinedError if owned_types.empty?
      Tree.new(self)
    end

    def subclass.has?(klass)
      owned_types.include?(klass)
    end
  end
end

This code includes some important points involved with my intention.

Data must be metaclass to create type container (I called something like sum type above).
Data's subclass must be a statefull but never be instantiated for gathering member types.
Data's subclass should not be an abstractclass for practial usefulness.

Mainly, I puzzed about inheritention and ruby's singleton class(Actually I don't know how should I say in english. In japanese, I call it "特異クラス")'s self.

I recognized that ruby's singleton class's self is just self lexically.

I mean,

class Data
   include Singleton

   # This `self` is Data itself.
   def self.define_type(type)
      ...
   def 
end

So I use inherited hook and define subclass's method dynamically.
I don't want to metaprogramming but I don't know how avoid it.

Additinally, not so essential but trivial probrme is ruby's class variable.

Though I think that class variable should be used so careful basically because class variable is shared, I want to use class variable at Data's subclass to store member types.
But class variable is not so match my intention, you know that if I set a class variable in Data directly then this attribute belongs to Data not Data's subclass.

Define errors, Testing etc

I'm curious about strictness, of course I should avoid bottom case.
But I know this topic is so boring for you.

If you interested in, please refer test codes.
And example is here.

Conclusion

I rethink ruby's pattern match style. This is so personal, hobby, very not for production, yah, I know.

But I dould ruby more and more depeply. It have been so fun and so nice experience.

Tanks to read.

Shell script is such a powerful

mtwtkman — Thu, 06 Jun 2024 09:14:15 +0000

Anyone knows, yes, this is known all over the world. But let me say, shell script is such a powerful.

I have tried some ways of initial setup my linux environment like dotfiles repository, nix, chef.

All of them are not so bad, but not perfect to me.

For example,

dotfiles repository is separated from system package installation.
- I know that all I need is just preparing single install script.
nix is easy but complex and too large to me, sometimes building package time is so long.
chef is overspec for single host machine.

My requirements for setup are below.

100% for me
- I don't need a general system.
Basically oneshot
- But I can setup as many times.
Simple
- All I needed is just 2 layers of install packages and user configuration for packages.
On Linux
- Use shell script, yeah.
Always latest
- Arch like rolling release provides me this spec.

So, now I have had a non-difficut (for me) shell script of bash.

Detail

I need 2 layers of install and configuration.

Install

I defined install as 2 type of standard install and custom install.

Standard install

Standard install is just package manager of OS built-in.
In Arch, via pacman. In Debian, via apt.

Custom install

On the other hand custom install is user-defined installation like using git, curl or make.

Configuration

I defined configuration is just configuration. No trick.

For example create a .bashrc symlink to ${HOME}, create a neovim config directory symlink to ${XDG_CONFIG_HOME}/nvim.

Picture

Constructure

So simple.
I put shell scripts for install and configuration and packages directory to detect my own necessary.

setup.sh
install_batch.sh
install_single.sh
configure_batch.sh
configure_single.sh
install_custom_batch.sh
install_custom_single.sh
configure_custom_batch.sh
configure_custom_single.sh
packages/

packages directories has subdirectory for each pacakges.

packages/
  bash/
    .bashrc
    .bash_profile
    configure.sh
    install.sh
  tmux/
    tmux.conf
    install.sh
    configure.sh
...

And each implementations are like this. Basicly, I don't create functions intentinally for maintenance.

I decided that each shellscript files should be seemed as isolated module or namespace.

# setup.sh
sh "./install_batch.sh"
sh "./configure_batch.sh"
sh "./install_custom_batch.sh"
sh "./configure_batch.sh"

# install_batch.sh

pushd packages
for package in *
do
  sh "${package}/install.sh"
done
popd

# <pacakge name>/install.sh

sh "$(sh install_command.sh) ${1}"

About configure is as same as install.

This design allows me do install or configuration isolated for single package like sh ./install_single.sh podman. 100% for me.

Conclusion

Shell script is powerful to make modular system.

Though I don't write any tests, maybe I can write test easily.

Haskell I/O Handler is my friend now

mtwtkman — Sun, 07 May 2023 03:02:57 +0000

I'm learning Haskell and it feeds me some new experiences, but I'm scary against its difficulties sometimes. (Actually so many times.)

At a glance, Haskell's I/O handler looks difficult but not actually.

I figured out that Haskell's I/O handler is so simple and there is no difference with other language's ones like python's file like object.

Let's go with a concrete example.

I wrote logging function for my interest like below.(Please ignore detail and structures, naming.)

module Main where

import Data.Time (UTCTime, getCurrentTime)
import Prelude hiding (log)
import System.IO (stdout, Handle, openFile, IOMode (WriteMode), hFlush, hClose, hPutStrLn)

data Severity
  = Debug
  | Info
  | Warning
  | Error
  deriving (Ord, Eq)

severityLabel :: Severity -> Char
severityLabel Debug = 'D'
severityLabel Info = 'I'
severityLabel Warning = 'W'
severityLabel Error = 'E'

newtype LogFormatter = LogFormatter {format :: UTCTime -> Severity -> String -> String}

data Logger = Logger
  { loggerSeverity :: Severity,
    loggerHandler :: Handle,
    loggerFormatter :: LogFormatter
  }

log :: String -> Logger -> IO ()
log msg logger = do
  timestamp <- getCurrentTime
  let formatter = loggerFormatter logger
      severity = loggerSeverity logger
      handler = loggerHandler logger
  hPutStrLn handler (format formatter timestamp severity msg)
  hFlush handler

basicFormatter :: LogFormatter
basicFormatter = LogFormatter formatter
  where
    formatter t s msg = show t <> " - " <> [severityLabel s] <> ": " <> msg

stdInLogger :: Severity -> Logger
stdInLogger sev = Logger sev stdout basicFormatter

main :: IO ()
main = do
  let debugLogger = stdInLogger Debug
  log "this is logger" debugLogger

  let logfilePath = "out.log"
  hdl <- openFile logfilePath WriteMode
  let fileLogger = Logger Debug hdl basicFormatter
  log "this is on file" fileLogger
  hClose hdl

This code generates like 2023-05-07 02:27:25.997054484 UTC - D: <arbitrary message> to stdout and a logfile.

When I am going to display some messages to stdout, I use print and putStrLn usually.

As well as I am goint to write out some messages to any files, I use openFile and writeFile usually.

In above example case, I have to make the something to write out to real world via I/O handler abstraction, so I guess my function log is the one of core concept of Haskell's I/O handleing.

log msg logger = do
  timestamp <- getCurrentTime
  let formatter = loggerFormatter logger
      severity = loggerSeverity logger
      handler = loggerHandler logger
  hPutStrLn handler (format formatter timestamp severity msg)
  hFlush handler

log uses h prefixed function for System.IO.Handle. So this is
all things about Haskell's I/O handling.

I just do passing System.IO.Handle type something to the I/O handle wrapper and this wrapper just writes some messages to handler's buffer and finally flushes, NO DIFFICULTIES! YAY!

Haskell is difficult to me. This truth is maybe never changed forever to me.

But I learned those difficurlties are from some impressions.

Forgetting type system, Monad, etc and treating as a just function makes me more easy to understanding what is it.

Now Haskell's I/O handling is no fear, it is my friend (maybe).

Piping in Python

mtwtkman — Tue, 28 Jul 2020 13:18:30 +0000

Piping of shell likes cat foo | sort | uniq | wc -l is very simple, clear and fun.
Python gives us the way to implement this piping idiom by overriding special method.

All you needs are only the special method __ror__ like below.

class Pipable:
    def __init__(self, cmd):
        if callable(cmd):
            self.cmd = cmd
        else:
            raise ValueError

    def __ror__(self, other):
        return self.cmd(other)

    def __call__(self, *args):
        return self.cmd(*args)

OK, use it.

import os


def read_file(f):
    with open(f) as fd:
        return fd.read()

p1 = Pipable(read_file)
p2 = Pipable(lambda x: x.upper())
p3 = Pipable(lambda x: '-'.join(x))

f = 'foo.txt'
with open(f, 'w') as fd:
    fd.write('meow')
assert p1(f) == 'meow'
assert p1(f) | p2 == 'MEOW'
assert p1(f) | p2 | p3 == 'M-E-O-W'
os.remove(f)

Now you have the simple magic of function composition in Python!

You can override other operation symbols via corresponded special methods, so let's explore there.

Write a simplest audio player in browser.

mtwtkman — Sun, 07 Jun 2020 00:57:33 +0000

I play with <audio> tag to play mp3 file handy and portably.

This simplest audio player has no special feature, just plays an audio file!

You can use it like below.

<audio src="/yourfile.mp3" controls></audio>

DONE!

...oh, This doesn't looks convenient so much.

At the least, I want to choose a file. HOW?

<audio> detects the file to play from src attribute.
So, All I need are preparing file choose and creating <audio> DOM.

Maybe it needs a little state managing.

No file to play: Only <input type="file"> is enabled
There is a file to play: <audio> is enabled

I decided to use mithriljs to control states because this is declarative, easy and compile free.

Implementing looks like below. (details are omitted.)

// The global model to manage state.
const model = {
  fileObj: null,
  blobUrl: null,
};

function handleFile(e) {
  // create blob URL.
  model.fileObj = e.target.files[0];
  model.blobUrl = URL.createObjectURL(model.fileObj);
}

// The component to choose file.
const itemComponent = {
  view() {
    return m('input', {type: "file", onclick: handleFile });
  },
};

// The component rendering <audio> DOM.
const audioComponent = {
  view() {
    return m('audio', { controls: true, src: model.blobUrl });
  },
};

// Entrypoint
const app = {
  view() {
    // This draws <audio> DOM after chosen file. 
    return m(model.fileObj ? audioComponent : itemComponent);
  }
};

Actual implementing has file drop and restore playing posigion, but essentials are just these. (please see: https://js.do/code/451129)

Write a frontend application with Rust

mtwtkman — Sat, 11 Apr 2020 15:41:29 +0000

yew helps you making a frontend application.
I remind how to do it.

Prerequests

I need some tools to do it.
Basically it is clear what I need by reading yew official document.

Now I choose wasm-pack to build a wasm application.

$ cargo install wasm-pack
$ cargo new myapp
$ cd myapp

So, I need edit Cargo.toml to build using wasm-pack.

[dependencies]
yew = { version = "0.14.3", features = ["web_sys"] }
wasm-bindgen = "0.2"

[lib]
crate-type = ["cdylib"]

Done.

Write Rust code

I defined my rust application as lib type although I created my project as bin type.
So I modified my project looks like now.

myapp
  - src
    - app.rs  # my application body (renamed from `main.rs`)
    - lib.rs  # entrypoint of wasm application (added by manually)
  - Cargo.toml
  - Cargo.lock

app.rs looks like below.

use yew::prelude::*;

pub struct Model {
    link: ComponentLink<Self>,
    value: i64,
}

pub enum Msg {
    AddOne,
    SubOne,
}

impl Component for Model {
    type Message = Msg;
    type Properties = ();
    fn create(_: Self::Properties, link: ComponentLink<Self>) -> Self {
        Self {
            link,
            value: 0,
        }
    }

    fn update(&mut self, msg: Self::Message) -> ShouldRender {
        match msg {
            Msg::AddOne => self.value += 1,
            Msg::SubOne => self.value -= 1,
        }
        true
    }

    fn view(&self) -> Html {
        html! {
            <div>
                <button onclick=self.link.callback(|_| Msg::AddOne)>{ "+1" }</button>
                <button onclick=self.link.callback(|_| Msg::SubOne)>{ "-1" }</button>
                <p>{ self.value }</p>
            </div>
        }
    }
}

And lib.rs is

use yew;
use wasm_bindgen::prelude::*;

mod app;

#[wasm_bindgen]
pub fn start() {
    yew::initialize();
    yew::App::<app::Model>::new().mount_to_body();
}

wasm_bindgen allows to us using our Rust code in javascript world, awesome.

Build Rust code to wasm application

After wrote Rust code with yew, I must run wasm-pack for building it.

$ wasm-pack build

So, wasm-pack without any parameter generates pkg directory.
pkg directory has many stuffs that I don't know there are, but I know that there work fine :-).

Write my frontend code

Now I have wasm code generated by Rust code.
All I need is using it, HOW?
You know anytime MDN documents helps us, refer this article.

$ mkdir site
$ cd site
$ npm init
$ npm i -D webpack webpack-dev-server webpack-cli
$ npm i ../pkg

OK, next I write webpack.config.js

const path = require('path');
module.exports = {
  entry: './index.js',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'index.js',
  },
  mode: 'development',
  devServer: {
    host: '0.0.0.0',
    port: 55301,
  },
};

And index.html and inde.js which calls the wasm application.

index.js is

const js = import('./node_modules/myapp/myapp.js');
js.then(js => js.start());

index.html is

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title>anond browser</title>
    </head>
    <body>
        <script src="./index.js"></script>
    </body>
</html>

Run server

Now I can ensure my application works fine.

$ npx webpack-dev-server

Looks good.

HOT RELOAD?

Yes, of course.
I modify my Rust code while running dev server.

...
html! {
    <div>
        <h1>{ "Modifying" }</h1>
        ...
    </div>
}
...

Build manually.

$ wasm-pack build

After building, dev server detected this changing and reloaded the built wasm application. It means my browser was refreshed and shows new sentence added by me.

I just said AWESOME EASY, yeah.

Build your webframework in Python

mtwtkman — Mon, 30 Sep 2019 04:08:32 +0000

There are many really nice webframeworks written by Python in this world.
You know these webframeworks on WSGI, so let's building your original webframework now!

If you want to know the detail about WSGI spec, please reference PEP3333. This post doesn't care any details, just implementing.

Write our application

Luckly, you have already wsgi server defined at wsgiref module. All you need is creating an WSGI application entrypoint.

A most simple application is like below.

# app.py
from wsgiref.simple_server import make_server


def app(environ, start_response):
    start_response('200 OK', headers=[('Content-Type', 'text/plain:charset=utf-8')])
    response = [b'my toy app']
    return response


with make_server('', 8088, app) as server:
    server.serve_forever()

Hmm, this is so boring. Typically an webframework must have http request handlers and routing systems. So I should have these.
At first, I should think about the way to using in the real world.

from wsgiref.simple_server import make_server


things = {x: x.upper()  for x in ('a', 'b', 'c')}


def get_all_things(request):
    return ','.join(things.keys())


def create_things(request):
    # do something
    return 'ok'


class App:
    def get(self, path, handler):
        # TODO
        return self

    def post(self, path, handler):
        # TODO
        return self

    def __call__(self, environment, start_response):
        # TODO
        return response

    def start(self):
        with make_server('', 8088, self) as server:
            server.serve_forever()


app = App().get('/things', get_all_things).post('/things', create_things)
app.start()

This webframework has

Routing
Querystring
Path parameter
Only GET and POST handlers
App class includes WSGI server starter

and doesn't have

Middleware
Any error handlings
Staticfile serving
Template
Flexible content type
Redirect
More, more, more..

Overview

This is implementing example.

from urllib.parse import parse_qs
from collections import defaultdict
import re
from wsgiref.simple_server import make_server


class App:
    handler_map = defaultdict(dict)

    def _register(self, method_name, path, handler):
        self.handler_map[fr'^{path}$'].update({method_name: handler})
        return self

    def get(self, path, handler):
        return self._register('get', path, handler)

    def post(self, path, handler):
        return self._register('post', path, handler)

    def _find_handler(self, path, method):
        for pattern, info in self.handler_map.items():
            matched = re.match(pattern, path)
            if matched:
                return info[method], matched.groupdict()

    def __call__(self, environment, start_response):
        method = environment['REQUEST_METHOD'].lower()
        path = environment['PATH_INFO']
        status = {
            'get': '200 OK',
            'post': '201 Created',
        }[method]
        start_response(status, headers=[('Content-Type', 'text/plain:charset=utf-8')])
        request_body = {
            'get': lambda: environment['QUERY_STRING'],
            'post': lambda: environment['wsgi.input'].read(int(environment.get('CONTENT_LENGTH', 0))).decode(),
        }[method]
        handler, path_params = self._find_handler(path, method)
        response = handler(parse_qs(request_body), **path_params)
        return [response.encode()]

    def start(self):
        with make_server('', 8088, self) as server:
            server.serve_forever()

Routing paths and mapping handlers are important things.

App memories routing paths and corresponding handlers in handler_map.

See _register.

    def _register(self, method_name, path, handler):
        self.handler_map[fr'^{path}$'].update({method_name: handler})
        return self

    def get(self, path, handler):
        return self._register('get', path, handler)

    def post(self, path, handler):
        return self._register('post', path, handler)

This is a just method wrapper against each http method.
So App retrieves the handler corresponding requested path.

I choice re module to detect path like Django etc.

Handling request is in __call__.

    def __call__(self, environment, start_response):
        method = environment['REQUEST_METHOD'].lower()
        path = environment['PATH_INFO']
        status = {
            'get': '200 OK',
            'post': '201 Created',
        }[method]
        start_response(status, headers=[('Content-Type', 'text/plain:charset=utf-8')])
        request_body = {
            'get': lambda: environment['QUERY_STRING'],
            'post': lambda: environment['wsgi.input'].read(int(environment.get('CONTENT_LENGTH', 0))).decode(),
        }[method]()
        handler, path_params = self._find_handler(path, method)
        response = handler(parse_qs(request_body), **path_params)
        return [response.encode()]

__call__ does just simple processes.

fetches an http method
fetches a request path
builds a request body corresponding the http method
fetches a handler
calls a handler

OK, now I get my own toy webframework! Try to run.

Start server.

$ python3 app.py

And request.

$ curl localhost:8088
$ curl localhost:8088/things
$ curl localhost:8088/things/a
$ curl -X POST -d 'x=X' localhost:8088/things

At last, I created tiny toy not productive webframework named tomoyo which is a little little more complex than above webframework.

Bye!

GOTO sentence in Python

mtwtkman — Sun, 29 Sep 2019 12:22:43 +0000

GOTO sentence is known as evil. I think so.

And Python has try ... except ... which works similar to GOTO sentence.

Suddenly I want to try to implement GOTO sentence like functionality in Python without using try ... except ....

Looks like below.

from functools import wraps
from contextlib import contextmanager


class AlreadyRegistered(Exception):
    ...


class UnknownLabel(Exception):
    ...


class GOTO:
    goto_funcs = {}
    current_label = None

    def __init__(self, name=None):
        self._name = name

    def jump(self, label: str):
        func = self.goto_funcs.get(label)
        if not func:
            raise UnknownLabel(label)
        self.current_label = label
        func()

    def __call__(self, label: str):
        def _inner(func):
            if label not in self.goto_funcs:
                self.goto_funcs[label] = func
            else:
                raise AlreadyRegistered(label)

            @wraps(func)
            def __inner(*args, **kwargs):
                return func(*args, **kwargs)
            return __inner
        return _inner

    def __str__(self):
        return f'{self.__class__}: {self._name}'


if __name__ == '__main__':
    goto = GOTO('mygoto')
    count = 0

    @goto('loop')
    def loop():
        global count
        print(f'current count = {count}')
        count += 1
        if count >= 2:
            return goto.jump('end')
        goto.jump('loop')


    @goto('end')
    def end():
        print('all done')


    loop()

This maybe very very limited and clearly very useless!

Bye.

DEV Community: mtwtkman

I made a small script as distrobox thin wrapper

TL;DR

Why and what for

Architecture

boxkit command

box command

configured distrobox manifest file

Conclusion

Rethink pattern matching in Ruby

Decide interface or usage

Implementing

Define errors, Testing etc

Conclusion

Shell script is such a powerful

Detail

Install

Standard install

Custom install

Configuration

Picture

Constructure

Conclusion

Haskell I/O Handler is my friend now

Piping in Python

Write a simplest audio player in browser.

Write a frontend application with Rust

Prerequests

Write Rust code

Build Rust code to wasm application

Write my frontend code

Run server

HOT RELOAD?

Build your webframework in Python

Write our application

Overview

GOTO sentence in Python

`boxkit` command

`box` command