rucy 0.3.11 → 0.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89db0f3be96a0564f5ed99044093f111decff6d0dd89a613251be1bda89163ca
-  data.tar.gz: 6c7b8d8aafc090fb75d7fb2c3cfc16fe9026b8da93d4673ee5cc9b3d8e2aba6e
+  metadata.gz: b1729a91940f9162509a18696813859a374ccb82c4af989b4c782e6015e394fa
+  data.tar.gz: 645ee9505dc9178bd1aa77093f44566290e05dac58ca5d20d62193e0d7a5c0d3
 SHA512:
-  metadata.gz: a82fd0de0e5e372e8dbb25b335c3cb27e7209c691522058e26c324dfb16204b181c72326439e5f05c2a54ed7199fb23d5315f3a02b4f8de8d35533b1e9977036
-  data.tar.gz: 510edf2d681cc108435efc854c26446afc4560e7a0471269f68661bc6f8f9eedbf2c8d55ef2733dce46e78c1a01c5ca86b8dcb0c2b84723474a2d60cf2b3c885
+  metadata.gz: 2995825674988de7587c353785c032f15e974e5074412497b448fd6ac0450d0450dc4a0951b805e80ef58c66d47c92546e88da36127c4cbd0693c768b94e0b57
+  data.tar.gz: b7fbe367adbbcfd7de8dc7176f488a776451dbfb9658ac9c3f6a7b857aa3327cfcf5713f26b9bae709a4a3eb746c124917cb926da8df77ef728fe6701c9c1ba6

data/.doc/ext/rucy/value.cpp

@@ -28,6 +28,30 @@ VALUE value_to_ushort(VALUE self, VALUE num)
 	return value(to<unsigned short>(num));
 }
 
+static
+VALUE value_to_int(VALUE self, VALUE num)
+{
+	return value(to<int>(num));
+}
+
+static
+VALUE value_to_uint(VALUE self, VALUE num)
+{
+	return value(to<unsigned int>(num));
+}
+
+static
+VALUE value_to_long(VALUE self, VALUE num)
+{
+	return value(to<long>(num));
+}
+
+static
+VALUE value_to_ulong(VALUE self, VALUE num)
+{
+	return value(to<unsigned long>(num));
+}
+
 static
 VALUE true_to_value(VALUE self)
 {
@@ -84,6 +108,10 @@ Init_value ()
 	rb_define_method(mTester, "value_to_uchar", RUBY_METHOD_FUNC(value_to_uchar), 1);
 	rb_define_method(mTester, "value_to_short", RUBY_METHOD_FUNC(value_to_short), 1);
 	rb_define_method(mTester, "value_to_ushort", RUBY_METHOD_FUNC(value_to_ushort), 1);
+	rb_define_method(mTester, "value_to_int", RUBY_METHOD_FUNC(value_to_int), 1);
+	rb_define_method(mTester, "value_to_uint", RUBY_METHOD_FUNC(value_to_uint), 1);
+	rb_define_method(mTester, "value_to_long", RUBY_METHOD_FUNC(value_to_long), 1);
+	rb_define_method(mTester, "value_to_ulong", RUBY_METHOD_FUNC(value_to_ulong), 1);
 
 	rb_define_method(mTester, "true_to_value", RUBY_METHOD_FUNC(true_to_value), -1);
 	rb_define_method(mTester, "false_to_value", RUBY_METHOD_FUNC(false_to_value), -1);

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

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,16 @@
 # rucy ChangeLog
 
 
+## [v0.3.12] - 2026-05-10
+
+- Migrate to TypedData API for Ruby 4.x compatibility
+- Enable WB_PROTECTED for TypedData with no mark function
+- Add range checks to integer value_to conversions
+- Add Value::respond_to wrapping rb_respond_to
+- Use hint_memory_usage callback for external memory GC integration
+- Remove deprecated has_rdoc= from gemspecs
+
+
 ## [v0.3.11] - 2026-04-17
 
 - Fix ANYARGS function pointer warnings in module bindings

data/VERSION

@@ -1 +1 @@
-0.3.11
+0.3.12

data/ext/rucy/value.cpp

@@ -32,6 +32,34 @@ RUCY_DEF1(value_to_ushort, num)
 }
 RUCY_END
 
