enclave 0.1.0

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

@@ -0,0 +1,92 @@
+assert('sprintf invalid') do
+  assert_raise(ArgumentError) { sprintf('%1$*d', 3) }
+  assert_raise(ArgumentError) { sprintf('%1$.*d', 3) }
+end
+
+assert('String#%') do
+  assert_equal "one=1", "one=%d" % 1
+  assert_equal "1 one", "%d %s" % [ 1, "one" ]
+  assert_equal "123 < 456", "%{num} < %<str>s" % { num: 123, str: "456" }
+  assert_equal 15, ("%b" % (1<<14)).size
+  skip unless Object.const_defined?(:Float)
+  assert_equal "1.0", "%3.1f" % 1.01
+  assert_equal " 12345.12", "% 4.2f" % 12345.1234
+  assert_equal "12345.12", "%-4.2f" % 12345.12345
+  assert_equal "+12345.12", "%+4.2f" % 12345.1234
+  assert_equal "12345.12", "%04.2f" % 12345.12345
+  assert_equal "0012345.12", "%010.2f" % 12345.1234
+end
+
+assert('String#% with inf') do
+  skip unless Object.const_defined?(:Float)
+  inf = Float::INFINITY
+
+  assert_equal "Inf", "%f" % inf
+  assert_equal "Inf", "%2f" % inf
+  assert_equal "Inf", "%3f" % inf
+  assert_equal " Inf", "%4f" % inf
+  assert_equal "  Inf", "%5f" % inf
+
+  assert_equal "+Inf", "%+f" % inf
+  assert_equal "+Inf", "%+2f" % inf
+  assert_equal "+Inf", "%+3f" % inf
+  assert_equal "+Inf", "%+4f" % inf
+  assert_equal " +Inf", "%+5f" % inf
+
+  assert_equal "Inf", "%-f" % inf
+  assert_equal "Inf", "%-2f" % inf
+  assert_equal "Inf", "%-3f" % inf
+  assert_equal "Inf ", "%-4f" % inf
+  assert_equal "Inf  ", "%-5f" % inf
+
+  assert_equal " Inf", "% f" % inf
+  assert_equal " Inf", "% 2f" % inf
+  assert_equal " Inf", "% 3f" % inf
+  assert_equal " Inf", "% 4f" % inf
+  assert_equal "  Inf", "% 5f" % inf
+end
+
+assert('String#% with nan') do
+  skip unless Object.const_defined?(:Float)
+  nan = Float::NAN
+
+  assert_equal "NaN", "%f" % nan
+  assert_equal "NaN", "%2f" % nan
+  assert_equal "NaN", "%3f" % nan
+  assert_equal " NaN", "%4f" % nan
+  assert_equal "  NaN", "%5f" % nan
+
+  assert_equal "+NaN", "%+f" % nan
+  assert_equal "+NaN", "%+2f" % nan
+  assert_equal "+NaN", "%+3f" % nan
+  assert_equal "+NaN", "%+4f" % nan
+  assert_equal " +NaN", "%+5f" % nan
+
+  assert_equal "NaN", "%-f" % nan
+  assert_equal "NaN", "%-2f" % nan
+  assert_equal "NaN", "%-3f" % nan
+  assert_equal "NaN ", "%-4f" % nan
+  assert_equal "NaN  ", "%-5f" % nan
+
+  assert_equal " NaN", "% f" % nan
+  assert_equal " NaN", "% 2f" % nan
+  assert_equal " NaN", "% 3f" % nan
+  assert_equal " NaN", "% 4f" % nan
+  assert_equal "  NaN", "% 5f" % nan
+end
+
+assert("String#% %b") do
+  assert_equal("..10115", "%0b5" % -5)
+end
+
+assert("String#% %d") do
+  assert_equal("  10",   "%4d" % 10)
+  assert_equal("1000",   "%4d" % 1000)
+  assert_equal("10000",  "%4d" % 10000)
+end
+
+assert("String#% invalid format") do
+  assert_raise ArgumentError do
+    "%?" % ""
+  end
+end

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

