enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-socket/test/addrinfo.rb

@@ -0,0 +1,91 @@
+assert('Addrinfo') do
+  assert_equal(Class, Addrinfo.class)
+end
+
+assert('super class of Addrinfo') do
+  assert_equal(Object, Addrinfo.superclass)
+end
+
+assert('Addrinfo.getaddrinfo') do
+  ary = Addrinfo.getaddrinfo("localhost", 53, Socket::AF_INET, Socket::SOCK_STREAM)
+  assert_true(ary.size >= 1)
+  ai = ary[0]
+  assert_equal(ai.afamily, Socket::AF_INET)
+  assert_equal(ai.pfamily, Socket::PF_INET)
+  assert_equal(ai.socktype, Socket::SOCK_STREAM)
+  assert_equal(ai.ip_address, '127.0.0.1')
+  assert_equal(ai.ip_port, 53)
+end
+
+assert('Addrinfo.foreach') do
+  # assume Addrinfo.getaddrinfo works well
+  a = Addrinfo.getaddrinfo("localhost", 80)
+  b = []
+  Addrinfo.foreach("localhost", 80) { |ai| b << ai }
+  assert_equal(a.size, b.size)
+end
+
+assert('Addrinfo.ip') do
+  ai = Addrinfo.ip('127.0.0.1')
+  assert_equal('127.0.0.1', ai.ip_address)
+  assert_equal(Socket::AF_INET, ai.afamily)
+  assert_equal(0, ai.ip_port)
+  assert_equal(0, ai.socktype)
+  assert_equal(0, ai.protocol)
+end
+
+assert('Addrinfo.tcp') do
+  ai = Addrinfo.tcp('127.0.0.1', 25)
+  assert_equal('127.0.0.1', ai.ip_address)
+  assert_equal(Socket::AF_INET, ai.afamily)
+  assert_equal(25, ai.ip_port)
+  assert_equal(Socket::SOCK_STREAM, ai.socktype)
+  assert_equal(Socket::IPPROTO_TCP, ai.protocol)
+end
+
+assert('Addrinfo.udp') do
+  ai = Addrinfo.udp('127.0.0.1', 53)
+  assert_equal('127.0.0.1', ai.ip_address)
+  assert_equal(Socket::AF_INET, ai.afamily)
+  assert_equal(53, ai.ip_port)
+  assert_equal(Socket::SOCK_DGRAM, ai.socktype)
+  assert_equal(Socket::IPPROTO_UDP, ai.protocol)
+end
+
+assert('Addrinfo.unix') do
+  skip "unix is not supported on Windows" if SocketTest.win?
+  a1 = Addrinfo.unix('/tmp/sock')
+  assert_true(a1.unix?)
+  assert_equal('/tmp/sock', a1.unix_path)
+  assert_equal(Socket::SOCK_STREAM, a1.socktype)
+  a2 = Addrinfo.unix('/tmp/sock', Socket::SOCK_DGRAM)
+  assert_equal(Socket::SOCK_DGRAM, a2.socktype)
+end
+
+assert('Addrinfo#afamily') do
+  skip "afamily is not supported on Windows" if SocketTest.win?
+  ai4 = Addrinfo.new(Socket.sockaddr_in(1, '127.0.0.1'))
+  ai6 = Addrinfo.new(Socket.sockaddr_in(1, '::1'))
+  aiu = Addrinfo.new(Socket.sockaddr_un('/tmp/sock'))
+  assert_equal(Socket::AF_INET, ai4.afamily)
+  assert_equal(Socket::AF_INET6, ai6.afamily)
+  assert_equal(Socket::AF_UNIX, aiu.afamily)
+end
+
+# assert('Addrinfo#canonname') do
+
+# #getnameinfo
+# assert('Addrinfo#inspect') do
+# assert('Addrinfo#inspect_socket') do
+# assert('Addrinfo#ip?') do
+# assert('Addrinfo#ip_address') do
+# assert('Addrinfo#ip_port') do
+# assert('Addrinfo#ip_unpack') do
+# assert('Addrinfo#ipv4?') do
+# assert('Addrinfo#ipv6?') do
+# assert('Addrinfo#pfamily') do
+# assert('Addrinfo#protocol') do
+# assert('Addrinfo#socktype') do
+# assert('Addrinfo#to_sockaddr') do
+# assert('Addrinfo#unix?') do
+# #unix_path

