enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-test/vformat.c

@@ -0,0 +1,151 @@
+#include <string.h>
+#include <mruby.h>
+#include <mruby/class.h>
+#include <mruby/data.h>
+#include <mruby/string.h>
+
+/* no argument */
+static mrb_value
+vf_s_format_0(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str;
+  mrb_get_args(mrb, "S", &fmt_str);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  return mrb_format(mrb, fmt);
+}
+
+/* c char */
+static mrb_value
+vf_s_format_c(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_str;
+
+  mrb_get_args(mrb, "SS", &fmt_str, &arg_str);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  char c = RSTRING_CSTR(mrb, arg_str)[0];
+
+  return mrb_format(mrb, fmt, c);
+}
+
+/* d int */
+static mrb_value
+vf_s_format_d(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str;
+  mrb_int i;
+
+  mrb_get_args(mrb, "Si", &fmt_str, &i);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  int d = (int)i;
+  return mrb_format(mrb, fmt, d);
+}
+
+#ifndef MRB_NO_FLOAT
+/* f float */
+static mrb_value
+vf_s_format_f(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str;
+  mrb_float f;
+
+  mrb_get_args(mrb, "Sf", &fmt_str, &f);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  return mrb_format(mrb, fmt, f);
+}
+#endif
+
+/* i fixnum */
+static mrb_value
+vf_s_format_i(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str;
+  mrb_int i;
+
+  mrb_get_args(mrb, "Si", &fmt_str, &i);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  return mrb_format(mrb, fmt, i);
+}
+
+/* l char*, size_t */
+static mrb_value
+vf_s_format_l(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_str;
+  mrb_int i;
+
+  mrb_get_args(mrb, "SSi", &fmt_str, &arg_str, &i);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  const char *s = RSTRING_PTR(arg_str);
+  size_t len = (size_t)i;
+  if (len > (size_t)RSTRING_LEN(arg_str)) len = (size_t)RSTRING_LEN(arg_str);
+
+  return mrb_format(mrb, fmt, s, len);
+}
+
+/* n symbol */
+static mrb_value
+vf_s_format_n(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str;
+  mrb_sym sym;
+
+  mrb_get_args(mrb, "Sn", &fmt_str, &sym);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  return mrb_format(mrb, fmt, sym);
+}
+
+/* s char* */
+static mrb_value
+vf_s_format_s(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_str;
+  mrb_get_args(mrb, "SS", &fmt_str, &arg_str);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  const char *s = RSTRING_CSTR(mrb, arg_str);
+  return mrb_format(mrb, fmt, s);
+}
+
+/* C RClass */
+static mrb_value
+vf_s_format_C(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_cls;
+
+  mrb_get_args(mrb, "SC", &fmt_str, &arg_cls);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  struct RClass *c = mrb_class_ptr(arg_cls);
+  return mrb_format(mrb, fmt, c);
+}
+
+/* v value */
+static mrb_value
+vf_s_format_v(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_v;
+
+  mrb_get_args(mrb, "So", &fmt_str, &arg_v);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  return mrb_format(mrb, fmt, arg_v);
+}
+
+void
+mrb_init_test_vformat(mrb_state *mrb)
+{
+  struct RClass *vf = mrb_define_module(mrb, "TestVFormat");
+  mrb_define_class_method(mrb, vf, "z", vf_s_format_0, MRB_ARGS_REQ(1));
+
+#define VF_DEFINE_FORMAT_METHOD(t) VF_DEFINE_FORMAT_METHOD_n(t,2)
+#define VF_DEFINE_FORMAT_METHOD_n(t,n) mrb_define_class_method(mrb, vf, #t, vf_s_format_##t, MRB_ARGS_REQ(n));
+
+  VF_DEFINE_FORMAT_METHOD(c);
+  VF_DEFINE_FORMAT_METHOD(d);
+#ifndef MRB_NO_FLOAT
+  VF_DEFINE_FORMAT_METHOD(f);
+#endif
+  VF_DEFINE_FORMAT_METHOD(i);
+  VF_DEFINE_FORMAT_METHOD_n(l,3);
+  VF_DEFINE_FORMAT_METHOD(n);
+  VF_DEFINE_FORMAT_METHOD(s);
+  VF_DEFINE_FORMAT_METHOD(C);
+  VF_DEFINE_FORMAT_METHOD(v);
+}

data/ext/enclave/mruby/mrbgems/mruby-test-inline-struct/mrbgem.rake

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-test-inline-struct') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'inline structure'
+end

data/ext/enclave/mruby/mrbgems/mruby-test-inline-struct/test/inline.c

