xot 0.3.11 → 0.3.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d39e1f35513ab0d63cdf20e907d710f2ee955ede52fa2734b4ec8e1e2f129b0c
-  data.tar.gz: 8e998e8a7ab8afd2450c1c1c52aec4640466e9c73ea0a41e28778af065274bbf
+  metadata.gz: 9b42a573c90d9544aae23f3fe0768c88205bea55ca9279b68e794fd6067d7671
+  data.tar.gz: 4f3c4072b4c446d4b2afa46226df1f8e2101717951f274913b4a2ed81ae8dc39
 SHA512:
-  metadata.gz: ba04a304d6e2ff49e0af62102235720bd3057a4e7545a022de7dfdcfd8bff747a77d77aa9171dfe6cf02adc7b774e57adaaca31b2a5cdc78f824644b59d64175
-  data.tar.gz: 6a280e45f3bdf1fef6188a88097ff00de70bb1bc9900e3a159003ca232b06066b0d626fde1490084145d7dc65320755df62c30e3c657602f5962e657d0aa09b4
+  metadata.gz: 0c98011d4d8e0b8a8f31365af23d52ce1f170abacd1edbc8b704cbf098da6e4f174f41e24a54d819e7816499fd801c9a09ef33283cefaad127e443fff9cacb0c
+  data.tar.gz: 1c73c446d67a45360c08b4db4f6de67a5330d1d320f4cc8fd5badf5f1758391b35dbbb2d74e49c529dacbf3c876c438e787153827630f3c6e29b5da409383eb0

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

@@ -4,6 +4,9 @@ on:
   push:
     tags: ['v[0-9]*']
 
+permissions:
+  contents: write
+
 jobs:
   release:
     runs-on: macos-latest
@@ -33,23 +36,9 @@ jobs:
           echo path=$(ruby -e 'print Dir.glob("*.gem").first') >> $GITHUB_OUTPUT
 
       - name: create github release
-        id: release
-        uses: actions/create-release@v1
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: ${{ github.ref }}
-
-      - name: upload to github release
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.release.outputs.upload_url }}
-          asset_path: ./${{ steps.gem.outputs.path }}
-          asset_name:   ${{ steps.gem.outputs.path }}
-          asset_content_type: application/zip
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: ruby -I.github/workflows -rutils -e 'release(*ARGV)' ./${{ steps.gem.outputs.path }}
 
       - name: upload to rubygems
         env:

data/.github/workflows/utils.rb

@@ -1,3 +1,9 @@
+require 'shellwords'
+
+ALL_REPO        = 'xord/all'
+ALL_DIR         = '../all'
+ALL_FETCH_DEPTH = 100
+
 RENAMES = {reflex: 'reflexion'}
 
 def sh(cmd)
@@ -5,7 +11,7 @@ def sh(cmd)
   system cmd
 end
 
-def setup_dependencies(build: true, only: nil)
+def setup_dependencies(only: nil)
   gemspec_path = `git ls-files`.lines(chomp: true).find {|l| l =~ /\.gemspec$/}
   return unless gemspec_path
 
@@ -13,44 +19,109 @@ def setup_dependencies(build: true, only: nil)
   name    = File.basename gemspec_path, '.gemspec'
 
   exts = File.readlines('Rakefile')
-    .map {|l| l[%r|^\s*require\W+(\w+)/extension\W+$|, 1]}
+    .map {|l| l[%r|^\s*require\W+([\w\-\_]+)/extension\W+$|, 1]}
     .compact
     .reject {|ext| ext == name}
   exts = exts & [only].flatten.map(&:to_s) if only