data/ext/enclave/mruby/mrbgems/mruby-socket/test/basicsocket.rb

@@ -0,0 +1,17 @@
+assert('BasicSocket') do
+  assert_equal(Class, BasicSocket.class)
+end
+
+assert('super class of BasicSocket') do
+  assert_equal(IO, BasicSocket.superclass)
+end
+
+assert('BasicSocket.do_not_reverse_lookup') do
+  assert_equal(BasicSocket.do_not_reverse_lookup, true)
+end
+
+assert('BasicSocket.do_not_reverse_lookup=') do
+  BasicSocket.do_not_reverse_lookup = false
+  assert_equal(BasicSocket.do_not_reverse_lookup, false)
+  BasicSocket.do_not_reverse_lookup = true
+end

data/ext/enclave/mruby/mrbgems/mruby-socket/test/ipsocket.rb

@@ -0,0 +1,44 @@
+unless SocketTest.win?
+
+# Note: most of tests below will fail if UDPSocket is broken.
+
+assert('IPSocket.getaddress') do
+  l = IPSocket.getaddress("localhost")
+  assert_true (l == "127.0.0.1" or l == "::1")
+end
+
+assert('IPSocket.addr') do
+  localhost = "127.0.0.1"
+  s = UDPSocket.new
+  s.bind(localhost, 0)
+  port = Addrinfo.new(s.getsockname).ip_port
+
+  a = s.addr
+  assert_equal "AF_INET", a[0]
+  assert_equal port,      a[1]
+  assert_equal localhost, a[2]
+  assert_equal localhost, a[3]
+  s.close
+  true
+end
+
+assert('IPSocket.peeraddr') do
+  localhost = "127.0.0.1"
+  server = UDPSocket.new
+  server.bind(localhost, 0)
+  port = server.local_address.ip_port
+
+  client = UDPSocket.new
+  client.connect(localhost, port)
+
+  a = client.peeraddr
+  assert_equal "AF_INET", a[0]
+  assert_equal port,      a[1]
+  assert_equal localhost, a[2]
+  assert_equal localhost, a[3]
+  client.close
+  server.close
+  true
+end
+
+end # win?

data/ext/enclave/mruby/mrbgems/mruby-socket/test/socket.rb

@@ -0,0 +1,38 @@
+unless SocketTest.win?
+
+assert('Socket.gethostname') do
+  assert_true(Socket.gethostname.is_a? String)
+end
+
+assert('Socket::getaddrinfo') do
+  ret = Socket.getaddrinfo("localhost", 53, Socket::AF_INET, Socket::SOCK_DGRAM)
+  assert_true ret.size >= 1
+  a = ret[0]
+  assert_equal "AF_INET",           a[0]
+  assert_equal 53,                  a[1]
+  # documents says it's a hostname but CRuby returns an address
+  #assert_equal "127.0.0.1",         a[2]
+  assert_equal "127.0.0.1",         a[3]
+  assert_equal Socket::AF_INET,     a[4]
+  assert_equal Socket::SOCK_DGRAM,  a[5]
+  assert_equal Socket::IPPROTO_UDP, a[6] unless SocketTest.cygwin?
+end
+
+assert('Socket#recvfrom') do
+  begin
+    sstr = "abcdefg"
+    s = Socket.new(Socket::AF_INET, Socket::SOCK_DGRAM, 0)
+    c = Socket.new(Socket::AF_INET, Socket::SOCK_DGRAM, 0)
+    s.bind(Socket.sockaddr_in(0, "127.0.0.1"))
+    c.send sstr, 0, s.getsockname
+    rstr, ai = s.recvfrom sstr.size
+
+    assert_equal sstr, rstr
+    assert_equal "127.0.0.1", ai.ip_address
+  ensure
+    s.close rescue nil
+    c.close rescue nil
+  end
+end
+
+end   # win?

data/ext/enclave/mruby/mrbgems/mruby-socket/test/sockettest.c

