xot 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e347867590b9d9d97a002320ac500f075dde62556b0944b2a35705b415e2806
-  data.tar.gz: c684375fa42a755e7cef817aad1c658fd26f484b515876cb35323e56e1c313bd
+  metadata.gz: 8bdbb4eecd0d88463747c1df1bd34d727f94eec833ae6d02827b991353f8f294
+  data.tar.gz: 43945ff6140b64dda239f7cd7ebfbfd9445140e3569582be88c2f17a105653ca
 SHA512:
-  metadata.gz: d94d2378ba6835df631dd21ef26140f3cc43af8c370478d7b7c6ce0e6e433fd08deafa45810970995942e3f1a1f04f4343894aa9ce5c5a276c60f442f1faf0de
-  data.tar.gz: 2dd7f8827dd1804be81babfe7b89410f41a96b280ac57f30724c67b63b3356a2ab71cddb4d10465e4ee49c34450d1e5f961dff24a84931a89a0bbf5f60159cda
+  metadata.gz: 411340544314d34155b41df758eb53d053fdb58e805bba8ddc34d588e834e3b21caa48bd89827847ca93d946efa114c46fda3ba2e29c12350da5af2c2df129ba
+  data.tar.gz: ef728a1a99b8211faa0b73e1d9ee14391a4e9197959b33dff6de15b7499552beb7b06410881d1e14721f231f033db28e54e4ef98c3828c1d892a5bfad62892ab

data/.github/actions/setup-monorepo/action.yml

@@ -0,0 +1,44 @@
+name: setup monorepo
+description: 'check out xord/all next to the app, and build and link its libraries, with the cache'
+
+inputs:
+  ref:
+    description: 'branch, tag or commit of xord/all'
+    required: true
+  libraries:
+    description: 'the libraries of xord/all, by the order to build'
+    required: true
+
+runs:
+  using: composite
+
+  steps:
+    - name: prepare monorepo
+      id: prepare
+      shell: bash
+      env:
+        REF:     ${{ inputs.ref }}
+        LIBS:    ${{ inputs.libraries }}
+        RUBYLIB: ${{ github.action_path }}/../../../lib
+      run: |
+        commit=$(git ls-remote https://github.com/xord/all.git "$REF" | tail -1 | cut -f1)
+        commit=${commit:-$REF}
+        dir=$(ruby -rxot/rake -e 'puts File.expand_path MONOREPO_DIR')
+        prefix=$(ruby -e 'puts RbConfig::CONFIG["prefix"]')
+        echo "commit=$commit"                           >> "$GITHUB_OUTPUT"
+        echo "dir=$dir"                                 >> "$GITHUB_OUTPUT"
+        echo "cache-key=monorepo-$commit-$LIBS-$prefix" >> "$GITHUB_OUTPUT"
+
+    - name: cache monorepo
+      uses: actions/cache@v4
+      with:
+        path: ${{ steps.prepare.outputs.dir }}
+        key:  ${{ steps.prepare.outputs.cache-key }}
+
+    - name: setup monorepo
+      shell: bash
+      env:
+        COMMIT:  ${{ steps.prepare.outputs.commit }}
+        LIBS:    ${{ inputs.libraries }}
+        RUBYLIB: ${{ github.action_path }}/../../../lib
+      run: ruby -rxot/rake -e 'setup_monorepo(*ARGV)' "$COMMIT" $LIBS

data/.github/workflows/release-gem.yml

@@ -4,6 +4,16 @@ on:
   push:
     tags: ['v[0-9]*']
 
+  workflow_call:
+    inputs:
+      ruby-version:
+        type: string
+      zig:
+        type: boolean
+    secrets:
+      RUBYGEMS_AUTH_TOKEN:
+        required: true
+
 permissions:
   contents: write
 
@@ -12,28 +22,33 @@ jobs:
     runs-on: macos-latest
 
     steps:
-      - name: ruby 3.2
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 3.2
-
       - name: checkout
         uses: actions/checkout@v4
 
+      - name: setup ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ inputs.ruby-version || '3.3' }}
+
       - name: setup gems
         run: bundle install
 
