xot 0.4.0 → 0.5.0

data/lib/xot/rake/github.rb

@@ -0,0 +1,106 @@
+require 'tmpdir'
+require 'xot/rake/util'
+require 'xot/rake/changelog'
+
+
+module Xot
+
+
+  module Rake
+
+    MONOREPO             = 'xord/all'
+    MONOREPO_DIR         = '../all'
+    MONOREPO_FETCH_DEPTH = 100
+
+    def setup_dependencies(only: nil, ext: true)
+      deps  = dependency_names
+      deps &= Array(only).map(&:to_s) if only
+      return if deps.empty?
+
+      checkout_monorepo
+      link_monorepo deps, ext: ext
+    end
+
+    def setup_monorepo(ref, *libraries)
+      raise 'no libraries of the monorepo to set up' if libraries.empty?
+      sh 'git', 'init', '-q', MONOREPO_DIR
+      Dir.chdir MONOREPO_DIR do
+        sh 'git', 'fetch', '-q', '--depth', '1', "https://github.com/#{MONOREPO}.git", ref
+        sh 'git', 'checkout', '-q', 'FETCH_HEAD'
+      end
+      link_monorepo libraries
+    end
+
+    MESA_VERSION = '26.2.0'
+
+    def setup_mesa(version = MESA_VERSION)
+      name = "mesa3d-#{version}-release-msvc"
+      url  = "https://github.com/pal1000/mesa-dist-win/releases/download/#{version}/#{name}.7z"
+      Dir.mktmpdir do |dir|
+        Dir.chdir dir do
+          sh 'curl', '-sSfL', '-o', 'mesa.7z', url
+          sh '7z', 'x', 'mesa.7z'
+          sh 'powershell.exe', '.\\systemwidedeploy.cmd', '1'
+        end
+      end
+      File.open(ENV['GITHUB_ENV'], 'a') {|f| f.puts 'GALLIUM_DRIVER=llvmpipe'}
+    end
+
+    def dependency_names()
+      File.readlines('Rakefile')
+        .filter_map {_1[%r{^\s*require\W+([\w\-]+)/extension\W+$}, 1]}
+        .reject {File.file? "lib/#{_1}/extension.rb"} # of this repository
+    end
+
+    def checkout_monorepo()
+      uuid   = git('log', '-1', '--format=%B')[/^\[\[([0-9a-fA-F-]+)\]\]$/, 1] ||
+        raise('no UUID of the monorepo in the last commit')
+      commit = fetch_monorepo(uuid) ||
+        raise("no commit of the monorepo with the UUID #{uuid}")
+
+      Dir.chdir(MONOREPO_DIR) {sh 'git', 'checkout', '-q', commit}
+    end
+
+    def release_on_github(*paths, tag: ENV['GITHUB_REF_NAME'], notes: nil)
+      raise 'no tag to release' unless tag
+      notes ||= ChangeLog.new.changes(tag).to_s
+      sh('gh', 'release', 'create', tag, *paths, '--notes', notes) {|ok, _| ok} ||
+        sh('gh', 'release', 'upload', tag, *paths, '--clobber')
+    end
+
+    private
+
+    def link_monorepo(libraries, ext: true)
+      libraries.each {|lib| sh %( cd #{MONOREPO_DIR}/#{lib} && rake ext )} if ext
+      libraries.each do |lib|
+        if win32?
+          rm_rf "../#{lib}"
+          cp_r "#{MONOREPO_DIR}/#{lib}", "../#{lib}"
+        else
+          sh 'ln', '-snf', "#{File.basename MONOREPO_DIR}/#{lib}", "../#{lib}"
+        end
+      end
+    end
+
+    def fetch_monorepo(uuid)
+      unless File.directory? MONOREPO_DIR
+        sh 'git', 'clone', '--no-tags', '--depth', MONOREPO_FETCH_DEPTH.to_s,
+          "https://github.com/#{MONOREPO}.git", MONOREPO_DIR
+      end
+      Dir.chdir MONOREPO_DIR do
+        loop do
+          commit = git('log', 'origin/HEAD', '-F', "--grep=[[#{uuid}]]", '--format=%H', '-1').strip
+          return commit unless commit.empty?
+
+          count = git('rev-list', '--count', 'HEAD').to_i
+          sh 'git', 'fetch', '--deepen', MONOREPO_FETCH_DEPTH.to_s
+          return nil if git('rev-list', '--count', 'HEAD').to_i == count
+        end
+      end
+    end
+
+
+  end# Rake
+
+
+end# Xot

data/lib/xot/rake/hooks/pre-commit

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+# Writes the version of the section added to a ChangeLog.md in the commit
+# into the VERSION beside it, and adds it to the commit.
+#
+# Copied into .git/hooks by 'rake hooks' of xot as it is, so that it runs
+# with any ruby, requiring nothing.
+
+
+def git(*args)
+  IO.popen ['git', *args], &:read
+end
+
+def added_version(changelog)
+  git('diff', '--cached', '--', changelog)
+    .slice(/^\+\s*##\s*\[\s*v(\d[\d\.]*)\s*\]\s*-\s*\d{4}-\d{2}-\d{2}\s*$/, 1)
+end
+
+git('ls-files').lines(chomp: true)
+  .grep(%r{(\A|/)VERSION\z})
+  .map    {[_1.sub(/VERSION\z/, 'ChangeLog.md'), _1]}
+  .select {|paths| paths.all? {File.file? _1}}
+  .each do |changelog, version|
+    ver = added_version changelog
+    next if !ver || ver == File.read(version)[/[\d\.]+/]
+
+    abort "pre-commit: #{version} has changes not to be overwritten" unless
+      git('diff', '--', version).empty?
+
+    File.write version, ver
+    system 'git', 'add', version, exception: true
+  end

data/lib/xot/rake/util.rb

@@ -1,6 +1,8 @@
 require 'erb'
+require 'fileutils'
 require 'rbconfig'
 require 'xot/util'
+require 'xot/rake/changelog'
 
 
 module Xot
@@ -125,37 +127,6 @@ module Xot
       excludes.any? {|s| path =~ %r{#{s}}}
     end
 
-    def glob(*patterns)
-      paths = []
-      patterns.each do |pattern|
-        paths.concat Dir.glob(pattern)
-      end
-      paths
-    end
-
-    def rake_puts(*args)
-      $stderr.puts(*args)
-    end
-
-    def verbose_puts(*args)
-      rake_puts(*args) if ::Rake.verbose
-    end
-
-    def noverbose_puts(*args)
-      rake_puts(*args) unless ::Rake.verbose
-    end
-
-    def filter_file(path, &block)
-      File.write path, block.call(File.read path)
-    end
-
-    def cd_sh(dir, cmd)
-      Dir.chdir dir do
-        rake_puts "(in #{Dir.pwd})"
-        sh cmd
-      end
-    end
-
     def compile_erb(path, out)
       open(path) do |input|
         open(out, 'w') do |output|
@@ -187,16 +158,19 @@ module Xot
       a  = defs.dup
       a << (debug? ? '_DEBUG' : 'NDEBUG')
       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?
-      a << '_THREAD_SAFE'      if linux?
+      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?
+      a << '_THREAD_SAFE'             if linux?
+      a << 'GL_SILENCE_DEPRECATION'   if osx?
+      a << 'GLES_SILENCE_DEPRECATION' if ios?
+      a << 'OPENAL_DEPRECATED='       if osx? || ios?
       a
     end
 
@@ -224,7 +198,7 @@ module Xot
       s << " -arch arm64"                       if osx? && arm64?
       s << " -std=#{std}"                       if clang? || gcc? || emcc?
       s << " -stdlib=#{stdlib}"                 if clang? && stdlib
-      s << ' -mmacosx-version-min=10.10'        if clang? && osx?
+      s << ' -mmacosx-version-min=11.0'         if clang? && osx?
       s << ' ' + RbConfig::CONFIG['debugflags'] if debug?
       s.gsub!(/-O\d?\w*/, '-O0')                if debug?
       s << warn_opts.map {|s| " -W#{s}"}.join
@@ -278,6 +252,51 @@ module Xot
       flags
     end
 
+    def install_hooks()
+      dir = git('rev-parse', '--git-path', 'hooks').strip
+      FileUtils.mkdir_p dir
+      Dir.glob(File.join __dir__, 'hooks', '*').each do |hook|
+        FileUtils.cp hook, dir
+        FileUtils.chmod 0755, File.join(dir, File.basename(hook))
+      end
+    end
+
+    def version_changes(dir = '.')
+      commit = git('log', '-1', '--format=%H', '--', File.join(dir, 'VERSION')).strip
+      range  = commit.empty? ? 'HEAD' : "#{commit}..HEAD"
+      git('log', '--first-parent', '--reverse', '--format=%x00%P%n%B', range, '--', dir)
+        .split("\0")
+        .drop(1)
+        .map do |log|
+          parents, *lines = log.lines(chomp: true)
+          lines = lines.reject {_1.strip.empty?}
+          merge = parents.split.size > 1 && lines.first&.start_with?('Merge branch ')
+          (merge && lines[1]) || lines.first
+        end
+    end
+
+    def next_version(dir = '.')
+      nums = File.read(File.join dir, 'VERSION')[/[\d\.]+/].split('.').map(&:to_i)
+      nums = (nums + [0, 0, 0]).first(3)
+      nums[2] += 1
+      nums.join '.'
+    end
+
+    def tag_versions()
+      changelog = ChangeLog.new
+      tags      = git('tag').lines chomp: true
+      versions  = git('log', '--format=%H', '--', 'VERSION').lines(chomp: true)
+        .map {[git('show', "#{_1}:VERSION")[/[\d\.]+/], _1]}
+        .select {|version, _| version}
+        .uniq   {|version, _| version} # the newest commit of a version
+
+      versions.each do |version, commit|
+        tag = "v#{version}"
+        break if tags.include? tag
+        sh 'git', 'tag', '-a', '-m', changelog.changes(version).to_s, tag, commit
+      end
+    end
+
     def default_tasks(default = nil)
       verbose? get_env(:VERBOSE, false)
 
@@ -296,6 +315,43 @@ module Xot
       end
     end
 
+    private
+
+    def glob(*patterns)
+      paths = []
+      patterns.each do |pattern|
+        paths.concat Dir.glob(pattern)
+      end
+      paths
+    end
+
+    def rake_puts(*args)
+      $stderr.puts(*args)
+    end
+
+    def verbose_puts(*args)
+      rake_puts(*args) if ::Rake.verbose
+    end
+
+    def noverbose_puts(*args)
+      rake_puts(*args) unless ::Rake.verbose
+    end
+
+    def filter_file(path, &block)
+      File.write path, block.call(File.read path)
+    end
+
+    def cd_sh(dir, cmd)
+      Dir.chdir dir do
+        rake_puts "(in #{Dir.pwd})"
+        sh cmd
+      end
+    end
+
+    def git(*args, **opts)
+      IO.popen ['git', *args], **opts, &:read
+    end
+
 
   end# Rake
 

data/lib/xot/rake.rb

@@ -3,6 +3,7 @@ require 'rake'
 require 'rake/loaders/makefile'
 require 'rake/testtask'
 require 'xot/rake/alias_task'
+require 'xot/rake/github'
 require 'xot/rake/util'
 #require 'xot/rake/escalation'
 
@@ -258,6 +259,34 @@ module Xot
       end
     end
 
+    def automate_release()
+      desc 'install the git hooks'
+      task :hooks do
+        install_hooks
+      end
+
+      namespace :changelog do
+        desc 'show the commits for the next version'
+        task :check => :hooks do
+          puts version_changes
+        end
+
+        desc 'add the section of the next version'
+        task :update => :hooks do
+          changes = version_changes
+          next puts 'no changes since VERSION was changed, skipped' if changes.empty?
+          ChangeLog.new.add ENV['version'] || next_version, changes
+        end
+      end
+
+      namespace :version do
+        desc 'tag the new version'
+        task :tag do
+          tag_versions
+        end
+      end
+    end
+
     def install_packages(osx: [], mingw: [], apt: [])
       desc "install packages"
       task :packages do

data/lib/xot/setter.rb

@@ -14,11 +14,11 @@ module Xot
 
     private
 
-      def set_value__(name, *values)
-        raise ArgumentError, "set '#{values}' to '#{name}'" if
-          !name || name.empty? || values.empty?
-        __send__ "#{name}=", *values
-      end
+    def set_value__(name, *values)
+      raise ArgumentError, "set '#{values}' to '#{name}'" if
+        !name || name.empty? || values.empty?
+      __send__ "#{name}=", *values
+    end
 
   end# Setter
 

data/lib/xot/universal_accessor.rb

@@ -10,19 +10,19 @@ module Xot
 
     private
 
-      def define_universal_accessor(name, options = {})
-        set = "ua_set_#{name}__"
-        get = "ua_get_#{name}__"
-        class_eval <<-END
-          alias_method :#{set}, options[:writer] || :#{name}=
-          alias_method :#{get}, options[:reader] || :#{name}
-          private :#{set}, :#{get}
-          def #{name}(*args, **kwargs)
-            #{set}(*args, **kwargs) unless args.empty? && args.empty?
-            #{get}
-          end
-        END
-      end
+    def define_universal_accessor(name, options = {})
+      set = "ua_set_#{name}__"
+      get = "ua_get_#{name}__"
+      class_eval <<-END
+        alias_method :#{set}, options[:writer] || :#{name}=
+        alias_method :#{get}, options[:reader] || :#{name}
+        private :#{set}, :#{get}
+        def #{name}(*args, **kwargs)
+          #{set}(*args, **kwargs) unless args.empty? && kwargs.empty?
+          #{get}
+        end
+      END
+    end
 
   end# UniversalAccessor
 

data/src/util.cpp

@@ -53,22 +53,6 @@ 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/test/helper.rb

@@ -6,6 +6,57 @@ require 'xot'
 require 'xot/test'
 require_relative '../ext/xot/tester'
 
+require 'fileutils'
+require 'tmpdir'
 require 'test/unit'
 
 include Xot::Test
+
+
+module GitRepo
+
+  GIT_ENV = {
+    'GIT_CONFIG_GLOBAL'   => File::NULL,
+    'GIT_CONFIG_NOSYSTEM' => '1',
+    'GIT_AUTHOR_NAME'     => 'test',
+    'GIT_AUTHOR_EMAIL'    => 'test@example.com',
+    'GIT_COMMITTER_NAME'  => 'test',
+    'GIT_COMMITTER_EMAIL' => 'test@example.com'
+  }
+
+  CHANGELOG = "# app ChangeLog\n\n\n## [v0.1.0] - 2026-10-01\n\n- First\n"
+
+  def repo(&block)
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do
+        with_env GIT_ENV do
+          git! 'init', '-q'
+          commit 'Start', 'VERSION' => '0.1.0', 'ChangeLog.md' => CHANGELOG
+          block.call dir
+        end
+      end
+    end
+  end
+
+  def commit(message, files = {})
+    files.each do |path, text|
+      FileUtils.mkdir_p File.dirname(path)
+      File.write path, text
+    end
+    git! 'add', '-A'
+    git! 'commit', '-q', '-m', message
+  end
+
+  def git!(*args)
+    system 'git', *args, exception: true, out: File::NULL, err: File::NULL
+  end
+
+  def with_env(env, &block)
+    saved = env.to_h {|key, _| [key, ENV[key]]}
+    env.each {|key, value| ENV[key] = value}
+    block.call
+  ensure
+    saved.each {|key, value| ENV[key] = value}
+  end
+
+end# GitRepo

data/test/test_bit_flag.rb

@@ -16,39 +16,45 @@ class TestBitFlag < Test::Unit::TestCase
   end
 
   def test_bits2symbols()
-    assert_equal [], flag.bits2symbols(0)
-    assert_equal [:bit1], flag.bits2symbols(bit 1)
-    assert_equal [:bit2], flag.bits2symbols(bit 2)
-    assert_equal [:bit5], flag.bits2symbols(bit 5)
-    assert_equal [:bit1, :bit2], flag.bits2symbols(bit 1, 2)
-    assert_equal [:bit1, :bit5], flag.bits2symbols(bit 1, 5)
-    assert_equal [:bit3, :bit5], flag.bits2symbols(bit 3, 5)
+    assert_equal [],                           flag.bits2symbols(0)
+    assert_equal [:bit1],                      flag.bits2symbols(bit 1)
+    assert_equal [:bit2],                      flag.bits2symbols(bit 2)
+    assert_equal [:bit5],                      flag.bits2symbols(bit 5)
+    assert_equal [:bit1, :bit2],               flag.bits2symbols(bit 1, 2)
+    assert_equal [:bit1, :bit5],               flag.bits2symbols(bit 1, 5)
+    assert_equal [:bit3, :bit5],               flag.bits2symbols(bit 3, 5)
     assert_equal [:bit1, :bit2, :bit3, :bit5], flag.bits2symbols(bit 1, 2, 3, 5)
 
-    assert_raise(RuntimeError) {flag.bits2symbols(bit 0)}
-    assert_raise(RuntimeError) {flag.bits2symbols(bit 4)}
-    assert_raise(RuntimeError) {flag.bits2symbols(bit 6)}
-    assert_raise(RuntimeError) {flag.bits2symbols(bit 0, 1)}
+    assert_raise(ArgumentError) {flag.bits2symbols(bit 0)}
+    assert_raise(ArgumentError) {flag.bits2symbols(bit 4)}
+    assert_raise(ArgumentError) {flag.bits2symbols(bit 6)}
+    assert_raise(ArgumentError) {flag.bits2symbols(bit 0, 1)}
+
+    Xot::BitFlag.new.tap do |bf|
+      bf.flag :first,  bit(9)
+      bf.flag :second, bit(1)
+      assert_equal [:first, :second], bf.bits2symbols(bit 1, 9)
+    end
   end
 
   def test_symbols2bits()
-    assert_equal bit(1), flag.symbols2bits(:bit1)
-    assert_equal bit(2), flag.symbols2bits(:bit2)
-    assert_equal bit(5), flag.symbols2bits(:bit5)
-    assert_equal bit(1, 2), flag.symbols2bits(:bit1, :bit2)
-    assert_equal bit(1, 5), flag.symbols2bits(:bit1, :bit5)
-    assert_equal bit(3, 5), flag.symbols2bits(:bit3, :bit5)
+    assert_equal bit(1),          flag.symbols2bits(:bit1)
+    assert_equal bit(2),          flag.symbols2bits(:bit2)
+    assert_equal bit(5),          flag.symbols2bits(:bit5)
+    assert_equal bit(1, 2),       flag.symbols2bits(:bit1, :bit2)
+    assert_equal bit(1, 5),       flag.symbols2bits(:bit1, :bit5)
+    assert_equal bit(3, 5),       flag.symbols2bits(:bit3, :bit5)
     assert_equal bit(1, 2, 3, 5), flag.symbols2bits(:bit1, :bit2, :bit3, :bit5)
 
     assert_equal 0, flag.symbols2bits(:none)
     assert_equal 0, flag.symbols2bits(:no)
     assert_equal 0, flag.symbols2bits(:none, :no)
 
-    assert_raise(RuntimeError) {flag.symbols2bits(:bit0)}
-    assert_raise(RuntimeError) {flag.symbols2bits(:bit4)}
-    assert_raise(RuntimeError) {flag.symbols2bits(:bit6)}
-    assert_raise(RuntimeError) {flag.symbols2bits(:bit0, :bit1)}
-    assert_raise(RuntimeError) {flag.symbols2bits(nil)}
+    assert_raise(ArgumentError) {flag.symbols2bits(:bit0)}
+    assert_raise(ArgumentError) {flag.symbols2bits(:bit4)}
+    assert_raise(ArgumentError) {flag.symbols2bits(:bit6)}
+    assert_raise(ArgumentError) {flag.symbols2bits(:bit0, :bit1)}
+    assert_raise(ArgumentError) {flag.symbols2bits(nil)}
   end
 
 end# TestBitFlag

data/test/test_rake.rb

@@ -1,4 +1,5 @@
 require_relative 'helper'
+require 'stringio'
 require 'xot/rake'
 
 
@@ -15,7 +16,17 @@ FalseStr   = 'false'
 
 class TestRake < Test::Unit::TestCase
 
+  include Rake::DSL
   include Xot::Rake
+  include GitRepo
+
+  def stdout(&block)
+    out, $stdout = $stdout, StringIO.new
+    block.call
+    $stdout.string
+  ensure
+    $stdout = out
+  end
 
   def test_set()
     assert_equal 'const', get_env(:Const, :dummy)
@@ -29,4 +40,23 @@ class TestRake < Test::Unit::TestCase
     assert_equal false,   get_env(:FalseStr, :dummy)
   end
 
+  def test_automate_release()
+    automate_release
+    %w[hooks changelog:check changelog:update version:tag].each do |name|
+      assert Rake::Task.task_defined?(name), name
+    end
+
+    update = -> {stdout {Rake::Task['changelog:update'].tap(&:reenable).invoke}}
+    repo do
+      assert_match(/no changes/, update.call)
+      assert File.file?('.git/hooks/pre-commit')
+      assert_equal CHANGELOG, File.read('ChangeLog.md')
+
+      commit 'Add a', 'a.rb' => ''
+      update.call
+      assert_equal %w[0.1.1 0.1.0], Xot::ChangeLog.new.versions
+      assert_equal '- Add a',       Xot::ChangeLog.new.changes('0.1.1')
+    end
+  end
+
 end# TestRake