+static
+RUCY_DEF1(value_to_int, num)
+{
+	return value(to<int>(num));
+}
+RUCY_END
+
+static
+RUCY_DEF1(value_to_uint, num)
+{
+	return value(to<unsigned int>(num));
+}
+RUCY_END
+
+static
+RUCY_DEF1(value_to_long, num)
+{
+	return value(to<long>(num));
+}
+RUCY_END
+
+static
+RUCY_DEF1(value_to_ulong, num)
+{
+	return value(to<unsigned long>(num));
+}
+RUCY_END
+
 static
 RUCY_DEFN(true_to_value)
 {
@@ -89,10 +117,14 @@ Init_value ()
 	Module mRucy   =       define_module("Rucy");
 	Module mTester = mRucy.define_module("Tester");
 
-	mTester.define_method("value_to_char",  value_to_char);
-	mTester.define_method("value_to_uchar", value_to_uchar);
+	mTester.define_method("value_to_char",   value_to_char);
+	mTester.define_method("value_to_uchar",  value_to_uchar);
 	mTester.define_method("value_to_short",  value_to_short);
 	mTester.define_method("value_to_ushort", value_to_ushort);
+	mTester.define_method("value_to_int",    value_to_int);
+	mTester.define_method("value_to_uint",   value_to_uint);
+	mTester.define_method("value_to_long",   value_to_long);
+	mTester.define_method("value_to_ulong",  value_to_ulong);
 
 	mTester.define_method("true_to_value", true_to_value);
 	mTester.define_method("false_to_value", false_to_value);

data/include/rucy/extension.h.erb

@@ -4,6 +4,7 @@
 #define __RUCY_EXTENSION_H__
 
 
+#include <typeinfo>
 #include <xot/ref.h>
 #include <xot/string.h>
 #include <rucy/defs.h>
@@ -384,81 +385,101 @@ namespace Rucy
 	};// ClassWrapper
 
 
-	template <typename T> inline void delete_type (void* p)
+	template <typename T>
+	inline void delete_type (void* p)
 	{
 		delete (T*) p;
 	}
 
-	template <typename T> inline void release_ref (void* p)
+	template <typename T>
+	inline void release_ref (void* p)
 	{
 		if (p) ((T*) p)->release();
 	}
 
-	template <typename T> inline void release_wrapper (void* p)
+	template <typename T>
+	inline void release_wrapper (void* p)
 	{
 		if (p) ((T*) p)->release(true);
 	}
 
 
-	template <typename T> inline Value new_type (
-		Value klass, T* ptr,
-		RUBY_DATA_FUNC mark = NULL,
-		RUBY_DATA_FUNC free = delete_type<T>)
+	template <typename T, RUBY_DATA_FUNC mark, RUBY_DATA_FUNC free>
+	inline const rb_data_type_t* get_data_type ()
+	{
+		static const rb_data_type_t data_type = {
+			typeid(T).name(),
+			{mark, free, NULL, NULL, {NULL}},
+			NULL, NULL,
+			RUBY_TYPED_FREE_IMMEDIATELY |
+				(mark == nullptr ? RUBY_TYPED_WB_PROTECTED : 0)
+		};
+		return &data_type;
+	}
+
+
+	template <
+		typename T,
+		RUBY_DATA_FUNC mark = nullptr,
+		RUBY_DATA_FUNC free = delete_type<T>>
+	inline Value new_type (Value klass, T* ptr)
 	{
 		if (!ptr) return nil();
-		return Data_Wrap_Struct(klass, mark, free, ptr);
+		return rb_data_typed_object_wrap(klass, ptr, get_data_type<T, mark, free>());
 	}
 
-	template <typename T> inline Value new_type (
-		Value klass,
-		RUBY_DATA_FUNC mark = NULL,
-		RUBY_DATA_FUNC free = delete_type<T>)
+	template <
+		typename T,
+		RUBY_DATA_FUNC mark = nullptr,
+		RUBY_DATA_FUNC free = delete_type<T>>
+	inline Value new_type (Value klass)
 	{
-		return new_type(klass, new T, mark, free);
+		return new_type<T, mark, free>(klass, new T);
 	}
 