@@ -0,0 +1,140 @@
+# mruby-strftime
+
+`Time#strftime` implementation for mruby.
+
+## Overview
+
+This gem provides the `strftime` method for `Time` objects in mruby, enabling
+formatted time string output using standard format directives.
+
+## Usage
+
+```ruby
+require 'mruby-strftime'
+
+t = Time.new(2023, 12, 25, 10, 30, 45)
+
+t.strftime("%Y-%m-%d")           #=> "2023-12-25"
+t.strftime("%H:%M:%S")           #=> "10:30:45"
+t.strftime("%Y-%m-%d %H:%M:%S")  #=> "2023-12-25 10:30:45"
+t.strftime("%A, %B %d, %Y")      #=> "Monday, December 25, 2023"
+```
+
+## Format Specifiers
+
+The `strftime` method supports standard format directives. The exact set of
+available directives depends on your system's `strftime(3)` implementation.
+Common directives include:
+
+### Date Components
+
+- `%Y` - Year with century (e.g., 2023)
+- `%y` - Year without century (00-99)
+- `%m` - Month of the year (01-12)
+- `%B` - Full month name (e.g., "December")
+- `%b` - Abbreviated month name (e.g., "Dec")
+- `%d` - Day of the month (01-31)
+- `%j` - Day of the year (001-366)
+
+### Time Components
+
+- `%H` - Hour of the day, 24-hour clock (00-23)
+- `%I` - Hour of the day, 12-hour clock (01-12)
+- `%M` - Minute of the hour (00-59)
+- `%S` - Second of the minute (00-60)
+- `%p` - AM/PM indicator
+- `%Z` - Timezone name or abbreviation
+
+### Weekday
+
+- `%A` - Full weekday name (e.g., "Monday")
+- `%a` - Abbreviated weekday name (e.g., "Mon")
+- `%w` - Day of the week (0-6, Sunday is 0)
+- `%u` - Day of the week (1-7, Monday is 1)
+
+### Combined Formats
+
+- `%c` - Preferred date and time representation
+- `%x` - Preferred date representation
+- `%X` - Preferred time representation
+- `%F` - ISO 8601 date format (equivalent to `%Y-%m-%d`)
+- `%T` - ISO 8601 time format (equivalent to `%H:%M:%S`)
+
+### Special Characters
+
+- `%%` - Literal `%` character
+- `%n` - Newline character
+- `%t` - Tab character
+
+## Features
+
+### Timezone Support
+
+The method respects the timezone of the `Time` object:
+
+```ruby
+t_utc = Time.utc(2023, 12, 25, 12, 0, 0)
+t_local = Time.local(2023, 12, 25, 12, 0, 0)
+
+t_utc.strftime("%Y-%m-%d %H:%M:%S %Z")
+#=> "2023-12-25 12:00:00 UTC"
+
+t_local.strftime("%Y-%m-%d %H:%M:%S %z")
+#=> "2023-12-25 12:00:00 +0900" (example for JST)
+```
+
+### NUL Byte Handling
+
+Unlike some implementations, mruby-strftime correctly handles NUL bytes (`\0`)
+embedded in format strings, preserving them in the output:
+
+```ruby
+t = Time.gm(2023, 12, 25)
+result = t.strftime("year\0%Y")
+result.length  #=> 9 (includes the NUL byte)
+```
+
+This behavior maintains Ruby's string semantics where strings are length-based
+rather than null-terminated.
+
+## Implementation Details
+
+### Buffer Management
+
+The implementation uses dynamic buffer allocation:
+
+- Initial buffer size: 64 bytes
+- Maximum buffer size: 4096 bytes
+- Automatically grows when needed for longer formatted strings
+
+### Platform Compatibility
+
+This gem uses the system's `strftime(3)` function for formatting. The exact
+behavior of format directives may vary slightly between platforms, particularly
+for:
+
+- Locale-dependent formats (day/month names, date/time preferences)
+- Timezone representations
+- Platform-specific extensions
+
+## Dependencies
+
+- `mruby-time` - Required for `Time` class support
+
+## Installation
+
+Add to your `build_config.rb`:
+
+```ruby
+conf.gem :core => 'mruby-strftime'
+```
+
+Or include via gembox:
+
+```ruby
+conf.gembox 'stdlib-ext'  # Includes mruby-strftime
+```
+
+## License
+
+MIT License - See mruby's main license file for details.

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

@@ -0,0 +1,7 @@
+MRuby::Gem::Specification.new('mruby-strftime') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Time#strftime implementation'
+
+  spec.add_dependency 'mruby-time'
+end

data/ext/enclave/mruby/mrbgems/mruby-strftime/src/strftime.c

@@ -0,0 +1,119 @@
+/*
+** strftime.c - Time#strftime
+**
+** See Copyright Notice in mruby.h
+*/
+
+#include <mruby.h>
+#include <mruby/string.h>
+#include <mruby/time.h>
+#include <mruby/class.h>
+#include <mruby/presym.h>
+#include <time.h>
+#include <string.h>
+
+#define MAX_BUFFER_SIZE 4096
+
+/*
+ * call-seq:
+ *   time.strftime(format) -> string
+ *
+ * Formats time according to the directives in the given format string.
+ *
+ * The format string may contain NUL bytes, which will be preserved in
+ * the output string.
+ *
+ * Common format directives:
+ *   %Y - Year with century (e.g., 2023)
+ *   %m - Month of the year (01-12)
+ *   %d - Day of the month (01-31)
+ *   %H - Hour of the day, 24-hour clock (00-23)
+ *   %M - Minute of the hour (00-59)
+ *   %S - Second of the minute (00-60)
+ *   %% - Literal % character
+ *
+ * See your system's strftime(3) documentation for a complete list.
+ *
+ *   t = Time.new(2023, 12, 25, 10, 30, 45)
+ *   t.strftime("%Y-%m-%d %H:%M:%S")  #=> "2023-12-25 10:30:45"
+ *   t.strftime("%A, %B %d, %Y")      #=> "Monday, December 25, 2023"
+ */
+static mrb_value
+mrb_time_strftime(mrb_state *mrb, mrb_value self)
+{
+  const char *format;
+  mrb_int format_len;
+
+  mrb_get_args(mrb, "s", &format, &format_len);
+  struct tm *tm = mrb_time_get_tm(mrb, self);
+
+  mrb_value result = mrb_str_new(mrb, NULL, 0);
+  const char *fmt_ptr = format;
+  mrb_int remaining = format_len;
+
+  /* Process format string in segments, handling NUL bytes */
+  while (remaining > 0) {
+    const char *nul_pos = (const char *)memchr(fmt_ptr, '\0', (size_t)remaining);
+    mrb_int segment_len = nul_pos ? (nul_pos - fmt_ptr) : remaining;
+
+    /* Process this segment (up to NUL or end of string) */
+    if (segment_len > 0) {
+      char *segment;
+      char *buf;
+      size_t n;
+
+      /* Create null-terminated copy of this segment */
+      /* Use mrb_temp_alloc for exception safety - GC will clean up on exception */
+      segment = (char *)mrb_temp_alloc(mrb, (size_t)segment_len + 1);
+      memcpy(segment, fmt_ptr, (size_t)segment_len);
+      segment[segment_len] = '\0';
+
+#ifdef _MSC_VER
+      /* Check for GNU extension %-flag which crashes on MSVC */
+      /* Scan for %- patterns in the format string */
+      for (const char *p = segment; *p != '\0'; p++) {
+        if (p[0] == '%' && p[1] == '-') {
+          mrb_raisef(mrb, E_ARGUMENT_ERROR,
+                     "strftime format flag '%-' not supported on this platform (use '%%#' on Windows)");
+        }
+      }
+#endif
+
+      /* Allocate buffer for formatted output */
+      /* Use mrb_temp_alloc with max size for exception safety */
+      buf = (char *)mrb_temp_alloc(mrb, MAX_BUFFER_SIZE);
+
+      /* Try formatting with max buffer size */
+      n = strftime(buf, MAX_BUFFER_SIZE, segment, tm);
+
+      /* Append formatted output to result */
+      mrb_str_cat(mrb, result, buf, n);
+    }
+
+    /* If there was a NUL, append it to result and advance past it */
+    if (nul_pos) {
+      mrb_str_cat(mrb, result, "\0", 1);
+      fmt_ptr = nul_pos + 1;
+      remaining -= segment_len + 1;
+    }
+    else {
+      break;
+    }
+  }
+
+  return result;
+}
+
+void
+mrb_mruby_strftime_gem_init(mrb_state *mrb)
+{
+  struct RClass *time_class;
+
+  time_class = mrb_class_get_id(mrb, MRB_SYM(Time));
+  mrb_define_method_id(mrb, time_class, MRB_SYM(strftime), mrb_time_strftime, MRB_ARGS_REQ(1));
+}
+
+void
+mrb_mruby_strftime_gem_final(mrb_state *mrb)
+{
+}

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

@@ -0,0 +1,152 @@
+assert('Time#strftime') do
+  t = Time.now
+  assert_true t.respond_to?(:strftime)
+end
+
+assert('Time#strftime with basic formats') do
+  t = Time.gm(2023, 12, 25, 10, 30, 45)
+
+  assert_equal '2023', t.strftime('%Y')
+  assert_equal '23', t.strftime('%y')
+  assert_equal '12', t.strftime('%m')
+  assert_equal '25', t.strftime('%d')
+  assert_equal '10', t.strftime('%H')
+  assert_equal '30', t.strftime('%M')
+  assert_equal '45', t.strftime('%S')
+end
+
+assert('Time#strftime with combined formats') do
+  t = Time.gm(2023, 12, 25, 10, 30, 45)
+
+  assert_equal '2023-12-25', t.strftime('%Y-%m-%d')
+  assert_equal '10:30:45', t.strftime('%H:%M:%S')
+  assert_equal '2023-12-25 10:30:45', t.strftime('%Y-%m-%d %H:%M:%S')
+end
+
+assert('Time#strftime with weekday formats') do
+  # 2023-12-25 is Monday
+  t = Time.gm(2023, 12, 25)
+
+  result = t.strftime('%A')
+  assert_true result.include?('Mon') || result == 'Monday'
+
+  result = t.strftime('%a')
+  assert_true result.length >= 2
+
+  assert_equal '1', t.strftime('%w')  # Monday is day 1
+end
+
+assert('Time#strftime with month formats') do
+  t = Time.gm(2023, 12, 25)
+
+  result = t.strftime('%B')
+  assert_true result.include?('Dec') || result == 'December'
+
+  result = t.strftime('%b')
+  assert_true result.length >= 2
+end
+
+assert('Time#strftime with literal percent') do
+  t = Time.gm(2023, 12, 25)
+
+  assert_equal '%', t.strftime('%%')
+  assert_equal '100%', t.strftime('100%%')
+  assert_equal '2023%12', t.strftime('%Y%%%m')
+end
+
+assert('Time#strftime with empty format') do
+  t = Time.now
+
+  assert_equal '', t.strftime('')
+end
+
+assert('Time#strftime with no format specifiers') do
+  t = Time.now
+
+  assert_equal 'hello', t.strftime('hello')
+  assert_equal 'test123', t.strftime('test123')
+end
+
+assert('Time#strftime with NUL byte') do
+  t = Time.gm(2023, 12, 25)
+
+  result = t.strftime("foo\0bar")
+  assert_equal 7, result.length
+  assert_equal 'f', result[0]
+  assert_equal 'o', result[1]
+  assert_equal 'o', result[2]
+  assert_equal "\0", result[3]
+  assert_equal 'b', result[4]
+  assert_equal 'a', result[5]
+  assert_equal 'r', result[6]
+end
+
+assert('Time#strftime with NUL and format specifiers') do
+  t = Time.gm(2023, 12, 25)
+
+  result = t.strftime("year\0%Y")
+  assert_true result.length >= 9  # "year\0" (5) + "2023" (4)
+  assert_true result.include?("\0")
+  # Check last 4 characters are "2023"
+  assert_equal '2023', result[-4, 4]
+end
+
+assert('Time#strftime with multiple NULs') do
+  t = Time.now
+
+  result = t.strftime("\0\0")
+  assert_equal 2, result.length
+  assert_equal "\0\0", result
+end
+
+assert('Time#strftime with NUL at beginning') do
+  t = Time.gm(2023, 1, 1)
+
+  result = t.strftime("\0%Y")
+  assert_equal 5, result.length
+  assert_equal "\0", result[0]
+  assert_equal '2023', result[1, 4]
+end
+
+assert('Time#strftime with NUL at end') do
+  t = Time.gm(2023, 1, 1)
+
+  result = t.strftime("%Y\0")
+  assert_equal 5, result.length
+  assert_equal '2023', result[0, 4]
+  assert_equal "\0", result[4]
+end
+
+assert('Time#strftime preserves timezone') do
+  t_utc = Time.utc(2023, 1, 1, 12, 0, 0)
+  t_local = Time.local(2023, 1, 1, 12, 0, 0)
+
+  # Both should format their time correctly
+  assert_equal '12', t_utc.strftime('%H')
+  assert_equal '12', t_local.strftime('%H')
+end
+
+assert('Time#strftime with various time components') do
+  t = Time.gm(2023, 6, 15, 14, 23, 7)
+
+  # Use portable format specifiers that work on all platforms
+  assert_equal '06', t.strftime('%m')   # Month with leading zero (portable)
+  assert_equal '15', t.strftime('%d')
+  assert_equal '14', t.strftime('%H')
+  assert_equal '23', t.strftime('%M')
+  assert_equal '07', t.strftime('%S')
+end
+
+assert('Time#strftime argument type error') do
+  t = Time.now
+
+  assert_raise(TypeError) { t.strftime(123) }
+  assert_raise(TypeError) { t.strftime(nil) }
+end
+
+assert('Time#strftime argument count error') do
+  t = Time.now
+
+  assert_raise(ArgumentError) { t.strftime }
+  assert_raise(ArgumentError) { t.strftime('%Y', '%m') }
+end