xot 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 542e0190c871258dcaeecacf936de4181ccc66a72e527e9c998bfc6714d62029
-  data.tar.gz: 639a4874658638bfe7b1550b3dceab8965d499487a9cfcf26df981c2ee91ebfa
+  metadata.gz: 1a3ec9fd69e881ecb8a828cca918588b19a772dd024342e8b2a82f6e8365e8f7
+  data.tar.gz: 8d40b3de7ef8c45a92e090c1c0b2b6920f607f0be4d4c681c0421ee00816e065
 SHA512:
-  metadata.gz: 432e5c625b94c3d89400abada614c6dede4ddb5282b8c4e32a2e1f08fb1a22218866837b0254f84b9994d82d56b25f929b6bb8dfd27455e6e6ca17b88508208a
-  data.tar.gz: 4d7fb96c8190e2aed12572c6e282d6f1c25d5893a76a93b2d1316de9b95440954f13999139d4b385912cb60cdd6acf3bcd5b142779ec0559e392d422c98f2565
+  metadata.gz: 8a41380d0bdf8d0afa5a4948a5e431850c1ade73db5cd17181e6f2cc8a1684691ec17cd0bb85aff2963d8777fbcabab45b6bf40a434275e152509011330769f8
+  data.tar.gz: deec3342fd9bc24d708988bacc75314c4d78d75412e725da8a8ea233668b36e52febe3e5465eeeaac47996e5351e8ecf0915514e400399a5edf90df1f4fce8c4

data/ChangeLog.md

@@ -1,6 +1,17 @@
 # xot ChangeLog
 
 
+## [v0.3.10] - 2026-04-09
+
+- Add minimal support for SDL2
+- Add '-bind_at_load' linker option for C-extension
+- Add '-Wl,-bind_at_load' for linker option for debug builds on Mac
+- Add 'apt' for install_packages()
+- Compile .swift files
+- Copy import lib file on mingw or cygwin
+- Move utilities like get_env() from Xot::Rake to Xot::Util
+
+
 ## [v0.3.9] - 2025-07-06
 
 - Add deepwiki badge

data/VERSION

@@ -1 +1 @@
-0.3.9
+0.3.10

data/lib/xot/extconf.rb

@@ -37,6 +37,7 @@ module Xot
       if osx?
         opt = '-Wl,-undefined,dynamic_lookup'
         ldflags << " #{opt}" unless ($DLDFLAGS || '').include?(opt)
+        ldflags << ' -Wl,-bind_at_load' if osx? && debug?
       end
 
       local_libs << (clang? ? 'c++' : 'stdc++')

data/lib/xot/extension.rb

@@ -25,6 +25,10 @@ module Xot
       root_dir 'lib'
     end
 
+    def ext_dir()
+      root_dir 'ext'
+    end
+
   end# Extension
 
 

data/lib/xot/rake/util.rb

@@ -11,7 +11,7 @@ module Xot
     include Xot::Util
 
     def extensions()
-      env(:EXTENSIONS, []).map {|m| m::Extension}
+      get_env(:EXTENSIONS, []).map {|m| m::Extension}
     end
 
     def target()
@@ -19,62 +19,106 @@ module Xot
     end
 
     def target_name()
-      env :EXTNAME, target.name.downcase
+      get_env :EXTNAME, target.name.downcase
     end
 
     def inc_dir()
-      env :INCDIR, 'include'
+      get_env :INCDIR, 'include'
     end
 
     def src_dir()
-      env :SRCDIR, 'src'
+      get_env :SRCDIR, 'src'
     end
 
     def lib_dir()
-      env :LIBDIR, 'lib'
+      get_env :LIBDIR, 'lib'
     end
 
     def doc_dir()
-      env :DOCDIR, 'doc'
+      get_env :DOCDIR, 'doc'
     end
 
     def ext_dir()
-      env :EXTDIR, "ext/#{target_name}"
-    end
-
-    def ext_lib_dir()
-      env :EXTLIBDIR, "lib/#{target_name}"
+      get_env :EXTDIR, "ext/#{target_name}"
     end
 
     def test_dir()
-      env :TESTDIR, 'test'
+      get_env :TESTDIR, 'test'
     end
 
     def vendor_dir()
-      env :VENDORDIR, 'vendor'
+      get_env :VENDORDIR, 'vendor'
+    end
+
+    def tests_alone()
+      get_env :TESTS_ALONE, []
+    end
+
+    def tests_exclude()
+      get_env :TESTS_EXCLUDE, []
     end
 
     def inc_dirs()
-      dirs  = env_array :INCDIRS, []
+      dirs  = get_env_array :INCDIRS, []
       dirs += extensions.reverse.map {|m| m.inc_dir}.flatten
-      dirs << "#{env :MINGW_PREFIX}/include" if mingw?
+      dirs << "#{get_env :MINGW_PREFIX}/include" if mingw?
+      dirs << "/usr/include/SDL2" if linux?
       dirs
     end
 
     def src_dirs()
-      env_array :SRCDIRS, []
+      get_env_array :SRCDIRS, []
     end
 
     def src_exts()
-      env_array(:SRCEXTS, []) + %w[c cc cpp m mm]
+      get_env_array(:SRCEXTS, []) + %w[c cc cpp m mm swift]
+    end
+
+    def srcs_map(src_dir: self.src_dir, src_exts: self.src_exts)
+      paths = glob("#{src_dir}/**/*.{#{src_exts.join ','}}") +
+        erbs_map.values.grep(/\.(#{src_exts.join '|'})$/)
+      paths.reject! {|path| excluded? path}
+      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?
+      make_path_map paths, src_ext_map
+    end
+
+    def erbs_map(inc_dir: self.inc_dir, src_dir: self.src_dir)
+      paths = glob(*[inc_dir, src_dir].map {|s| "#{s}/**/*.erb"})
+      paths.reject! {|path| excluded? path}
+      make_path_map paths, {".erb" => ""}
+    end
+
+    def vendor_srcs_map(*dirs, src_exts: self.src_exts)
+      dirs  = src_dirs if dirs.empty?
+      paths = dirs.map {|dir| glob "#{dir}/**/*.{#{src_exts.join ','}}"}.flatten
+      paths.reject! {|path| excluded? path}
+      make_path_map paths.flatten, src_ext_map(src_exts: src_exts)
+    end
+
+    def src_ext_map(to = '.o', src_exts: self.src_exts)
+      Hash[*src_exts.map {|ext| [".#{ext}", to]}.flatten]
+    end
+
+    def make_path_map(paths, ext_map)
+      paths = paths.map do |path|
+        newpath = ext_map.inject path do |value, (from, to)|
+          value.sub(/#{from.gsub('.', '\.')}$/, to)
+        end
+        raise "map to same path" if path == newpath
+        [path, newpath]
+      end
+      Hash[*paths.flatten]
     end
 
     def defs()
-      env_array :DEFS, []
+      get_env_array :DEFS, []
     end
 
     def excludes()
-      env_array :EXCLUDES, []
+      get_env_array :EXCLUDES, []
     end
 
     def excluded?(path)
@@ -131,42 +175,6 @@ module Xot
       (1..max).map(&block).join(sep)
     end
 
-    def make_path_map(paths, ext_map)
-      paths = paths.map do |path|
-        newpath = ext_map.inject path do |value, (from, to)|
-          value.sub(/#{from.gsub('.', '\.')}$/, to)
-        end
-        raise "map to same path" if path == newpath
-        [path, newpath]
-      end
-      Hash[*paths.flatten]
-    end
-
-    def get_env(name, defval = nil)
-      val = ENV[name.to_s] || Object.const_get(name) rescue defval
-      val.dup rescue val
-    end
-
-    def env(name, defval = nil)
-      case val = get_env(name, defval)
-      when /^\d+$/        then val.to_i
-      when 'true',  true  then true
-      when 'false', false then false
-      when nil            then nil
-      else                     val
-      end
-    end
-
-    def env_array(name, defval = nil)
-      val = get_env name, defval
-      val = val.strip.split(/\s+/) if val.kind_of? String
-      val
-    end
-
-    def append_env(name, *args)
-      ENV[name] = (ENV[name] || '') + " #{args.flatten.join ' '}"
-    end
-
     def make_cppflags(flags = '', defs = [], incdirs = [])
       s  = flags.dup
       s += make_cppflags_defs(defs)          .map {|s| " -D#{s}"}.join
@@ -183,9 +191,11 @@ module Xot
       a << 'WIN32'             if win32?
       a << 'OSX'               if osx?
       a << 'IOS'               if ios?
+      a << 'LINUX'             if linux?
       a << 'GCC'               if gcc?
       a << 'CLANG'             if clang?
       a << '_USE_MATH_DEFINES' if gcc?
+      a << '_THREAD_SAFE'      if linux?
       a
     end
 
@@ -210,7 +220,7 @@ module Xot
       ] if clang?
       s  = flags.dup
       s << warning_opts.map {|s| " -W#{s}"}.join
-      s << " -arch arm64" if RUBY_PLATFORM =~ /arm64-darwin/
+      s << " -arch arm64"                                          if osx? && arm64?
       s << ' -std=c++20'                                           if gcc?
       s << ' -std=c++20 -stdlib=libc++ -mmacosx-version-min=10.10' if clang?
       s << ' ' + RbConfig::CONFIG['debugflags']                    if debug?
@@ -222,48 +232,41 @@ module Xot
       s  = flags.dup
       s << libdirs.map    {|s| " -L#{s}"}.join
       s << frameworks.map {|s| " -framework #{s}"}.join
+      s << ' -Wl,-bind_at_load' if osx? && debug?
       s
     end
 
-    def verbose?(state = nil)
-      if state != nil
-        ::Rake.verbose state
-        ENV['VERBOSE'] = (!!state).to_s
-      end
-      ::Rake.verbose
-    end
-
-    def debug?(state = nil)
-      ENV['DEBUG'] = (!!state).to_s if state != nil
-      env :DEBUG, false
-    end
-
-    def cxx()
-      env :CXX, RbConfig::CONFIG['CXX'] || 'g++'
-    end
-
-    def ar()
-      env :AR, RbConfig::CONFIG['AR']  || 'ar'
-    end
-
     def cppflags()
-      flags = env :CPPFLAGS, RbConfig::CONFIG['CPPFLAGS']
+      flags = get_env :CPPFLAGS, RbConfig::CONFIG['CPPFLAGS']
       make_cppflags flags, defs, inc_dirs
     end
 
     def cxxflags(warnings = true)
-      cflags   = env :CFLAGS,   RbConfig::CONFIG['CFLAGS']
-      cxxflags = env :CXXFLAGS, RbConfig::CONFIG['CXXFLAGS']
+      cflags   = get_env :CFLAGS,   RbConfig::CONFIG['CFLAGS']
+      cxxflags = get_env :CXXFLAGS, RbConfig::CONFIG['CXXFLAGS']
       cflags   = cflags.gsub(/-W[\w\-\=]+/, '') + ' -w' unless warnings
       make_cflags "#{cflags} #{cxxflags}"
     end
 
     def arflags()
-      env :ARFLAGS, RbConfig::CONFIG['ARFLAGS'] || 'crs'
+      get_env :ARFLAGS, RbConfig::CONFIG['ARFLAGS'] || 'crs'
+    end
+
+    def swiftc()
+      get_env :SWIFTC, 'swiftc'
+    end
+
+    def swiftflags()
+      flags = get_env :SWIFTFLAGS, ''
+      flags += " -sdk #{`xcrun --show-sdk-path`.strip} -module-name #{target.name} -emit-object"
+      flags += ' -target arm64-apple-macos11.0'  if osx? && arm64?
+      flags += ' -target x86_64-apple-macos11.0' if osx? && x86_64?
+      flags += debug? ? ' -g -Onone' : ' -O'
+      flags
     end
 
     def default_tasks(default = nil)
-      verbose? env(:VERBOSE, true)
+      verbose? get_env(:VERBOSE, true)
 
       if default
         task :default => default

data/lib/xot/rake.rb

@@ -12,41 +12,6 @@ module Xot
 
   module Rake
 
-    def srcs_map()
-      paths = glob("#{src_dir}/**/*.{#{src_exts.join ','}}") +
-        erbs_map.values.grep(/\.(#{src_exts.join '|'})$/)
-      paths.reject! {|path| excluded? path}
-      paths.reject! {|path| path =~ %r(/win32/)} unless win32?
-      paths.reject! {|path| path =~ %r(/osx/)}   unless osx?
-      paths.reject! {|path| path =~ %r(/ios/)}   unless ios?
-      make_path_map paths, src_ext_map
-    end
-
-    def erbs_map()
-      paths = glob(*[inc_dir, src_dir].map {|s| "#{s}/**/*.erb"})
-      paths.reject! {|path| excluded? path}
-      make_path_map paths, {".erb" => ""}
-    end
-
-    def vendor_srcs_map(*dirs)
-      dirs  = src_dirs if dirs.empty?
-      paths = dirs.map {|dir| glob "#{dir}/**/*.{#{src_exts.join ','}}"}.flatten
-      paths.reject! {|path| excluded? path}
-      make_path_map paths.flatten, src_ext_map
-    end
-
-    def src_ext_map(to = '.o')
-      Hash[*src_exts.map {|ext| [".#{ext}", to]}.flatten]
-    end
-
-    def test_alones()
-      env :TESTS_ALONE, []
-    end
-
-    def test_excludes()
-      env :TESTS_EXCLUDE, []
-    end
-
     def use_bundler()
       task :clobber => 'bundle:clobber'
 
@@ -64,11 +29,12 @@ module Xot
     end
 
     def build_native_library()
-      outname = "lib#{target_name}.a"
-      out     = File.join lib_dir, outname
-      erbs    = erbs_map
-      srcs    = srcs_map
-      depend  = 'depend.mf'
+      outname       = "lib#{target_name}.a"
+      out           = File.join lib_dir, outname
+      erbs          = erbs_map
+      srcs          = srcs_map
+      depend        = 'depend.mf'
+      swift_headers = srcs.select {_1.end_with? '.swift'}.to_h {[_1, _1 + '.h']}
 
       alias_task :erb   => 'lib:erb'
       alias_task :lib   => out
@@ -91,7 +57,7 @@ module Xot
         end
 
         desc "create #{depend}"
-        file depend => erbs.values do
+        file depend => erbs.values + swift_headers.values do
           sh %( #{cxx} -M #{cppflags} #{srcs.keys.join ' '} > #{depend} )
           input = open(depend) {|f| f.read}
           open(depend, 'w') do |output|
@@ -105,7 +71,20 @@ module Xot
           desc "compile #{src}"
           file obj => [:vendor, depend, src] + erbs.values do
             noverbose_puts "compiling #{src}"
-            sh %( #{cxx} -c #{cppflags} #{cxxflags} -o #{obj} #{src} )
+            case src
+            when /\.swift/
+              sh %( #{swiftc} #{swiftflags} -o #{obj} -c #{src} )
+            else
+              sh %( #{cxx} #{cppflags} #{cxxflags} -o #{obj} -c #{src} )
+            end
+          end
+        end
+
+        swift_headers.each do |swift, header|
+          desc "create #{header}"
+          file header => swift do
+            opts = "-emit-objc-header -emit-objc-header-path #{header} -o /dev/null"
+            sh %( #{swiftc} #{swiftflags} #{opts} -c #{swift} )
           end
         end
 
@@ -118,15 +97,15 @@ module Xot
         end
 
         task :clean do
-          tmps = srcs.values + erbs.values
+          tmps = srcs.values + swift_headers.values + erbs.values
           sh %( rm -rf #{out} #{depend} #{tmps.join ' '} )
         end
       end
     end
 
-    def build_ruby_extension(dlname: 'native', dlext: nil, liboutput: true)
-      dlname = env :DLNAME, dlname
-      dlext  = env :DLEXT,  dlext || RbConfig::CONFIG['DLEXT'] || 'so'
+    def build_ruby_extension(dlname: nil, dlext: nil, liboutput: true)
+      dlname = get_env :DLNAME, dlname || "#{target_name}_ext"
+      dlext  = get_env :DLEXT,  dlext  || RbConfig::CONFIG['DLEXT'] || 'so'
 
       extconf  = File.join ext_dir, 'extconf.rb'
       makefile = File.join ext_dir, 'Makefile'
@@ -134,7 +113,7 @@ module Xot
 
       outname = "#{dlname}.#{dlext}"
       extout  = File.join ext_dir, outname
-      libout  = File.join ext_lib_dir, outname
+      libout  = File.join lib_dir, outname
 
       srcs = FileList["#{ext_dir}/**/*.cpp"]
       libs = extensions.map {|x| "#{x.lib_dir}/lib#{x.name.downcase}.a"}
@@ -146,7 +125,10 @@ module Xot
       namespace :ext do
         desc "build #{libout}"
         file libout => extout do
-          sh %( cp #{extout} #{libout} )
+          libdir = File.dirname libout
+          libimp = extout.sub /\.#{dlext}$/, '.dll.a'
+          sh %( cp #{extout} #{libdir} )
+          sh %( cp #{libimp} #{libdir} ) if mingw? || cygwin?
         end
 
         desc "build #{extout}"
@@ -186,13 +168,13 @@ module Xot
       namespace :test do
         ::Rake::TestTask.new :full do |t|
           t.libs << lib_dir
-          t.test_files = FileList["#{test_dir}/**/test_*.rb"] - test_alones - test_excludes
+          t.test_files = FileList["#{test_dir}/**/test_*.rb"] - tests_alone - tests_exclude
           t.verbose = ::Rake.verbose
         end
 
         task :alones do
-          test_alones.each do |rb|
-            next if test_excludes.include? rb
+          tests_alone.each do |rb|
+            next if tests_exclude.include? rb
             sh %( ruby #{rb} )
           end
         end
@@ -201,8 +183,8 @@ module Xot
 
     def build_ruby_gem()
       gemspec = "#{target_name}.gemspec"
-      gemname = env :GEMNAME,    target_name
-      gemver  = env :GEMVERSION, target.version
+      gemname = get_env :GEMNAME,    target_name
+      gemver  = get_env :GEMVERSION, target.version
       gemfile = "#{gemname}-#{gemver}.gem"
 
       alias_task :gem       => gemfile
@@ -241,7 +223,7 @@ module Xot
     end
 
     def build_application()
-      bindir    = env :BINDIR, 'bin'
+      bindir    = get_env :BINDIR, 'bin'
       bin       = "#{bindir}/#{target_name}"
       appdir    = "#{target.name}.app"
       appbindir = "#{appdir}/Contents/MacOS"
@@ -268,16 +250,19 @@ module Xot
       end
     end
 
-    def install_packages(osx: [], win32: [])
+    def install_packages(osx: [], mingw: [], apt: [])
       desc "install packages"
       task :packages do
         case
         when osx? && osx.size > 0
           sh %( brew install #{osx.join ' '} )
-        when win32? && win32.size > 0
-          prefix   = 'MINGW_PACKAGE_PREFIX'
-          packages = win32.map {|package| package.sub prefix, ENV[prefix]}
-          sh %( pacman -S --noconfirm #{packages.join ' '} )
+        when mingw? && mingw.size > 0
+          prefix = 'MINGW_PACKAGE_PREFIX'
+          mingw  = mingw.map {|package| package.sub prefix, ENV[prefix]}
+          sh %( pacman -S --noconfirm #{mingw.join ' '} )
+        when linux? && apt.size > 0
+          sh %( sudo apt-get update )
+          sh %( sudo apt-get install -y -qq #{apt.join ' '} )
         end
       end
     end
@@ -328,7 +313,7 @@ module Xot
               end
             end
             Dir.chdir(dir) {after_clone_block.call} if after_clone_block
-            unless env :VENDOR_NOCOMPILE, false
+            unless get_env :VENDOR_NOCOMPILE, false
               vendor_srcs_map(*srcdirs).each do |src, obj|
                 sh %( #{cxx} -c #{cppflags} #{cxxflags false} -o #{obj} #{src} )
               end

data/lib/xot/util.rb

@@ -6,6 +6,64 @@ module Xot
 
   extend module Util
 
+    def get_env!(name, defval = nil)
+      val = ENV[name.to_s] || Object.const_get(name) rescue defval
+      val.dup rescue val
+    end
+
+    def get_env(name, defval = nil)
+      case val = get_env!(name, defval)
+      when /^\d+$/        then val.to_i
+      when 'true',  true  then true
+      when 'false', false then false
+      when nil            then nil
+      else                     val
+      end
+    end
+
+    def get_env_array(name, defval = nil)
+      val = get_env! name, defval
+      val = val.strip.split(/\s+/) if val.kind_of? String
+      val
+    end
+
+    def append_env(name, *args)
+      ENV[name] = (ENV[name] || '') + " #{args.flatten.join ' '}"
+    end
+
+    def cc()
+      get_env :CC, RbConfig::CONFIG['CC'] || 'gcc'
+    end
+
+    def cxx()
+      get_env :CXX, RbConfig::CONFIG['CXX'] || 'g++'
+    end
+
+    def ar()
+      get_env :AR, RbConfig::CONFIG['AR']  || 'ar'
+    end
+
+    def verbose?(state = nil)
+      if state != nil
+        ::Rake.verbose state
+        ENV['VERBOSE'] = (!!state).to_s
+      end
+      ::Rake.verbose
+    end
+
+    def debug?(state = nil)
+      ENV['DEBUG'] = (!!state).to_s if state != nil
+      get_env :DEBUG, false
+    end
+
+    def arm64?()
+      /arm64/.match? RUBY_PLATFORM
+    end
+
+    def x86_64?()
+      /x86_64/.match? RUBY_PLATFORM
+    end
+
     def osx?()
       /darwin/.match? RUBY_PLATFORM
     end
@@ -30,12 +88,16 @@ module Xot
       /cygwin/.match? RUBY_PLATFORM
     end
 
+    def linux?()
+      /linux/.match? RUBY_PLATFORM
+    end
+
     def gcc?()
-      /(^|\s)g\+\+/i.match? RbConfig::CONFIG['CXX']
+      /(^|\-)gcc$/i.match? cc
     end
 
     def clang?()
-      /(^|\s)clang/i.match? RbConfig::CONFIG['CXX']
+      /(^|\-)clang/i.match? cc
     end
 
     def github_actions?()

data/test/test_rake.rb

@@ -18,15 +18,15 @@ class TestRake < Test::Unit::TestCase
   include Xot::Rake
 
   def test_set()
-    assert_equal 'const', env(:Const, :dummy)
-    assert_equal 0, env(:Zero, :dummy)
-    assert_equal 1, env(:NonZero, :dummy)
-    assert_equal 0, env(:ZeroStr, :dummy)
-    assert_equal 1, env(:NonZeroStr, :dummy)
-    assert_equal true, env(:True, :dummy)
-    assert_equal false, env(:False, :dummy)
-    assert_equal true, env(:TrueStr, :dummy)
-    assert_equal false, env(:FalseStr, :dummy)
+    assert_equal 'const', get_env(:Const, :dummy)
+    assert_equal 0,       get_env(:Zero, :dummy)
+    assert_equal 1,       get_env(:NonZero, :dummy)
+    assert_equal 0,       get_env(:ZeroStr, :dummy)
+    assert_equal 1,       get_env(:NonZeroStr, :dummy)
+    assert_equal true,    get_env(:True, :dummy)
+    assert_equal false,   get_env(:False, :dummy)
+    assert_equal true,    get_env(:TrueStr, :dummy)
+    assert_equal false,   get_env(:FalseStr, :dummy)
   end
 
 end# TestRake

metadata

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