@@ -0,0 +1,84 @@
+#include <stdlib.h>
+
+#include <mruby.h>
+#include <mruby/error.h>
+
+#if defined(_WIN32)
+
+#include <io.h>
+
+#if defined(_MSC_VER) || \
+    (defined(MRB_MINGW32_VERSION) && MRB_MINGW32_VERSION < 3021) || \
+    (defined(MRB_MINGW64_VERSION) && MRB_MINGW64_VERSION < 4000)
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#define open  _open
+#define close _close
+#define unlink _unlink
+
+static int
+mkstemp(char *p)
+{
+  int fd;
+  char* fname = _mktemp(p);
+  if (fname == NULL)
+    return -1;
+  fd = open(fname, O_RDWR | O_CREAT | O_EXCL, _S_IREAD | _S_IWRITE);
+  if (fd >= 0)
+    return fd;
+  return -1;
+}
+#endif
+
+#else
+
+#include <unistd.h>
+
+#endif
+
+mrb_value
+mrb_sockettest_tmppath(mrb_state *mrb, mrb_value klass)
+{
+  char name[] = "mruby-socket.XXXXXXXX";
+  int fd = mkstemp(name);
+  if (fd == -1) {
+    mrb_sys_fail(mrb, 0);
+  }
+  if (close(fd) == -1) {
+    mrb_sys_fail(mrb, 0);
+  }
+  if (unlink(name) == -1) {
+    mrb_sys_fail(mrb, 0);
+  }
+  return mrb_str_new_cstr(mrb, name);
+}
+
+mrb_value
+mrb_sockettest_win_p(mrb_state *mrb, mrb_value klass)
+{
+#ifdef _WIN32
+  return mrb_true_value();
+#else
+  return mrb_false_value();
+#endif
+}
+
+mrb_value
+mrb_sockettest_cygwin_p(mrb_state *mrb, mrb_value klass)
+{
+#if defined(__CYGWIN__) || defined(__CYGWIN32__)
+  return mrb_true_value();
+#else
+  return mrb_false_value();
+#endif
+}
+
+void
+mrb_mruby_socket_gem_test(mrb_state* mrb)
+{
+  struct RClass *c = mrb_define_module(mrb, "SocketTest");
+  mrb_define_class_method(mrb, c, "tmppath", mrb_sockettest_tmppath, MRB_ARGS_NONE());
+  mrb_define_class_method(mrb, c, "win?", mrb_sockettest_win_p, MRB_ARGS_NONE());
+  mrb_define_class_method(mrb, c, "cygwin?", mrb_sockettest_cygwin_p, MRB_ARGS_NONE());
+}

data/ext/enclave/mruby/mrbgems/mruby-socket/test/tcpsocket.rb

@@ -0,0 +1,4 @@
+#assert('TCPSocket.gethostbyname') do
+#assert('TCPSocket.new') do
+#assert('TCPSocket#close') do
+#assert('TCPSocket#write') do

data/ext/enclave/mruby/mrbgems/mruby-socket/test/udpsocket.rb

@@ -0,0 +1,16 @@
+assert('UDPSocket.new') do
+  s = UDPSocket.new
+  assert_true(s.is_a? UDPSocket)
+  s.close
+  s = UDPSocket.new(Socket::AF_INET6)
+  assert_true(s.is_a? UDPSocket)
+  s.close
+  true
+end
+
+#assert('UDPSocket#connect') do
+#assert('UDPSocket#send') do
+#assert('UDPSocket#recv') do
+
+#assert('UDPSocket#bind') do
+#assert('UDPSocket#recvfrom_nonblock') do

data/ext/enclave/mruby/mrbgems/mruby-socket/test/unix.rb

@@ -0,0 +1,130 @@
+unless SocketTest.win? || SocketTest.cygwin?
+
+def unixserver_test_block
+  path = SocketTest.tmppath
+  File.unlink path rescue nil
+  begin
+    result = yield path
+  ensure
+    File.unlink path rescue nil
+  end
+  result
+end
+
+def with_unix_server
+  unixserver_test_block do |path|
+    UNIXServer.open(path) { |server|
+      yield path, server
+    }
+  end
+end
+
+def with_unix_client
+  with_unix_server do |path, server|
+    UNIXSocket.open(path) do |csock|
+      ssock = server.accept
+      begin
+        yield path, server, ssock, csock
+      ensure
+        ssock.close unless ssock.closed? rescue nil
+      end
+    end
+  end
+end
+
+assert('UNIXServer.new') do
+  unixserver_test_block do |path|
+    server = UNIXServer.new(path)
+    assert_true server.is_a? UNIXServer
+    server.close
+    File.unlink path
+
+    s2 = nil
+    result = UNIXServer.open(path) { |s1|
+      assert_true s1.is_a? UNIXServer
+      s2 = s1
+      1234
+    }
+    assert_equal 1234, result
+    assert_true s2.is_a? UNIXServer
+    assert_true s2.closed?
+  end
+end
+
+# assert('UNIXServer#accept_nonblock') - would block if fails
+
+assert('UNIXServer#addr') do
+  with_unix_server do |path, server|
+    assert_equal [ "AF_UNIX", path], server.addr
+  end
+end
+
+assert('UNIXServer#path') do
+  with_unix_server do |path, server|
+    assert_equal path, server.path
+  end
+end
+
+# assert('UNIXServer#peeraddr') - will raise a runtime exception
+
+assert('UNIXServer#listen') do
+  with_unix_server do |path, server|
+    assert_equal 0, server.listen(1)
+  end
+end
+
+assert('UNIXServer#sysaccept') do
+  with_unix_server do |path, server|
+    UNIXSocket.open(path) do |csock|
+      begin
+        fd = server.sysaccept
+        assert_true fd.kind_of? Integer
+      ensure
+        IO._sysclose(fd) rescue nil
+      end
+    end
+  end
+end
+
+assert('UNIXSocket.new') do
+  with_unix_server do |path, server|
+    c = UNIXSocket.new(path)
+    assert_true c.is_a? UNIXSocket
+    c.close
+    true
+  end
+end
+
+assert('UNIXSocket#addr') do
+  with_unix_client do |path, server, ssock, csock|
+    assert_equal [ "AF_UNIX", path ], ssock.addr
+    assert_equal [ "AF_UNIX", "" ],   csock.addr
+  end
+end
+
+assert('UNIXSocket#path') do
+  with_unix_client do |path, server, ssock, csock|
+    assert_equal path, ssock.path
+    assert_equal "",   csock.path
+  end
+end
+
+assert('UNIXSocket#peeraddr') do
+  with_unix_client do |path, server, ssock, csock|
+    assert_equal [ "AF_UNIX", ""   ], ssock.peeraddr
+    assert_equal [ "AF_UNIX", path ], csock.peeraddr
+  end
+end
+
+assert('UNIXSocket#recvfrom') do
+  with_unix_client do |path, server, ssock, csock|
+    str = "0123456789"
+    ssock.send str, 0
+    a = csock.recvfrom(8)
+    assert_equal str[0, 8], a[0]
+    assert_equal "AF_UNIX", a[1][0]
+    # a[1][1] would be "" or something
+  end
+end
+
+end # SocketTest.win?

data/ext/enclave/mruby/mrbgems/mruby-sprintf/README.md

@@ -0,0 +1,235 @@
+# mruby-sprintf
+
+This mrbgem provides `sprintf` functionality for mruby. It allows you to format strings according to a specified format string, similar to the `sprintf` function in C or other languages.
+
+## Functionality
+
+- Provides the `sprintf` kernel function.
+- Adds the `%` operator to the `String` class as an alias for `sprintf`.
+
+## Usage
+
+You can use `sprintf` or the `String#%` operator for string formatting:
+
+```ruby
+# Using sprintf
+str = sprintf("Hello, %s! You are %d years old.", "World", 30)
+puts str # Output: Hello, World! You are 30 years old.
+
+# Using String#%
+str2 = "The value is %.2f" % 12.3456
+puts str2 # Output: The value is 12.35
+
+# Using String#% with an array of arguments
+str3 = "%d + %d = %d" % [1, 2, 1+2]
+puts str3 # Output: 1 + 2 = 3
+```
+
+## Format Specifiers
+
+This mrbgem supports a wide range of format specifiers, flags, width, and precision options. For a comprehensive list and detailed explanation of all supported format specifiers and their behavior, please refer to the extensive comments within the C source file: [`src/sprintf.c`](src/sprintf.c).
+
+## Format Specifiers Details
+
+The `sprintf` function in this mrbgem supports a variety of field type characters that control how arguments are interpreted and formatted.
+
+### Integer Formats
+
+| Field | Description                                                                                                             |
+| :---- | :---------------------------------------------------------------------------------------------------------------------- |
+| `b`   | Convert argument as a binary number. Negative numbers will be displayed as a two's complement prefixed with `..1`.      |
+| `B`   | Equivalent to `b`, but uses an uppercase `0B` for prefix in the alternative format (when `#` flag is used).             |
+| `d`   | Convert argument as a decimal number.                                                                                   |
+| `i`   | Identical to `d`.                                                                                                       |
+| `o`   | Convert argument as an octal number. Negative numbers will be displayed as a two's complement prefixed with `..7`.      |
+| `u`   | Identical to `d`. (In many `sprintf` implementations, `u` is for unsigned decimal, but here it behaves like `d`).       |
+| `x`   | Convert argument as a hexadecimal number. Negative numbers will be displayed as a two's complement prefixed with `..f`. |
+| `X`   | Equivalent to `x`, but uses uppercase letters for hexadecimal digits (e.g., `0XFF` vs `0xff`).                          |
+
+### Float Formats
+
+| Field | Description                                                                                                                                             |
+| :---- | :------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `e`   | Convert floating-point argument into exponential notation (e.g., `[-]d.dddddde[+-]dd`). Precision specifies digits after the decimal point (default 6). |
+| `E`   | Equivalent to `e`, but uses an uppercase `E` for the exponent.                                                                                          |
+| `f`   | Convert floating-point argument as `[-]ddd.dddddd`. Precision specifies digits after the decimal point.                                                 |
+| `g`   | Converts a floating-point number using `e` or `f` form based on exponent and precision. Precision specifies significant digits.                         |
+| `G`   | Equivalent to `g`, but uses an uppercase `E` in exponent form if applicable.                                                                            |
+
+### Other Formats
+
+| Field | Description                                                                                                     |
+| :---- | :-------------------------------------------------------------------------------------------------------------- |
+| `c`   | Argument is treated as the numeric code for a single character or a single character string itself.             |
+| `p`   | Argument's `inspect` method is called, and the result is substituted.                                           |
+| `s`   | Argument is a string to be substituted. If precision is specified, at most that many characters will be copied. |
+| `%`   | A literal percent sign (`%`) itself will be displayed. No argument is taken.                                    |
+
+### Flags
+
+Flags modify the behavior of the format specifiers:
+
+| Flag       | Applies to                          | Meaning                                                                                                                                                                                                                                                                                       |
+| :--------- | :---------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `space`    | Numeric Formats (bBdiouxX, aAeEfgG) | Leave a space at the start of non-negative numbers. For `o`, `x`, `X`, `b`, `B`, uses a minus sign with absolute value for negative values.                                                                                                                                                   |
+| `(digit)$` | All                                 | Specifies the absolute argument number for this field (e.g., `%2$d` uses the second argument). Cannot be mixed with relative argument numbers.                                                                                                                                                |
+| `#`        | bBoxX, aAeEfgG                      | Use an alternative format. For `o`, increases precision to make the first digit `0` if not formatted as complement. For `x`, `X`, `b`, `B` (non-zero), prefixes with `0x`, `0X`, `0b`, `0B`. For `e`, `E`, `f`, `g`, `G`, forces a decimal point. For `g`, `G`, do not remove trailing zeros. |
+| `+`        | Numeric Formats                     | Add a leading plus sign (`+`) to non-negative numbers. For `o`, `x`, `X`, `b`, `B`, uses a minus sign with absolute value for negative values.                                                                                                                                                |
+| `-`        | All                                 | Left-justify the result of this conversion.                                                                                                                                                                                                                                                   |
+| `0` (zero) | Numeric Formats                     | Pad with zeros, not spaces. For `o`, `x`, `X`, `b`, `B`, radix-1 is used for negative numbers formatted as complements.                                                                                                                                                                       |
+| `*`        | All                                 | Use the next argument as the field width. If negative, left-justifies. If `*` is followed by a number and `$`, use that argument as width (e.g., `%*1$d`).                                                                                                                                    |
+
+## Further Examples (from C source comments)
+
+Here are more examples illustrating the use of flags, width, and precision, adapted from the comments in `src/sprintf.c`.
+
+### Examples of Flags
+
+```ruby
+# '+' and space flag specifies the sign of non-negative numbers.
+puts sprintf("%d", 123)  #=> "123"
+puts sprintf("%+d", 123) #=> "+123"
+puts sprintf("% d", 123) #=> " 123"
+
+# '#' flag for 'o' increases number of digits to show '0'.
+# '+' and space flag changes format of negative numbers.
+puts sprintf("%o", 123)   #=> "173"
+puts sprintf("%#o", 123)  #=> "0173"
+puts sprintf("%+o", -123) #=> "-173"
+puts sprintf("%o", -123)  #=> "..7605"
+puts sprintf("%#o", -123) #=> "..7605"
+
+# '#' flag for 'x' add a prefix '0x' for non-zero numbers.
+# '+' and space flag disables complements for negative numbers.
+puts sprintf("%x", 123)   #=> "7b"
+puts sprintf("%#x", 123)  #=> "0x7b"
+puts sprintf("%+x", -123) #=> "-7b"
+puts sprintf("%x", -123)  #=> "..f85"
+puts sprintf("%#x", -123) #=> "0x..f85" # Note: mruby's output might differ slightly for complements with #
+puts sprintf("%#x", 0)    #=> "0"
+
+# '#' for 'X' uses the prefix '0X'.
+puts sprintf("%X", 123)  #=> "7B"
+puts sprintf("%#X", 123) #=> "0X7B"
+
+# '#' flag for 'b' add a prefix '0b' for non-zero numbers.
+# '+' and space flag disables complements for negative numbers.
+puts sprintf("%b", 123)   #=> "1111011"
+puts sprintf("%#b", 123)  #=> "0b1111011"
+puts sprintf("%+b", -123) #=> "-1111011"
+puts sprintf("%b", -123)  #=> "..10000101"
+puts sprintf("%#b", -123) #=> "0b..10000101" # Note: mruby's output might differ slightly for complements with #
+puts sprintf("%#b", 0)    #=> "0"
+
+# '#' for 'B' uses the prefix '0B'.
+puts sprintf("%B", 123)  #=> "1111011"
+puts sprintf("%#B", 123) #=> "0B1111011"
+
+# '#' for 'e' forces to show the decimal point.
+puts sprintf("%.0e", 1)  #=> "1e+00"
+puts sprintf("%#.0e", 1) #=> "1.e+00"
+
+# '#' for 'f' forces to show the decimal point.
+puts sprintf("%.0f", 1234)  #=> "1234"
+puts sprintf("%#.0f", 1234) #=> "1234."
+
+# '#' for 'g' forces to show the decimal point.
+# It also disables stripping lowest zeros.
+puts sprintf("%g", 123.4)   #=> "123.4"
+puts sprintf("%#g", 123.4)  #=> "123.400"
+puts sprintf("%g", 123456)  #=> "123456"
+puts sprintf("%#g", 123456) #=> "123456."
+```
+
+### Examples of Width
+
+The width specifies the minimum number of characters that will be written.
+Padding is typically done with spaces, or with zeros if the `0` flag is used.
+
+```ruby
+# padding is done by spaces, width=20
+# 0 or radix-1.             <------------------>
+puts sprintf("%20d", 123)   #=> "                 123"
+puts sprintf("%+20d", 123)  #=> "                +123"
+puts sprintf("%020d", 123)  #=> "00000000000000000123"
+puts sprintf("%+020d", 123) #=> "+0000000000000000123"
+puts sprintf("% 020d", 123) #=> " 0000000000000000123"
+puts sprintf("%-20d", 123)  #=> "123                 "
+puts sprintf("%-+20d", 123) #=> "+123                "
+puts sprintf("%- 20d", 123) #=> " 123                "
+puts sprintf("%020x", -123) #=> "..ffffffffffffffff85" # Output for negative hex with 0-padding can vary
+```
+
+### Examples of Precision
+
+For numeric fields, precision controls the number of decimal places or minimum number of digits.
+For strings, it determines the maximum number of characters.
+
+```ruby
+# precision for 'd', 'o', 'x' and 'b' is minimum number of digits
+#                                     <------>
+puts sprintf("%20.8d", 123)  #=> "            00000123"
+puts sprintf("%20.8o", 123)  #=> "            00000173"
+puts sprintf("%20.8x", 123)  #=> "            0000007b"
+puts sprintf("%20.8b", 123)  #=> "            01111011"
+puts sprintf("%20.8d", -123) #=> "           -00000123"
+puts sprintf("%20.8o", -123) #=> "            ..777605" # Complemented output
+puts sprintf("%20.8x", -123) #=> "            ..ffff85" # Complemented output
+puts sprintf("%20.8b", -11)  #=> "            ..110101" # Complemented output
+
+# "0x" and "0b" for '#x' and '#b' is not counted for precision,
+# but "0" for '#o' is counted.        <------>
+puts sprintf("%#20.8d", 123)  #=> "            00000123"
+puts sprintf("%#20.8o", 123)  #=> "            00000173" # '#' with 'o' and precision
+puts sprintf("%#20.8x", 123)  #=> "          0x0000007b"
+puts sprintf("%#20.8b", 123)  #=> "          0b01111011"
+puts sprintf("%#20.8d", -123) #=> "           -00000123"
+puts sprintf("%#20.8o", -123) #=> "            ..777605" # Complemented output
+puts sprintf("%#20.8x", -123) #=> "          0x..ffff85" # Complemented output with #
+puts sprintf("%#20.8b", -11)  #=> "          0b..110101" # Complemented output with #
+
+# precision for 'e' is number of digits after the decimal point
+#                                     <------>
+puts sprintf("%20.8e", 1234.56789) #=> "      1.23456789e+03"
+
+# precision for 'f' is number of digits after the decimal point
+#                                     <------>
+puts sprintf("%20.8f", 1234.56789) #=> "       1234.56789000"
+
+# precision for 'g' is number of significant digits
+#                                     <------->
+puts sprintf("%20.8g", 1234.56789) #=> "           1234.5679"
+#                                     <------->
+puts sprintf("%20.8g", 123456789)  #=> "       1.2345679e+08"
+
+# precision for 's' is maximum number of characters
+#                                     <------>
+puts sprintf("%20.8s", "string test") #=> "            string t"
+```
+
+### General Examples
+
+```ruby
+puts sprintf("%d %04x", 123, 123)               #=> "123 007b"
+puts sprintf("%08b '%4s'", 123, 123)            #=> "01111011 ' 123'" # Note: mruby output for %s with number might differ
+puts sprintf("%1$*2$s %2$d %1$s", "hello", 8)   #=> "   hello 8 hello"
+puts sprintf("%1$*2$s %2$d", "hello", -8)       #=> "hello    -8"
+puts sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23)   #=> "+1.23: 1.23:1.23"
+puts sprintf("%u", -123)                        #=> "-123"
+```
+
+### Named References
+
+For more complex formatting, Ruby supports a reference by name.
+`%<name>s` style uses format style, but `%{name}` style doesn't (in standard Ruby, mruby might vary).
+
+```ruby
+puts sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2.0 }) # Using a float for %f
+#=> "1 : 2.000000"
+
+# The %{name} style might behave differently or not be supported in the same way as CRuby.
+# Standard CRuby example:
+# puts sprintf("%{foo}f", { :foo => 1 }) # => "1f" (This specific syntax might not apply or work in mruby)
+# For mruby, stick to %<name>type for named arguments:
+puts sprintf("%<foo>s", { :foo => "test" }) #=> "test"
+```

data/ext/enclave/mruby/mrbgems/mruby-sprintf/mrbgem.rake

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-sprintf') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'standard Kernel#sprintf method'
+end