+  return if exts.empty?
+
+  unless setup_dependencies_via_monorepo(exts)
+    setup_dependencies_via_each_repo_by_version(gemspec, exts)
+  end
+
+  exts.each {|ext| sh %( cd ../#{ext} && rake ext )}
+end
+
+def setup_dependencies_via_monorepo(exts)
+  return false unless checkout_monorepo
+  exts.each {|ext| sh %( ln -snf all/#{ext} ../#{ext} )}
+  true
+end
+
+def checkout_monorepo()
+  uuid = `git log -1 --format=%B`[/^\[\[([0-9a-fA-F-]+)\]\]$/, 1]
+  return false unless uuid
+
+  commit = setup_monorepo uuid
+  return false unless commit
+
+  Dir.chdir(ALL_DIR) {sh %( git checkout -q #{commit} )}
+  true
+end
+
+def setup_monorepo(uuid)
+  unless File.directory? ALL_DIR
+    url = "https://github.com/#{ALL_REPO}.git"
+    sh %( git clone --no-tags --depth #{ALL_FETCH_DEPTH} #{url} #{ALL_DIR} )
+  end
+  loop do
+    commit = find_monorepo_commit uuid
+    return commit if commit
+
+    deepened = Dir.chdir ALL_DIR do
+      before = `git rev-list --count HEAD`.to_i
+      sh %( git fetch --deepen #{ALL_FETCH_DEPTH} )
+      `git rev-list --count HEAD`.to_i > before
+    end
+    return nil unless deepened
+  end
+end
+
+def find_monorepo_commit(uuid)
+  Dir.chdir ALL_DIR do
+    out = `git log origin/HEAD -F --grep="[[#{uuid}]]" --format=%H -1`.strip
+    out.empty? ? nil : out
+  end
+end
 
+def setup_dependencies_via_each_repo_by_version(gemspec, exts)
   exts.each do |ext|
     gem   = RENAMES[ext.to_sym].then {|s| s || ext}
-    ver   = gemspec[/add_dependency.*['"]#{gem}['"].*['"]\s*>=\s*([\d\.]+)\s*['"]/, 1]
+    ver   = gemspec[/add_dependency.*['"]#{gem}['"].*['"]\s*~>\s*([\d\.]+)\s*['"]/, 1]
     opts  = '-c advice.detachedHead=false --depth 1'
     clone = "git clone #{opts} https://github.com/xord/#{ext}.git ../#{ext}"
 
     # 'rake subtree:push' pushes all subrepos, so cloning by new tag
     # often fails before tagging each new tag
     sh %( #{clone} --branch v#{ver} || #{clone} )
-    sh %( cd ../#{ext} && rake ext )
   end
 end
 
 def tag_versions()
-  tags = `git tag`.lines chomp: true
-  vers = `git log --oneline ./VERSION`
+  changes = changelogs
+  tags    = `git tag`.lines chomp: true
+  vers    = `git log --oneline ./VERSION`
     .lines(chomp: true)
     .map {|line| line.split.first[/^\w+$/]}
-    .map {|hash| [`git cat-file -p #{hash}:./VERSION 2>/dev/null`[/[\d\.]+/], hash]}
-    .select {|ver, hash| ver && hash}
+    .map {|sha| [`git cat-file -p #{sha}:./VERSION 2>/dev/null`[/[\d\.]+/], sha]}
+    .select {|ver, sha| ver && sha}
     .reverse
     .to_h
 
-  changes = File.read('ChangeLog.md')
-    .split(/^\s*##\s*\[\s*v([\d\.]+)\s*\].*$/)
-    .slice(1..-1)
-    .each_slice(2)
-    .to_h
-    .transform_values(&:strip!)
-
-  vers.to_a.reverse.each do |ver, hash|
+  vers.to_a.reverse.each do |ver, sha|
     tag = "v#{ver}"
     break if tags.include?(tag)
-    sh %( git tag -a -m \"#{changes[ver]&.gsub '"', '\\"'}\" #{tag} #{hash} )
+    sh %( git tag -a -m \"#{changes[tag]&.gsub '"', '\\"'}\" #{tag} #{sha} )
   end
 end
+
+def release(*paths)
+  tag   = ENV['GITHUB_REF']&.sub(%r|^refs/tags/|, '') || raise('GITHUB_REF tag not set')
+  notes = (changelogs[tag] || '').shellescape
+  paths = paths.flatten.join ' '
+
+  sh(%( gh release create #{tag} #{paths} --notes #{notes} )) ||
+    sh(%( gh release upload #{tag} #{paths} --clobber )) ||
+    raise('failed to upload to releases')
+end
+
+def changelogs()
+  File.read('ChangeLog.md')
+    .split(/^\s*##\s*\[\s*(v[\d\.]+)\s*\].*$/)
+    .slice(1..)
+    .each_slice(2)
+    .to_h
+    .transform_values(&:strip!)
+rescue Errno::ENOENT
+  raise 'failed to get changelogs'
+end

data/ChangeLog.md

@@ -1,6 +1,26 @@
 # xot ChangeLog
 
 
+## [v0.3.13] - 2026-05-17
+
+- Rewrite README.md
+- CI: Migrate release-gem.yml from actions/create-release to gh release create
+
+
+## [v0.3.12] - 2026-05-10
+
+- Add hint_memory_usage callback for external memory GC integration
+- Add release helper that uploads to GitHub Releases via gh CLI
+- Add Extension.name(downcase) for kebab-case module naming
+- Add lib_name to Extension and use import libraries on Windows
+- Clear DEFFILE in generated Makefile on Windows
+- Resolve dependencies by monorepo commit UUID in CI
+- Remove deprecated has_rdoc= from gemspecs
+
+- Skip linking dependency native extensions to avoid duplicate symbols
+- Fix compiler and linker warnings
+
+
 ## [v0.3.11] - 2026-04-17
 
 - Invert build script default verbosity: quiet by default, add verbose option

data/README.md

@@ -1,4 +1,4 @@
-# Xot - Some useful utility classes and functions
+# Xot - Shared utility classes and functions for C++ and Ruby
 
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/xord/xot)
 ![License](https://img.shields.io/github/license/xord/xot)
@@ -21,20 +21,29 @@ Thanks for your support! 🙌
 
 ## 🚀 About
 
-**Xot** is a small utility library that was extracted for internal use to provide basic helper classes and functions across our own Ruby gems.
+**Xot** is the foundational utility layer used by every other library in the `xord/*` family — Rucy, Beeps, Rays, Reflex, Processing, RubySketch, and Reight.
 
-It’s not intended for general public use, but rather serves as a simple collection of utilities to make our own development process more efficient and consistent.
+It is split into two layers that ship in a single gem:
 
-Feel free to explore, but please note that it’s not actively maintained or intended for broad adoption.
+- **C++ headers and library** (`include/xot/`, `src/`) — building blocks such as reference counting, the pimpl idiom, non-copyable base, plus thin wrappers for strings, time, exceptions, and debug output. These are linked into the native extensions of the other `xord/*` gems.
+- **Ruby helpers** (`lib/xot/`) — small meta-programming mixins (`Hookable`, `Inspectable`, accessor builders, ...), bit-flag utilities, and shared Rake / test scaffolding used by our gems.
+
+Xot exists primarily to keep these patterns consistent across our own projects. It is not designed as a general-purpose dependency, and its API is not promised to be stable for outside use. You are welcome to read and learn from it, but pin a specific version if you depend on it directly.
+
+## 📋 Requirements
+
+- Ruby **3.0.0** or later
+- A C++ compiler with C++20 support (Clang on macOS / iOS, GCC or MSVC on Linux / Windows)
+- [Rake](https://rubygems.org/gems/rake) and [test-unit](https://rubygems.org/gems/test-unit) (development only)
 
 ## 📦 Installation
 
 Add this line to your Gemfile:
 ```ruby
-$ gem 'xot'
+gem 'xot'
 ```
 
-Then, install gem:
+Then install:
 ```bash
 $ bundle install
 ```
@@ -44,6 +53,145 @@ Or install it directly:
 $ gem install xot
 ```
 
+When installed via `gem install`, the C++ headers under `include/xot/` are placed inside the gem directory so that other `xord/*` extensions can locate them at build time (via `Xot::Extension.inc_dir`).
+
+## 📚 What's Included
+
+### C++ headers (`include/xot/`)
+
+| Header           | Provides                                                                 |
+| ---------------- | ------------------------------------------------------------------------ |
+| `defs.h`         | Type aliases (`uint`, `ushort`, `ulong`, `schar`, `longlong`, ...)       |
+| `noncopyable.h`  | `Xot::NonCopyable` — base class that disables copy and assignment        |
+| `ref.h`          | `Xot::RefCountable<>` and `Xot::Ref<T>` — intrusive reference counting   |
+| `pimpl.h`        | `Xot::PImpl<T>` / `Xot::PSharedImpl<T>` — pimpl idiom on top of smart ptrs |
+| `string.h`       | `Xot::String` (extends `std::string`), `stringf`, `split`, `to_s`         |
+| `time.h`         | `Xot::time()` (seconds since epoch, double), `Xot::sleep(seconds)`        |
+| `exception.h`    | `XotError` hierarchy and `xot_error` / `argument_error` / ... throw helpers |
+| `debug.h`        | `Xot::dout` / `doutln` — printf-style debug output (no-op in release)     |
+| `util.h`         | Bit / flag helpers, `random`, `deg2rad`, `rad2deg`, memory-usage hints   |
+| `windows.h`      | Win32 helpers used by other libraries                                    |
+
+### Ruby modules (`lib/xot/`)
+
+| Module / class              | Purpose                                                                 |
+| --------------------------- | ----------------------------------------------------------------------- |
+| `Xot::Hookable`             | Attach `on_*` hook methods, or `before` / `after` wrappers around an existing method, on a single object |
+| `Xot::Inspectable`          | Compact default `inspect` (class + object_id only) — safe under circular references |
+| `Xot::BitFlag`              | Build symbolic bit-flag sets and convert between symbols and bitmasks   |
+| `Xot::BitFlagAccessor`      | Class-level accessor generator backed by a `BitFlag`                    |
+| `Xot::BitUtil`              | Bit manipulation helpers (`bit(n)`, etc.)                               |
+| `Xot::BlockUtil`            | `instance_eval`-or-block-call dispatching                               |
+| `Xot::ConstSymbolAccessor`  | Define accessors that translate symbols to module constants             |
+| `Xot::UniversalAccessor`    | Single-method getter / setter (`obj.x` reads, `obj.x value` writes)     |
+| `Xot::Setter`               | Bulk attribute setter mixin                                             |
+| `Xot::Invoker`              | Helper for invoking methods / blocks safely                             |
+| `Xot::Util`                 | Misc Ruby utilities                                                     |
+| `Xot::Extension`            | Path / name / version helpers used by every `xord/*` gem's build script |
+| `Xot::Rake`                 | Rake DSL (`default_tasks`, `build_native_library`, `build_ruby_extension`, `test_ruby_extension`, `build_ruby_gem`, ...) |
+| `Xot::Test`                 | Test-unit helpers                                                       |
+
+## 💡 Usage
+
+### C++ — reference counting
+
+```cpp
+#include <xot/ref.h>
+
+class Thing : public Xot::RefCountable<>
+{
+    protected:
+        ~Thing () = default;   // destructor is protected; Ref<> handles deletion
+};
+
+Xot::Ref<Thing> a = new Thing;   // refcount = 1
+{
+    Xot::Ref<Thing> b = a;       // refcount = 2
+}                                // refcount = 1
+// when `a` goes out of scope, refcount = 0 and the object is deleted
+```
+
+### C++ — pimpl
+
+```cpp
+#include <xot/pimpl.h>
+
+// in the header
+class Widget
+{
+    public:
+        Widget ();
+        int value () const;
+    private:
+        struct Data;
+        Xot::PImpl<Data> self;
+};
+
+// in the .cpp
+struct Widget::Data { int n = 42; };
+Widget::Widget () {}
+int Widget::value () const { return self->n; }
+```
+
+### Ruby — `BitFlag`
+
+```ruby
+require 'xot/bit_flag'
+
+flags = Xot::BitFlag.new(read: 0x1, write: 0x2, exec: 0x4)
+mask  = flags.symbols2bits(:read, :exec)   # => 5
+flags.bits2symbols(mask)                   # => [:read, :exec]
+```
+
+### Ruby — `Hookable`
+
+```ruby
+require 'xot/hookable'
+
+class Greeter
+  include Xot::Hookable
+  def greet(name) = "hello, #{name}"
+end
+
+g = Greeter.new
+g.before(:greet) {|name| puts "about to greet #{name}" }
+g.greet 'world'
+# => about to greet world
+# => "hello, world"
+
+# `on` creates a brand-new on_* method instead of wrapping an existing one
+g.on(:click) {|x, y| puts "clicked at #{x}, #{y}" }
+g.on_click 1, 2
+```
+
+### Ruby — `UniversalAccessor`
+
+```ruby
+require 'xot/universal_accessor'
+
+class Box
+  attr_accessor :width
+  universal_accessor :width
+end
+
+box = Box.new
+box.width 10    # writes
+box.width       # => 10 (reads)
+```
+
+## 🛠️ Development
+
+Xot uses a shared Rakefile pattern. From the gem root:
+
+```bash
+$ rake lib    # build the native C++ library (libxot)
+$ rake ext    # build the Ruby C extension
+$ rake test   # run the test suite (test/test_*.rb)
+$ rake       # default: builds the extension
+```
+
+In the [`xord/all`](https://github.com/xord/all) monorepo you can also scope by module, e.g. `rake xot test`.
+
 ## 📜 License
 
 **Xot** is licensed under the MIT License.

data/VERSION

@@ -1 +1 @@
-0.3.11
+0.3.13

data/include/xot/util.h

@@ -5,6 +5,7 @@
 
 
 #include <stdint.h>
+#include <sys/types.h>
 #include <math.h>
 #include <assert.h>
 #include <xot/defs.h>
@@ -124,6 +125,13 @@ namespace Xot
 	}
 
 
+	typedef void (*HintMemoryUsageFun)(ssize_t);
+
+	void set_hint_memory_usage_fun (HintMemoryUsageFun fun);
+
+	void     hint_memory_usage (ssize_t size);
+
+
 #if defined(OSX) || defined(IOS)
 
 	void safe_cfrelease (const void* ref);

data/include/xot.h

@@ -1,7 +1,7 @@
 // -*- c++ -*-
 #pragma once
-#ifndef __XOT_H__
-#define __XOT_H__
+#ifndef __XOT_ALL_H__
+#define __XOT_ALL_H__
 
 
 #include <xot/defs.h>

data/lib/xot/extconf.rb

@@ -11,8 +11,6 @@ module Xot
     include Xot::Rake
     include Xot::Util
 
-    attr_reader :extensions, :defs, :inc_dirs, :lib_dirs, :headers, :libs, :local_libs, :frameworks
-
     def initialize(*extensions, &block)
       @extensions = extensions.map {|x| x.const_get :Extension}
       @defs, @inc_dirs, @lib_dirs, @headers, @libs, @local_libs, @frameworks =
@@ -20,6 +18,12 @@ module Xot
       Xot::BlockUtil.instance_eval_or_block_call self, &block if block
     end
 
+    attr_reader :extensions, :defs, :inc_dirs, :lib_dirs, :headers, :libs, :local_libs, :frameworks
+
+    def my_ext()
+      extensions.last
+    end
+
     def debug()
       env :DEBUG, false
     end
@@ -28,19 +32,23 @@ module Xot
       yield if block_given?
 
       extensions.each do |ext|
-        name = ext.name.downcase
-        headers    << "#{name}.h"
-        local_libs << name
+        name     = ext.name true
+        lib_name = ext == my_ext ? name : ext.lib_name
+        headers << "#{name}.h"
+        local_libs << lib_name if lib_name
       end
 
       ldflags = $LDFLAGS.dup
-      if osx?
+      case
+      when osx?
         opt = '-Wl,-undefined,dynamic_lookup'
         ldflags << " #{opt}" unless ($DLDFLAGS || '').include?(opt)
         ldflags << ' -Wl,-bind_at_load' if osx? && debug?
+      when wasm?
+        build_lib_objs_for_wasm
       end
 
-      local_libs << (clang? ? 'c++' : 'stdc++')
+      local_libs << 'stdc++' if gcc?
 
       $CPPFLAGS = make_cppflags $CPPFLAGS, defs, inc_dirs
       $CFLAGS   = make_cflags   $CFLAGS   + ' -x c++'
@@ -51,13 +59,62 @@ module Xot
 
     def create_makefile(*args)
       extensions.each do |ext|
-        dir_config ext.name.downcase, ext.inc_dir, ext.lib_dir
+        dir_config ext.name(true), ext.inc_dir, ext.lib_dir
       end
 
       exit 1 unless headers.all? {|s| have_header s}
-      exit 1 unless libs.all?    {|s| have_library s, 't'}
+      exit 1 unless libs.all?    {|s| have_library s, 't'} unless wasm?
 
       super
+
+      export_all_symbols     if mingw? || cygwin?
+      link_lib_objs_for_wasm if wasm?
+    end
+
+    def export_all_symbols()
+      name = my_ext.name true
+      opts = %W[
+        -Wl,--export-all-symbols,--whole-archive
+        -l#{name}
+        -Wl,--no-whole-archive
+      ].join ' '
+      filter_file('Makefile') {|s|
+        s.sub(/^DEFFILE\s*=.*$/, 'DEFFILE =')
+         .sub(/^(LOCAL_LIBS\s*=.*) -l#{name}\b/) {"#{$1} #{opts}"}
+      }
+    end
+
+    def build_lib_objs_for_wasm()
+      ruby_dirs = [
+        "#{ENV['extout']}/include/wasm32-emscripten",
+        "#{ENV['top_srcdir']}/include"
+      ]
+      envs      = {
+        CC:       '',
+        CXX:      '',
+        AR:       '',
+        RANLIB:   '',
+        CPPFLAGS: ' -sUSE_SDL=2 -sUSE_SDL_TTF=2',
+        CFLAGS:   ' -sUSE_SDL=2 -sUSE_SDL_TTF=2',
+        CXXFLAGS: '',
+        LDFLAGS:  ' -sUSE_SDL=2 -sUSE_SDL_TTF=2',
+        INCDIRS:  ruby_dirs.join(' ')
+      }.map {|k, v| "#{k}='#{(RbConfig::CONFIG[k.to_s] || '') + v}'"}
+
+      Dir.chdir target.root_dir do
+        cmd = "#{envs.join ' '} rake ext:lib_objs"
+        puts cmd
+        system cmd
+      end
+    end
+
+    def link_lib_objs_for_wasm()
+      lib_objs = Dir.glob "#{target.ext_dir}/**/__libobj_*.o"
+      filter_file 'Makefile' do |str|
+        str.sub(/^(\s*)(.*\$\(AR\).*)$/) {
+          "#{$1}#{$2}\n#{$1}$(Q) $(AR) r $@ #{lib_objs.join ' '}"
+        }
+      end
     end
 
   end# ExtConf

data/lib/xot/extension.rb

@@ -5,8 +5,10 @@ module Xot
 
     module_function
 
-    def name()
-      super.split('::')[-2]
+    def name(downcase = false)
+      super().split('::')[-2].then {|s|
+        downcase ? s.gsub(/([a-z])([A-Z])/) {"#{$1}-#{$2}"}.downcase : s
+      }
     end
 
     def version()
@@ -29,6 +31,10 @@ module Xot
       root_dir 'ext'
     end
 
+    def lib_name()
+      name true
+    end
+
   end# Extension
 
 

data/lib/xot/rake/util.rb

@@ -19,7 +19,7 @@ module Xot
     end
 
     def target_name()
-      get_env :EXTNAME, target.name.downcase
+      get_env :EXTNAME, target.name(true)
     end
 
     def inc_dir()
@@ -81,7 +81,7 @@ module Xot
       paths.reject! {|path| path =~ %r(/osx/)}   unless osx?
       paths.reject! {|path| path =~ %r(/ios/)}   unless ios?
       paths.reject! {|path| path =~ %r(/win32/)} unless win32?
-      paths.reject! {|path| path =~ %r(/sdl/)}   unless linux?
+      paths.reject! {|path| path =~ %r(/sdl/)}   unless linux? || wasm?
       make_path_map paths, src_ext_map
     end
 
@@ -186,12 +186,13 @@ module Xot
     def make_cppflags_defs(defs = [])
       a  = defs.dup
       a << (debug? ? '_DEBUG' : 'NDEBUG')
-      a << target.name.upcase
+      a << target_name.gsub('-', '_').upcase
       a << $~[0].upcase        if RUBY_PLATFORM =~ /mswin|mingw|cygwin|darwin/i
       a << 'WIN32'             if win32?
       a << 'OSX'               if osx?
       a << 'IOS'               if ios?
       a << 'LINUX'             if linux?
+      a << 'WASM'              if wasm?
       a << 'GCC'               if gcc?
       a << 'CLANG'             if clang?
       a << '_USE_MATH_DEFINES' if gcc?
@@ -221,7 +222,7 @@ module Xot
       s  = flags.dup
       s << warning_opts.map {|s| " -W#{s}"}.join
       s << " -arch arm64"                                          if osx? && arm64?
-      s << ' -std=c++20'                                           if gcc?
+      s << ' -std=c++20'                                           if gcc? || emcc?
       s << ' -std=c++20 -stdlib=libc++ -mmacosx-version-min=10.10' if clang?
       s << ' ' + RbConfig::CONFIG['debugflags']                    if debug?
       s.gsub!(/-O\d?\w*/, '-O0')                                   if debug?

data/lib/xot/rake.rb

@@ -104,7 +104,7 @@ module Xot
     end
 
     def build_ruby_extension(dlname: nil, dlext: nil, liboutput: true)
-      dlname = get_env :DLNAME, dlname || "#{target_name}_ext"
+      dlname = get_env :DLNAME, dlname || "#{target_name.gsub('-', '_')}_ext"
       dlext  = get_env :DLEXT,  dlext  || RbConfig::CONFIG['DLEXT'] || 'so'
 
       extconf  = File.join ext_dir, 'extconf.rb'
@@ -116,7 +116,7 @@ module Xot
       libout  = File.join lib_dir, outname
 
       srcs = FileList["#{ext_dir}/**/*.cpp"]
-      libs = extensions.map {|x| "#{x.lib_dir}/lib#{x.name.downcase}.a"}
+      libs = extensions.map {|x| "#{x.lib_dir}/lib#{x.name(true)}.a"}
 
       alias_task :ext     => (liboutput ? libout : extout)
       alias_task :clean   => 'ext:clean'
@@ -126,7 +126,7 @@ module Xot
         desc "build #{libout}"
         file libout => extout do
           libdir = File.dirname libout
-          libimp = extout.sub /\.#{dlext}$/, '.dll.a'
+          libimp = File.join File.dirname(extout), "lib#{target_name}.dll.a"
           sh %( cp #{extout} #{libdir} )
           sh %( cp #{libimp} #{libdir} ) if mingw? || cygwin?
         end
@@ -150,9 +150,17 @@ module Xot
           sh %( cd #{ext_dir} && #{cxx} -M #{cppflags} #{inc} #{src} > #{dep} )
         end
 
+        desc "compile src/**/*"
+        task :lib_objs => :lib do
+          (srcs_map.values + vendor_srcs_map.values).each do |obj|
+            to = File.join ext_dir, "__libobj_#{obj.gsub '/', '_'}"
+            sh %( cp #{obj} #{to} )
+          end
+        end
+
         task :clean do
           sh %( cd #{ext_dir} && make clean ) if File.exist? makefile
-          sh %( rm -rf #{libout} )
+          sh %( rm -rf #{libout} #{ext_dir}/__libobj_*.o )
         end
 
         task :clobber do
@@ -297,24 +305,25 @@ module Xot
           file dir do
             rake_puts "vendoring #{name}"
             q     = ::Rake.verbose ? '' : '-q'
-            opts  = "#{q} -c advice.detachedHead=false --depth 1"
+            opts  = "#{q} -c advice.detachedHead=false --depth 1 --no-tags"
             opts += " --branch #{branch || tag}" if branch || tag
-            opts += " --recursive"               if submodules.empty?
             sh %( git clone #{opts} #{repos} #{dir} )
             Dir.chdir dir do
-              sh %( git fetch #{q} --depth 1 origin #{commit} )
-              sh %( git checkout #{q} #{commit} )
-            end if commit
-            unless submodules.empty?
-              Dir.chdir dir do
-                submodules.each do |path|
-                  sh %( git submodule #{q} init #{path} )
-                end
-                sh %( git submodule #{q} update --depth=1 )
+              if commit
+                sh %( git fetch #{q} --depth 1 origin #{commit} )
+                sh %( git checkout #{q} #{commit} )
+              end
+
+              if submodules.empty?
+                sh %( git submodule #{q} update --init --recursive --depth 1 )
+              else
+                submodules.each {|path| sh %( git submodule #{q} init #{path} )}
+                sh %( git submodule #{q} update --depth 1 )
                 sh post_submodules if post_submodules
               end
+
+              after_clone_block.call if after_clone_block
             end
-            Dir.chdir(dir) {after_clone_block.call} if after_clone_block
             unless get_env :VENDOR_NOCOMPILE, false
               vendor_srcs_map(*srcdirs).each do |src, obj|
                 rake_puts "compiling #{src}"

data/lib/xot/util.rb

@@ -65,7 +65,7 @@ module Xot
     end
 
     def osx?()
-      /darwin/.match? RUBY_PLATFORM
+      !wasm? && /darwin/.match?(RUBY_PLATFORM)
     end
 
     def ios?()
@@ -73,23 +73,27 @@ module Xot
     end
 
     def win32?()
-      /mswin|ming|cygwin/.match? RUBY_PLATFORM
+      !wasm? && /mswin|ming|cygwin/.match?(RUBY_PLATFORM)
     end
 
     def mswin?()
-      /mswin/.match? RUBY_PLATFORM
+      !wasm? && /mswin/.match?(RUBY_PLATFORM)
     end
 
     def mingw?()
-      /ming/.match? RUBY_PLATFORM
+      !wasm? && /ming/.match?(RUBY_PLATFORM)
     end
 
     def cygwin?()
-      /cygwin/.match? RUBY_PLATFORM
+      !wasm? && /cygwin/.match?(RUBY_PLATFORM)
     end
 
     def linux?()
-      /linux/.match? RUBY_PLATFORM
+      !wasm? && /linux/.match?(RUBY_PLATFORM)
+    end
+
+    def wasm?()
+      emcc?
     end
 
     def gcc?()
@@ -100,6 +104,10 @@ module Xot
       /(^|\-)clang/i.match? cc
     end
 
+    def emcc?()
+      /(^|\-)emcc$/i.match? cc
+    end
+
     def github_actions?()
       ENV['GITHUB_ACTIONS'] == 'true'
     end

data/src/util.cpp

@@ -53,6 +53,22 @@ namespace Xot
 	}
 
 
+	static HintMemoryUsageFun hint_memory_usage_fun = NULL;
+
+	void
+	set_hint_memory_usage_fun (HintMemoryUsageFun fun)
+	{
+		hint_memory_usage_fun = fun;
+	}
+
+	void
+	hint_memory_usage (ssize_t size)
+	{
+		if (hint_memory_usage_fun && size != 0)
+			hint_memory_usage_fun(size);
+	}
+
+
 #if defined(OSX) || defined(IOS)
 
 	void

data/xot.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   end
 
   ext   = Xot::Extension
-  name  = ext.name.downcase
+  name  = ext.name true
   rdocs = glob.call *%w[README]
 
   s.name        = name
@@ -29,7 +29,6 @@ Gem::Specification.new do |s|
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}
   s.test_files       = s.files.grep %r{^(test|spec|features)/}
   s.extra_rdoc_files = rdocs.to_a
-  s.has_rdoc         = true
 
   s.extensions << 'Rakefile'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xot
 version: !ruby/object:Gem::Version
-  version: 0.3.11
+  version: 0.3.13
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-17 00:00:00.000000000 Z
+date: 2026-05-16 00:00:00.000000000 Z
 dependencies: []
 description: This library include some useful utility classes and functions for development
   with C++.