-	template <typename T> inline Value new_ref (
-		Value klass, T* ptr,
-		RUBY_DATA_FUNC mark = NULL,
-		RUBY_DATA_FUNC free = release_ref<T>)
+	template <
+		typename T,
+		RUBY_DATA_FUNC mark = nullptr,
+		RUBY_DATA_FUNC free = release_ref<T>>
+	inline Value new_ref (Value klass, T* ptr)
 	{
 		if (ptr) ptr->retain();
-		return new_type(klass, ptr, mark, free);
+		return new_type<T, mark, free>(klass, ptr);
 	}
 
-	template <typename T> inline Value new_ref (
-		Value klass,
-		RUBY_DATA_FUNC mark = NULL,
-		RUBY_DATA_FUNC free = release_ref<T>)
+	template <
+		typename T,
+		RUBY_DATA_FUNC mark = nullptr,
+		RUBY_DATA_FUNC free = release_ref<T>>
+	inline Value new_ref (Value klass)
 	{
-		return new_ref(klass, new T, mark, free);
+		return new_ref<T, mark, free>(klass, new T);
 	}
 
-	template <typename T> inline Value new_wrapper (
-		Value klass, T* ptr,
-		RUBY_DATA_FUNC mark = NULL,
-		RUBY_DATA_FUNC free = release_wrapper<T>)
+	template <
+		typename T,
+		RUBY_DATA_FUNC mark = nullptr,
+		RUBY_DATA_FUNC free = release_wrapper<T>>
+	inline Value new_wrapper (Value klass, T* ptr)
 	{
 		if (ptr) ptr->retain(true);
-		return new_type(klass, ptr, mark, free);
+		return new_type<T, mark, free>(klass, ptr);
 	}
 
-	template <typename T> inline Value new_wrapper (
-		Value klass,
-		RUBY_DATA_FUNC mark = NULL,
-		RUBY_DATA_FUNC free = release_wrapper<T>)
+	template <
+		typename T,
+		RUBY_DATA_FUNC mark = nullptr,
+		RUBY_DATA_FUNC free = release_wrapper<T>>
+	inline Value new_wrapper (Value klass)
 	{
-		return new_wrapper(klass, new T, mark, free);
+		return new_wrapper<T, mark, free>(klass, new T);
 	}
 
 
 	template <typename T> inline T* get_type_ptr (Value obj, Value klass = nil())
 	{
 		if (!klass.is_nil()) check_class(obj, klass);
-		RubyValue o = obj.value();
-		T* p        = NULL;
-		Data_Get_Struct(o, T, p);
-		return p;
+		return (T*) DATA_PTR(obj.value());
 	}
 
 

data/include/rucy/value.h.erb

@@ -109,6 +109,8 @@ namespace Rucy
 
 			bool is_a (Value klass) const;
 
+			bool respond_to (Symbol name) const;
+
 			Value inspect () const;
 
 			// String

data/include/rucy.h

@@ -1,7 +1,7 @@
 // -*- c++ -*-
 #pragma once
-#ifndef __RUCY_H__
-#define __RUCY_H__
+#ifndef __RUCY_ALL_H__
+#define __RUCY_ALL_H__
 
 
 #include <rucy/ruby.h>

data/lib/rucy/extension.rb

@@ -5,8 +5,10 @@ module Rucy
 
     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 Rucy
       root_dir 'ext'
     end
 
+    def lib_name()
+      name true
+    end
+
   end# Extension
 
 

data/rucy.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   end
 
   ext   = Rucy::Extension
-  name  = ext.name.downcase
+  name  = ext.name true
   rdocs = glob.call *%w[README .doc/ext/**/*.cpp]
 
   s.name        = name
@@ -25,13 +25,12 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_dependency 'xot', '~> 0.3.11'
+  s.add_dependency 'xot', '~> 0.3.12'
 
   s.files            = `git ls-files`.split $/
   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

data/src/rucy.cpp

@@ -2,6 +2,7 @@
 #include "rucy/rucy.h"
 
 
+#include <xot/util.h>
 #include "rucy/exception.h"
 
 