@@ -0,0 +1,92 @@
+#include <mruby.h>
+#include <mruby/class.h>
+#include <mruby/string.h>
+#include <mruby/istruct.h>
+
+static mrb_value
+istruct_test_initialize(mrb_state *mrb, mrb_value self)
+{
+  char *string = (char*)mrb_istruct_ptr(self);
+  mrb_int size = mrb_istruct_size();
+  mrb_value object = mrb_get_arg1(mrb);
+
+  if (mrb_integer_p(object)) {
+    strncpy(string, "fixnum", size-1);
+  }
+#ifndef MRB_NO_FLOAT
+  else if (mrb_float_p(object)) {
+    strncpy(string, "float", size-1);
+  }
+#endif
+  else if (mrb_string_p(object)) {
+    strncpy(string, "string", size-1);
+  }
+  else {
+    strncpy(string, "anything", size-1);
+  }
+
+  string[size - 1] = 0; // force NULL at the end
+  return self;
+}
+
+static mrb_value
+istruct_test_to_s(mrb_state *mrb, mrb_value self)
+{
+  return mrb_str_new_cstr(mrb, (const char*)mrb_istruct_ptr(self));
+}
+
+static mrb_value
+istruct_test_length(mrb_state *mrb, mrb_value self)
+{
+  return mrb_fixnum_value(mrb_istruct_size());
+}
+
+static mrb_value
+istruct_test_test_receive(mrb_state *mrb, mrb_value self)
+{
+  mrb_value object = mrb_get_arg1(mrb);
+
+  if (mrb_obj_class(mrb, object) != mrb_class_get(mrb, "InlineStructTest"))
+  {
+    mrb_raise(mrb, E_TYPE_ERROR, "Expected InlineStructTest");
+  }
+  return mrb_bool_value(((char*)mrb_istruct_ptr(object))[0] == 's');
+}
+
+static mrb_value
+istruct_test_test_receive_direct(mrb_state *mrb, mrb_value self)
+{
+  mrb_value is = mrb_get_arg1(mrb);
+  struct RClass *klass = mrb_class_get(mrb, "InlineStructTest");
+  /* if you need to protect istruct retrieval from untrusted code,
+     you need to care about class replacing.
+     See mrbgem/mruby-random/src/random.c for detail */
+  if (mrb_istruct_p(is) && mrb_obj_is_kind_of(mrb, is, klass)) {
+    char *ptr = (char*)mrb_istruct_ptr(is);
+    return mrb_bool_value(ptr[0] == 's');
+  }
+  mrb_raise(mrb, E_TYPE_ERROR, "InlineStructTest");
+  return mrb_false_value();
+}
+
+static mrb_value
+istruct_test_mutate(mrb_state *mrb, mrb_value self)
+{
+  char *ptr = (char*)mrb_istruct_ptr(self);
+  memcpy(ptr, "mutate", 6);
+  return mrb_nil_value();
+}
+
+void mrb_mruby_test_inline_struct_gem_test(mrb_state *mrb)
+{
+  struct RClass *cls;
+
+  cls = mrb_define_class(mrb, "InlineStructTest", mrb->object_class);
+  MRB_SET_INSTANCE_TT(cls, MRB_TT_ISTRUCT);
+  mrb_define_method(mrb, cls, "initialize", istruct_test_initialize, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, cls, "to_s", istruct_test_to_s, MRB_ARGS_NONE());
+  mrb_define_method(mrb, cls, "mutate", istruct_test_mutate, MRB_ARGS_NONE());
+  mrb_define_class_method(mrb, cls, "length", istruct_test_length, MRB_ARGS_NONE());
+  mrb_define_class_method(mrb, cls, "test_receive", istruct_test_test_receive, MRB_ARGS_REQ(1));
+  mrb_define_class_method(mrb, cls, "test_receive_direct", istruct_test_test_receive_direct, MRB_ARGS_REQ(1));
+}

data/ext/enclave/mruby/mrbgems/mruby-test-inline-struct/test/inline.rb

