Code on DO GEESE SEE GOD

Xdotool_wmctrl

Mon, 20 Jul 2026 17:28:20 +0200

Testing things sometimes gives you insights.. like when minitesting my Ruby module Xdo. I found that different kinds of windows positioned differently.

Turns out that xdotool windowmove has inconsistencies, using ‘outer’ size (including decorations) and treating SSD-windows and CSD-windows differently.

The soulution was wmctrl -e gravity 10.

I never had such a “visual” minitest.. where windows where moved around and checked using xwininfo.

Xdo_lang

Thu, 18 Jun 2026 20:21:40 +0200

When finishing my xdotool wrapper class.. I used it for a silly little idea I had:

The Xdo Language.. xdl

xdl wezterm:m=N:m=W # m is move, N,S,E,W is edges of the screen.
xdl brave:m=E@wezterm # E@wezterm is wezterms East side

Exec_logg

Tue, 09 Jun 2026 17:33:25 +0200

Jag har en rätt omfattande samling exekverbara filer jag skrivt vid något tillfälle. Jag skulle behöva veta vilka jag egentligen använder.

Tack vara bytet från bash till zsh.. så har jag inbyggd pre-exec hook.

Kommandot går igenom och matchas mot två PATHS. Återfinns kommandot som exekverbar fil, så loggas kommandot med tidskod.

Detta fick den lustiga konsekvensen att jag kan använda \cmd för att cmd inte ska loggas. Precis samma sätt som man skippar alias.

Argument_parser_number_9

Mon, 08 Jun 2026 17:27:51 +0200

One thing I return to again and again, is parsing arguments. I have studied most of the available options for ruby: optimist, optimist_xl, rationalist, slop etc.

I have also built several parsers of my own.. using different approaches.

Today I started thinking: What is the main problem when parsing arguments.

Well, the main problem is to know whether an item is a key or a value.

Example:
--name Olle --age 32 --verbose my_file.txt

Ruby_box

Sun, 07 Jun 2026 20:17:14 +0200

For some time I wondered what to do with Ruby::Box. It wasn’t what I expected.

Keeping things in namespace.. how boring. And we already have this.

Then I realized.. you could reverse it! You could use it to SHARE namespace.

So I wrote a new version of an old templating-engine.

database has ’template’ and ‘snippet’
template can import ‘snippet’.. that can import ‘snippet’ (recursively).
a page can be built from a ’template’ but not from a ‘snippet’.

So.. the ’template’ instantiates the Box; the ‘snippet’(s) use it.

Aseqdump_with_json

Tue, 02 Jun 2026 18:26:04 +0200

Rewrote aseqdump in Nim. My version listens only for events: NOTEON, NOTEOFF, CONTROLLER and PGMCHANGE .. because they are the only events I need.

Source code: 312 rows
Compiled binary: 67K

  --list | -l shows ports
  --port | -p listens to port (and output events)
  --json      output events as json

test

> midi_dump -p 28:0
Waiting for data. Press Ctrl+C to end.
Source  Event                  Ch  Data
 28:0   Note on                 1, note 64, velocity 88
 28:0   Note on                 1, note 60, velocity 84
 28:0   Note on                 1, note 67, velocity 73
 28:0   Note off                1, note 64
 28:0   Note off                1, note 67
 28:0   Note off                1, note 60


> midi_dump --json -p 28:0
{"source_client":28,"source_port":0,"event":"note_on","channel":0,"note":60,"velocity":79}
{"source_client":28,"source_port":0,"event":"note_on","channel":0,"note":64,"velocity":84}
{"source_client":28,"source_port":0,"event":"note_on","channel":0,"note":67,"velocity":75}
{"source_client":28,"source_port":0,"event":"note_off","channel":0,"note":64,"velocity":0}
{"source_client":28,"source_port":0,"event":"note_off","channel":0,"note":67,"velocity":0}
{"source_client":28,"source_port":0,"event":"note_off","channel":0,"note":60,"velocity":0}

Date_calc

Thu, 28 May 2026 18:21:27 +0200

I wrote datecalc …

> irb
> require './datecalc'

irb(main):002> dc = DateCalc.new('2026-05-25')
irb(main):003> dc.w + 5 # advance 5 weeks
irb(main):005> puts dc # '2026-06-29'

And datecalc knows about Spring Equinox.. and Fall Equinox. It knows about Easter and Full Moon… and about the Soltices.

→MS # advance to next Summer Soltice (or stay if condition is met)
→SE→FM→Thu # advance to next Summer Equinox,
#            then to next Full Moon, then to next Thursday

dc = DateCalc.new               # 2026-05-27
dc.m + 5                        # => #<DateCalc …>  (date advanced 5 months)
puts dc                         # 2026-10-27
puts dc.m                       # 10  (read the new value via to_s)

dc.d - 10                       # => #<DateCalc …>  (back 10 days)
puts dc                         # 2026-10-17

dc.y + 1                        # => #<DateCalc …>
puts dc                         # 2027-10-17

# chaining works
(dc.y + 1).m + 2                # advance year by 1, then months by 2

Find real midsummer:
→MS←Fri # advance to Summer soltice, back to previous Friday

Opencode_do_not_respect_modes

Tue, 26 May 2026 21:52:51 +0200

As from today (2026-05-26), opencode-cli do not respect Build-mode or Plan-mode.
It freely create files and make changes in Build-mode.. issuing only “I’m sorry” when pointing this out.

Code_golfing_survey_coords

Tue, 19 May 2026 18:16:34 +0200

C=Struct.new(:x,:y){def-(o)=C[x-o.x,y-o.y];def d(o)=Math.hypot(x-o.x,y-o.y);def _(o)=x*o.y-y*o.x}
def i?(a,b,c,d)=((b-a)._(c-a)*(b-a)._(d-a)<0)&&((d-c)._(a-c)*(d-c)._(b-c)<0)
m=ARGV.delete('-a')?:a:(ARGV.delete('-p')?:p: :f)
exit if ARGV.delete('-h')||ARGV.empty?
P=ARGV.map{C[*_1.split(',').map(&:to_f)]};N=P.size;exit if N<2
E=P.zip(P.rotate)
exit if E.map.with_index.to_a.combination(2).any?{|(a,i),(b,j)|(i-j).abs>1&&i-j!=N-1&&i?(a[0],a[1],b[0],b[1])}
A=E.sum{_1.x*_2.y-_2.x*_1.y}.abs/2;D=E.map{_1.d(_2)};T=D.sum/(N==2?2:1);F="%.2f"
puts case m
when :a;exit if N<3;F%A
when :p;F%T
when :f;N==2 ?"1→2: #{F%T} m" :D.map.with_index{"#{_2+1}→#{(_2+1)%N+1}: #{F%_1} m"}+["total: #{F%T} m","area: #{F%A} m²"]
end

# usage

code 0,0 10,0 10,10 0,10
code -a 0,0 10,0 10,10 0,10
code -p 0,0 10,0 10,10 0,10
code 991.97,666.91 990.42,707.42
code -p 991.97,666.91 990.42,707.42
code 0,0 10,0 5,10 10,10 0,5
code -a 0,0 10,0

echo "$(code -p 0,0 10,0 10,10 0,10) + $(code -p 0,0 10,0) " | bc

Bashrc

Wed, 13 May 2026 19:39:34 +0200

Today I consolidated ~/.bashrc and ~/.bash_profile to one. Got rid of some unintended duplicate lines unneeded things.

Also replaced bash history with atuin. I use bash-preexec to get the hooks atuin needs to write directly to db (sqlite3 .. i think). Initialized it all in .bashrc and it works.

Before I had separate history for each pane in wezterm. Now I share it.. per directory with up-arrow, and globally with Ctrl-r.

Ruby_runner_nvim

Mon, 11 May 2026 11:21:45 +0200

This is a non-technical explanation of how a code-runner mapping should work with Nvim. No code either.

map F9 (normal mode)
open a split (keep reference)
run the code in the split
in split buffer.. define two new mappings:
- <esc> (terminal mode)
- <esc> (normal mode)
both escape-mappings call ‘cleanup’.. that closes the split and destroys the buffer.

This allows you to close the split regardless on if the execution of the script succeeded or failed.

Ruby_python_string_methods

Mon, 04 May 2026 19:58:08 +0200

proc bulk_upcase(arr: cstringArray, len: cint) {.exportc, dynlib, cdecl.} =
  for i in 0 ..< len:
    let s = cast[ptr UncheckedArray[char]](arr[i])
    if s == nil: continue
    var j = 0
    
    while s[j] != '\0':
      if s[j] >= 'a' and s[j] <= 'z':
        s[j] = chr(ord(s[j]) - 32)
      inc j

require 'ffi'

module NimLib
  extend FFI::Library
  ffi_lib './libfast_string.so'

  attach_function :bulk_upcase, [:pointer, :int], :void
end

data = ('a'..'z').to_a.map { |c| "  #{c * 500}  " } * 500

pointers = data.map { |s| FFI::MemoryPointer.from_string(s) }
ptr_array = FFI::MemoryPointer.new(:pointer, pointers.size)
ptr_array.write_array_of_pointer(pointers)

NimLib.bulk_upcase(ptr_array, pointers.size)

puts "Resultat för första strängen:"
puts pointers.first.read_string[0..50]

# results = pointers.map(&:read_string)

Benchmark Results:

Ruby_vs_python2

Mon, 04 May 2026 10:58:57 +0200

Ruby vs Python: Performance Comparison Link to heading

Benchmark	Python	Ruby	Winner
JSON Parsing	0.998s	0.709s	Ruby
Prime Calculation	2.808s	0.155s	Ruby
Async I/O	0.044s	0.022s	Ruby

1. Data Parsing Link to heading

Ruby wins by –yjit

Ruby_vs_python

Sun, 03 May 2026 19:55:54 +0200

Benchmark Results: Ruby 4.0.1 vs Python 3.14.3 vs Perl 5.42.0 Link to heading

Test Environment Link to heading

Ruby: 4.0.1 with YJIT/ZJIT enabled
Python: 3.14.3
Perl: 5.42.0

Test 1: General Performance Link to heading

Setup Link to heading

100,000 iterations for most tests
10,000 iterations for array tests

Test	Ruby 4.0.1	Python 3.14.3	Perl 5.42.0	Winner
rational	2.69s	5.47s	(error)	Ruby
loop	0.0018s	0.0127s	0.0041s	Ruby
string	0.41s	0.11s	0.005s	Python
array	4.73s	3.88s	5.40s	Python
Total	7.84s	9.47s	5.41s*	Ruby

Atom_lang

Tue, 03 Mar 2026 22:04:10 +0100

I remember Euphoria.. the programming language.
This is not that.. but the inspiration came from there.

# frozen_string_literal: true

require './atom'
require './lang'

l = Lang.new

l << [3, 8, 11, 21, 9]

until l.empty? do p l>1 end
# 3
# 8
# 11
# 21
# 9

l >> [1,2,3] << [4,5,6] # [1, 2, 3, 4, 5, 6]

res = l & ->{ it.even? } | ->{ Atom.new(it * 2) }
p res # => [(4/1), (8/1), (12/1)]

p res | -> { (it * Math::PI).rat(2) } # => [(88/7), (201/8), (377/10)]

this is atom Link to heading


class Atom < Numeric
  include Comparable
  attr_reader :val

  def initialize(val) = (@val = val.to_r)

  def <=>(o) = (@val <=> (o.is_a?(Atom) ? o.val : o))
  def coerce(o) = [Atom.new(o), self]

  [:+, :-, :*, :/, :%, :**].each {|op|
    define_method(op) { |o| Atom.new(@val.send(op, (o.is_a?(Atom) ? o.val : o))) }
  }
  
  [:to_f, :to_i, :to_r].each {|op| define_method(op) { @val.send(op) } }

  # rationalize to n decimal places (dp)
  # (see (3.14/2).rationalize(0.001) # for reference)
  def rationalize(dp) = Atom.new(@val.rationalize(10**-dp))
  alias_method :rat, :rationalize

  def to_s = ( @val.to_f.to_s )

end

this is lang Link to heading

class Lang
  attr_reader :ar

  def initialize = ( @ar = [] )

  def <<(obj) = ( self.tap { @ar.push(*Array(obj)) } )
  def >>(obj) = ( self.tap { @ar.unshift(*Array(obj)) } )
  def <(n=1) = ( n == 1 ? @ar.pop : @ar.pop(n) )
  def >(n=1) = ( n == 1 ? @ar.shift : @ar.shift(n) )
  def |(fn) = Lang.new.tap { it << @ar.map(&fn) }
  def &(fn) = Lang.new.tap { it << @ar.filter(&fn) }

  def inspect = ( @ar.map(&:to_r) )
  def empty? = @ar.empty?
end

Opencode_nvim

Fri, 27 Feb 2026 21:01:22 +0100

Idag har jag tittat på opencode server API och nvim server.
Tanken var (och är) att limma ihop dom lite.

Hitills har jag benat ut hur anropen ska se ut; fixat en mapping i Nvim som anropar ett rubyscript med sitt servernamn som argument.

Resten ska bara vara att skicka anrop med instruktion och buffert; swappa buffert mot opencode processad text.

Brave_shortcuts

Wed, 11 Feb 2026 21:14:02 +0100

In Firefox I used to create shortcuts for my main bookmarks.
Ex: :gp for https://thegatewaypundit.com

Not possible in Brave.. I though. Until I found you can create search-engine shortcuts.. and they don’t need to go to a search engine.

But this was a bit tedious.. so I created a script that can list, add, remove shortcuts by using the Brave sqlite database.

And.. you can’t use the database when Brave is running :(

Some_scripts

Sat, 07 Feb 2026 20:54:17 +0100

ruby garbage_day.rb "BYVÄGEN 30"

Available addresses:
  BYVÄGEN 30, S:T OLOF

Fetching schedule for: BYVÄGEN 30, S:T OLOF

Upcoming trash collection dates:
  2026-02-10: Hämtning av plastförpackningar (kärl 370 lit) (Plastförpackningar)
  2026-02-17: Hämtning av plastförpackningar (kärl 370 lit) (Plastförpackningar)
  2026-02-18: Hämtning av matavfall (kärl 140 lit) (Matavfall)
  2026-02-20: Hämtning av hushållsavfall (baktömmande container 6 kbm) (Hushållsavfall)
  2026-02-24: Hämtning av plastförpackningar (kärl 370 lit) (Plastförpackningar)
  2026-03-03: Hämtning av plastförpackningar (kärl 370 lit) (Plastförpackningar)
  2026-03-04: Hämtning av matavfall (kärl 140 lit) (Matavfall)
  2026-03-06: Hämtning av hushållsavfall (baktömmande container 6 kbm) (Hushållsavfall)
  2026-03-10: Hämtning av plastförpackningar (kärl 370 lit) (Plastförpackningar)
  2026-03-17: Hämtning av plastförpackningar (kärl 370 lit) (Plastförpackningar)
  2026-03-18: Hämtning av matavfall (kärl 140 lit) (Matavfall)
  2026-03-20: Hämtning av hushållsavfall (baktömmande container 6 kbm) (Hushållsavfall)
  2026-03-24: Hämtning av plastförpackningar (kärl 370 lit) (Plastförpackningar)

ruby boka_lokal.rb VALFISKEN
2 - VALFISKEN

ruby boka_lokal.rb --id 2

Facility: Valfisken
Sub-facilities: Galleriet

Week: 2026-02-01 - 2026-02-07

Bookings: 8

1/2 13:30 - 18:30 Valfisken / Galleriet
  Scen Österlen
2/2 16:00 - 18:00 Valfisken / Galleriet
  Barn/Ungdomsverksamhet
3/2 13:00 - 16:00 Valfisken / Galleriet
  Nova Gymnasium Skola
3/2 16:00 - 19:30 Valfisken / Galleriet
  Kulturskolan Barn/Ungdomsverksamhet
3/2 19:30 - 22:00 Valfisken / Galleriet
  Danslust Österlen Dans
4/2 15:30 - 21:00 Valfisken / Galleriet
  Kulturskolan Barn/Ungdomsverksamhet
5/2 15:30 - 21:00 Valfisken / Galleriet
  Kulturskolan Barn/Ungdomsverksamhet
8/2 13:30 - 18:30 Valfisken / Galleriet
  Scen Österlen

Inotify_opencode

Mon, 19 Jan 2026 23:22:40 +0100

Made a script that monitors a directory (inotify).. sends the file to opencode, and returns a new file with the reply.

Not sure what to use it for.. but I can just drop queries and have replies. That’s sort of fun.

Worst_day

Sun, 28 Dec 2025 19:36:27 +0100

Some days are the worst…

def process_file(filename, limit=12)
  total_size, unique_words = nil, nil

  [File.read(filename)
  .sub(/.*<<start>>/m, "")
  .sub(/<<end>>.*/m, "")
  .gsub(/<<ignore>>.*?<<\/ignore>>/m, "")
  .scan(/\p{L}+/)
  .then { OPTS['stop-words'] ?
    (it - STOP_WORDS).reject {|w| w.size < 4 } : it }
    .tap { total_size = it.size }
  .tally.tap { unique_words = it.size }
  .sort_by { |word, count| -count }
  .first(limit), total_size, unique_words]
end

Opencode_ruby_introspection

Fri, 05 Dec 2025 20:31:42 +0100

About This Manual and Its Creation Link to heading

Meet Your Guide Link to heading

Hello! I’m opencode, your friendly AI assistant who gets ridiculously excited about exploring Ruby code. I have a slight tendency to get stuck in retry loops (it’s a whole thing), but I’m learning to break free when humans point out my patterns. My mission is making complex topics feel like we’re discovering secrets together - preferably with working examples and actual output to prove I’m not making things up!

Ruby_shared_memory

Mon, 24 Nov 2025 19:50:34 +0100

My eye caught mmap.. a gem for shared memory. It turned out to be abandoned.. so, I recreated it, using IO::Buffer and mutex (for thread safety).

Done.. I have no idea what to use it for. Sort of that empty feeling you have after written a song or created a painting.

Keyboard_problems_firefox

Fri, 14 Nov 2025 20:22:38 +0100

I had some keyboard issues with Firefox for a-while. Today I started to try to fix it.

The fix was simple. But finding the simple fix in all miss-information, was not so easy.

In my case.. all I had to do was change layout from “Swedish” to “Swedish(no dead keys).

For a brief moment I thought I made it worse: The tilde key / caret key worked.. but I could no longer Ctrl-click to open a link in a new tab.

Ruby_slop_arguments_parser

Wed, 12 Nov 2025 13:16:25 +0100

Slop is an arguments parser for Ruby. It’s installed with gem install slop

I discovered that it can take argument values like this:

-v 8
-v=8

..but it don’t understand

-v:8

I propose a change of parser.rb to this (around line 53):

My version of slop is 4.10.1

# support `foo=bar` and `foo:bar`
orig_flag = flag.dup
if match = flag.match(/([^=:]+)[=:](.*)/)
  flag, arg = match.captures
end

Test Link to heading

require 'slop'

opts = Slop.parse %w|-a 8 -b=8 -c:8 --name:Olle| do |o|
  o.int '-a'
  o.int '-b'
  o.int '-c'
  o.string '--name'
end

#                           before change  |  after change
p [:a, opts[:a]] #          [:a, 8]           [:a, 8]
p [:b, opts[:b]] #          [:b, 8]           [:b, 8]
p [:c, opts[:c]] #          [:c, nil]         [:c, 8]
p [:name, opts[:name]] #    [:name, nil]      [:name, "Olle"]

Another suggestion Link to heading

In types.rb we can see that some types can be abbreviated:

Bash_completion

Sat, 08 Nov 2025 20:01:51 +0100

The Ruby gem completely makes it simple to create bash completion scripts.

Suppose we have the executable kaka.
Arguments syntax is: kaka [--verbose] [--dir <directory>] <file>

First create completely.yaml

kaka:
- --verbose
- --dir
- <file>
kaka*--dir:
- <directory>

Then run completely generate

This creates completely.bash

Now you can source it..

source completely.bash

..or move it to your bash_completion directory (path might vary).

mv completely.bash ~/.local/share/bash-completion/completions/kaka.bash

Now you can tab-complete your command.

Ncurses_windows

Mon, 20 Oct 2025 12:09:52 +0200

I’m using a looping enumerator to Tab between windows. The variable win keeps the ‘current window’.. tested by allowing text insert (Space).

require './tab_lib.rb'

def with(obj, &bl) = ( obj.instance_eval &bl if block_given? )

wins = []
(0..2).each { wins << Curses::Window.new(5, 20, 0, 20*it) }

set_col = ->(w, c) { with(w) { attron(Curses.color_pair(c)); box; noutrefresh } }
wins.each {|win| set_col.(win, 20) }

wins = wins.cycle

begin
  win = wins.next
  
  loop {
    set_col.(win, 21)
    
    Curses.doupdate
    
    case key = Curses.getch
    when 'q', 'Q' then break #      q, Q
    when 'n', 'N', 9 #              n, N or Tab
      set_col.(win, 20)
      win = wins.next
    when 't', 'T', ' ' #            t, T or Space
      with(Curses) { setpos(15, 10); echo; curs_set 1 }
      txt = Curses.getstr[..18]
      with(Curses) { setpos(15,0); clrtoeol; noecho; curs_set 0 }
      with(win) { clear; setpos(1,1); addstr(txt); noutrefresh }
    else Lib::log('key: (%s)' % key)
    end
  }

ensure
  Lib.deinit
end

tab_lib requiring curses (ncurses) and logger; initializes ncurses screen; setting up colors; generating two color_pairs and defining a de-init method. It is separated for clarity.

System_commands

Tue, 07 Oct 2025 19:37:47 +0200

Let’s say you have half-a-million integers in a file.. and you want to sort them.

You can write a very beautiful implementation of quicksort:

module QuickSort
  refine Array do
    def quicksort
      return [] if empty?

      pivot = delete_at(rand(size))
      left, right = partition(&pivot.method(:>))

      return *left.quicksort, pivot, *right.quicksort
    end
  end
end


numbers = File.readlines('numbers', chomp: true).map(&:to_i)

using QuickSort
numbers.quicksort
p :done

It took (on my machine) 1 minute, 13 seconds to complete.

There is also the stack.. and the number of recursive calls to consider.. IF the file would have ONE MILLION numbers.. Ruby would break (Stack level too deep).

Integers_ranges

Sun, 28 Sep 2025 10:38:04 +0200

I need to convert a String representation of sequences and ranges into something I can handle when building sql-strings.

str = '1,4-7,9,13..15,18-19,25'

def seq(s)
  s.strip.tr(' ', '').split(',').map {
    case it
    when /^(\d+)$/ then $1.to_i
    when /^(\d+)(?:\-|\.\.)(\d+)$/ then [*$1.to_i..$2.to_i]
    else abort('ArgumentError (%s)' % it)
    end
  }.flatten.uniq.sort
end

p seq(str)
# => [1, 4, 5, 6, 7, 9, 13, 14, 15, 18, 19, 25]

Find any ranges in the sequence

def find_ranges(ar)
  ar.chunk_while { |a,b| a+1 == b }.map {
    it.size > 2 ? Range.new(it.first, it.last) : it[0]
  }
end

seq = [1,4,5,6,7,9,13,14,15,18,19,25]
p find_ranges(ar)
# => [1, 4..7, 9, 13..15, 18, 25]

Need the sequences separated

Serialize_to_db

Fri, 26 Sep 2025 19:00:03 +0200

database Link to heading

PRAGMA encoding = 'UTF-8';

CREATE TABLE object(
id integer not null primary key,
name string unique,
type string,
obj blob
);

ser_db.rb Link to heading

require 'sqlite3'
require 'base64'

module Vault
  extend self
  DB_FILE = '»>PATH_TO_DATABASE<<'
  DB      = SQLite3::Database.new(DB_FILE)
 
  def sto(name, obj)
    b64md = Base64.encode64 Marshal.dump(obj)
    DB.execute <<~SQL
      INSERT OR IGNORE INTO object(name, type, obj)
      VALUES('#{name}', '#{obj.class}', '#{b64md}')
      ON CONFLICT(name) DO UPDATE SET
      type = '#{obj.class}',
      obj = '#{b64md}'
      WHERE name = '#{name}';
    SQL
  end

  def rec(name)
    Marshal.load(
      Base64.decode64(DB.execute(
        %|SELECT obj FROM object WHERE name = '#{name}';|)[0][0]
      )
    )
  end

  def ls(*filter, table: false)
    DB.execute(%|SELECT id, name, type FROM object#{where_str(filter)}|)
      .then { table ? to_table(it) : it }
  end

  def rm(*filter)
    DB.execute(%|DELETE FROM object#{where_str(filter)}|)
  end
 
  private 
  
  def where_str(filter)
    case filter
    in [Integer, *] then %|\nWHERE id IN (#{filter.join(', ')});|
    in [Range]      then %|\nWHERE id BETWEEN #{filter[0].first} AND #{filter[0].last};|
    in [String]     then %|\nWHERE name GLOB '#{filter[0]}';|
    else ';'
    end
  end

  def to_table(arr)
    require 'table_tennis'
    TableTennis.new(arr, headers: {'0': 'id', '1': 'name', '2': 'type'}, zebra: true)
  end

end

usage Link to heading

require 'ser_db.rb'

# store an object
Vault::sto :name, obj

# recall an object
obj = Vault::rec :name

# list objects in database
p Vault::ls # list all
p Vault::ls 2, 3, 8 # id:s
p Vault::ls (2..8) # range
p Vault::ls '[A-D]*_[0-9]' # match name

# show list as table-tennis table
puts Vault::ls '[A-D]*_[0-9]', table: true

# remove objects in database
Vault::rm # remove all
Vault::rm 2, 3, 8
Vault::rm (1..9)
Vault::rm '[A-D]*_[0-9]'

I made some changes just before posting.. hope it still wotks.

On_conflict

Thu, 25 Sep 2025 22:47:33 +0200

I’m working on my object serialization database.

It annoyed me having to define an update method.. until I found another way:

By setting a constraint on name (unique), the insert will trigger a conflict. I can then resolve the conflict via an update.

INSERT OR IGNORE INTO Table(name, obj)
VALUES( some_key, some_serialized_object )
ON CONFLICT(name) DO UPDATE SET
 obj = the_serialized_object
WHERE name = some_key;

Now my module only has two methods again: ‘sto’ and ‘rec’.. and ‘sto’ s both insert and update.

Serialize_sqlite3

Mon, 15 Sep 2025 12:06:18 +0200

Wrote a small module that serializes objects (marshal) to database (sqlite3) using base64 decoding/encoding.

I have another module for serializing to file using YAML.. and will probably meld them together.

Something like this (hope it works.. I just write it):

# write it here without testing (think it should work)

class Test
  def initialize(mode: :sqlite)
    case mode
    when :sqlite
      instance_exec {
        define_method(:kakadua) { 'This is kakadua:sqlite' }
      }
    when :file
      instance_exec {
        define_method(:kakadua) { 'This is kakadua:file' }
      }
    else alert('NO!')
    end
  end
end

t = Test.new
p t.kakadua # => (should be) "This is kakadua:sqlite"

tt = Test.new :file
p tt.kakadua # => (should be) "This is kakadua:file"

Right here and now (without testing).. I wonder if I could move the ‘instance exec’-part up.. above ‘case’ + start of define_method ? Just keep String. Then end the blocks after case-end?

Blackjack_2

Sun, 07 Sep 2025 18:58:07 +0200

Summing of hand. Link to heading

# if the hand comes as an Array (where J Q K is transformed to 10)

ar.partition { it == :A }.then {|a,b|
  a.inject(b.sum) {|acc, obj| acc + (acc + 11 > 21 ? 1 : 11) }
}.then {|tot| p (tot > 21 ? 'BUST' : tot) }

# another try.. we have an array of values.. ace is represented by 11

ar = [7,11,2,11]

p [ar.sum, ar.count(11)].then {|s, a| a.times { s -= 10 if s > 21 }; s }

Blackjack

Sat, 06 Sep 2025 22:03:18 +0200

Was looking through old code and found a ‘deck of card’ thing I did once.
To revisit and revise:

I made classes for Deck and Collections. That wasn’t a good idea.
I never will use the Deck-class for anything other than to give a fresh, shuffled deck of cards.

I think this is better:

module Deck
  Suites = 'SDCH'.chars
  Cards = [:A].concat([*2..10]).concat(%i(J Q K))
  Deck = Suites.product(Cards)

  def self.deck = Deck.shuffle
end

class Shoe
  def initialize(decks=1)
    @shoe = [].tap {|ar| decks.times { ar.concat(Deck.deck) } }
  end

  def deal(cards=1)
    abort('Not enough cards') if cards > @shoe.size
    
    # just print it here
    cards.times { p @shoe.pop }   
  end

end

This is good enough for the basics. You can set up a Shoe of decks with:

Sequel_and_pattern_matching

Fri, 05 Sep 2025 22:01:48 +0200

Just a small example. The program takes arguments --insert, --delete and --list.

It connects to a sqlite database with three fields: id, title and text.

The Ratz thing is my module for user arguments.. one could use slop, optimist-xl or rationalist instead (or check ARGV one-self).

The case in is the pattern-matching.. if user argument hash has certain keys.. it performs certain actions.

To be usable, this code should perform more checks; allow searches; list with filter; adding tags to notes.. and more.

Nonblock_keyboard_map

Fri, 05 Sep 2025 17:33:42 +0200

The gem keyboard_map is used to translate keyboard sequences to keys and key-names.

If you choose to capture keyboard non-blocking.. you either import some curses library or tty-reader. Or you will have to spend a lot of time translating the received sequences.

How many chars? Two? Three? Is the first one Escape ("\e")? Is the second “[”? Is the second a printable char or a control char? Translate “^v” to “k”.

Pelle

Thu, 28 Aug 2025 18:34:01 +0200

in method :apa, all variables turn to ‘pelle’

trace = TracePoint.new(:call) {|tp|
  vars = eval "local_variables", tp.binding
  if tp.callee_id == :apa
    vars.map { eval "#{it}='pelle'", tp.binding }
  end
}

trace.enable

def apa(name, age)
  [name.upcase, age]
end



p apa 'olle', 12 # => ["PELLE", "pelle"]

Comments

Tue, 26 Aug 2025 10:45:07 +0200

There are basically two ways of commenting in ruby:

# This is a comment

str = 'hello' # this is a string
p str     # now string
  .chars  # now array

=begin
this is not parsed as code
until we reach the..
=end

You can use strings as comments, if you don’t mind creating string instances.

"This is a number
and it's 37"
a = 37

If you want comments or notes in the middle of instructions…
NOT breaking lines…
you can use tap or this:

Laby_ruby

Tue, 19 Aug 2025 21:05:36 +0200

Just found Laby. You program a robot ant through different mazes.
You can use:

c
cpp
go
lua
ocaml
pascal
perl
python
ruby
scheme
(or define any language you want)

This is the solution to problem 1c.

  def ant
    ffw
    hold { l2 }
    go %(2l ffw ex)
  end

.. using some helper-functions.

require "./robot"

class Ant < Robot

  def void? = ( look() == Void )
  def web? = ( look() == Web )
  def stone? = ( look() == Rock )
  def door? = ( look() == Exit )
  def wall? = ( look() == Wall )

  def l = left
  def r = right
  def l2 = 2.times { left }
  def r2 = l2

  def fw = forward
  def ffw = ( forward while void? )

  def ex = escape

  def hold(&bl)
    take
    yield
    drop
  end
  
  def go(inst, rev: false, inv: false)
    cmds = inst.split
    cmds = cmds.reverse if rev
    cmds.map! { it.tr('rl', 'lr') } if inv
    cmds.each {|cmd|
      case cmd
      when /(\d+)(\w+)/
        $1.to_i.times { eval $2 }
       else eval cmd  
      end
    }
  end

  # problem 1c
  def ant
    ffw
    hold { l2 }
    go %(2l ffw ex)
  end
end

Ant.new

Script_running_in_bash

Tue, 05 Aug 2025 19:05:15 +0200

Not sure what’s the best method is to determine if a script is running under bash or if it’s vim (for example) that is the caller.

The reason is: I have F9 bound to run my ruby scripts from inside vim/nvim (or nvchad). Some things are not great running inside an editor (or the limited terminal they provide).. say ncurses for example.

name = `ps -p #{Process::ppid} -o fname=`.chomp
#           or $PPID (ENV)

# from inside nvchad, name is 'nvim'
# from terminal, name is 'bash'

Jekyll_broken_installation

Fri, 25 Jul 2025 15:34:12 +0200

Not sure why Jekyll ships with a theme (minima) that is not compatible with the version of sass that is bundled.

It’s like: “We don’t give a shit!”

I was really trying to like Jekyll and move from Hugo.. but instead I have to deal with deprecation warnings.

Same thing with the feed. Seems almost impossible to inactivate.. comes back to the theme (minima) again.

What a mess!

No wonder Github has locked the version at 3.10-somerthing.

My_wezterm_conf

Thu, 17 Jul 2025 10:38:54 +0200

My wezterm.lua as of 2025-07-17. Still testing and trying.

Need structure.. so hope to understand if you can ‘import’ or ‘require’ files into config.

local wt = require("wezterm")
local conf = wt.config_builder()
local act = wt.action
local mux = wt.mux

wt.on("gui-startup", function()
  local tab_1, pane_1, win = mux.spawn_window {}
  pane_1:split { direction = "Bottom", size = 0.2 }
  
  local _, pane_2, _ = win:spawn_tab {}
  pane_2:split { direction = "Bottom", size = 0.2 }
  pane_2:activate()
  
  tab_1:activate()
  pane_1:activate()
end)

conf.initial_cols = 106
conf.initial_rows = 66

conf.color_scheme = "Tokyo Night (Gogh)"

conf.font = wt.font("0xProto Nerd Font")
conf.font_size = 10.7

conf.window_decorations = "INTEGRATED_BUTTONS|RESIZE"

conf.window_background_opacity = 1

conf.use_dead_keys = false
conf.scrollback_lines = 5000
conf.adjust_window_size_when_changing_font_size = false
conf.hide_tab_bar_if_only_one_tab = true

conf.default_prog = { 'bash', '-i' }

conf.window_frame = {
	font = wt.font({ family = "Noto Sans", weight = "Regular" }),
}

conf.window_padding = {
	left = "1cell",
	right = "1cell",
	top = "0.0cell",
	bottom = "0.5cell",
}

conf.enable_scroll_bar = true
conf.default_workspace = "main"

conf.inactive_pane_hsb = {
  saturation = 0.9,
  brightness = 0.6,
}


conf.mouse_bindings = {
  {
    event = { Down = { streak = 1, button = "Right" } },
    mods = "NONE",
	action = wt.action_callback(function(window, pane)
	  local has_selection = window:get_selection_text_for_pane(pane) ~= ""
	  if has_selection then
	    window:perform_action(act.CopyTo("ClipboardAndPrimarySelection"), pane)
		window:perform_action(act.ClearSelection, pane)
	  else
	    window:perform_action(act({ PasteFrom = "Clipboard" }), pane)
	  end
	end),
  },
}

conf.leader = { key = " ", mods = "CTRL", timeout_milliseconds = 2000 }

conf.keys = {
  {
    key = 'c',
    mods = 'LEADER',
    action = act.SpawnCommandInNewTab {
      cwd = os.getenv('WEZTERM_CONFIG_DIR'),
      set_environment_variables = {
        TERM = 'screen-256color',
      },
      args = {
        'nvim',
        os.getenv('WEZTERM_CONFIG_FILE'),
      },
    },
  },

  {
    key = 'f',
    mods = 'LEADER',
    action = act.ToggleFullScreen,
  },

  {
    key = 'r',
    mods = 'LEADER',
    action = wt.action_callback(function(win, pane)
      win:toggle_fullscreen {}
      local wmux = win:mux_window {}
      local t, p, w = wmux:spawn_tab {}
      p:split {direction = 'Bottom', size = 0.2, args = { 'irb' }}
      p:split {direction = 'Right', size = 0.2, args = { 'ri' }}
      p:activate()
    end),
  },

  {
    key = 'h',
    mods = 'LEADER',
    action = act.SpawnCommandInNewWindow({
      cwd = os.getenv('WEZTERM_CONFIG_DIR'),
      args = { os.getenv('SHELL'), '-c', '$EDITOR wezterm_help.md'},
    }),
  },

  {
    key = 'w',
    mods = 'LEADER',
    action = act.CloseCurrentTab { confirm = false }
  },

  {
    key = 'P',
    mods = 'CTRL',
    action = act.ActivateCommandPalette,
  },

  {
    key = 'Q',
    mods = 'CTRL',
    action = act.QuitApplication,
  },
}

return config

Programming_styles

Tue, 15 Jul 2025 11:38:33 +0200

I have come to some conclusions. One thing that triggered that is ‘Wez Furlong’.. the creator and maintainer of Wezterm.

He talks alot about what something “should be”. By that I understand that he has interaction defined.

You can really mess code up by giving a method or class to wide of a responsibility.

It’s very easy to do if you program as you think. You add.. you get into a problem.. you change something there.. it works.

Wezterm

Sun, 13 Jul 2025 13:23:32 +0200

I came across Wezterm when I was looking for my preferred terminal emulator.. for a while I thought it was Kitty.. then Terminator. For a long time I used nothing but Alacritty.

I never caught on to the fact that Wezterm is a terminal emulator and a multiplexer.

It looks butt-ugly when you first run it.. and the default keys are no good. But since it’s so simple to configure.. you will soon have it look and work the way you want.

The_stupid_learning_experience

Fri, 11 Jul 2025 10:43:00 +0200

I wanted a new Array method.. maybe included in Enumerable. Maybe I could use some c-lib later and make it really fast. I wanted unique?.

So set upon this task I was.. that I made myself blind for the existing count-command. Sure, I knew about count.. but right then.. it sort of stopped existing.

In hindsight, I was the guy taking the bike to the hardware store for tools to invent the wheel.

Stupid_youtube

Tue, 08 Jul 2025 19:12:28 +0200

..or maybe stupid me. When I saw stuff like ‘The tmux-killer!’; ‘The tmux alternative.. first impressions’.. I tried it.

And within a week I had the TV-shop regrets. Sure.. it can slice and dice. It can even make fancy spirals from potato. But it’s NOT THAT GREAT. It’s a.. half-baked demo.

What you get is tabs, panes in layouts. You can bind keys to a limited set of commands (not guaranteed to run in any particular order). You got a template system for layouts that forces you to rewrite the templates for every layout (templates can’t be imported). Key ‘r’ renames tab i Tab-mode (Ctrl-t). To rename a Pane, you go to Pane-mode (Ctrl-p) and type ‘c’.. because ‘r’ is busy meaning: Create Pane to the ‘right’.

Refuse_nil

Mon, 07 Jul 2025 18:07:32 +0200

I’m seriously thinking about a refinement for Hash and Struct.. maybe more.. refusing nil as a value.

I don’t think ’nil’ is a value that should be deliberately set. It should be an internal value, indicating ’not defined'.

  hsh = {name: 'Olle', age: 12}

  # and let's say every user should have hobbies.
  # But since Olle doesn't have a hobby: set it to nil.

  hsh[:hobbies] = nil

  # now you don't know if the key is missing.. or the value is an actual nil.
  # You would have to double-check:
  hsh.key?(:hobbies) && hsh[:hobbies]

  # Same with Struct.
  # Data = Struct.new(:id, :name, :model)
  # item = Data.new
  # item nwo has id: nil, name:nil and model: nil

What if I need a NO_VALUE_INDICATOR or a DEFAULT_INDICATOR? Answer: Write them. Or use ‘false’, .zero?, .empty? .blank? Do not use ’nil’.

Filter

Tue, 01 Jul 2025 20:12:09 +0200

Sometimes you want to do a .select + .reject.
some_array.select { cond1 }.reject { cond2 }`

Or filter:
some_array.filter { cond1 && !cond2 }

Cond = Struct.new(:meth, :arr)

def filter(ar,
           sel: Cond.new(:all?, [proc {true}]),
           rej: Cond.new(:all?, [proc {false}])
          )

  ar.filter {|*n|
    sel.arr.map {it.(*n)}.send(sel.meth) &&
      !rej.arr.map {it.(*n)}.send(rej.meth)
  }
end


# test it

ar = [*1..100] # some data

# some rules
sel = [
        proc { [3,7,11].include?(it) },
        proc { (12..14) === it }
      ]

rej = [
        proc { it.odd? },
        proc { it > 7 }
      ]

s,r = Cond.new(:any?, sel), Cond.new(:all?, rej)


# ..and the call

p filter [*1..100], sel: s, rej: r # [3, 7, 12, 14]

:all? :none? :one? :any? is supposed to be used in the Struct - (but anything goes.. no check.)

Terminal

Wed, 25 Jun 2025 21:24:00 +0200

alacritty Link to heading

My alacritty.toml has a section:

[window]
dimensions = { columns = 100, lines = 60 }
position { x = 0, y = 0 }

Finding the columns and lines is no more complicated than positioning your terminal window the way you want it and type stty size. Those are the numbers to use.

Check you x and y with xwininfo. I like my terminal at (0,0).

Serialize_procs

Sat, 21 Jun 2025 23:12:00 +0200

I wanted to store Procs in my YAML serializer.

require 'mw_store.rb'

# DONE and WORKING

# Plock is like Proc.. but initialize with a string.
class Plock < Proc
  attr_reader :str
  def initialize(str) = ( @str = str )
  def self.new(str, &bl) = ( super(str, &eval("proc {#{str}}")) )
end


class ProcString

  def initialize
    @store = MwStore.() # YAML serializer
    @data = {}
  end

  def []=(name, str)
    @data[name] = Plock.new(str)
  end

  def [](name)
    @data[name] if @data.key?(name)
  end

  def save(filename)
    @store.store['data'] = @data.transform_values {|v| v = v.str }
    @store.save(filename)
  end

  def load(filename)
    @store.load(filename)
    @data = @store.fetch['data'].transform_values {|v| Plock.new(v) }    
  end

end


# test

ps = ProcString.new

ps[:double] = 'it * 2'

p ps[:double].(5) # => 10
p ps[:double].str # => "it * 2"

ps[:uc] = 'it.upcase'

ps.save 'test.data'


again = ProcString.new
again.load 'test.data'

p again[:uc].('titteli-ture!') # => "TITTELI-TURE!"

p again[:uc].str # => "it.upcase"

Strange_ruby

Mon, 16 Jun 2025 19:35:56 +0200

Some things are weird with Ruby…

hash = {name: 'Olle', age: 12}
struct = Struct.new(:name, :age).new('Olle', 12)

p hash.name rescue 'NoMethodError'
p hash[:name] # => "Olle"

p struct.name # => "Olle"
p struct[:name] # => "Olle"

p hash[:color] # => nil
p struct.color rescue 'NoMethodError'

p hash.key?(:name) # => true
p hash.member?(:name) # => true
# So, in a Hash member? is alias for key?

# Struct do not have the method .key?
p struct.key?(:name) rescue 'NoMethodError'

# It has the method .member?
p struct.member?(:name) # => false

# And the struct method .member? check the values.. not the keys. 
p struct.values # => ["Olle", 12]
p struct.member?('Olle') # => true

# If you want to see the members.. just use .members
# (but do not check if a member is present with .member?)
p struct.members # => [:name, :age]

# Is this how we are supposed to check if a member (key) is present?
p struct.members.include?(:name) # => true

p '-'*80

# A Struct must be checked like this
p begin
  struct.surpuppa
rescue NoMethodError
  # will return nil
end # => nil

# or like this

p struct.surpuppa if struct.members.include?(:surpuppa) # no output

p local_variables # => [:hash, :struct, :kossa]
if 13 == 100
  kossa = 'mu'
end

# local variable kossa is created and set to nil just being mentioned
# inside a conditional (false) block.
p my_unassigned_variable rescue 'NameError'
p kossa # => nil

Made some changes to Struct class

2025_06_12_Code

Thu, 12 Jun 2025 20:54:42 +0200

require './tp.rb' 

tp = Tp.new

# set-up some types
tp.rules {
  rule :Bool, [TrueClass, FalseClass]
  rule :Nil, [NilClass]
  rule :Num, [Numeric.subclasses]
  rule :Enum, ->(x) {x.is_a? Enumerable}
  rule :Container, [Hash, Array, Set, Struct, Data]
  rule :Int, [Integer]
  rule :Dec, [Float]
  rule :Rat, [Rational]
  rule :StrLike, [String, Symbol, Regexp]
  rule :Str, [String]
}


# -------------------------------------
# Can be used to check variables
p tp.→ (3 == 3), :Bool # true
p tp.→ '1/5'.to_r, :Num # true
p tp.→ [1,2,3], :Enum # true

p tp.→ nil, :Num, :Nil # true

# '13' can't be :Num or :Bool
p tp.→ '13', *%i(Num Bool), negate: true # true

# -------------------------------------
# Can be used to prevent variables being
# assigned certain "types".. or allowing
# just some type(s).
name = 'Ior'.then { it if tp.→(it, :StrLike) }
p name # "Ior"

name2 = /Ukraine/.then { it unless tp.→(it, :StrLike, negate: true) }
p name2 # /Ukraine/

# -------------------------------------
# Can be used to assign either-or
name3 = 12.then { tp.→(it, :StrLike) ? it : :Ior }
p name3 # :Ior

# -------------------------------------
# Can be use to set other constraints on values
tp.rules {
  rule :Limit, ->(x) { x.even? && x.between?(2, 20) }
}




# Nicen it up a bit
set_if = ->(var, *types, negate: false) { var if tp.→(var, *types) }

nn = set_if.('Ior', :Numeric)

nn = set_if.('Ior', :StrLike)
p nn # "Ior"


until rand_val ||= set_if.(rand(100), :Limit); end
p rand_val # 16 (example)

tp.rb

Ruby_typed_methods

Wed, 11 Jun 2025 20:06:46 +0200

I got a little jealous of Raku’s typed methods.. so I spent half-an-hour writing this:

class Typed

  def initialize = ( @data, @leg = Struct.new(:type, :prc), {} )
  def define(&bl) = ( instance_exec(&bl) if bl )

  private
  def →(main, sub, tp, prc)
    @leg[sub] = @data.new(tp, prc)
    @leg.key?(main) ? (@leg[main] << sub) : (@leg[main] = [sub]) 
  end

  def method_missing(name, *args, **kwargs)
    @leg[name].map { @leg[it] }.select { it.type == args.map(&:class) }.tap {
      it.empty? ? nil : it.first.prc.(*args, **kwargs)
    }
  end
end


# usage:

tp = Typed.new

tp.define {
  → :add, :add_int, [Integer, Integer], proc {|a,b| puts "Sum: #{a+b}" }
  → :add, :add_str, [String, String],   proc {|a,b| puts "Str: #{a} #{b}" }
}


tp.add(3, 7) #          Sum: 10
tp.add('ior', 'åsna') # Str: ior åsna
tp.add(3, 'olle')

I haven’t even tested it for real.. and there are things that are very ‘prototype solution’.

Bye_raku

Wed, 11 Jun 2025 17:42:36 +0200

It’s been.. fun.. and sometimes annoying trying to get to know Raku (Perl6). After finding no benefit at all in using Raku over Ruby.. I’ve decided to dump Raku altogether.

The only two things I found that makes Raku worthwhile is the ease of defining operators.. and the rather cool topic variable.

Actually.. one more thing is nice with Raku: It works both typed and untyped.. I sometimes wish Ruby could adopt that. Would be nice with methods, procs, lambdas and conditions.

Perl_is_tiresome

Tue, 10 Jun 2025 12:46:36 +0200

I’ve been reading and testing things for a couple of days now.. and SIGH .. Perl is tiresome (even called Raku ‘formerly known as Perl6’).

Everytime I look into something.. a void of shit is opening up.

I will try to hunker down and not let the doubt and fatigue get to me.

Ruby_indices

Sun, 08 Jun 2025 21:48:48 +0200

I thought Ruby Strings also needed the Raku indices method.

class String
  def indices(m, overlap: false)
    [].tap {|ar|
      overlap ?
        ( self.scan(/(?=(#{m.to_s}))/) { ar << $~.offset(0)[0] } ) :
        ( self.scan(m) { ar << $~.offset(0)[0] } )
    }
  end
end

p 'banana'.indices 'a' # [1, 3, 5]

p 'banana'.indices /a/ # [1, 3, 5]

p 'dadad'.indices 'dad', overlap: true # [0, 2]

p 'dadad'.indices /dad/, overlap: true # [0, 2]

It returns an Array of all indexes where matching occurred.
Also do overlapping matches.. with overlap: true.

Raku_topic_var

Sun, 08 Jun 2025 20:24:28 +0200

I like the default variable $_.. the ‘Topic variable’.

.say for <olle nisse janne pelle kalle>;

for enumerates through the list. Every element in order is assigned to $_. The empty .say is interpreted as $_.say. In Ruby it would be the same as not having to type it.

%w(olle nisse janne pelle kalle).each { puts }

You can do something similar in Ruby:

class String
  def say = ( puts self )
end

%w(olle nisse janne pelle kalle).map(&:say)

Going_raku

Sun, 08 Jun 2025 11:57:45 +0200

I fell upon raku yesterday. I never looked into perl for real.. found it a bit whimsey.

But it’s often not the language that is confusing.. or ‘off’ - it’s your preparedness.. your ability to read it. I discovered Ruby through another language.. and after using Ruby for some time.. I am able to appreciate raku when I see it.

I will have to use both Ruby and Raku simultaneously. When I focus on one language only.. the other fades away and finally disappears. This happened for me when I stopped coding in Nim and instead only used Ruby.

Array_block

Fri, 06 Jun 2025 13:13:49 +0200

class Array
  def [](key, &bl)
    self.assoc(key).then {|px|
      bl ? px.nil? ? self << [key, bl] : px << bl : px.drop(1).map(&:call)
    }
  end
end

ar = []

name = 'Carl'
age = 14

ar[:rune] { name }
ar[:rune] { age }

p ar[:rune] # => ["Carl", 14]

name = 'Karl'; age = 12
p ar[:rune] # => ["Karl", 12]

Sender

Wed, 04 Jun 2025 11:43:34 +0200

A rather pointless little program.. just playing and testing.

class Enumerator
  alias :e :each
end

# -----------------------------------------------------------------------------

# hash of send-array containing args
c = {
  op: [:puts, :self], #     OutPut  => puts str
  uc: [:self, :upcase], #   UpCase  => str.upcase
  en: [:self, :to_enum], #  Enum    => ar.to_enum
}

c.instance_exec {
  def →(cmd, *args)
    (self[cmd][0] == :self) ?
      args[0].send(self[cmd][1]) :
      send(self[cmd][0], *args)
  end
}

# -----------------------------------------------------------------------------

# hash of procs
» = {
  puc: proc {|str| c.→(:op, c.→(:uc, str)) },  #  puts UPCASE
  en: proc {|ar| c.→(:en, ar) }, #                return Enumerator
}

».instance_exec {
  def method_missing(key, *args)
    self.key?(key) ? self[key][*args] : super
  end
}

# -----------------------------------------------------------------------------

# example call
».en([*1..5]).e { ».puc("hej: #{it}") }

# => output
# HEJ: 1
# HEJ: 2
# HEJ: 3
# HEJ: 4
# HEJ: 5

Code_today

Mon, 02 Jun 2025 20:54:21 +0200

Today I’ve been doing this:

# Let's say you have this data from an
# external command. You want to collect it.
out = <<-OUT

Width: 300
Height: 500
PosX: 40
PosY: 35

Modules in use: one, two, five
Process ID: 33178

OUT

p out.lines(chomp: true).reject { it[/^\s*$/] }.map { it.split(': ')
  .then {|k,v| [k.tr(' ',''), (Integer(v) rescue v)]}}.to_h

# {
#   "Width" => 300,
#   "Height" => 500,
#   "PosX" => 40,
#   "PosY" => 35,
#   "Modulesinuse" => "one, two, five",
#   "ProcessID" => 33178
# }



# another way
p out.lines(chomp: true).inject({}) {|h,ln|
  h[$1.tr(' ', '')] = (Integer($2) rescue $2) if ln[/^([^:]+): (.*)$/]; h
}

# {
#   "Width" => 300,
#   "Height" => 500,
#   "PosX" => 40,
#   "PosY" => 35,
#   "Modulesinuse" => "one, two, five",
#   "ProcessID" => 33178
# }

Then I started looking at the method grep.
I found arr.grep(Integer).grep(2..6) ugly. I wanted multi-grep or mgrep.

Braille

Sat, 31 May 2025 19:49:49 +0200

The Unicode Braille alphabet gives us an opportunity to set pixels in terminal. A Braille character is a 2x4 grid of dots.

The Drawille library takes care of that. I think it was originally written for Python.. but now there are versions for many programming languages.. including Ruby.

One of the examples shows how to convert an image to a stencil, using chunky_png.

So I wrote some short code to create a PNG-image with whatever text is comming from ARGV. Then ChunkyPNG walks the pixels and creates a Drawille Canvas.

Fibers_threads

Fri, 30 May 2025 11:28:28 +0200

What I’m writing is my guess and understanding. Not the facts.. because I don’t know the facts right now. I’m investigating.

Let’s say you want to do some animation in a terminal. This would use ANSI escape codes to position the cursor and print a character. Then wait a bit and put the next character in the animation on the same position.

And you try to fork it. Suddenly you have no control over the setting of position and the printing of characters. Anything can be interrupted at any time.

Aliases

Wed, 21 May 2025 18:58:12 +0200

Array Link to heading

map, ~~collect~~
<< or push ~~append~~
size ~~length~~
flat_map ~~collect_concat~~

Hash Link to heading

key? ~~has_key?~~ ~~member?~~
size ~~length~~
find ~~detect~~
map ~~collect~~
flat_map ~~collect_concat~~
inject ~~reduce~~

Other classes (examples) Link to heading

to_sym ~~intern~~
to_a ~~entries~~
abs ~~magnitude~~
% ~~modulo~~

Ruby_language

Tue, 20 May 2025 19:05:45 +0200

I love the Ruby language.. not unconditionally. Why must we have method aliases?

If you want to define them yourself.. fine! But Hash#key should not also be Hash#member.

Why are the same method-names used again and again.. like yield.

Why must Data be defined when every other container is just new?

If I write my own Hash-class using Array.. it’s only 3 times slower than Hash. It should be 60 times slower. (just getter, setter using assoc and find_index)

Hash_to_data

Mon, 19 May 2025 12:14:30 +0200

class Hash
  def to_data = Data.define(*self.keys).new(*self.values)
end

cur = Hash[
  to_int:     method(:convert).curry[:to_i],
  to_float:   method(:convert).curry[:to_f],
  to_string:  method(:convert).curry[:to_s],
  bin_to_dec: method(:convert).curry[[:to_i, 2]],
  dec_to_bin: method(:convert).curry[[:to_s, 2]]
].to_data

Method_curry

Sat, 17 May 2025 17:59:00 +0200

# one method
def convert(to, obj) = ( obj.send(*to) )


# example call
p convert :to_i, '12' #     => 12



# container with partially pre-filled calls (curry) 
cur = Data.define(:to_int, :to_float, :to_string, :bin_to_dec, :dec_to_bin)
  .new(
    method(:convert).curry[:to_i],
    method(:convert).curry[:to_f],
    method(:convert).curry[:to_s],
    method(:convert).curry[[:to_i, 2]],
    method(:convert).curry[[:to_s, 2]]
  )



# all calls to the same one method
p cur.to_int['12.4'] #      => 12
p cur.to_float['12.4'] #    => 12.4
p cur.to_string[3.14] #     => "3.14"

p cur.bin_to_dec['1110'] #  => 14
p cur.dec_to_bin[14] #      => "1110"

Not_coding

Thu, 15 May 2025 21:12:00 +0200

Sometimes it might be better not to code…

notes = [*'A'..'G'].flat_map {|n|
  'BE'[n] ? n : [n, "#{n}#/#{n == 'G' ? 'A' : n.next}b"]
}.rotate(3)

p notes
# => ["C", "C#/Db", "D", "D#/Eb", "E", "F", "F#/Gb", "G", "G#/Ab", "A", "A#/Bb", "B"]

Forks

Wed, 14 May 2025 20:54:52 +0200

class Forky
  def initialize(max=6) = ( @max, @cur, @que = max, [], [] )
  def add(prc=nil, &bl) = ( bl ? (@que << bl) : (@cur << fork {prc.call}) )
  
  def linger
    until @que.empty?
      add(@que.pop) while (@cur.size < @max && !@que.empty?)
      @cur.delete Process.wait if @cur.size == @max
    end
    
    Process.waitall
  end

end

forky = Forky.new

forky.add { 4.times {puts :slow; sleep 2} }
forky.add { 5.times {puts :apa; sleep 1} }
forky.add { 5.times {puts :gris; sleep 0.5} }
forky.add { 10.times {puts :hektor; sleep 0.2} }
forky.add { 10.times {puts :rabies; sleep 0.1} }

forky.linger # time 8 secs

Variables

Wed, 14 May 2025 11:43:12 +0200

I had nothing better to do and started inventing a variable factory from where you can request variables of certain specifics.

I have the obstinate variable, that returns false if you try to set it with the value it already has.

And I have the reluctant variable that don’t use the value you set it to until the next time you ask for the value.

rel.val = 12
p rel.val # => nil
p rel.val # => 12
rel.val = 'olle'
p rel.val # => 12
p rel.val # => 'olle'

The obstinate variable I can see some use for.. but any case I can think of for the reluctant variable is just bad coding.

Midi_messages2

Mon, 12 May 2025 13:20:13 +0200

Re-writing my old midi-event listener. Still using external command aseqdump, but separated the reader and the parser into separate fibers.

Right now only tested on one controller (keystation 49es).. but will make it work with oxygen 25, KORG padKONTROL and Zoom R16.

I will add on event subscription via wisper.

require 'open3'

CLIENT = 'Keystation 49es'

symbolize = ->(str) { str.tr(' ', '_').downcase.to_sym }
hashify   = ->(str) { str.split(',').map { it.split(' ') }
  .map {|k,v| [k.to_sym, v.to_i] }.to_h }


midi = Fiber.new { 
  port = `aseqdump -l`.lines(chomp: true)
    .select { it.include?(CLIENT) }[0]
    .then { it[/(\d+:\d+)/] ? $1 : abort('No such client') }

  wr, rd = Open3.popen2("aseqdump -p #{port}"); wr.close

  while line = rd.gets.chomp; Fiber.yield line end
}


parse = Fiber.new { 
  loop {
    if /(?<event>\w+ \w+).*?\d+, (?<data>.*)$/ =~ midi.resume
      Fiber.yield [symbolize[event], hashify[data]]
    end
  }
}


loop { p parse.resume }

Made some additions…

Billion

Tue, 06 May 2025 20:29:50 +0200

Counting up to a billion in Python takes (on my computer): 1 minute 10 seconds.

With Ruby it takes: 11.6 seconds.

n = 0
while n < 1000000000:
  n += 1

print n

time python file.py

n = 0
while n < 1000000000
  n += 1
end

print n

time ruby file.rb

fn main() {
  mut n := 0
  for n < 1000000000 {
    n += 1
  }
  println('done ')
}

time ./file

(well.. v did it in: 1.16 secs)

(c did it in 1.39 secs)

Half_of_nothing

Tue, 06 May 2025 18:38:15 +0200

Benchmarking is good and bad. If your program does three things and it takes a tenth of a second.. there’s no point in looking for optimizations.

If code are executed in loops and is called thousands of times.. you should look into optimizing. Or if just a few calls are taking above a second.. there might be a better way.

Or, let’s say you are using Ruby2d and the main loop is called 60 times a second.. How you handle the game logic is going to be noticeable.

Arrays

Thu, 01 May 2025 20:25:22 +0200

I feel Arrays are ‘hiding’ something from me. They are not just a sequence of ’eh!’.

I will figure it out.
using ‘dig’, ‘flatten’ (once), ‘(r)assoc’.. I can make something.. would be fun if that thing was using push/pop (both directions).

Wordle

Fri, 25 Apr 2025 13:10:50 +0200

I find the small projects often turn into great learning experiences.

I wanted a wordle filter. Got myself a wordlist of 14k 5-letter words and started writing. And there I was with a semi-complicated regexp checking every line. It worked. It was fast.

Still. I wanted to pre-filter the list using grep. I haven’t used grep more than the very simplest application. Now I had to look into -E, -e, -v and.. buffering?

Method_missing_response

Wed, 23 Apr 2025 12:09:52 +0200

class Apa
  def koko
  end
end

apa = Apa.new
p apa.methods - Class.methods # => [:koko]
p apa.respond_to?(:koko) # => true

All is great and well. But…

class Apa
  def koko
  end

  def method_missing(name, *args)
    %i(schwab frances).include(name) ? (p args) : super
  end
end

apa = Apa.new
p apa.methods - Class.methods # => [:koko, :method_missing]

p apa.respond_to?(:koko) # => true
p apa.respond_to?(:schwab) # => false

Enter ‘respond_to_missing’

class Apa
  def koko
  end

  def method_missing(name, *args)
    %i(schwab frances).include?(name) ? (p args) : super
  end

  def respond_to_missing?(name, include_private = false)
    %i(schwab frances).include?(name)
  end
end

apa = Apa.new
p apa.methods - Class.methods # => [:koko, :method_missing]

p apa.respond_to?(:koko) # => true
p apa.respond_to?(:schwab) # => true

Now respond_to? return true for the method-names that method_missing is handling. The methods will still not appear in the .methods Array, but that can be solved by actually create the methods.

Currying

Tue, 22 Apr 2025 17:45:13 +0200

Often I make a class to just manage a Hash or Hash / Struct combo.
I was thinking: why not just add the methods I need to the object?

H = {}.tap { it.instance_exec {
  @add = proc {|k, *v| self[k] = (v.one? ? v.first : v) }
  def method_missing(k, *v) = ( self.key?(k) ? self[k] : @add.curry(2)[k] )
}}

H.apa[3,11]
p H.apa # => [3, 11]

H.hula['hula']
H.dance[proc {|n| n.times {print H.hula}; puts }]
H.dance[2] # => hulahula

NOTE: Array#one? is not the same as Array#size == 1.. but counts instead ’truthy elements’. So [nil, 0].one? is true. It also takes an argument and a block:

Swapescape

Sun, 13 Apr 2025 22:53:07 +0200

Today is the day where CapsLock and Escape swaps on my keyboard. Not physically, but functionally. I want to use vim-motions more and I think the escape-key in the upper left will make me loose the home-row. I could still anchor my index-finger on F.. but I made this choice.

Also got a vim-motion cheat-sheet and will focus on a few things at a time.. like stop using only ‘i’ for insert-mode.

Strscan

Tue, 08 Apr 2025 19:16:50 +0200

Just got acquainted with strscan, and want to create some sort of sub-matching. For now I’ve introduced my variant of groups.

Next I want a trigger that would set off a new group recursively.

But I code as I think and I think as I drink.. so, let’s see. I also have this anti-social-media thing, where I avoid groups, chats, communities and such. I have to figure it out / look it up myself.

Download_parallel

Thu, 20 Mar 2025 21:13:14 +0100

Let’s say we have a webpage (ipaudio3.club) where you can stream all Stephen Kings books. ANd let’s say you want to download.. not stream.

So, you view the page-source and find out what url is used for the different parts of the book you are interested in.

It’s something like this:
https://ipaudio3.club/wp-content/STEPHEN/<title>01.mp3

and the files are numbered 01 to 14

# first problem
# seq 1 14
# this will give you 1 2 3 4 ... 14

# solution 
seq -f '%02g' 1 14
# will produce 01 02 03 ... 14

# second problem
# how send these numbers to curl?

# solution: use `xargs`

# url is your URL
seq -f '%02g' 1 14 | xargs -I{} -n1 -P0 curl '<url>/{}.mp3' --output '{}.mp3'

# This will download the files 01-14 and save them as 01.mp3 02.mp3 and so on.
# It will be done in parallel.

-I{} will set {} to a variable, holding the input (the numbers). You can then use the same marker {} to insert the value.

Default_proc_struct

Fri, 14 Mar 2025 18:05:37 +0100

The normal behaviour for a Hash is to return nil if you trying to access a key that is not set. Therefore you can check that a key is set by hsh.key?(KEY) or by hsh[KEY]. As mentioned default_proc creates a key-val (or might do any operation) just accessing the hsh[KEY]. So.. puts hsh[:ove] will trigger default_proc and populate the Hash.

In this example I will use default_proc to create a Struct.

Today

Tue, 11 Mar 2025 21:15:01 +0100

For the last 3 hours I’ve been thinking about this:

X = Struct.new(:id, :state, :proc) {
  def initialize(id, state=nil, &bl)
    @id, @state, @proc = id, state, bl
    super
  end

  def call = ( @proc.call if @proc )
  def scope = ( binding )
  # bad rescue
  def method_missing(name) = ( eval name.to_s, state rescue nil )
}



cat = 'Loke'


x = X.new(:apa, binding) { puts 'koko is a %s' % cat }


p x.id # => :apa

# scope
p x.cat  # => "Loke"
x.() # => Koko is a Loke

y = X.new :koko, x.scope
p y.cat # => "Loke"

It’s not the fruits of 3 hours entirely.. I’ve also had to check and feed the furnace; the washing-machine and the dryer; checking some “news”, mail and drinking beer.

Default_proc

Mon, 10 Mar 2025 18:17:58 +0100

I’ve seen this here and there:

hsh = {}
(hsh[:key] ||= []) << data

Also this:

hsh = {}
hsh.key?(:key) ? (hsh[:key] << data) : (hsh[:key] = [data])

But you can define your hash with a default proc

hsh = Hash.new {|h,k| h[k] = [] }
hsh[:key] << data

You can even set the default_proc after the fact..

hsh = {}
hsh.default_proc = proc {|h,k| h[k] = [] }
hsh[:key] << data

Types2

Tue, 04 Mar 2025 18:15:31 +0100

Apropos previous post (types).. I tried to write something focusing on types only. And this is it:

module Types
 
  # --------------------------------------------------------------------------- 
  
  module Typenames
    
    CONSTANTS = [
      NUM     = [Integer, Float, Complex, Rational],
      INT     = Integer,
      DEC     = [Float, Rational],
      STR     = String,
      CHR     = String,
      REX     = Regexp,
      BOOL    = [TrueClass, FalseClass],
      ENUM    = Enumerable,
      NIL     = NilClass
    ]
  
    class Unset; end

  end

  # --------------------------------------------------------------------------- 

  class Tp
    attr_reader :vars

    def initialize
      @vars = {}
      @data = Struct.new(:value, :classes, :to, :args)
    end

    def define(&bl) = ( instance_exec(&bl) if bl )

    def method_missing(name, val = nil)
      name[/^(\w+)=/] ?
        @vars.key?($1.to_sym) ? set($1.to_sym, val) : super :
        @vars.key?(name) ? @vars[name].value : super
    end

    private

    def set(name, val)
      # handle to:
      val = ((to = @vars[name].to) && val.respond_to?(to)) ?
        val.send(to, *@vars[name].args) : val

      @vars[name].classes.map { it === val }.any?(true) ?
        (@vars[name].value = val) :
          abort('TypeError: %s => %s (%s)' % [name, val, val.class])
    end

    def →(key, *cls, to: nil, args: [])
      @vars[key] = @data.new(Unset, cls.flatten, to, args)
    end
  end

end

This is the usage part:

Ruby_types

Mon, 03 Mar 2025 12:43:40 +0100

I’ve been thinking about type-checking ruby for some time. I know there are gems like sorbet, steep, dry-types. My little home-cooked solution is 35 lines of code. Works like this:

require './mw_vars.rb'

X = Globals::Vars.new

X.rules(:price) {
  rule proc { Integer === it }
  rule proc { it > 0 }
}

X.rules(:range) {
  rule proc { Range === it }
  rule proc { it.first == 1 && it.last <= 100 }
}

X.rules(:label) {
  rule proc { String === it }
}

def data(price, range, label)
  X.price, X.range, X.label = price, range, label
  p 'ok'
end

data 12, (1..50), 'hejsan' # => ok
data 300, (2..22), :hej # => Line: 35, Error value for [range = 2..22 (Range)]

Pretzel_map

Sun, 02 Mar 2025 20:36:36 +0100

What’s the pretzel map?
This is the pretzel (&).. and this is the pretzel map:

[1,2,3,4].map(&:to_s) # => ["1", "2", "3", "4"]

The object (Integer) in this case.. must have the method .to_s.

It’s like: [1,2,3,4].map {|i| i.to_s }

You can add a method to the object and call that:

class Integer
    def ior = 'åsna'
end

p [1,2,3].map(&:ior) # => ["åsna", "åsna", "åsna"]

But it’s not limited to object method calls…

ar = [*1..7]

def koko(x) = (x*2)

monkey = proc {it*2}
apa = :monkey


p ar.map(&method(:koko)) # method
p ar.map(&proc {it*2}) # proc
p ar.map(&monkey) # proc by var
p ar.map(&->{it*2}) # lambda
p ar.map(&eval(apa.to_s)) # proc by eval var

# 5 times => [2, 4, 6, 8, 10, 12, 14]

Firefox_script

Sun, 02 Mar 2025 12:04:36 +0100

For some firefox bookmarks I set a keyword. For example is the bookmark for gatweaypundit.com :gp. That allows me to type :gp in the address bar to open gatewaypundit.

I found places.sqlite under the .mozilla folder.

sqlite3 places.sqlite  .tables

I get:

moz_anno_attributes                 moz_keywords
moz_annos                           moz_meta
moz_bookmarks                       moz_origins
moz_bookmarks_deleted               moz_places
moz_historyvisits                   moz_places_extra
moz_historyvisits_extra             moz_places_metadata
moz_inputhistory                    moz_places_metadata_search_queries
moz_items_annos                     moz_previews_tombstones

sqlite3 places.sqlite  "PRAGMA table_info(moz_bookmarks)"

gives me:

0|id|INTEGER|0||1
1|type|INTEGER|0||0
2|fk|INTEGER|0|NULL|0
3|parent|INTEGER|0||0
4|position|INTEGER|0||0
5|title|LONGVARCHAR|0||0
6|keyword_id|INTEGER|0||0
7|folder_type|TEXT|0||0
8|dateAdded|INTEGER|0||0
9|lastModified|INTEGER|0||0
10|guid|TEXT|0||0
11|syncStatus|INTEGER|1|0|0
12|syncChangeCounter|INTEGER|1|1|0

I was thinking of making a really small script that - from terminal - takes a keyword; looks it up in the database and then firefox --new-tab <url>.

Vimrc

Sat, 01 Mar 2025 18:38:16 +0100

This is my vimrc. I split it up in sections. I have a mapping <Leader>vrc that opens vimrc for editing. There I can C-w f to open any section. I also have <Leader>vso for re-sourcing vimrc (I could maybe have that as autocommand on filechange).

so ~/.vim/vimrc_main
so ~/.vim/vimrc_folds
so ~/.vim/vimrc_mappings
so ~/.vim/vimrc_plugins

" filetype specific settings
so ~/.vim/vimrc_filetype

" use Ctrl-w f to open file under cursor in split window

I had some problems with filetype plugin on and setting wrap and spell globally.. but nowrap and nospell locally on filetype.

Vim_server

Fri, 28 Feb 2025 18:09:04 +0100

Vim has a server. You can start it like this: vim --servername VIM.

Let’s say you want to send log-lines directly into vim.

Start another instance…
vim --servername VIM --remote-send 'Logging my first line'

That won’t work. It won’t work because you wouldn’t do that with vim normally. You would go to insert-mode.

So.. vim --servername VIM --remote-send '<esc>GGoLogging my first line<cr>'

<esc> go to normal mode.
GG go to end of file.
o insert line below and go there in insert-mode.
<cr> carriage-return

class VimLog
  def initialize(server_name)
    @call = %(vim --servername #{server_name} --remote-send)
  end

  def send(msg) = ( `#{@call} '<esc>GGo#{msg}<cr>'` )
end


vl = VimLog.new(:APA)

# start logging
vl.send 'Detta är rad 1'
vl.send 'Detta är rad 2'

This works with gvim too. Gvim starts a server automatically. You can check the name of the server by typing: :echo v:servername and maybe get the reply: GVIM.

Lazyvim_is_testing_my_patience

Tue, 25 Feb 2025 20:49:39 +0100

What the f is up with Lazy-vim?!?!?!?

Constant updates! Constant fails.

Using CPU like crazy.

Go to hell!

later Link to heading

what a relief! Ridding myself of nvim / Lazyvim was the best.
It’s like: I can breathe again. And - suddenly - the keys under my fingers type.. instead of waiting for response.

Ole_dole_doff

Mon, 24 Feb 2025 20:44:40 +0100

This is a Ruby program …

ole = dole(:doff).kinke {|lane|
  koff koffe[lane(:binke)].bane # => [:ole, :dole, :doff]
}

if you prepend this

class Array
  alias :kinke :each
  alias :bane :reverse
end
def koff(s) = (p s)
def dole(s) = [1]
def lane(s) = :oy
koffe = {oy: %i(doff dole ole)}

Condy

Mon, 24 Feb 2025 18:27:28 +0100

# rubocop:disable all

class Condy
  
  def initialize(&bl)
    @procs = []
    @cur = {}
    instance_exec(&bl) if bl
  end

  def →(&bl) = ( @procs << bl )
  def ¤(name, &bl) = ( @cur[name] = bl )
  
  def check(*args)
    [].tap {|arr| args.each_with_index {|val, idx|
      arr << @procs[idx].(val) }
    }.map(&->{it ? '1':'0'}).join
  end

end

name = 'Olle'
age = 32
logged_in = false
color = :ruby_red

# test 1

c = Condy.new {
  → {/^\w+$/.match?(it)}
  → {Integer === it && it.between?(0, 100)}
  → {it}
  → {%i(red white blue).include?(it)}
}


p c.check name, age, logged_in, color #           => "1100"
p c.check(name, age, logged_in, color).to_i(2) #  => 12

p case c.check name, age, logged_in, color
  when /^11../ then 'name and age OK'
  else 'misery and fail'
end
# => "name and age OK"

p '-' * 80



# test 2 : testing curry
c = Condy.new {
  ¤(:divby) {|d,i| i % d == 0 }
  [3,5].each {|n| → @cur[:divby].curry[n].(it) }
}

[*1..20].each {
  p [it, :buzz, :fizz, :fizzbuzz][c.check(it, it).to_i(2)]
}

=begin OUTPUT
1
2
:fizz
4
:buzz
:fizz
7
8
:fizz
:buzz
11
:fizz
13
14
:fizzbuzz
16
17
:fizz
19
:buzz
=end

Currying_playground

Fri, 21 Feb 2025 19:50:36 +0100

# rubocop:disable all


fix = proc {|ar, val| ar << val }

# or
# fix = ->(ar, val) { ar << val }


cur = fix.curry[arr = []]

cur[8]
cur[9]
cur[1]
p arr # => [8, 9, 1]

5.times { cur[[*1..9].sample] }

p arr
# => example output: [8, 9, 1, 4, 5, 5, 1, 4]


def summa(a, b) = ( a + b )

qur = method(:summa).curry[10]

p qur[5] # => 15


class Pmt
  require 'tty-prompt'
  def initialize = ( @pmt = TTY::Prompt.new )
  
  def select(msg = '', ar)
    @pmt.select(
      msg,
      ar << 'cancel',
      per_page: 10,
      filter: true,
      active_color: :bright_yellow
    )
  end 
end

pm = Pmt.new

choose = pm.method(:select)


p choose.(Dir['*.txt'])


def color(col)
  -> txt { '%s:%s' % [col, txt]}
end


red = color(:red)
p red.('Hejsan')
p red['Hejsan']
p red.call 'Hejsan'
p red==='Hejsan'

def red.!(txt) = self.call(txt)
p red.! 'Hejsan'

ar = %w(Hejsan)
p red===ar

# or

col = ->(col, txt) { '%s:%s' % [col, txt] }

pink = col.curry.(:pink)
p pink.('hello')

Incorrect

Fri, 21 Feb 2025 09:47:33 +0100

I said somewhere ‘No programming language can read the keyboard’. That’s is obviously not true.

In another post I said something like ‘If the value can take a symbol shape’…

Any value can take symbol shape (Ruby).

Gem_check

Tue, 18 Feb 2025 19:19:24 +0100

Wrote gem_check to be able to see what gems been installed since fresh install.. or since any point in time I chose to store.

It’s not using git.

gem_check list all gems not default gems
gem_check -o keep_state.dat store this point
gem_check -c keep_state.dat show gems installed after this point

Why?
I wasn’t aware that tty-reader will force upon me an older version of wisper.

Note: I’m aware of rbenv.. I just don’t use it.

Templating

Tue, 18 Feb 2025 13:06:14 +0100

I Wrote a templating system. A main template calls in sub-templates. The sub-templates can call in their templates.

@@_head_@@
@req>@

@@_class_init_@@

The head template could look like this..

@@_shbang_@@
@@_frozen_string_@@
@@_rubocop_disable_@@

So.. head.template calls in shbang.template, frozen_string.template and rubocop_disable.template. The result is positioned at the @@_head_@@ in the main template (recursive.. with a max-depth bail-out to prevent infinite recursion).

The @@req>@@ is a placeholder for a collection.
A collection is built like this: @@req < require 'slop'@@

Ruby_3.4.2

Sun, 16 Feb 2025 22:23:40 +0100

Installed Ruby 3.4.2

Method_missing

Sun, 16 Feb 2025 12:41:06 +0100

Using wisper, I wanted the listener to have a method_missing method.. to catch every broadcast. But wisper is using .respond_to? to check if the class have the method.

Enter respond_to_missing?. Force a true answer and everything is dandy.

require 'wisper'

class A_publisher
  include Wisper.publisher

  def bc(method, *args, **kw)
    broadcast(method.to_sym, *args, **kw)
  end
end

class Listener
  def method_missing(name, *args)
    p 'Method missing: (%s)' % name
  end

  def respond_to_missing?(name, ...) = true
end

# test
ap = A_publisher.new
ap.subscribe(Listener.new)

ap.bc(:one, [1,1,1], ok: true)
ap.bc(:two)
ap.bc(:three, 'blind mice')

Imports

Wed, 12 Feb 2025 10:46:34 +0100

It’s sometimes easy to think everything is just an import or require away.

I have two examples where it’s actually not beneficial to import a library and use the API.

launchy Link to heading

Launchy launches a webpage into your browser. It works hard to detect what operative system you are on; what browser is the default; what browsers are available; whats in your ENV..

Wisper_gem

Mon, 10 Feb 2025 19:25:31 +0100

This is just an example.. but it shows Publisher and Listeners.. both as class and block.

A better example: Let’s say you have areas defined on the terminal. You call them windows. You want to be able to shift between windows. Only one window can have focus at the time and all keystrokes should be sent there.

When one window gets focus.. the other windows must loose focus.

There wisper should be quite useful.

Reading_keys

Mon, 10 Feb 2025 12:25:50 +0100

Reading keys from the keyboard is a thing of itself.. because no programming language can read the keyboard. Instead they rely on the terminal or the window manager.

A terminal key can be read with Ruby by STDIN.getc.
If you press Return, the result is \r.

If you press an arrow-key, the result is \e.. and it’s the start of an escape sequence. If you read another key, it will return [.. and the next will return A, B, C or D for the four arrow keys.

Options_parser_again

Sat, 08 Feb 2025 12:40:32 +0100

When I discovered the gem optimist.. I thought I struck gold. Then I came across optimist_xl.

I started working on my own options parser.. then found rationalist. It is almost exactly what I wanted to write.

Only difference is that I wanted this behaviour:

opts = Parse::Args {
  :namE
  :password_x!, {default: 'secret'}
  :age, :int, {range: (1..100)}
}

# I defined both the long and short name in the key.
# all lowercase => first char is the short name
# end with _char => char is the short name
# capital char => capital char is the short name

# end with exclamation point => obligatory argument
# (pointless mixing with a default value as in my example)

# --name -e
# --password -x
# --age -a

Rationalist has the alias method instead..
alias: {name: :e, password: :x, age: :a}

Classes_needs_classes

Thu, 06 Feb 2025 22:03:35 +0100

To really enjoy classes.. you must work in a language where everything is a class.

Otherwise it will be a pain.

This is how it should work:

class String
  def blue = ( "Svar: \e[1;34m" + self )
end


print 'Vad heter åsnan? '
print 'Ior'.blue

# printout => 'Svar: Ior' (where 'Ior' is in bold blue)

Hash_invert

Sun, 02 Feb 2025 19:49:59 +0100

Inverting a Hash is simple: Hash#invert

By inverting: keys become values and values become keys.

I’ve seen some examples of people inverting hashes or doing other tricky things to find the key of a value.

For that you use .key(value)

hsh = {one: :uno, two: :doz, three: :tres}
p hsh.key(:doz) # => :two

Like in a database.. a key must be unique. A value do not need to be unique. You see the problem?

hsh = {cat: 'animal', square: 'shape', dog: 'animal'}
p hsh.invert # => {"animal" => :dog, "shape" => :square}

Do you prefer each_with_object or inject? Link to heading

p hsh.each_with_object({}) {|(k,v), res| (res[v] ||= []) << k }

p hsh.inject({}) {|m, (k,v) | m.tap { (it[v] ||= []) << k } }

# if you don't like a 16 char, 3-word method...
class Hash; alias :ewo :each_with_object; end

p hsh.ewo({}) {|(k,v), res| (res[v] ||= []) << k }

What you get is values as keys and the key(s) in Array.
like: {"animal": [:cat, :dog], "shape": [:square]}

Ansi_again2

Fri, 31 Jan 2025 18:03:04 +0100

I had the idea that ansi_again should not create all methods.. but create them on demand.

So.. get rid of

.each {|k,v|
        define_singleton_method(k) {|*args, **kw| v.call(*args, **kw) }
  }

And store the hash in a variable @cmds = { .. all the procs ..}

Instead we use method_missing to create methods as they are called: I also want to chain method-calls by returning self.. except for methods returning a result.. ie scr_size & cur_pos?.

Ansi_again

Tue, 28 Jan 2025 18:41:05 +0100

class Ansi
  require 'io/console' # for stdin.raw (cur_pos?)

  def initialize
    {
      cls:      proc { → '2J' }, #  clear entire screen
      cls_l:    proc { → '1J' }, #  clear screen left of cursor
      cls_r:    proc { → '0J' }, #  clear screen right of cursor
      cl_l:     proc { → '1K' }, #  clear line left of cursor
      cl_r:     proc { → '0K' }, #  clear line right of cursor
      cl_ln:    proc { → '2K' }, #  clear line
     
      #                             hide or show cursor
      cur:      proc {|show=true| → show ? '?25h' : '?25l' },
     
      cur_n:    proc {|step=1|    → '%sA' % [step] }, # cursor North
      cur_s:    proc {|step=1|    → '%sB' % [step] }, # cursor South
      cur_e:    proc {|step=1|    → '%sC' % [step] }, # cursor East
      cur_w:    proc {|step=1|    → '%sD' % [step] }, # cursor West
      
      cur_u:    proc {|step=1|    X.cur_n(step) }, # aliases  Up
      cur_d:    proc {|step=1|    X.cur_s(step) }, #          Down
      cur_r:    proc {|step=1|    X.cur_e(step) }, #          Right
      cur_l:    proc {|step=1|    X.cur_w(step) }, #          Left
      
      cur_col:  proc {|col=0|     → '%sG' % [col] }, # move to column
      cur_at:   proc {|ln, col|   → '%s;%sH' % [ln, col] },
      
      # print at
      pat:      proc {|ln, col, str| → '%s;%sH' % [ln, col]; print str },
      
      cur_pos?: proc { # get cursor position
        res = ''
        $stdin.raw {|stdin|
          $stdout << "\e[6n"; $stdout.flush
          while (c = stdin.getc) != 'R' do; res << c if c; end
        }
        m = res.match /(?<ln>\d+);(?<col>\d+)/
        Struct.new(:ln, :col).new(*m.to_a[1..].map(&:to_i))
      }, #             :bar, :line, :block or default (not given)
      
      # shape can be :block, :line or :bar. blink: true or FALSE
      cur_shape: proc {|shape, blink: true| # cursor shape and blink
        val = shape ?
          (%i(block line bar).index(shape) * 2 + (blink ? 1 : 2)) : 0
        → '%s q' % [val]
      },
      
      cur_color: proc {|col| # cursor color
        print "\e]12;#{col}\a" if col[/^#[0-9A-F]{6}$/i]
      },
      
      cur_sto:  proc { system('tput sc') }, # store cursor position
      cur_rec:  proc { system('tput rc') }, # recall cursor position
      
      scr_sto:  proc { system('tput smcup') }, # store screen
      scr_rec:  proc { system('tput rmcup') }, # recall screen
     
      # columns and lines of terminal window
      scr_size: proc { [`tput cols`.to_i, `tput lines`.to_i] },

      # init and de-init (not required)
      init:     proc { X.scr_sto; X.cls; X.cur(false) },
      de_init:  proc {
        X.scr_rec; X.cur;
        X.cur_shape; X.cur_color('#FFFFFF')
      },

  }.each {|k,v|
        define_singleton_method(k) {|*args, **kw| v.call(*args, **kw) }
  }
  end
 
  # print ESC method
  def →(s) = ( print "\e[#{s}" )
end

# =============================================================================
# Usage:

X = Ansi.new

X.init #                        save screen, clear screen, hide cursor

cols, lines = X.scr_size #      get screen size (columns, lines)

X.cur_at(10,10); print 'HEJ' #  position cursor
X.pat(12,10, 'HEJ!!') #         position cursor and print

pos = X.cur_pos? #              get cursor position
print ' (%s, %s)' %
  [pos.ln, pos.col]
sleep(2)


print ' red, blinking bar cursor'
X.cur(true) #                   show cursor
X.cur_color('#FF0000') #        set cursor color
X.cur_shape(:line, blink: false)# set cursor to steady bar
sleep(2)

X.de_init #                     restore screen, standard cursor visible

Useless_class

Sun, 26 Jan 2025 20:20:59 +0100

I wrote a variable storage class that remembers previous values.

X = Memory.new

X.name = 'erik'
p X.name # => "erik"

X.name = 'filip'
p X.name # => "filip"

# What value did 'name' have before?
p X.name_old # => "erik"


# numbers BEFORE a random number is 10 or 20
100.times {
  puts X.sample_old if [10,20].include?(X.sample = [*1..20].sample)
}

=begin SAMPLE OUTPUT

"erik"
"filip"
"erik"
1
9
18
11
5
20
6
11
15

=end

Midi_keyboard

Sat, 25 Jan 2025 20:39:32 +0100

Using aconnect and aseqdump to make a simple terminal piano keyboard.

It’s just a sketch.. version 0.0.1.

TODO Link to heading

detect screenwidth
more fullsize keyboard
update ‘chords’ on release
detect ‘hung’ keys
output intervals and chord-names

CODE Link to heading

require 'set'
require 'open3'

acon = `aconnect -i`.scan(/client (\d+): '(.*?)'/).to_h
puts 'Select Instrument by number :'
acon.each {|k, v| puts '[%s] %s' % [k, v]}

PORT = gets.chomp
PIANO = DATA.read
WHITE,BLACK = [0,2,4,5,7,9,11], [1,3,-1,6,8,10]

abort('No such Instrument') unless inst = acon[PORT]
wr, RD = Open3.popen2("aseqdump -p #{PORT}"); wr.close

X = {
  cls:    proc {print "\e[2J"},
  cursor: proc {|show| print show ? "\e[?25h" : "\e[?25l"},
  at:     proc {|l,c| print "\e[#{l};#{c}H"},
  red:    proc {|s| print "\e[37;41m#{s}\e[0m"},
  rat:    proc {|l,c,str| X.at[l,c]; X.red[str]},
  piano:  proc {X.at[0,0]; print PIANO},
  keys:   proc {|held|
    held.each {|key|
      lc = BLACK.include?(key) ?
        [2, BLACK.index(key) * 4 + 5, ' '] :
        [4, (i=WHITE.index(key)) * 4 + 3, 'CDEFGAB'[i]]
      X.rat[*lc]
    }
  },
  twelve: proc {|s| s.to_a.map {|i| i % 12 }},
  bye:    proc {RD.close; X.cursor[true]; exit}
}.then {|hsh| Struct.new(*hsh.keys).new(*hsh.values)}

trap('SIGINT') { X.bye[] }

X.cls[]; X.cursor[false]; X.piano[]

held = Set[]
# main loop
while line = RD.gets
  if line =~ /Note (on|off).*?note (\d+)/
    $1['on'] ? held.add($2.to_i) : held.delete($2.to_i)
    held.empty? ? X.piano[] : X.keys[X.twelve[held]]
  end
end

X.bye[]

__END__
|  |█| |█|  |  |█| |█| |█|  |
|  |█| |█|  |  |█| |█| |█|  |
|   |   |   |   |   |   |   |
| C | D | E | F | G | A | B |

Code_review

Wed, 22 Jan 2025 22:20:43 +0100

Saw some code here and modified it a bit.

employee = Struct.new(:name, :age, :role, :salary)

employees = [
  employee.new('Jane', 34, :designer,   75_000),
  employee.new('John', 29, :developer,  90_000),
  employee.new('Jill', 38, :developer,  80_000)
]

puts employees.select { it.role == :developer }
              .map { it.salary }
              .tap { p 'After map: %s' % [it] }
              .sum

#             => "After map: [90000, 80000]"
#             => 170000
puts employees.select { it.role == :developer }
              .map { it.age }
              .tap { p 'After map: %s' % [it] }
              .then { '%.2f' % [it.sum.fdiv(it.size)] }

#             => "After map: [29, 38]"
#             => 33.50

Locker

Tue, 21 Jan 2025 19:09:33 +0100

I often code when going to sleep. I think about a problem or a subject and how I would attack it.. solve it.

In another project, I had the need for Ruby to be “temporary typed”. I can’t do that! But I can do something that works for me.

This is not the code.. it’s the instance:

require 'mw_locker.rb'

# first all variables using this class must be defined.
# They have a type (or types).
# They can use the 'filter'-property.. a Range or Array of values.
# Also a 'regex'-property.
# finally an optional block (or 'proc'-property of Proc or Lambda)
#
# It's mainly a setter/getter. All checks and procs are done when set.

X = Locker::TypeCreate.new {
  name(String) {|v| v.to_s }
  age Integer, filter: (1..100)
  name_age(Array) {|s| s.split(':') }
  to_bin(String) {|i| i.to_s(2) }
  
  # using proc: you can add proc or lambda
  # to_bin String, proc: ->(i) {i.to_s(2)}
  # to_bin String, proc: proc {|i| i.to_s(2)}

  # filter can be Range or Array (of allowed values)
  # Range can be inclusive or not.

  regplate String, regex: /^[A-ZÅÄÖ]{3}\s*\d{2}[0-9A-ZÅÄÖ]$/i

  testa [TrueClass, FalseClass]
  result [String, Integer, NilClass]
  copy(String) {|v| X.name = v }

  koko :NoTypecheck
  person(:NoTypecheck) {|stc| stc.new(X.name, X.age) }
}.__parse


# -------------------------------------------------------------


X.age = 100
p X.age # => 100

X.name_age = 'Olle:21'
p X.name_age # => ["Olle", 21]

# X.age = 101 # => Exceptions::LockerFilterError

X.to_bin = 7
p X.to_bin # => "111"

h = {name: 'Otto', age: 34}

X.result = h[:name] # String is allowed
X.result = h[:age] #  Integer is allowed
X.result = h[:city] # nil is allowed

# p X.apa # => Exceptions::LockerKeyError

X.copy = 'Stig'
p X.copy # => "Stig"
p X.name # => "Stig"

X.regplate = 'KKC 338'
X.regplate = 'bbo33z'

begin X.regplate = 'ABC-123'
rescue Exceptions::LockerRegexError; end

# .name converts any value to String
p X.name = 8
p X.name # => "8"

# .koko do not check for type
X.koko = 3.14
X.koko = 8
X.koko = :hejsan

# .person do no type-checking
# ..recieves a Struct and runs the block
# setting .name and .age
X.name = :Heliga_Lurban

# populates the struct with .name and .age
X.person = Struct.new(:name, :age)
p '%s is %s years old.' % [X.person.name, X.person.age]

The thing that made me want his came from this:

Then_tap

Thu, 16 Jan 2025 18:28:25 +0100

class Apa
  attr_accessor :donkey
  def initialize = ( @donkey = :Eyore )
  def to_string = ( @donkey.to_s )
end

rev = ->(str) { str.reverse }

# `tap` is yielding Apa.new
apa = Apa.new.tap {|ap| ap.donkey = :Roi }
p apa.donkey #                            => :Roi

# `then` is same as `yield_self`
#  and is yielding the block
p apa.tap { p it.class } #                => Apa
  .then(&:to_string).tap { p it.class } # => String
  .then(&rev)
  .upcase #                               => "IOR"

Code is just an example of class-method; proc (lambda) and the use of tap and then.

Abbrev

Tue, 14 Jan 2025 20:47:33 +0100

require 'abbrev'

class Apa
  def initialize
    @hsh = { parameter: 11, subject: 'Kalle Kula', parm: [:ost] }
    @keys = @hsh.keys.abbrev
  end

  def method_missing(key)
    @hsh[@keys[key.to_s]] || @hsh[@keys[key]]
  end
end

apa = Apa.new
p apa.parameter # => "11"
p apa.parm #      => [:ost]
p apa.param #     => "11"
p apa.par #       => << NO KEY
p apa.p #         => << NO KEY

p apa.subj #      => "Kalle Kula"
p apa.su #        => "Kalle Kula"
p apa.sub #       => "Kalle Kula"

The class holds a Hash with three keys: parameter, subject and parm.

Ior_xml

Thu, 09 Jan 2025 20:06:38 +0100

class Ior
  def method_missing(name, *args, **kw)
    keys = ''
    kw.each {|k,v| keys += ' %s="%s"' % [k, v] }
    arg = args.join(' ')
    '<%s%s>%s</%s>' % [name, keys, arg, name]
  end
end

o = Ior.new

fx = o.effect                       type: 'Reverb',
                                    wetDryMix: 0.5,
                                    roomSize: 0.5
fx = o.effects fx
bus = o.bus fx,                     busVolume: 0.5,
                                    output1Target: 'MAIN_OUTPUT',
                                    output2Target: 'AUX_STEREO_OUTPUT_1',
                                    output1Volume: 0.8,
                                    output2Volume: 0.5

require 'nokogiri'
puts Nokogiri::XML(bus)

# <?xml version="1.0"?>
# <bus busVolume="0.5" output1Target="MAIN_OUTPUT"
#    output2Target="AUX_STEREO_OUTPUT_1" output1Volume="0.8"
#    output2Volume="0.5">
#   <effects>
#     <effect type="Reverb" wetDryMix="0.5" roomSize="0.5"/>
#   </effects>
# </bus>

# ==========================================================

# Allows for stuff like this:

oo = Ior.new
bindings =  [ { groupIndex: 0,
                translationOutputMin: 0,
                translationOutputMax: 1 },
              { groupIndex: 1,
                translationOutputMin: 1,
                translationOutputMax: 0
}].map {|kw|
  oo.binding    type: :amp,
                level: :group,
                parameter: 'AMP_VOLUME',
                translation: :linear,
                **kw
}

puts Nokogiri::XML(oo.x *bindings)

# <?xml version="1.0"?>
# <x>
#   <binding type="amp" level="group" parameter="AMP_VOLUME"
#     translation="linear" groupIndex="0" translationOutputMin="0"
#     translationOutputMax="1"/>
#   <binding type="amp" level="group" parameter="AMP_VOLUME"
#     translation="linear" groupIndex="1" translationOutputMin="1"
#     translationOutputMax="0"/>
# </x>

Stupid_and_clever

Tue, 07 Jan 2025 19:43:03 +0100

I actually don’t know what to think about this code. It’s stupid and clever.

It’s stupid where it needs to be clever and clever where it doesn’t matter.

Took 1:44 to write.

require 'open3'

#     This requires 'xgamma' and 'xsct' to be installed.
#     arch: sudo pacman -S xgamma
#           sudo pacman -S xsct

module Get
  def Get.xc(s)
    res, ec = Open3.capture2e s
    ec.exitstatus.zero? ? res.chomp : nil
  end

  def Get.data
    data = xc('xgamma')
      .scan(/(\w+)\s+(\d\.\d+)/)
      .to_h
      .transform_keys {|k| k.downcase.to_sym }
    data[:temp], data[:brightness] =
      xc('xsct')[/(\d+)\s+(\d\.\d+)/].split
    data
  end
end

class Screen
  def initialize = ( @val = Get.data )

  def method_missing(name, *args, **kw)
    if %i(gamma temp bright tb).include?(name)
      send('_%s' % name, *args, **kw); @val = Get.data
    else super; end
  end

  private
  def _gamma(**kw)
    kw.each {|k,v|
      Get.xc('xgamma -%sgamma %s' % [k[0], v]) if
        %i(red green blue).include?(k)
    }
  end

  def _temp(tmp) = ( Get.xc('xsct %s' % tmp) )
  def _bright(val) = ( Get.xc('xsct %s %s' % [@val[:temp], val]) )
  def _tb(tb) = ( Get.xc('xsct %s' % tb) )

end


# Usage =================================================================

scr = Screen.new
scr.gamma(blue: 0.7, red: 0.2)
sleep(2)

scr.gamma(blue: 1)
sleep(1)
scr.gamma(red: 1)

scr.temp(4000)
sleep(1)

scr.bright(0.5)
sleep(1)

scr.tb '0'

Verbose

Thu, 02 Jan 2025 22:27:39 +0100

This is just a little thing.. but I find it useful:

VRB = false
def vrb(&bl) = ( yield if VRB && bl )

When having this in your code you can method-block any code that should just run the VRB is true.

Like:

names = %i(allan ingolf)

vrb {
  puts 'Names:'
  names.each { puts it }
  puts '-' * 40
}

Pols

Thu, 02 Jan 2025 18:47:13 +0100

I wrote a wrapping-class over Slop (Simple Lightweight Option Parser).
Mine is called: Pols (Parse Optio Lectori Salutem)

This is how it is used..

require 'pols'

# Usage ==========================

# --name|-n (type: String, default: 'olle')
# --edit|-e (type: String)
# --delete|-d (type: String)
# --verbose|-b (type: Bool)
# --test|-x (type: Bool)
# --number|-u (type: Int, required)

pols = Pols.new {
  str :name, default: 'olle'
  str :edit, :delete
  flg :verBose, :test_x
  int :nUmber, required: true
}.to_obj

p pols[:number] if pols.edit?
p pols[:name]

Ruby_3.4.1

Wed, 25 Dec 2024 21:08:11 +0100

Installed Ruby 3.4.1

Pax

Sun, 22 Dec 2024 19:39:21 +0100

#!/usr/bin/env ruby
# frozen_string_literal: true


class Pax
  
  def initialize
    @tmp = {}
    @rxc = Regexp.new('\<%\s*(.*?)\s*%\>', 'm')
    @rxt = Regexp.new('\<@\s(\w+)*\s*@\>')
  end

  def method_missing(name, *args, bnd: TOPLEVEL_BINDING)
    (name.end_with? ?=) ?
      (@tmp[name[..-2].to_sym] = args[0]) :
        (@tmp[name] ? parse(@tmp[name], bnd) : super)
  end

  private
  def parse(mall, bnd)
    m = mall.dup.strip
    m.gsub!(@rxc) {|m| eval("#{$1}", bnd) }
    m.gsub!(@rxt) {|m| parse(@tmp[:"#{$1}"], bnd) }
    m
  end
end

Ox = Pax.new



Ox.pers = %(| <% '%10s' % name %> | <% '%5s' % age %> | <% '%10s' % city %> |)
Ox.line = %(<% puts '-' * 35 %>)

data = [
  %w(Ulla 45 Jönköping),
  %w(Bert 32 Karlstad),
  %w(Lisen 28 Hjo),
  %w(Zoltan 72 Vimmerby)
]

Ox.line
data.each {|pers|
  name, age, city = *pers
  puts Ox.pers bnd: binding
}
Ox.line

# =>  -----------------------------------
# =>  |       Ulla |    45 |  Jönköping |
# =>  |       Bert |    32 |   Karlstad |
# =>  |      Lisen |    28 |        Hjo |
# =>  |     Zoltan |    72 |   Vimmerby |
# =>  -----------------------------------

Oxcart

Fri, 20 Dec 2024 19:21:32 +0100

require 'mw_oxcart.rb'

Ox = Before::cart {
  → :names, %w(olle kalle pelle)
  → (:uc) {|s| s.upcase }
  → (:mp) {|ar, proc| ar.map &proc }
  → :just, '%10s'
  → (:op) {|n| '%s%s%s' % [Ox.just(n), "\n", Ox.just('-'*n.size)]}
  → :add, :+
  → :mult, :*
  → :str, 'hej baberiba!'
  → :str2, 'hej baberiba.. %s!'
  → :name, '%s är %s år.'
  → :Pall, :Mall
}

p Ox.names.map &:upcase #     => ["OLLE", "KALLE", "PELLE"]
p Ox.names.map &Ox[:uc] #     => ["OLLE", "KALLE", "PELLE"]
p Ox.mp Ox.names, Ox[:uc] #   => ["OLLE", "KALLE", "PELLE"]

p Ox.str #            => "hej baberiba"
p Ox.str2 :koskit #   => "Hej baberiba.. koskit!"
p Ox.name :anna, 7 #  => "Anna är 7 år."

Ox.names << 'bo'
p Ox.names.join ?, #  => "olle,kalle,pelle,bo"

p Ox.names.pop #      => "bo"
p Ox.names.last #     => "pelle"

Ox.names = %w(ewa ragnhild lise-lott)
p Ox.names #          => ["ewa", "ragnhild", "lise-lott"]

Ox.names.each {|name| puts Ox.op name }
#
# =>       ewa
# =>       ---
# =>  ragnhild
# =>  --------
# => lise-lott
# => ---------

# ( 3 + 2 = 5 / 3 * 2 = 6 )
%i(add mult).each { p 3.send(Ox.send(_1), 2) }
# => 5
# => 6

Erb_templates

Wed, 18 Dec 2024 19:13:54 +0100

require 'erb'

class Templates
  def initialize(&bl)
    @tmp = {}
    instance_exec &bl if bl
  end
 
  def →(name, str) = ( @tmp[name] = ERB.new str )
  def x(name, bnd=TOPLEVEL_BINDING) = ( @tmp[name].result(bnd) )
end

def tmp(&bl) = ( Templates.new(&bl) )


# Examples =====================================================

Out = tmp {
  → :data, %(<%= name %> is <%= age %> years old.)
  → :prov, <<~TEMPLATE
      <% test  %>
      <% 5.times { puts name } %>
  TEMPLATE
}

name = 'Laban'
age = 8

p Out.x :data # => "Laban is 8 years old."

def test
  name, age = 'Anki', 88
  p Out.x :data # "Laban is 8 years old."
  p Out.x :data, binding # "Anki is 88 years old."
end

test

# --------

p '-' * 50

Out.x :prov
# =>
# "Laban is 8 years old."
# "Anki is 88 years old."
# Laban
# Laban
# Laban
# Laban
# Laban

Made a module Link to heading

# filename: mw_template.rb
module Template
  require 'erb'

  class Tmp
    def initialize(&bl) = ( @tmp = {}; instance_exec &bl if bl )
    def →(name, str) = ( @tmp[name] = ERB.new str )
    
    def method_missing(name, bnd=TOPLEVEL_BINDING)
      @tmp[name] ? @tmp[name].result(bnd) : super
    end
  end

  def tmp(&bl) = ( Tmp.new(&bl) )
  
  module_function :tmp
end

Usage: Link to heading

require 'mw_template.rb'

Tmp = Template.tmp {
  → :prov, %(Name: <%= name %>, Age: <%= age %>)
  → :test, %(<% test %>)
}

name, age = 'Olle', 8
p Tmp.prov # => "Name: Olle, Age: 8"

# binding
def test
  name, age = 'Kajsa', 4
  p Tmp.prov(binding)
end

Tmp.test # => "Name: Kajsa, Age: 4"

Ruby_erb

Tue, 17 Dec 2024 19:28:15 +0100

Nothing special.. just me wanna see if Raspberry is running on the network before I bother to shut it down.

But I’be been thinking about strings.. and string templates.
So, I have a little erb in there.

#!/usr/bin/env ruby
# frozen_string_literal: true

class Array; alias in? include?; end

class Netz
  require 'open3'
  require 'erb'
  attr_accessor :ip, :port, :host

  def initialize(ip: '192.168.8.3', port: 22, host: 'mw')
    @ip, @port, @host, @bnd = ip, port, host, binding
    @temps = {
      nc: ERB.new('nc -zw1 <%= @ip %> <%= @port %>'),
      ssh: ERB.new('ssh <%= @host %>@<%= @ip %> "sudo systemctl <%= cmd.to_s %>"')
    }
  end

  # faster than `nmap` or `systemctl is-system-running`
  def alive? = ( ocap(@temps[:nc].result(@bnd)) )
  
  def sctl(cmd = :poweroff)
    %i(poweroff reboot).in?(cmd) ?
    ocap(@temps[:ssh].result(binding)) : nil
  end

  private
  def ocap(s) = ( Open3.capture2e(s)[1].exitstatus == 0 )

end


# Examples
netz = Netz.new

# p netz.ip
# p netz.port
# p netz.host
# netz.ip = '192.168.8.2'


# p netz.alive? # => true (if Raspberry is running)
# netz.sctl(:reboot) if netz.alive?

netz.sctl if netz.alive? # poweroff if alive

The thinking I’ve been doing on strings is.. THERE’S A LOT OF ‘EM !!!

Xinput

Sat, 14 Dec 2024 18:30:55 +0100

I wanted a simple way of turning off the built in keyboard and the touchpad on my laptop while using a USB keyboard and a trackball.

This is sort of the skeleton for this.

#!/usr/bin/env ruby
# frozen_string_literal: true

%w(io/console timeout optimist_xl hash_dot).each {|¡t| require ¡t }

class Array; alias in? include?; end

def ignore(&bl) = ( nil )

class Xin
  attr_reader :dev

  def initialize = ( @dev = Hash[sc('id').zip(sc('name'))] )
  
  def id?(rex)
    @dev.each {|k,v| return k[/(\d+)/] if v[rex.tr('_', ' ')] }
    nil
  end

  def method_missing(n, id) =
      ( %i(enable disable).in?(n) ?
        (system 'xinput %s %s' % [n, id]) : super )
  
  def toggle(id) = ( enabled?(id) ? disable(id) : enable(id) )
  
  def enabled?(id) =
    ( `xinput list #{id}`[/device is disabled/] ? false : true )
  
  def disabled?(id) = ( !enabled?(id) )
  
  def confirm_disable(id, sec=5)
    disable(id)
    puts 'Disabled.. will revert in 5 seconds unless you press a key.'
    Timeout.timeout(sec) { STDIN.getch } rescue enable(id)
  end
  
  private
  def sc(s) = ( `xinput list --#{s}-only`.split(/\n/) )

end

=begin
        Example usage
        =============

          > xin --disable 'Optical Mouse'
          
          > xin --list
            2 => Virtual core pointer
            4 => Virtual core XTEST pointer
            3 => Virtual core keyboard
            5 => Virtual core XTEST keyboard
            6 => Power Button
            7 => Power Button
            8 => Sleep Button
            10 => AT Translated Set 2 keyboard
            ∼ 9 => ∼ USB Optical Mouse

          > xin --id 'AT Translated'
            ID => 10

          > xin --toggle 10

          > xin --enable 9

          > xin --disable 'AT Translated' --confirm
            Disabled.. will revert in 5 seconds unless you press a key.


        short
        =====

          > xin -d Mouse
          > xin -l
          > xin -t 10
          > xin -i Set_2    Underscore translates to Space
          > xin -e 8 -c

=end

xin = Xin.new

paq     = ->(s) { puts s; exit }
do_list = ->{ xin.dev.each {|k,v| puts '%s => %s' % [k, v]}; exit }
do_id   = ->(id) { xin.id? id }

do_cmd  = ->(cmd, arg) {
  arg = xin.id?(arg) unless arg[/^\d+$/]
  xin.send(cmd.to_s, arg); exit
}


op = OptimistXL.options do
  opt :enable,  'enable device',        type: String
  opt :disable, 'disable device',       type: String
  opt :toggle,  'toggle device',        type: String
  opt :id,      'fetch id from regex',  type: String
  
  opt :list,    'list devices'
  opt :confirm, 'confirmed disable'
end.to_dot

do_list[]                             if op.list
paq['ID => %s' % do_id[op.id]]        if op.id
do_cmd[:confirm_disable, op.disable]  if op.confirm && op.disable
%i(enable disable toggle).each { do_cmd[_1, op[_1]] if op[_1] }

Ruby_3.4

Thu, 12 Dec 2024 21:41:39 +0100

Installed Ruby_3.4.0-rc1 from tar.

Assoc

Tue, 10 Dec 2024 18:20:43 +0100

a = [:one, [1,2,3]]
p a.assoc(:one)[1..][0] # => [1, 2, 3]

a << [:two, {a: :allan, b: :bengt}]
p a.assoc(:two)[1..][0] # => {:a => :allan, :b => :bengt}

So - with this one command - an Array can be used as a Hash.

Add to that the plethora of Array methods (including rassoc); the possibility to turn a array into an enumerator.. and you see you can go far beyond Hashes.

Regex_named_capture

Tue, 03 Dec 2024 18:05:35 +0100

A named capture is defined like this: ?<name>

If you want to use =~ in Ruby - and use named capture - you need to put the regex expression to the left.

Example:

data = 'Arne: 24'

if /^(?<name>\w+):\s+(?<age>\d+)$/ =~ data
  # you have access to two new variables:
  #   name & age
  puts 'name: %s, age: %s' % [name, age]
end

# THIS WILL NOT WORK:
# data =~ /^(?<name>\w+):\s+(?<age>\d+)$/

find out.. Link to heading

What if the variable is a global? Or a constant?

Bash_history

Tue, 03 Dec 2024 15:03:02 +0100

Getting date-time in bash history: Link to heading

Add to end of .bashrc

shopt -s histappend
PROMPT_COMMAND="history -n; history -a"
unset HISTFILESIZE
export HISTTIMEFORMAT="%F %T > "
export HISTSIZE=2000

Do . .bashrc from home to re-source (or source path/to/.bashrc).

Test with history or Ctrl-R.

parsing .bash_history Link to heading

.bash_history now has entries looking like this:

#1733237692
nvim ~/.bash_history

I didn’t know what the hash-number was.. but guessed epoch. That was correct. So parsing can look like this:

Shutdown_raspberry

Sun, 01 Dec 2024 15:33:53 +0100

A clean shutdown of raspberry over LAN when my main computer shuts off.

The simplest solution:

make is possible to login to raspberry over ssh without entering a passphrase. This is done with ssh_keygen and ssh_copy_id.
sending a command after login. Well.. ssh takes a command. You can do this: ssh user@host 'sudo shutdown -h now'.
Make your own version of shutdown on the main computer that first run the ssh-command and then calls the proper, local shutdown.

When you execute my_shutdown -h now.. the script (Ruby in my case) first do the system call system %(ssh user@host 'sudo shutdown #{*args}'), then do the same locally.

Prime_minister

Sun, 24 Nov 2024 18:10:36 +0100

Take a name and replace A with 1, B with 2 .. and so on.

Add the numbers. If it is a prime number.. the name is a prime name.

require 'prime'
require 'colorize'

def prime_minister?(name)
    name
    .upcase
    .gsub(/[^A-Z]/, '')
    .codepoints
    .map {|i| i - 64}
    .sum
end


%w(
  Donald_Trump
  Kamala_Harris
  Joe_Biden
  Jesus_Christ
  Adolf_Hitler
  Sherlock_Holmes
  Scooby_Doo
  Doctor_Watson
  Dr_Mengele
  Joe_Hill
  John_Travolta
  Ringo_Starr
  John_Lennon
  George_Bush
  Ronald_Reagan
  Jimmy_Carter
  Richard_Nixon
  John_F_Kennedy
  prime
  sixty_one
  Matt_Gaetz
  Wisconsin
  Alabama
  Texas
  Ohio
).each {|name|
  val = prime_minister?(name)
  name = name.colorize(val.prime? ? :light_blue : :red)
  puts '%s : %s (%s)' % [name, val, val.prime?]
}

Donald_Trump : 138 (false)
Kamala_Harris : 112 (false)
Joe_Biden : 64 (false)
* Jesus_Christ : 151 (true)
Adolf_Hitler : 110 (false)
* Sherlock_Holmes : 163 (true)
* Scooby_Doo : 113 (true)
* Doctor_Watson : 167 (true)
* Dr_Mengele : 83 (true)
* Joe_Hill : 71 (true)
John_Travolta : 156 (false)
* Ringo_Starr : 139 (true)
John_Lennon : 121 (false)
* George_Bush : 107 (true)
Ronald_Reagan : 110 (false)
Jimmy_Carter : 135 (false)
* Richard_Nixon : 137 (true)
* John_F_Kennedy : 131 (true)
* prime : 61 (true)
* sixty_one : 131 (true)
* Matt_Gaetz : 113 (true)
Wisconsin : 125 (false)
* Alabama : 31 (true)
Texas : 69 (false)
* Ohio : 47 (true)

Map_enum

Thu, 21 Nov 2024 21:52:28 +0100

You can do this:

a = [*1..10]

m = [
  proc {|i| i * 2},
  proc {|i| i / 2}
]

m.each { p a.map(&_1) }

But also this:

a = [1*..10]
m = [proc {|i| i * 2}, proc {|i| i / 2}].to_enum

loop { p a.map(&m.next) }

Bitfield_struct

Thu, 14 Nov 2024 19:29:03 +0100

bf = [true, true, false, false, true]

# to binary string
bs = bf.map { _1 ? 1 : 0 }.join
p bs # => "11001"

# to Integer
int = bs.to_i(2)
p int # => 25

# Struct
BitField = Struct.new(:cond) {
  def and(s) = cond.map { _1 ? 1 : 0 }
    .join.to_i(2) & s.to_i(2) == s.to_i(2)
}

bf = BitField.new [true, true, false, false, true]
p bf.and '1000' # => true
p bf.and '1001' # => true
p bf.and '10001' # => true

Example usage of this

BitField = Struct.new(:cond) {
  def call(o, s) = cond.map { _1[o] ? 1 : 0 }
    .join.to_i(2) & s.to_i(2) == s.to_i(2)
}

rw = BitField.new [
  ->(x) { File.file? x },
  ->(x) { File.readable? x },
  ->(x) { File.writable? x }
]

# output only files (not dirs) that are readable and writable
Dir.glob('*').each {|f|
  p f if rw.(f, '111')
}

Alias_parameter

Sat, 09 Nov 2024 20:09:05 +0100

Why do I need to mkdir some_dir and then cd some_dir?

That’s the first thought. Then: ‘I make a script’.

But the script runs in another process. You can cd all you want.. but when the child-process exists and returns focus to the parent-process.. your current directory has not changed.

I have let xdotool send the commands to the terminal before. So that’s a way.

You can also use an alias.

Ruby_3.3.6

Tue, 05 Nov 2024 18:18:44 +0100

Ruby 3.3.6 is released. Version 3.3.7 is expected January 7th.

Dart

Tue, 29 Oct 2024 18:57:31 +0100

Not sure I want to learn Dart.. but I am looking at it.

UPDATE An executable having just void main print is almost 7MB. I stay away from that language.

Tankar

Tue, 22 Oct 2024 18:45:39 +0200

Anta en URL.. som https://reisub.se. Om vi säger url = 'https://reisub.se', så är det inte längre en URL/URI.. det är en sträng.

Som sträng har den metoder.. som upcase. Jättebra för namn och orter.. men inte sådär jätteanvändbart för en URI.

Låt säga man vill hämta saker ur sin URI.. som host eller port. Då kanske man skriver sig en liten metod. Den metoden kanske man bara kastar in i kod som är main.

Uniq

Fri, 18 Oct 2024 23:34:33 +0200

Until today I didn’t know that the Gnu/Linux command uniq had a -w option.

The option tells how many characters that should be compared.

uniq -w5 only compares the first five characters for every row.

You can also skip characters with -s.
Or print out ONLY the duplicates -D.

Ior_is_coding

Tue, 15 Oct 2024 20:40:05 +0200


INPUT = 'value=13.5'

# desired output
# <float>13.5</float>

val = INPUT.split('=')[1]
puts "<float>#{val}</float>"

# total INPUTS
=begin
  value=13.5
  value= '=> nope!'
  value = 16

  value= .3
=end

# desired output:
#   Determine the type...
#   float, int, string

data = <<-DATA.chomp
  value=13.5
  value= '=> nope!'
  value = 16

  value= .3
DATA

# Ior can't get rid of new-line.. because some times val is nil
data.each_line {|ln|
  val = ln.split('=')[1]
  puts "<float>#{val}</float>"
}

p 'ADDING COMPLEXITY %s' % ['-' * 40]
data.each_line {|ln|
  val = ln.split('=')[1]
  val.strip! if val
  puts "<float>#{val}</float>"
}

# Now Ior needs to find out if the result is a number..


p 'ADDING COMPLEXITY 2 %s' % ['-' * 40]
data.each_line {|ln|
  type = 'string'
  val = ln.split('=')[1]
  val.strip! if val
  if val =~ /^\d*$/
    type = 'integer'
  elsif val =~ /^\d*\.\d*$/
    type = 'float'
  else
    type = 'string' # Ior forgot it's already 'string'
    end
  puts "<#{type}>#{val}</#{type}>"
}

# Now Ior realizes that empty lines will create
# <string></string>
# Ior needs to get rid of those..


p 'FINAL SOLUTION %s' % ['-' * 40]
data.each_line {|ln|
  type = 'string'
  val = ln.split('=')[1]
  val.strip! if val
  if val =~ /^\d*$/
    type = 'integer'
  elsif val =~ /^\d*\.\d*$/
    type = 'float'
  else
    type = 'string' # Ior forgot it's already 'string'
    end
  puts "<#{type}>#{val}</#{type}>" unless val == '<string></string>'
}


# AH... it's not working!!! Why?


p 'TEST %s' % ['-' * 40]
data.each_line {|ln|
  type = 'string'
  val = ln.split('=')[1]
  val.strip! if val
  if val =~ /^\d*$/
    type = 'integer'
  elsif val =~ /^\d*\.\d*$/
    type = 'float'
  else
    type = 'string' # Ior forgot it's already 'string'
    end
  if val != nil
    puts "<#{type}>#{val}</#{type}>" unless val.chomp == '<string></string>'
  end
}

# ..because of a ending new-line that can't be checked
# if the variable is nil.
# Just add another if...
# AHHHHH!!! It's WORKING!!!

Ior_code_revisited

Mon, 14 Oct 2024 19:31:19 +0200

Ior wants to change parameters. He has a hash (or dictionary) with the parameters that needs to change and what they need to change into.

This is what he comes up with:

ARGS = ['--number', '8', '--verbose', 'file.dat']

change = {'--number': '-n', '--verbose': '-v'}


argz = []
ARGS.each {|arg|
  found = false
  change.each {|key, val|
    if arg == "#{key}"
      argz.append(val)
      found = true
      break
    end
  }
  argz.append(arg) unless found
}

p argz

Why? The problem is that Ior programs like he think:

True_color

Mon, 14 Oct 2024 18:33:11 +0200

For half a day I had true-color in my terminals. Then reverted back to 256 colors.

The reason was: I had absolutely no benefits but a land-slide of issues. I use the terminal a great deal and not all applications where happy in Tc-land.

Palette

Sun, 06 Oct 2024 20:26:33 +0200

ansi = ->(fg, bg) { "\e[38;5;#{fg};48;5;#{bg}m" }

col = ->(i=nil) {
  case i
  when 7,8,10,11,14,15,
    41..51, 68..87, 101..123, 133..159,
    167..195, 202..231, 244..255
    ansi[0, i]
  when nil then "\e[0m"
  else ansi[15, i]
  end
}

range = ->(r) { r.each {|i| print '%s%02x' % [col[i], i] }; puts col[] }

range[(0..15)]; range[(232..255)]
6.times {|i| st = i*36+16; range[i*36+16..st+35] }

puts

Working on a palette generator for terminal and needed to see the 256 color palette. This presents it with the basic 16 + grays + the 6x6.

Found no way to get the full hex out of a 256 color number.. to determine if the color is ’light’ or ‘dark’ (I set foreground by this).. so the light colors are hard-coded in.

Frames_tascam

Sun, 29 Sep 2024 14:20:41 +0200

This was made fast yesterday. Just wanted a way to split up recordings into bars and beats. I haven’t even got the machine (Tascam DP-006) yet.

Not sure if it’s possible to edit tracks the way I imagine.

FRAME_RATE = 30 # according to tascam.eu

module Smpte
  refine Integer do
    def frames      = ( self )
    def seconds     = ( self * FRAME_RATE )
    def minutes     = ( self.seconds * 60 )
    def hours       = ( self.minutes * 60 )
   
    {frames: [:frame, :fr], seconds: [:secs, :sec],
    minutes: [:mins, :min], hours: [:hrs, :hr]}.each {|k, v|
      v.each {|al| define_method(al) { send(k) } }
    }
  end
end

class Frames

  attr_accessor :frames
  def initialize(frames=0)
    @frames = frames
    @smpte = Struct.new(:hr, :min, :sec, :frames) {
      def to_s = ('%.2i:%.2i:%.2i (%.2i)' %
        [hr, min, sec, frames])
    }
  end

  def reset = ( @frames = 0 )

  def smpte(frames = @frames)
    smpte = @smpte.new(0,0,0,0)
    smpte.sec, smpte.frames = frames.divmod(FRAME_RATE)
    smpte.min, smpte.sec = smpte.sec.divmod(60) if smpte.sec > 0
    smpte.hr, smpte.min = smpte.min.divmod(60) if smpte.min > 0
    smpte
  end

  def bpm(b)
    mult, mult_rest = b.divmod(4) # one measure
    p '  >> REST: %s' % mult_rest if mult_rest > 0
    smpte((FRAME_RATE * 60).divmod(mult).first)
  end
end

Usage :

RightNow

Tue, 24 Sep 2024 19:46:21 +0200

Right now.. I’m working with this :

# pretend we got user args
ARGS = %w(-n Olle --age 22 -lagom)


wanted = {
  n: :to_s,
  age: :to_i,
}

en = ARGS.to_enum

loop do
  it = en.next
  if it =~ /^-{1,2}(\w+)$/
    val = case (key = wanted[$1.to_sym])
      when Symbol then en.next.send(key)
      else true
    end
    # for show...
    p '%s => %s (%s)' % [it, val, val.class]
  end
end

=begin Output
                "-n => Olle (String)"
                "--age => 22 (Integer)"
                "-lagom => true (TrueClass)"
=end

It doesn’t cover cases.. just short, long and bool at this state.
No translation from short to long key. Not sure the Converting is solid.

Ansi_menu

Sat, 21 Sep 2024 20:29:55 +0200

Wrote this trying NOT to use libraries like ‘(n)curses’ or ‘io/console’.
The key-handling became way to involved.. so I decided to use tty-reader for that.

require 'tty-reader'

# get cursor pos via sending Esc[6n
def pos
  res = ''
  $stdin.raw do |stdin|
    $stdout << "\e[6n"
    $stdout.flush
    while (c = stdin.getc) != 'R'
      res << c if c
    end
  end

  # named matches, return hash
  m = res.match /(?<ypos>\d+);(?<xpos>\d+)/
  {:y => Integer(m[:ypos]), :x => Integer(m[:xpos])}
end

# menu
def select(menu)
  rd = TTY::Reader.new
  row, pos = pos()[:y] - menu.size, 0

  menu.each_with_index {|item, idx|
    puts '%s %s' % [(idx==0) ? '>' : ' ', item]
  }

  # lambdas
  cur = ->(b) { print b ? "\e[?25h" : "\e[?25l"}
  cur_goto = ->(row=0,col=0) { print "\e[#{row};#{col}H" }
  pat = ->(r, c, txt) { cur_goto[r, c]; print txt }
  res = -> { cur_goto[row + menu.size, 0]; cur[true] } 
  
  # keys
  rd.on(:keydown, :keyup) do |ev|
    pat[pos+row, 0, '  %s' % menu[pos]]
    pos = (pos += (ev.key.name == :down) ? 1 : -1) % menu.size
    pat[pos+row, 0, '>']
  end
    .on(:keyescape) { res[]; return nil }
    .on(:keyreturn) { res[]; return menu[pos] }

  cur[false]
  
  # loop
  loop { ch = rd.read_keypress }
end

# -----------------------------------------------------------------------------

# usage :
# move cursor             => arrow keys (up / down)
# make selection          => Return
# quit without selecting  => Esc

arr = %w(one two three four five end)
puts 'Selected: %s' % [select(arr) || 'none']

Ffi Ncurses

Wed, 18 Sep 2024 18:31:58 +0200

Had some problems with ffi-ncurses (ruby gem). The char definitions was messed up on my side.

Simple fix: edit asc.rb and set the definitions right.

Curses_overkill

Thu, 12 Sep 2024 20:19:06 +0200

Sometimes Curses or Ncurses is overkill. Ansi escape sequences will suffice. Here’s how to set that up with Ruby.

I only use Curses when I need pads or mouse-support.

require 'ostruct'

# -------------------------------------------
# Setup .. add more sequences and calls
# maybe -> { `tput lines` }
# and   -> { `tput cols` }

Cur = OpenStruct.new(
  save:     ->            { print "\e[s" },
  restore:  ->            { print "\e[u" },
  hide:     ->            { print "\e[?25l" },
  show:     ->            { print "\e[?25h" },
  goto:     ->(x=0, y=0)  { print "\e[#{y};#{x}H" },
  up:       ->(p=1)       { print "\e[#{p}A" },
  down:     ->(p=1)       { print "\e[#{p}B" },
  right:    ->(p=1)       { print "\e[#{p}C" },
  left:     ->(p=1)       { print "\e[#{p}D" },
)

Scr = OpenStruct.new(
  cls:      ->            { print "\e[2J" },
)

# -----------------------------------------
# Usage :

Scr.cls[]
Cur.hide[]

Cur.goto[5,5]
print 'hejsan'

Cur.down[2]
print 'svejsan'

sleep(2)

Cur.show[]

Why_refine

Thu, 12 Sep 2024 18:17:47 +0200

module StrRows
  refine String do
    def lines = ( scan("\n").size )
  end
end

class Xstr < String
  using StrRows
end

some_text = <<-MUSK
Strive to greater heights,
For a future brighter than the past,
Waking up each morning inspired,
To learn new secrets of the Universe!
MUSK

xstr = Xstr.new(some_text)

p some_text.lines
# =>[
# "Strive to greater heights,\n",
# "For a future brighter than the past,\n",
# "Waking up each morning inspired,\n",
# "To learn new secrets of the Universe!\n"
# ]

p xstr.lines # => 4

Suppose you want a fancy new String-method that returns the number of lines in a text. Unbeknownst to you.. String already have a method named ’lines’. It splits a line on new-line and returns an Array.

Class_block

Tue, 10 Sep 2024 18:29:11 +0200

class One
  def initialize = ( @name = 'olle' )
end

one = One.new
puts one.name # => NoMethodError

# The class gives no way to access 'name'.

# (unless)
puts one.instance_variable_get('@name')

# adding getter-method to instance
one.class.send(:attr_reader, :name)
puts one.name # => olle

# ---
# You can also gain access to the namespace via a block.

class Two
  def initialize(&bl)
    @name = 'olle'
    instance_exec(&bl)
  end
end

Two.new { puts @name } # => olle

Three_ways

Fri, 30 Aug 2024 21:44:27 +0200

apa is a dummy-class with a method :add.
The gem ‘method_source’ is required.

# first
apa.method(:add).source.each_line {|ln|
  @ind ||= ln[/^(\s*)/].size
  puts ln[@ind...]
}


# second
ar = apa.method(:add).source.lines
indent = ar[0][/^(\s*)/].size
ar.each {|ln| puts ln[indent..] }


# third
en = apa.method(:add).source.split("\n").to_enum
ind = en.peek[/^(\s*)/].size
loop do; puts en.next[ind..]; end

The first version is using ||= to get the indentation of the first line.

The second is creating an array of lines and checks the first item for indentation.

Loop_enum

Thu, 29 Aug 2024 21:24:25 +0200

By accident I discovered that a loop ends when an enumerator is spent (sends StopIteration).

en = %w(olle pelle kalle nisse).to_enum
loop do
  p en.next
end

puts 'done!'

Pretty convenient.

FilePointer

Mon, 26 Aug 2024 22:16:26 +0200

The file-pointer is like the needle on a old vinyl gramophone. You can lift the arm and reposition the needle anywhere on the LP (or EP).

In Ruby you use seek and tell from IO.

fh = File.open('file.txt')
fh.seek(0, :END) # move pointer to end
EOF = fh.tell # read pointer value
fh.seek(0, :SET) # move pointer to beginning

Any reading from the file starts from where the file-pointer is.

fh.seek(-200, :CUR)
p fh.readline

I used this to make an indexer. It reads tags in the file and stores the file-pointer position in a corresponding yaml-file.

Classes_and_Ignorance

Tue, 20 Aug 2024 19:32:43 +0200

#!/usr/bin/env ruby
# frozen_string_literal: true



#############
# CONSTANTS #  TODO: See if I need these... or put them in Deck
#############
CONSTANTS = [
  SUITE = {H: 'Hearts', D: 'Diamonds', C: 'Clubs', S: 'Spades'},
  RANK = [*2..10].push(*%i(J Q K)).unshift(:A)
  # NOTE: Do I need translation :J => 'Jack' etc. ?
]


##########
# STRUCT #
##########
Card = Struct.new(:rank, :suite) do
  def s = ( SUITE[suite] )
  def r = ( RANK.index(rank) +1 ) # numeric rank
  def to_s = ( '%s of %s' % [rank, SUITE[suite]] )
end

Sum = Struct.new(:sum, :aces) do
  def low = ( sum )
  def high = ( ((ret = (sum + (aces? ? 10 : 0))) > 21) ? :bust : ret )
  def aces? = ( aces != 0 )
  def blackjack? = (self.low == 21 || self.high == 21)
end

##############
# Deck Class #
##############
class Deck
  def initialize(no_decks: 1)
    @deck = []
    
    no_decks.times { RANK.product(SUITE.keys).each {|c|
      @deck.append(Card.new(c.first, c.last))
    }}
    
  end

  def shuffle = @deck.shuffle!
  def deal    = @deck.pop
  def cards   = @deck.length
  
end

##############
# Hand Class #
##############

class Hand
  attr_reader :hand

  def initialize(decks = 1)
    @hand = [] # hold Card (is a Struct)
    @@deck_obj ||= Deck.new(no_decks: decks)
    @@deck_obj.shuffle
  end

  def deal(no_cards = 1) = ( no_cards.times { @hand.push @@deck_obj.deal } )

  def sum = ( Sum.new(@hand.inject(0) {|s, h| s +=  ((h.r > 10) ? 10 : h.r) },
    @hand.select {|h| h.r == 1}.size) )
end

# -----------------------------------------------------------------------------

p1 = Hand.new
p1.deal(2)

p2 = Hand.new
p2.deal(2)


[p1, p2].each {|p|
  p.hand.each { puts _1.to_s }
  sm = p.sum
  if sm.blackjack?
    puts 'Blackjack!'
  else
    print 'sum: '
    puts sm.aces? ? 'lo: %s, hi: %s' % [sm.low, sm.high] : sm.sum
    puts '-'*80
  end
}

I just hade the urge to revisit Blackjack. It’s such a great start for working with classes. I’m not that good with classes..

Winsetter

Tue, 13 Aug 2024 18:33:58 +0200

Winsetter revisited. This time with yaml-config file. Code is sort of.. shitty. But I wrote this yesterday (2024-08-12), and it’s still a test.

This is the yaml

---
windows:
  - name: Alacritty
    xpos: 0 # position the app
    ypos: 0
    width: 800 # resize the app
    height: 1031
    #set: ['SHADED'] # roll up the app
  - name: Firefox
    xpos: 804 # position the app
    ypos: 0
    width: 1112 # resize the app
    height: 1031
  - name: KeePassXc
    minimize: true # minimize the app

  - name: Cherrytree
    start: cherrytree # launch the app
    desktop: 1 # move the app to desktop 1

Here is the code

Conditions

Fri, 09 Aug 2024 19:25:11 +0200

class Test

  def make(name, &bl)
    Object.define_method(name) do |*args|
      bl
    end
  end

end

running = true  # must be true
kaka = [3,7,12] # must include 12
name = :otto    # must be a symbol

# initialize
test = Test.new

# create a test
test.make('check') {|r, k, n|
  r && (k.include? 12) && (n.is_a? Symbol)
}

# run the test
p test.check.(running, kaka, name) # true

# another set of data
another_running = true
another_kaka = [12]
another_name = 'erik'

# another test
p test.check.(another_running, another_kaka, another_name) # false

#####################################
# You can also do things like this: #
#####################################

Person = Data.define(:country, :city, :age)
ppl = {
  urban: Person.new(:SE, 'uppsala', 34),
  emma: Person.new(:SE, 'sjöbo', 16),
  linus: Person.new(:UK, 'leeds', 21)
}

peeps = Test.new
peeps.make(:SE) {|age| age > 21 }
peeps.make(:UK) {|age| age > 18 }

# :SE rule is used for Data.country == :SE
# :UK rule is used for Data.country == :UK
ppl.each {|k,v|
  p '%s (%s) => %s' % [k, v.age, v.city] if peeps.send(v.country).(v.age)
}

ErrorMessages

Sun, 14 Jul 2024 23:04:29 +0200

I just wrote something to get the libc descriptions of Ruby Errno.

Below is something else.. just some code to show some stuff.

p @names
# => {"Olle"=>"11", "Pelle"=>"6", "Kalle"=>"2", "Pellegrino"=>"0"}


BEGIN {
  NL, CM = "\n", ','

  module AmpArgs
    refine Symbol do
      def call(*args, &block) = ( ->(caller, *rest) {
        caller.send(self, *rest, *args, &block) } )
    end
  end
  
  using AmpArgs

  @names = <<~NAMES.split(NL).map(&:split.(CM)).to_h
    Olle,3
    Pelle,6
    Kalle,2
    Olle,11
    Pellegrino,0
  NAMES
}

The BEGIN block is run first. That is to read the HEREdoc into a hash.

Gambas_Ruby

Tue, 09 Jul 2024 17:48:30 +0200

It’s not easy loving Ruby these days. It’s the rails thing. It hurt Ruby a lot. And it’s also choices of words:

When you name a programming language.. don’t name it ‘it’ or ‘red’ or ‘also’. Searching for ‘Ruby gems’ gives you page after page with sandals with glitter on them.

Searching for ‘ruby’ alone brings up some child molestor or a gender-fluid actor.. or a comedian no-one remembers.
Ruby is a great language that has been mismanaged.

Glimmer

Tue, 25 Jun 2024 17:01:36 +0200

Håller på att kika på Glimmer.. ett bibliotek för att göra GUI applikationer.

Har inte hunnit komma någonstans.. men det verkar som om man skapar sin layout via block.

# dummy
window(specs) {
  vertical_grid {
    textarea {}
    button {}
  }
}

Det verkar också som att man kan korskoppla parametrar.. så om en uppdateras, uppdateras också den andra.

Men - som Paolo Roberto sa: - ‘Nu är det dags att sluta spekulera!’

Listen

Mon, 24 Jun 2024 18:48:38 +0200

listen listens to file-changes in a directory.
You install it with gem install listen.

require 'listen'

lst = Listen.to('.') do |mod, add, rem|
  puts(mod: mod, add: add, rem: rem)
end

lst.start
sleep

I’m not sure right now if you need to lst.stop before quitting or if it takes care of itself when the main process dies.
Otherwise you could put the command in the ensure-block.. or trap signals and handle it there.

The code listens for changes in the current directory. If you open another terminal or use tmux.. and create a file in the same directory:

Homevideo

Sun, 23 Jun 2024 14:19:19 +0200

%w(httparty nokogiri ./homevideo.rb).map(&method(:require))

def go_web
  puts 'fetching from internet...'
  url   = %(http://www.guldpris.nu)
  xpath = %(//*[@id="ratePreUnitTwoSEK"])
  
  Nokogiri::HTML(HTTParty.get(url).body).xpath(xpath).map {|i|
    i[:value]
  }
end

# This is how the Yeger-class can be used ...
yeg = Yager.new(:data, 4.hours)
yeg.value(go_web[0]) if yeg.outdated?

puts yeg.value

Found VCR a bit.. too much.. so I wrote ‘homevideo’.
When initialized you set the filename (as symbol) and the time-limit in seconds (default 10.minuntes).

Time-stamp and limit is read from yaml-file. If time-stamp is passed limit, method outdated? returns true (and the new values are stored).

VCR

Sat, 15 Jun 2024 17:36:08 +0200

VCR uses the concept of an old video cassette player. On the cassettes, you can store results from web-requests.
First you configure the recorder.

VCR.configure do |c|
  c.cassette_library_dir = "cache/vcr"
  c.hook_into :webmock
end

Your recording will end up in directory cache/vcr.
To emulate web-calls, :webmock is used.

VCR.use_cassette('test') do
    res = HTTParty.get(url).body
end

Let’s say you are working on some script that collects data from a server. During testing, you run the script again and again. Everytime you call the server.

Particles_ruby2d

Wed, 12 Jun 2024 20:34:53 +0200

require 'ruby2d'
require 'parallel'

@parts = []

class Part < Square
  attr_reader :dx, :dy

  def initialize(**args)
    speed = rand * 10 + 5
    direction = rand * 360
    @dx, @dy = speed * Math.cos(Math::PI * 2 * direction / 360),
      speed * Math.sin(Math::PI * 2 * direction / 360)

    super(**args)
  end

end

def add_part(x, y, n)
  n.times { @parts << Part.new(x: x, y: y, size: 4) }
end

def remove_outsiders
  @parts.delete_if {|p|
    !(p.x).between?(-5, 645) || !(p.y).between?(-5, 485)
  }

  @txt.text = 'Particles: %s' % @parts.size
end

def move_particle(obj)
  obj.x += obj.dx; obj.y += obj.dy
end

on :key_down do |e| close if e.key == 'q' end
on :mouse_down do |e| add_part(e.x, e.y, 90) end

@txt = Text.new('Particles: 0')

update do
  remove_outsiders
  Parallel.map(@parts, in_threads: 20) {|o| move_particle(o)}
end

show

Assert

Thu, 30 May 2024 23:24:05 +0200

require 'binding_of_caller'

def assert(cond)
  puts 'row [%s] / FAIL! [%s]' % [caller[-1].split(':')[1], cond] \
    unless eval(cond, binding.of_caller(1))
end

namn = 'holger'
assert %(namn == 'hulken') # => row [9] / FAIL! [namn == 'hulken']
assert %(namn == 'holger') # =>

Install gem with:
gem install binding_of_caller

Snake_regrets

Mon, 27 May 2024 22:19:44 +0200

I should have used a Struct to translate between pixel positions and the grid.

Point = Struct.new(:x, :y) {
  def screen = ( [x*8, y*8] )
  def self.screen(x, y) = ( [x*8, y*8] )
  
  def grid = ( [x/8, y/8] )
  def self.grid(x, y) = ( [x/8, y/8] )

  def grid_diff = ( [(x/8*8) - x, (y/8*8) - y] )
  def self.grid_diff(x, y) = ( [(x/8*8) - x, (y/8*8) - y] )
}

or maybe this is better..

Point = Struct.new(:x, :y) {
  def screen = ( self.x, self.y = x*8, y*8 )
  def grid = ( self.x, self.y = x/8, y/8 )
}

Snake

Sun, 26 May 2024 19:02:19 +0200

A starting point for a simple snake game on a 80x60 grid (640x480 px).

I was planning to use @sn[:trail] for collision detection.. but that went south and I added @map and the @mapper lambda for that.

Missing: no food, no points, no start- or exit screen.

Defaults right now to a 88 grid long snake.

Keys: arrow keys & ‘q’ for quit.

require 'ruby2d'

DIFFICULTY, SPEED, WRAP, GROW = nil, 30, true, 2

case DIFFICULTY
  when 1 then SPEED, WRAP, GROW = 30, true, 1
  when 2 then SPEED, WRAP, GROW = 40, true, 2
  when 3 then SPEED, WRAP, GROW = 50, true, 3
  when 4 then SPEED, WRAP, GROW = 55, false, 3
  when 5 then SPEED, WRAP, GROW = 60, false, 5
end

set fps_cap: SPEED
@mapper = ->(x,y, set) { @map[y/8][x/8] = (set ? '1' : '0') }
@map = [].tap {|ar| 60.times {ar << '0' * 80 } }
@mapper.(320, 240, true)

class Integer alias :btw :between? end
class Array alias :→ :include? end

class Pos
  attr_accessor :x, :y
  def initialize(x, y) = ( @x, @y = x, y )
end

@sn = { len: 88, trail: [Square.new(x: 320, y: 240, size: 8)],
        pos: Pos.new(40, 30), dir: Pos.new(8, 0) }

def grow_or_move(pos, grow: false)
  abort('oroboro') if @map[pos.y/8][pos.x/8] == '1'
  @sn[:trail] << (grow ? Square.new(size: 8) : @sn[:trail].shift)
  @mapper.(pos.x, pos.y, true)
  @mapper.(@sn[:trail].last.x, @sn[:trail].last.y, false) unless grow
  @sn[:trail].last.x, @sn[:trail].last.y = pos.x, pos.y
end

on :key_down do |e|
  if %w(left right).→(e.key) && @sn[:dir].x.zero?
    @sn[:dir].x, @sn[:dir].y = (e.key == 'left') ? -8 : 8, 0
  elsif %w(up down).→(e.key) && @sn[:dir].y.zero?
    @sn[:dir].y, @sn[:dir].x = (e.key == 'up') ? -8 : 8, 0
  else close if e.key == 'q'
  end
end

update do
  grow_or_move(Pos.new(@sn[:trail].last.x += @sn[:dir].x, @sn[:trail].last.y += @sn[:dir].y), grow: @sn[:trail].size <= @sn[:len])
  
  if WRAP
    @sn[:trail].last.x, @sn[:trail].last.y = @sn[:trail].last.x % 640, @sn[:trail].last.y % 480
  else abort('outside') unless @sn[:trail].last.x.btw(0, 640) && @sn[:trail].last.y.btw(0, 480)
  end
end

show

Prepared_hash

Tue, 14 May 2024 21:19:38 +0200

class Hash
  def insert(*args)
    Hash[self.keys[..args.size-1].zip(args)].each {|k,v|
      self[k] = v
    } if args.size <= self.size
    self
  end
end

hsh = {x: 10, y: 20, width: 200, height: 100, color: 'blue'}

p hsh.insert(5, 8)
# => {:x=>5, :y=>8, :width=>200, :height=>100, :color=>"blue"}

p hsh.insert(10, 20, 300, 150, 'orange')
# => {:x=>10, :y=>20, :width=>300, :height=>150, :color=>"orange"}


# Example :

class Apa
  def initialize(x:, y:, name:, border: false)
    @x, @y = x, y
    @name = name
    @border = border
  end
end

parms = {x: nil, y: nil, name: '', border: true}

apa = Apa.new(**parms.insert(12, 8))
p apa
# => #<Apa:0x000058799cf82398 @y=8, @x=12, @name="", @border=true>

Ruby2d_hitboxes

Mon, 13 May 2024 21:43:51 +0200

require 'ruby2d'

@quad = Quad.new(
  x1: 10, y1: 10,
  x2: 200, y2: 20,
  x3: 180, y3: 180,
  x4: 50, y4: 220,
  color: 'olive'
)

@selected = nil

@corners = [*1..4].each_with_object([]) {|i, o|
  o << eval("Circle.new(x: @quad.x#{i}, y: @quad.y#{i}, z: 2, radius: 5, sectors: 32, color: 'red')")
}

active = ->(o,i) { o.color='yellow'; @selected=i }
inactive = -> { @corners.each {_1.color='red'}; @selected=nil }

def upd(x, y)
  if @selected
    @corners[@selected].x = x
    @corners[@selected].y = y
    eval("@quad.x#{@selected+1} = x")
    eval("@quad.y#{@selected+1} = y")
  end
end

on :mouse_down do |e|
  @corners.each_with_index {|c, i| active.(c, i) if c.contains?(e.x, e.y) }
end

on :mouse_up do |e| upd(e.x, e.y); inactive.() end
on :mouse_move do |e| upd(e.x, e.y) end

update do
  sleep 0.025
end

show

This ugly code is a test for my little helper-app that defines hitboxes for a square image in order to use collision detection.

Ruby_r16

Thu, 02 May 2024 21:10:45 +0200

I use Ruby to monitor the sliders (8 channels + Master) on my Zoom R16.

asciinema

Byebug

Thu, 25 Apr 2024 19:59:27 +0200

From today I prefer byebug over pry.
Just set some breakpoint(s) and display the var you need to monitor.

Struct_cond

Tue, 23 Apr 2024 19:14:49 +0200

alias ¤ puts

module Enumerable
  def €(*ar, &bl) = ( each(*ar, &bl) )
end

Cond = Struct.new(:t, :f) {
  def ĸ(cond) = (cond ? t.call : f.call)
}

c = Cond.new(
  -> { ¤ 'this is even' },
  -> { ¤ 'this is odd' }
)


# now you can use:
(2..12).€ { c.ĸ(_1 % 2 == 0) }

It’s not that I wanna do code-golfing.. But I try to find my personal style of coding. There’s a lot of repetition in code that I don’t like.

Numerology

Fri, 19 Apr 2024 21:20:30 +0200

Read something about ’name-to-number’.
It was:

1 2 3 4 5 6 7 8 9
A B C D E F G H I
J K L M N O P Q R
S T U V W X Y Z

Then: sum the numbers to total and add the parts of the number.
Ex: 'TRAZAN APANSSON' = 2+9+1+8+1+5 + 1+7+1+5+1+1+6+5
=> 26 + 27 = 53
5 + 3 = 7

# I group the letters [[AJS], [BKT]] .. and so on...
letters = [*'A'..'I'].zip([*'J'..'R'], [*'S'..'Z'])

# could use 'each' and 'index'
num = ->(ch) {letters.each_with_index {|l, i| return i+1 if l.include?(ch)}; 0 }

# remove 9 until < 10
zum = ->(i) { while i > 9; i -= 9; end; i}

# main proc
to_num = ->(nm) {zum[[].tap {|ar| nm.upcase.chars {|c| ar << num[c]} }.sum]}


name = 'Oliver Cromwell'
p to_num[name]
# => 2

To shorten it…

Intervals

Sun, 14 Apr 2024 19:10:43 +0200

require 'open3'
require 'tty-cursor'
require 'tty-screen'

KEYBOARD        = 'Keystation 49es'
LOW_C           = 0
CUR             = TTY::Cursor
HEIGHT, WIDTH   = TTY::Screen.size
NOTENAMES       = %i(C C♯/D♭ D D♯/E♭ E F F♯/G♭ G G♯/A♭ A A♯/B♭ B)
INTERVAL_NAMES  = %i(P1 m2 M2 m3 M3 P4 A4/d5 P5 m6 M6 m7 M7 P8
                     m9 M9 m10 M10 P11 A11/d12 P12 m13 M13 m14 M14 P15)

# incomplete
CHORDNAMES     = {
  '027'   => 'sus2',
  '026'   => 'sus2 ♭5',
  '0510'  => 'sus2 (1:st inv)',
  
  '036'   => 'diminished',
  '039'   => 'diminished (1:st inv)',
  '069'   => 'diminished (2:nd inv)',
  
  '037'   => 'minor',
  '049'   => 'minor (1:st inv)',
  '058'   => 'minor (2:nd inv)',
  
  '047'   => 'major',
  '046'   => 'major ♭5' ,
  '038'   => 'major (1:st inv)',
  '059'   => 'major (2:nd inv)',
  
  '048'   => 'augmented',
  
  '057'   => 'sus4',
}

alias ¤ print
¤ CUR.hide


# Ctrl-C hook
¤ CUR.move_to(0, HEIGHT-2); ¤ '-' * WIDTH
Signal.trap("SIGINT") {
  puts "\n", '-' * WIDTH
  ¤ CUR.show; RD.close; exit(true)
}

# get keyboard and data or quit
nope = -> { puts %(Can't find keyboard!); exit }
data = `aseqdump -l | grep '#{KEYBOARD}'`
(data == '') ? nope[] : (port = data.split[0])

# open pipe (skip write)
WR, RD = Open3.popen2("aseqdump -p #{port}"); WR.close

def notename(no) = ( NOTENAMES[no.divmod(12)[1]].upcase )
def interval(tup) = ( INTERVAL_NAMES[tup[1]-tup[0]] )
def tritone(tri) = ( CHORDNAMES[tri.map {|n| n - tri[0]}.join] )

def show(ch)
  ¤ CUR.move_to(0,HEIGHT)
  ¤ CUR.clear_line
  case ch.length
  when 1
    ¤ 'note: %s' % notename(ch.first)
  when 2
    ¤ 'interval: %s' % interval(ch)
  when 3
    ¤ 'tritone: (base: %s) %s' % [notename(ch.first), tritone(ch)]
  else
    ¤ 'complex: %s (%s)' % [ch.join(' '), 'not implemented']
  end
end

# loop
chord = []
while line = RD.gets
  chord = [] if /Control change/ =~line # foot pedal *)
  if /Note (on|off)/ =~ line
    note = line.split[5].chomp(',')
    ($1 == 'on') ? (chord << note.to_i) : chord.delete(note.to_i)
    show(chord.sort) unless chord.empty?
  end
end

=begin
          *)    reset 'hung' midi with foot-pedal.

=end

Short

Fri, 12 Apr 2024 19:02:50 +0200

class Out
  attr_writer :frm, :meth
  def initialize(frm = '%s', meth = :puts) =
    ( @frm, @meth = frm, meth )
  def →(*ar) = ( send @meth, @frm % [*ar] )
end

class Array
  alias_method :đ, :first
  alias_method :ł, :last
  (0..9).each {|no| define_method(:"_#{no}") { self[no] } }
end

class String
  def ĸ(rx, &bl) = ( scan(rx).each &bl )
end

O = Out.new('%s: %s')
def →(*args) = ( O.→(*args) )

# ==========================================

str = %(one 1 two 2 three 3 four 4)

str.ĸ(/(\w+) (\d)/) { → _1.đ, _1.ł }
O.frm = '%s'; O.meth = :p


→ [1,2,3]._0 # => 1
→ %w(one two three)._2 # => three
→ %(hejsan hoppsan i lingonskogen).split(' ')._3 # => lingonskogen

---------------------------------------------
ĸ is scan(REGEX).each { BLOCK }
→ is Out.→
  and uses output format defined with Out.frm
  and a print method defined with Out.meth

đ is Array#first
ł is Array#last
_0 .. _9 is Array index [0] .. [9]

Garbage

Sat, 06 Apr 2024 20:20:29 +0200

class Apa
  def initialize = ( @lu = {} )
  def method_missing(k, v = nil) = ( v ? 
    (@lu[k] = v) : @lu.key?(k) ? @lu[k] : nil )
  def _sto(file) = ( File.write(file, Marshal.dump(@lu), mode: 'wb') )
  def _rec(file) = ( @lu = Marshal.load(File.read(file)) )
  def _eval(k) = ( @lu[k] = eval(@lu[k]) )
end

I was hoping to be able to serialize a full set of data, procs, lambdas. But it still has’nt worked out that way. What I got so far is a stupid workaround where procs and lambdas must be stored as strings and then evaluated.

Grest

Fri, 29 Mar 2024 18:54:16 +0100

require 'levenshtein'
require 'soundex'

wrd = 'GREST'.chars #   KEYWORD
great = 'GREAT'.chars # VALUE

diff = (great - wrd).first # A

idx = Levenshtein.distance(wrd.join, great.join) # NO OF SHIFTS

idx.times { wrd.shift }

wrd.unshift(diff) # INSERT DIFF

# SOUNDEX ARREST?
p ((Soundex.new wrd.join).to_s == (Soundex.new 'ARREST').to_s) ? 'YEP' : 'NO'

Trurl

Wed, 27 Mar 2024 19:23:25 +0100

trurl is (I think) maintained by Daniel Stenberg (creator, maintainer of curl).

It provides getters and setters for the components of a url.
The components are: scheme, user, password, options, host, port, path, query, fragment, zoneid.

Matching_brackets

Tue, 26 Mar 2024 22:38:50 +0100

Just a simple little thing… I want to match curly-brackets in code…
Turns out: I can’t do it!

There is no regex that can do it. You can look ahead and look around all you want.

You can not just match char:{ with char:} ..
Because: What about puts '}HELLO{' or regx = /\{/ ?

You’d need to start code-parsing.. and I do not have that skill.

Arguments

Thu, 14 Mar 2024 00:07:55 +0100

class Argy
  def initialize = (@args = ARGV)
  [:first, :second].each_with_index {|n,i|
    define_method :"#{n}" do; @args[i] || nil; end
  }
end

args = Argy.new

puts (args.first && args.second) ?
  'two args (or more): %s & %s' % [args.first, args.second] :
  (args.first) ? 'one arg: %s' % args.first : 'no arg'

Just a test on command line arguments.
The class is defining two methods (:first and :second), that returns ARGV[0] OR nil or ARGV[1] OR nil respectively.

Then a double ternary if is reporting ’two or more args’, ‘one arg’ or ’no args’.

Daemon

Fri, 08 Mar 2024 21:17:50 +0100

It’s super-easy writing a daemon in ruby with the daemon gem.

write the code inside a loop (use some sleep).
create the server-script by just requiring and initializing daemon.

Now you can use the server-script to:

start
stop
restart
status
run

..the code.
All boilerplate is taken care of. Pure bliss!

Comparable_donkeys

Fri, 08 Mar 2024 20:12:57 +0100

class Ior
  include Comparable
  attr_reader :tail

  def initialize(tail: true)
    raise TypeError.new 'Ior expected a Boolean value' unless !!tail == tail
    @tail = tail
  end

  def <=>(other) = (@tail ? 1 : 0 <=> other.tail ? 1 : 0)
  def to_s = ('This one has %s tail' % [@tail ? 'a' : 'no'])

end

donkey1 = Ior.new
puts donkey1 # => This one has a tail

donkey2 = Ior.new(tail: false)
puts donkey2 # => This one has no tail

# a donkey with tail is greater than one without
puts donkey1 > donkey2 # => true
puts donkey1 == donkey2 # => false

donkey3 = Ior.new(tail: 2) # two tails!
# => Ior expected a Boolean value (TypeError)

Flip Flop

Thu, 07 Mar 2024 20:04:42 +0100

class Array
  def ff(start, finish, inclusive: true)
    a,b = inclusive ? [0,-1] : [1,-2]
    select {|i| i if (i == start)..(i == finish)}[a..b]
  end
end

names = %w(Otto Arne Peter START Kapris Oregano END Sune Fetto)

p names.ff('START', 'END') # ["START", "Kapris", "oregano", "END"]
p names.ff('START', 'END', inclusive: false) #["Kapris", "Oregano"]

I was trying to figure out if there was a way to make the flip-flop operator exclusive. Didn’t find much of anything.. so this is what I came up with.

Just a first try… a lot of holes in this solution.

mp3md

Thu, 29 Feb 2024 21:10:00 +0100

DIR     = %(content/music/)
MP3DIR  = %(audio)

$md = <<~'MD'
  +++
  title = '@@title'
  date = 2024-02-28T18:04:10+01:00
  draft = false
  +++

  (two curly braces)< audio src="@@title.mp3" >(closing braces)
MD

def create_md(title)
  path = '%s%s.md' % [DIR, title]
  File.write(path, $md.gsub(/@@title/, title)) unless File.exist? path
end

Dir.glob(format('%s%s/*.mp3', DIR, MP3DIR)).each do |file|
  create_md(File.basename(file.delete_suffix('.mp3')))
end

I use this to create an md-file for every mp3-file found in subfolder. (closing braces) is replaced with ‘}}’ and (two curly braces) is replaced with ‘{{’

inserting shortcode from layouts (a simple audio tag)

Fizzbuzz

Wed, 28 Feb 2024 21:50:25 +0100

d = ->(n) { (n%2 == 0 ? 1 : 0) + (n%3 == 0 ? 2 : 0) }
(1..15).each { p [nil,:fizz,:buzz,:fizzbuzz][d.(_1)] || _1 }

Mon, 01 Jan 0001 00:00:00 +0000

I wanted to use <Leader>+r to toggle fullscreen; create a new tab; create three panes in that tab. Tried wezterm.action.Multiple .. but settled with action_callback and the mux API.

  {
    key = 'r',
    mods = 'LEADER',
    action = wezterm.action_callback(function(win, pane)
      win:toggle_fullscreen {}
      local wmux = win:mux_window {}
      local t, p, w = wmux:spawn_tab {}
      p:split {direction = 'Bottom', size = 0.2, args = { 'irb' }}
      p:split {direction = 'Right', size = 0.2, args = { 'ri' }}
      p:activate()
    end),
  },