@@ -9,6 +10,18 @@ namespace Rucy
 {
 
 
+	static void
+	hint_memory_usage (ssize_t size)
+	{
+		rb_gc_adjust_memory_usage(size);
+
+		// rb_gc_adjust_memory_usage() uses MEMOP_TYPE_REALLOC internally,
+		// which increases malloc_increase but does not check the GC trigger.
+		// A tiny ruby_xmalloc() goes through MEMOP_TYPE_MALLOC and triggers
+		// GC when malloc_increase exceeds malloc_limit.
+		if (size > 0) ruby_xfree(ruby_xmalloc(1));
+	}
+
 	void
 	init ()
 	{
@@ -16,6 +29,8 @@ namespace Rucy
 		if (done) return;
 		done = true;
 
+		Xot::set_hint_memory_usage_fun(hint_memory_usage);
+
 		rucy_module();
 		native_error_class();
 		invalid_state_error_class();

data/src/value.cpp.erb

@@ -308,6 +308,12 @@ namespace Rucy
 		return rb_obj_is_kind_of(val, klass);
 	}
 
+	bool
+	Value::respond_to (Symbol name) const
+	{
+		return rb_respond_to(val, name.symbol());
+	}
+
 	Value
 	Value::inspect () const
 	{
@@ -646,29 +652,16 @@ namespace Rucy
 		return (bool) obj;
 	}
 
-	template <> int
-	value_to<int> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_i();
-		return NUM2INT(obj.value());
-	}
-
-	template <> unsigned int
-	value_to<unsigned int> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_i();
-		return NUM2UINT(obj.value());
-	}
-
 	template <> char
 	value_to<char> (Value obj, bool convert)
 	{
-		int n = value_to<int>(obj, convert);
+		if (convert) obj = obj.to_i();
+		int n = NUM2INT(obj.value());
 		if (
 			n < std::numeric_limits<char>::min() ||
 			n > std::numeric_limits<char>::max())
 		{
-			range_error(__FILE__, __LINE__, "cannot cast '%d' to char");
+			range_error(__FILE__, __LINE__, "cannot cast '%d' to char", n);
 		}
 		return (char) n;
 	}
@@ -676,12 +669,13 @@ namespace Rucy
 	template <> unsigned char
 	value_to<unsigned char> (Value obj, bool convert)
 	{
-		int n = value_to<int>(obj, convert);
+		if (convert) obj = obj.to_i();
+		int n = NUM2INT(obj.value());
 		if (
 			n < std::numeric_limits<unsigned char>::min() ||
 			n > std::numeric_limits<unsigned char>::max())
 		{
-			range_error(__FILE__, __LINE__, "cannot cast '%d' to unsigned char");
+			range_error(__FILE__, __LINE__, "cannot cast '%d' to unsigned char", n);
 		}
 		return (unsigned char) n;
 	}
@@ -689,12 +683,13 @@ namespace Rucy
 	template <> short
 	value_to<short> (Value obj, bool convert)
 	{
-		int n = value_to<int>(obj, convert);
+		if (convert) obj = obj.to_i();
+		int n = NUM2INT(obj.value());
 		if (
 			n < std::numeric_limits<short>::min() ||
 			n > std::numeric_limits<short>::max())
 		{
-			range_error(__FILE__, __LINE__, "cannot cast '%d' to short");
+			range_error(__FILE__, __LINE__, "cannot cast '%d' to short", n);
 		}
 		return (short) n;
 	}
@@ -702,28 +697,67 @@ namespace Rucy
 	template <> unsigned short
 	value_to<unsigned short> (Value obj, bool convert)
 	{
-		int n = value_to<int>(obj, convert);
+		if (convert) obj = obj.to_i();
+		int n = NUM2INT(obj.value());
 		if (
 			n < std::numeric_limits<unsigned short>::min() ||
 			n > std::numeric_limits<unsigned short>::max())
 		{
-			range_error(__FILE__, __LINE__, "cannot cast '%d' to unsigned short");
+			range_error(__FILE__, __LINE__, "cannot cast '%d' to unsigned short", n);
 		}
 		return (unsigned short) n;
 	}
 