@@ -0,0 +1,118 @@
+##
+# InlineStruct Test
+
+class InlineStructTest
+  def extra_method
+    :ok
+  end
+
+  def test_ivar_set
+    @var = :ivar
+  end
+
+  def test_ivar_get
+    @vat
+  end
+end
+
+assert('InlineStructTest#dup') do
+  obj = InlineStructTest.new(1)
+  assert_equal obj.to_s, 'fixnum'
+  assert_equal obj.dup.to_s, 'fixnum'
+end
+
+assert('InlineStructTest#clone') do
+  obj = InlineStructTest.new(1)
+  assert_equal obj.to_s, 'fixnum'
+  assert_equal obj.clone.to_s, 'fixnum'
+end
+
+assert('InlineStruct#object_id') do
+  obj1 = InlineStructTest.new(1)
+  obj2 = InlineStructTest.new(1)
+  assert_not_equal obj1, obj2
+  assert_not_equal obj1.object_id, obj2.object_id
+  assert_not_equal obj1.object_id, obj1.dup.object_id
+  assert_not_equal obj1.object_id, obj1.clone.object_id
+end
+
+assert('InlineStructTest#mutate (dup)') do
+  obj1 = InlineStructTest.new("foo")
+  assert_equal obj1.to_s, "string"
+  obj2 = obj1.dup
+  assert_equal obj2.to_s, "string"
+  obj1.mutate
+  assert_equal obj1.to_s, "mutate"
+  assert_equal obj2.to_s, "string"
+end
+
+assert('InlineStructTest#mutate (clone)') do
+  obj1 = InlineStructTest.new("foo")
+  assert_equal obj1.to_s, "string"
+  obj2 = obj1.clone
+  assert_equal obj2.to_s, "string"
+  obj1.mutate
+  assert_equal obj1.to_s, "mutate"
+  assert_equal obj2.to_s, "string"
+end
+
+assert('InlineStructTest#test_receive(string)') do
+  assert_equal InlineStructTest.test_receive(InlineStructTest.new('a')), true
+end
+
+assert('InlineStructTest#test_receive(float)') do
+  assert_equal InlineStructTest.test_receive(InlineStructTest.new(1.25)), false
+end
+
+assert('InlineStructTest#test_receive(invalid object)') do
+  assert_raise(TypeError) do
+    InlineStructTest.test_receive([])
+  end
+end
+
+assert('InlineStructTest#test_receive(string)') do
+  assert_equal InlineStructTest.test_receive_direct(InlineStructTest.new('a')), true
+end
+
+assert('InlineStructTest#test_receive(float)') do
+  assert_equal InlineStructTest.test_receive_direct(InlineStructTest.new(1.25)), false
+end
+
+assert('InlineStructTest#test_receive(invalid object)') do
+  assert_raise(TypeError) do
+    InlineStructTest.test_receive_direct([])
+  end
+end
+
+assert('InlineStructTest#extra_method') do
+  assert_equal InlineStructTest.new(1).extra_method, :ok
+end
+
+assert('InlineStructTest instance variable') do
+  obj = InlineStructTest.new(1)
+  assert_raise(ArgumentError) do
+    obj.test_ivar_set
+  end
+  assert_equal obj.test_ivar_get, nil
+end
+
+# 64-bit mode
+if InlineStructTest.length == 24
+  assert('InlineStructTest length [64-bit]') do
+    assert_equal InlineStructTest.length, 3 * 8
+  end
+end
+
+# 32-bit mode
+if InlineStructTest.length == 12
+  assert('InlineStructTest length [32-bit]') do
+    assert_equal InlineStructTest.length, 3 * 4
+  end
+end
+
+# 16-bit mode
+if InlineStructTest.length == 6
+  assert('InlineStructTest length [16-bit]') do
+    assert_equal InlineStructTest.length, 3 * 2
+  end
+end

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

@@ -0,0 +1,102 @@
+# mruby-time
+
+mruby-time is an mrbgem that provides a `Time` class for mruby, offering functionalities for time manipulation and representation. It is designed to be largely compatible with the Time class found in standard Ruby, following the ISO Ruby Time class specification.
+
+## Purpose
+
+The primary purpose of `mruby-time` is to enable mruby applications to:
+
+- Work with specific points in time.
+- Handle timezones, primarily UTC and the local system timezone.
+- Perform time arithmetic.
+- Format time information into human-readable strings.
+
+## Functionality
+
+### Creating Time Objects
+
+You can create `Time` objects in several ways:
+
+- **`Time.now`**: Returns a `Time` object representing the current time based on the system's clock.
+
+  ```ruby
+  t = Time.now
+  ```
+
+- **`Time.at(seconds_with_fraction)`**: Creates a `Time` object for the time `seconds_with_fraction` since the Epoch (January 1, 1970, 00:00:00 UTC). You can provide seconds as an integer or a float for sub-second precision.
+
+  ```ruby
+  t1 = Time.at(1678886400)       # Integer seconds
+  t2 = Time.at(1678886400.5)   # Seconds with microseconds
+  ```
+
+- **`Time.local(year, month, day, hour, min, sec, usec)`** (or **`Time.mktime`**): Creates a `Time` object from the given components in the local timezone. Arguments beyond `year` are optional and default to minimum values (e.g., month 1, day 1, hour 0, etc.).
+
+  ```ruby
+  t = Time.local(2023, 3, 15, 12, 30, 0) # March 15, 2023, 12:30:00 local time
+  ```
+
+- **`Time.gm(year, month, day, hour, min, sec, usec)`** (or **`Time.utc`**): Creates a `Time` object from the given components in UTC. Arguments are optional similar to `Time.local`.
+
+  ```ruby
+  t = Time.gm(2023, 3, 15, 12, 30, 0)    # March 15, 2023, 12:30:00 UTC
+  ```
+
+### Getting Time Components
+
+Once you have a `Time` object, you can extract its components:
+
+- `t.year`: Returns the year.
+- `t.month` (or `t.mon`): Returns the month of the year (1-12).
+- `t.day` (or `t.mday`): Returns the day of the month (1-31).
+- `t.hour`: Returns the hour of the day (0-23).
+- `t.min`: Returns the minute of the hour (0-59).
+- `t.sec`: Returns the second of the minute (0-59).
+- `t.usec`: Returns the microsecond of the second (0-999999).
+- `t.wday`: Returns the day of the week (0 for Sunday, 1 for Monday, ..., 6 for Saturday).
+- `t.yday`: Returns the day of the year (1-366).
+- `t.zone`: Returns the timezone name ("UTC" or local timezone offset like "+0900").
+
+### Timezone Conversions
+
+- `t.utc?` (or `t.gmt?`): Returns `true` if the `Time` object is in UTC.
+- `t.utc` (or `t.gmtime`): Converts the `Time` object to UTC and returns `self`.
+- `t.getutc` (or `t.getgm`): Returns a new `Time` object representing the same point in time as `t`, but in UTC.
+- `t.localtime`: Converts the `Time` object to the local timezone and returns `self`.
+- `t.getlocal`: Returns a new `Time` object representing the same point in time as `t`, but in the local timezone.
+
+### Time Arithmetic
+
+- **Addition (`+`)**: Adds a duration (in seconds) to a `Time` object, returning a new `Time` object.
+
+  ```ruby
+  t1 = Time.now
+  t2 = t1 + 60 # 60 seconds later
+  ```
+
+- **Subtraction (`-`)**:
+  - Subtracting a duration (in seconds) from a `Time` object returns a new `Time` object.
+  - Subtracting another `Time` object returns the difference in seconds as a Float.
+
+  ```ruby
+  t1 = Time.now
+  t_earlier = t1 - 3600 # One hour earlier
+
+  t2 = Time.local(2023, 1, 1)
+  t3 = Time.local(2023, 1, 2)
+  difference_seconds = t3 - t2 # Returns 86400.0
+  ```
+
+### Formatting Time
+
+- **`t.to_s`**: Returns a string representation of the time (e.g., "2023-03-15 10:30:00 +0000"). The format may vary slightly.
+- **`t.inspect`**: Similar to `to_s`, provides a string representation.
+- **`t.asctime`** (or **`t.ctime`**): Returns a canonical string representation (e.g., "Wed Mar 15 10:30:00 2023").
+- **`t.to_i`**: Returns the number of seconds since the Epoch as an integer.
+- **`t.to_f`**: Returns the number of seconds since the Epoch as a float (including microseconds).
+
+## Compatibility
+
+`mruby-time` aims to be compatible with the standard Ruby `Time` class as defined by ISO/IEC 30170:2012 (Ruby Language Specification). However, due to the nature of embedded systems and the mruby environment, there might be minor differences or limitations, especially concerning timezone data complexity beyond UTC and local system time.
+
+Refer to the source code and tests for detailed behavior.

data/ext/enclave/mruby/mrbgems/mruby-time/include/mruby/time.h

@@ -0,0 +1,27 @@
+/*
+** mruby/time.h - Time class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_TIME_H
+#define MRUBY_TIME_H
+
+#include <mruby/common.h>
+#include <time.h>
+
+MRB_BEGIN_DECL
+
+typedef enum mrb_timezone {
+  MRB_TIMEZONE_NONE   = 0,
+  MRB_TIMEZONE_UTC    = 1,
+  MRB_TIMEZONE_LOCAL  = 2,
+  MRB_TIMEZONE_LAST   = 3
+} mrb_timezone;
+
+MRB_API mrb_value mrb_time_at(mrb_state *mrb, time_t sec, time_t usec, mrb_timezone timezone);
+MRB_API struct tm* mrb_time_get_tm(mrb_state *mrb, mrb_value time);
+
+MRB_END_DECL
+
+#endif /* MRUBY_TIME_H */

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

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