+      - name: setup xot
+        run: git clone -q --depth 1 https://github.com/xord/xot.git "${{ runner.temp }}/xot"
+
       - name: setup dependencies
-        run: "ruby -I.github/workflows -rutils -e 'setup_dependencies'"
+        env:
+          RUBYLIB: ${{ runner.temp }}/xot/lib
+        run: ruby -rxot/rake -e 'setup_dependencies'
 
       - name: packages
         run: bundle exec rake packages
 
       - name: setup zig
-        if: github.event.repository.name == 'reflex-terminal'
+        if: inputs.zig
         uses: mlugg/setup-zig@v2
         with:
-          version: 0.16.0
+          version: 0.17.0
 
       - name: test
         run: bundle exec rake test
@@ -47,7 +62,8 @@ jobs:
       - name: create github release
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: ruby -I.github/workflows -rutils -e 'release(*ARGV)' ./${{ steps.gem.outputs.path }}
+          RUBYLIB: lib:../xot/lib
+        run: ruby -rxot/rake -e 'release_on_github(*ARGV)' ./${{ steps.gem.outputs.path }}
 
       - name: upload to rubygems
         env:

data/.github/workflows/tag.yml

@@ -1,35 +1,69 @@
 name: Tag
 
 on:
-  push:
+  workflow_run:
+    workflows: [Test]
+    types: [completed]
     branches: [master]
 
+  workflow_call:
+    inputs:
+      ruby-version:
+        type: string
+      git-user-name:
+        type: string
+      git-user-email:
+        type: string
+    secrets:
+      PAT:
+        required: true
+
 jobs:
   tag:
     runs-on: ubuntu-latest
 
-    steps:
-      - name: ruby 3.2
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 3.2
+    # after the tests of a push, not of a fork, or as the caller tells
+    if: github.event_name != 'workflow_run' || (
+      github.event.workflow_run.conclusion == 'success' &&
+      github.event.workflow_run.event == 'push')
 
+    steps:
       - name: checkout
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          ref: ${{ github.event.workflow_run.head_sha || github.sha }}
           token: ${{ secrets.PAT }}
 
+      - name: setup ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ inputs.ruby-version || '3.3' }}
+
+      - name: setup xot
+        run: git clone -q --depth 1 https://github.com/xord/xot.git "${{ runner.temp }}/xot"
+
       - name: setup dependencies
-        run: "ruby -I.github/workflows -rutils -e 'setup_dependencies only: :xot'"
+        env:
+          RUBYLIB: ${{ runner.temp }}/xot/lib
+        run: "ruby -rxot/rake -e 'setup_dependencies only: :xot, ext: false'"
 
       - name: setup user name and email
+        env:
+          NAME: ${{ inputs.git-user-name ||
+            (github.repository_owner == 'xord' && 'xord') ||
+            'github-actions[bot]' }}
+          EMAIL: ${{ inputs.git-user-email ||
+            (github.repository_owner == 'xord' && 'xordog@gmail.com') ||
+            '41898282+github-actions[bot]@users.noreply.github.com' }}
         run: |
-          git config --global user.email "xordog@gmail.com"
-          git config --global user.name "xord"
+          git config --global user.name  "$NAME"
+          git config --global user.email "$EMAIL"
 
       - name: tag versions
-        run: "ruby -I.github/workflows -rutils -e 'tag_versions'"
+        env:
+          RUBYLIB: lib:../xot/lib:${{ runner.temp }}/xot/lib
+        run: ruby -rxot/rake -e 'tag_versions'
 
       - name: push tags
         run: git push origin --tags

data/.github/workflows/test.yml

@@ -5,33 +5,63 @@ on:
     branches: [master]
   pull_request:
 
+  workflow_call:
+    inputs:
+      ruby-version:
+        type: string
+      zig:
+        type: boolean
+      all-ref:
+        description: 'branch, tag or commit of xord/all for an app to take'
+        type: string
+      libraries:
+        description: 'the libraries of xord/all for all-ref, by the order to build'
+        type: string
+
 jobs:
   test:
     runs-on: macos-latest
 
     steps:
-      - name: ruby 3.2
+      - name: checkout
+        uses: actions/checkout@v4
+
+      - name: setup ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.2
+          ruby-version: ${{ inputs.ruby-version ||
+            (hashFiles('.ruby-version') != '' && 'default') ||
+            '3.3' }}
 
-      - name: checkout
-        uses: actions/checkout@v4
+      - name: setup xot
+        run: git clone -q --depth 1 https://github.com/xord/xot.git "${{ runner.temp }}/xot"
+
+      - name: setup monorepo
+        if: inputs.all-ref
+        uses: xord/xot/.github/actions/setup-monorepo@master
+        with:
+          ref:       ${{ inputs.all-ref }}
+          libraries: ${{ inputs.libraries }}
 
       - name: setup gems
+        env:
+          # not for all-ref, as the Gemfile takes the gems of the monorepo then
+          BUNDLE_FROZEN: ${{ hashFiles('Gemfile.lock') != '' && !inputs.all-ref }}
         run: bundle install
 
       - name: setup dependencies
-        run: "ruby -I.github/workflows -rutils -e 'setup_dependencies'"
+        env:
+          RUBYLIB: ${{ runner.temp }}/xot/lib
+        run: ruby -rxot/rake -e 'setup_dependencies'
 
       - name: packages
         run: bundle exec rake verbose packages
 
       - name: setup zig
-        if: github.event.repository.name == 'reflex-terminal'
+        if: inputs.zig
         uses: mlugg/setup-zig@v2
         with:
-          version: 0.16.0
+          version: 0.17.0
 
       - name: vendor
         run: bundle exec rake vendor

data/ChangeLog.md

@@ -1,6 +1,26 @@
 # xot ChangeLog
 
 
+## [v0.5.0] - 2026-11-04
+
+- [BREAKING] Remove the hint_memory_usage callback
+- [BREAKING] Raise ArgumentError instead of RuntimeError for an unknown bit flag
+- [BREAKING] Raise the deployment targets to macOS 11.0 and iOS 14.0
+- Return symbols in declaration order from BitFlag#bits2symbols
+- Add Xot::update_flag to set or clear a flag by a bool
+- Add Xot::call_and_log_errors to write an error to stderr instead of throwing it
+- Add Xot::ChangeLog and automate_release for the tasks to release by VERSION and ChangeLog.md
+- Add package_application for the tasks to package and release an app
+- Make the workflows of xot callable from other repositories, to test, tag, release and package an app
+- Take Ruby 3.3 as the oldest for the workflows
+- Install the git hooks before the changelog tasks
+- Declare rake and ostruct, which xot requires, as dependencies
+- Silence the deprecation warnings of OpenGL and OpenAL on macOS
+
+- Fix universal_accessor ignoring keyword-only calls
+- Fix remove_flag clearing the upper bits of a 64-bit value
+
+
 ## [v0.4.0] - 2026-08-04
 
 - [BREAKING] Rework String conversions to std::wstring and CFString

data/Gemfile.lock

@@ -1,21 +1,26 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    power_assert (3.0.1)
-    rake (13.3.1)
-    test-unit (3.7.7)
+    power_assert (3.1.0)
+    rake (13.4.2)
+    test-unit (3.7.8)
       power_assert
-    yard (0.9.39)
+    yard (0.9.45)
 
 PLATFORMS
-  arm64-darwin-21
-  arm64-darwin-23
-  arm64-darwin-24
+  ruby
 
 DEPENDENCIES
   rake
   test-unit
   yard
 
+CHECKSUMS
+  bundler (4.0.20) sha256=7978a8ac648767f5e635bc522445b79e80a52b907a39a36c2d8085ed6bc762ae
+  power_assert (3.1.0) sha256=fefe98ed5d3140628138f3f9f9194d6ece01f1320e69700d3c928adca7518251
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
+  test-unit (3.7.8) sha256=689d1ca53f4d46f678b4e5d68d8e4294f87fc5e8b9238cc4de7c5727e8d65943
+  yard (0.9.45) sha256=52e211493f7cb8a3ebf7e104a25a1e73937a3103092545d34cb88fafebb3dc51
+
 BUNDLED WITH
-   2.4.19
+  4.0.20

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/ext/xot/tester.cpp

@@ -111,6 +111,18 @@ test_util ()
 	if ( Xot::has_flag(flags, F0 | F1))      return false;
 	if ( Xot::has_flag(flags, F0 | F1 | F2)) return false;
 
+	Xot::  update_flag(&flags, F1, true);
+	if (!Xot::has_flag(flags, F0))           return false;
+	if (!Xot::has_flag(flags, F1))           return false;
+	if (!Xot::has_flag(flags, F0 | F1))      return false;
+	if ( Xot::has_flag(flags, F0 | F1 | F2)) return false;
+
+	Xot::  update_flag(&flags, F1, false);
+	if (!Xot::has_flag(flags, F0))           return false;
+	if ( Xot::has_flag(flags, F1))           return false;
+	if ( Xot::has_flag(flags, F0 | F1))      return false;
+	if ( Xot::has_flag(flags, F0 | F1 | F2)) return false;
+
 	int value;
 	int* p = &value;
 	if (!(Xot::get_pointer_flag(p) == false)) return false;

data/include/xot/util.h

@@ -5,9 +5,11 @@
 
 
 #include <stdint.h>
-#include <sys/types.h>
+#include <stdio.h>
 #include <math.h>
 #include <assert.h>
+#include <exception>
+#include <functional>
 #include <xot/defs.h>
 #include <xot/time.h>
 
@@ -64,7 +66,17 @@ namespace Xot
 	{
 		assert(pvalue);
 
-		*pvalue &= ~flag;
+		*pvalue &= ~(T) flag;
+	}
+
+	template <typename T>
+	inline void
+	update_flag (T* pvalue, uint flag, bool add)
+	{
+		if (add)
+			add_flag(pvalue, flag);
+		else
+			remove_flag(pvalue, flag);
 	}
 
 	template <typename T>
@@ -125,11 +137,21 @@ namespace Xot
 	}
 
 
-	typedef void (*HintMemoryUsageFun)(ssize_t);
-
-	void set_hint_memory_usage_fun (HintMemoryUsageFun fun);
-
-	void     hint_memory_usage (ssize_t size);
+	template <typename E = std::exception>
+	inline bool
+	call_and_log_errors (const std::function<void()>& fun)
+	{
+		try
+		{
+			fun();
+			return true;
+		}
+		catch (const E& e)
+		{
+			fprintf(stderr, "%s\n", e.what());
+			return false;
+		}
+	}
 
 
 #if defined(OSX) || defined(IOS)

data/lib/xot/bit_flag.rb

@@ -33,13 +33,13 @@ module Xot
     end
 
     def bits2symbols(bits)
-      array = []
-      bits.to_s(2).reverse.each_char.with_index do |char, index|
-        next unless char == '1'
-        symbol = @bit2sym[bit index]
-        raise "unknown bit #{index} for flag." unless symbol
+      array, rest = [], bits
+      @bit2sym.each do |bit, symbol|
+        next if (bits & bit) == 0
         array << symbol
+        rest &= ~bit
       end
+      raise ArgumentError, "unknown bits 0b#{rest.to_s 2} for flag." if rest != 0
       array
     end
 
@@ -49,12 +49,12 @@ module Xot
 
     private
 
-      def sym2bit(symbol)
-        bit = @sym2bit[symbol]
-        bit = flag symbol if !bit && @auto
-        raise "unknown symbol #{symbol.inspect} for flag." unless bit
-        bit
-      end
+    def sym2bit(symbol)
+      bit = @sym2bit[symbol]
+      bit = flag symbol if !bit && @auto
+      raise ArgumentError, "unknown symbol #{symbol.inspect} for flag." unless bit
+      bit
+    end
 
   end# BitFlag
 

data/lib/xot/bit_flag_accessor.rb

@@ -23,45 +23,45 @@ module Xot
 
     private
 
-      def define_bit_flag(name, bit_flag, flags, block)
-        bit_flag ||= Xot::BitFlag.new(**flags)
-        Xot::BlockUtil.instance_eval_or_block_call bit_flag, &block if block
-
-        define_singleton_method "#{name}_flag".intern do
-          bit_flag
-        end
+    def define_bit_flag(name, bit_flag, flags, block)
+      bit_flag ||= Xot::BitFlag.new(**flags)
+      Xot::BlockUtil.instance_eval_or_block_call bit_flag, &block if block
 
+      define_singleton_method "#{name}_flag".intern do
         bit_flag
       end
 
-      def define_bit_flag_writer(name, bit_flag)
-        writer = "#{name}=".intern
-        setter = "bf_set_#{name}__".intern
+      bit_flag
+    end
 
-        alias_method setter, writer
-        private setter
+    def define_bit_flag_writer(name, bit_flag)
+      writer = "#{name}=".intern
+      setter = "bf_set_#{name}__".intern
 
-        define_method writer do |*symbols|
-          __send__ setter, bit_flag.symbols2bits(symbols)
-        end
+      alias_method setter, writer
+      private setter
 
-        name
+      define_method writer do |*symbols|
+        __send__ setter, bit_flag.symbols2bits(symbols)
       end
 
-      def define_bit_flag_reader(name, bit_flag)
-        reader = name.intern
-        getter = "bf_get_#{name}__".intern
+      name
+    end
 
-        alias_method getter, reader
-        private getter
+    def define_bit_flag_reader(name, bit_flag)
+      reader = name.intern
+      getter = "bf_get_#{name}__".intern
 
-        define_method reader do
-          bit_flag.bits2symbols __send__(getter)
-        end
+      alias_method getter, reader
+      private getter
 
-        name
+      define_method reader do
+        bit_flag.bits2symbols __send__(getter)
       end
 
+      name
+    end
+
   end# BitFlagAccessor
 
 

data/lib/xot/rake/changelog.rb

@@ -0,0 +1,49 @@
+module Xot
+
+
+  class ChangeLog
+
+    HEADING = /^[[:blank:]]*##\s*\[\s*v(\d[\d\.]*)\s*\].*$/
+
+    def initialize(path = 'ChangeLog.md')
+      @path = path
+    end
+
+    attr_reader :path
+
+    def add(version, changes, date: Time.now)
+      version = version.to_s.delete_prefix 'v'
+      section = [
+        "## [v#{version}] - #{date.strftime '%Y-%m-%d'}",
+        changes.map {"- #{_1}"}.join("\n")
+      ].join("\n\n")
+
+      text = File.read @path
+      if index = text.index(HEADING)
+        text.insert(index, "#{section}\n\n\n")
+      else
+        text = "#{text.rstrip}\n\n\n#{section}\n"
+      end
+      File.write @path, text
+    end
+
+    def sections()
+      File.read(@path)
+        .split(HEADING)
+        .drop(1)
+        .each_slice(2)
+        .to_h {|version, changes| [version, changes.to_s.strip]}
+    end
+
+    def versions()
+      sections.keys
+    end
+
+    def changes(version)
+      sections[version.to_s.delete_prefix 'v']
+    end
+
+  end# ChangeLog
+
+
+end# Xot