+	template <> int
+	value_to<int> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_i();
+		long long n = NUM2LL(obj.value());
+		if (
+			n < std::numeric_limits<int>::min() ||
+			n > std::numeric_limits<int>::max())
+		{
+			range_error(__FILE__, __LINE__, "cannot cast '%lld' to int", n);
+		}
+		return (int) n;
+	}
+
+	template <> unsigned int
+	value_to<unsigned int> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_i();
+		long long n = NUM2LL(obj.value());
+		if (
+			n < std::numeric_limits<unsigned int>::min() ||
+			n > std::numeric_limits<unsigned int>::max())
+		{
+			range_error(__FILE__, __LINE__, "cannot cast '%lld' to unsigned int", n);
+		}
+		return (unsigned int) n;
+	}
+
 	template <> long
 	value_to<long> (Value obj, bool convert)
 	{
 		if (convert) obj = obj.to_i();
-		return NUM2LONG(obj.value());
+		long long n = NUM2LL(obj.value());
+		if (
+			n < std::numeric_limits<long>::min() ||
+			n > std::numeric_limits<long>::max())
+		{
+			range_error(__FILE__, __LINE__, "cannot cast '%lld' to long", n);
+		}
+		return (long) n;
 	}
 
 	template <> unsigned long
 	value_to<unsigned long> (Value obj, bool convert)
 	{
 		if (convert) obj = obj.to_i();
-		return NUM2ULONG(obj.value());
+		long long n = NUM2LL(obj.value());
+		if (n < 0)
+			range_error(__FILE__, __LINE__, "cannot cast '%lld' to unsigned long", n);
+		return (unsigned long) n;
 	}
 
 	template <> long long
@@ -737,6 +771,9 @@ namespace Rucy
 	value_to<unsigned long long> (Value obj, bool convert)
 	{
 		if (convert) obj = obj.to_i();
+		long long n = NUM2LL(obj.value());
+		if (n < 0)
+			range_error(__FILE__, __LINE__, "cannot cast '%lld' to unsigned long long", n);
 		return NUM2ULL(obj.value());
 	}
 

data/test/test_value.rb

@@ -8,31 +8,46 @@ class TestFunction < Test::Unit::TestCase
   def test_value_to_char()
     assert_equal    0,        value_to_char(   0)
     assert_equal  127,        value_to_char( 127)
-    assert_equal -128,        value_to_char(-128)
     assert_raise(RangeError) {value_to_char  128}
-    assert_raise(RangeError) {value_to_char -129}
+    assert_equal(-128,        value_to_char(-128))
+    assert_raise(RangeError) {value_to_char(-129)}
   end
 
   def test_value_to_uchar()
-    assert_equal   0,         value_to_uchar(  0)
     assert_equal 255,         value_to_uchar(255)
     assert_raise(RangeError) {value_to_uchar 256}
-    assert_raise(RangeError) {value_to_uchar  -1}
+    assert_equal   0,         value_to_uchar(  0)
+    assert_raise(RangeError) {value_to_uchar( -1)}
   end
 
   def test_value_to_short()
-    assert_equal      0,        value_to_short(   0)
+    assert_equal      0,      value_to_short(     0)
     assert_equal  32767,      value_to_short( 32767)
-    assert_equal -32768,      value_to_short(-32768)
     assert_raise(RangeError) {value_to_short  32768}
-    assert_raise(RangeError) {value_to_short -32769}
+    assert_equal(-32768,      value_to_short(-32768))
+    assert_raise(RangeError) {value_to_short(-32769)}
   end
 
   def test_value_to_ushort()
-    assert_equal     0,         value_to_ushort(  0)
     assert_equal 65535,       value_to_ushort(65535)
     assert_raise(RangeError) {value_to_ushort 65536}
-    assert_raise(RangeError) {value_to_ushort    -1}
+    assert_equal     0,       value_to_ushort(    0)
+    assert_raise(RangeError) {value_to_ushort(   -1)}
+  end
+
+  def test_value_to_int()
+    assert_equal           0, value_to_int(          0)
+    assert_equal  2147483647, value_to_int( 2147483647)
+    assert_raise(RangeError) {value_to_int  2147483648}
+    assert_equal(-2147483648, value_to_int(-2147483648))
+    assert_raise(RangeError) {value_to_int(-2147483649)}
+  end
+
+  def test_value_to_uint()
+    assert_equal 4294967295,  value_to_uint(4294967295)
+    assert_raise(RangeError) {value_to_uint 4294967296}
+    assert_equal          0,  value_to_uint(         0)
+    assert_raise(RangeError) {value_to_uint(        -1)}
   end
 
   def test_to_value()

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rucy
 version: !ruby/object:Gem::Version
-  version: 0.3.11
+  version: 0.3.12
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-17 00:00:00.000000000 Z
+date: 2026-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
 description: This library helps you to develop Ruby Extension by C++.
 email: xordog@gmail.com
 executables: