enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-dir/test/dirtest.c

@@ -0,0 +1,125 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <mruby.h>
+#include <mruby/string.h>
+#include <mruby/variable.h>
+#include "dir_hal.h"
+
+#if defined(_WIN32)
+#include <io.h>
+#include <direct.h>
+#else
+#include <unistd.h>
+#endif
+
+static void
+make_dir(mrb_state *mrb, const char *name, const char *up)
+{
+  if (mrb_hal_dir_mkdir(mrb, name, 0) == -1) {
+    if (mrb_hal_dir_chdir(mrb, "..") == 0) {
+      mrb_hal_dir_rmdir(mrb, up);
+    }
+    mrb_raisef(mrb, E_RUNTIME_ERROR, "mkdir(%s) failed", mrb_str_new_cstr(mrb, name));
+  }
+}
+
+mrb_value
+mrb_dirtest_setup(mrb_state *mrb, mrb_value klass)
+{
+  char buf[2048];
+  char cwd[1024];
+  const char *aname = "a";
+  const char *bname = "b";
+
+  /* save current working directory */
+  if (mrb_hal_dir_getcwd(mrb, cwd, sizeof(cwd)) != 0) {
+    mrb_raise(mrb, E_RUNTIME_ERROR, "getcwd() failed");
+  }
+  mrb_cv_set(mrb, klass, mrb_intern_cstr(mrb, "pwd"), mrb_str_new_cstr(mrb, cwd));
+
+  /* create sandbox */
+#if defined(_WIN32)
+  snprintf(buf, sizeof(buf), "%s\\mruby-dir-test.XXXXXX", cwd);
+  if ((_mktemp(buf) == NULL) || mrb_hal_dir_mkdir(mrb, buf, 0) != 0) {
+    mrb_raisef(mrb, E_RUNTIME_ERROR, "mkdtemp(%s) failed", buf);
+  }
+#else
+  snprintf(buf, sizeof(buf), "%s/mruby-dir-test.XXXXXX", P_tmpdir);
+  if (mkdtemp(buf) == NULL) {
+    mrb_raisef(mrb, E_RUNTIME_ERROR, "mkdtemp(%s) failed", buf);
+  }
+#endif
+  mrb_cv_set(mrb, klass, mrb_intern_cstr(mrb, "sandbox"), mrb_str_new_cstr(mrb, buf));
+
+  /* go to sandbox */
+  if (mrb_hal_dir_chdir(mrb, buf) == -1) {
+    mrb_hal_dir_rmdir(mrb, buf);
+    mrb_raisef(mrb, E_RUNTIME_ERROR, "chdir(%s) failed", buf);
+  }
+
+  /* make some directories in the sandbox */
+  make_dir(mrb, aname, buf);
+  make_dir(mrb, bname, buf);
+
+  return mrb_true_value();
+}
+
+mrb_value
+mrb_dirtest_teardown(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value d, sandbox;
+  mrb_dir_handle *dirp;
+  const char *name;
+  const char *path;
+
+  /* cleanup sandbox */
+  sandbox = mrb_cv_get(mrb, klass, mrb_intern_cstr(mrb, "sandbox"));
+  path = mrb_str_to_cstr(mrb, sandbox);
+
+  dirp = mrb_hal_dir_open(mrb, path);
+  while ((name = mrb_hal_dir_read(mrb, dirp)) != NULL) {
+    if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
+      continue;
+    if (mrb_hal_dir_rmdir(mrb, name) == -1) {
+      mrb_raisef(mrb, E_RUNTIME_ERROR, "rmdir(%s) failed", name);
+    }
+  }
+  mrb_hal_dir_close(mrb, dirp);
+
+  /* back to original pwd */
+  d = mrb_cv_get(mrb, klass, mrb_intern_cstr(mrb, "pwd"));
+  path = mrb_str_to_cstr(mrb, d);
+  if (mrb_hal_dir_chdir(mrb, path) == -1) {
+    mrb_raisef(mrb, E_RUNTIME_ERROR, "chdir(%s) failed", path);
+  }
+
+  /* remove sandbox directory */
+  sandbox = mrb_cv_get(mrb, klass, mrb_intern_cstr(mrb, "sandbox"));
+  path = mrb_str_to_cstr(mrb, sandbox);
+  if (mrb_hal_dir_rmdir(mrb, path) == -1) {
+    mrb_raisef(mrb, E_RUNTIME_ERROR, "rmdir(%s) failed", path);
+  }
+
+  return mrb_true_value();
+}
+
+mrb_value
+mrb_dirtest_sandbox(mrb_state *mrb, mrb_value klass)
+{
+  return mrb_cv_get(mrb, klass, mrb_intern_cstr(mrb, "sandbox"));
+}
+
+void
+mrb_mruby_dir_gem_test(mrb_state *mrb)
+{
+  struct RClass *c = mrb_define_module(mrb, "DirTest");
+
+  mrb_define_class_method(mrb, c, "sandbox", mrb_dirtest_sandbox, MRB_ARGS_NONE());
+  mrb_define_class_method(mrb, c, "setup", mrb_dirtest_setup, MRB_ARGS_NONE());
+  mrb_define_class_method(mrb, c, "teardown", mrb_dirtest_teardown, MRB_ARGS_NONE());
+}

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

@@ -0,0 +1,96 @@
+# mruby-encoding
+
+This mrbgem provides a lightweight, "poorman's" encoding functionality for mruby. It is designed to offer basic encoding support, primarily focused on UTF-8 and ASCII-8BIT.
+
+## Summary
+
+- **License:** MIT
+- **Author:** mruby developers
+- **Supported Encodings:**
+  - `Encoding::UTF_8`
+  - `Encoding::ASCII_8BIT` (aliased as `Encoding::BINARY`)
+
+## Functionality
+
+This gem introduces an `Encoding` module and extends the `String` and `Integer` classes with encoding-related methods.
+
+### `Encoding` Module
+
+A module (not a class, unlike standard Ruby) that holds encoding constants.
+
+- `Encoding::UTF_8`: Represents the UTF-8 encoding.
+- `Encoding::ASCII_8BIT`: Represents the ASCII-8BIT encoding.
+- `Encoding::BINARY`: An alias for `Encoding::ASCII_8BIT`.
+
+### `String` Methods
+
+- `string.valid_encoding? -> true or false`
+  - Returns `true` if the string is correctly encoded (particularly useful for UTF-8 strings). For `ASCII-8BIT` strings, it generally returns `true`.
+- `string.encoding -> EncodingConstant`
+  - Returns the encoding of the string. This will be `Encoding::UTF_8` or `Encoding::BINARY`.
+- `string.force_encoding(encoding_name) -> string`
+  - Changes the string's reported encoding to the specified `encoding_name` (e.g., "UTF-8", "ASCII-8BIT", "BINARY").
+  - The actual byte sequence of the string is not changed.
+  - Raises an `ArgumentError` if an unsupported encoding name is provided.
+
+### `Integer` Method
+
+- `integer.chr(encoding_name = Encoding::BINARY) -> String`
+  - Returns a single-character string represented by the integer.
+  - If `encoding_name` is "UTF-8", the integer is treated as a Unicode codepoint.
+  - If `encoding_name` is "ASCII-8BIT" or "BINARY" (the default), the integer is treated as a byte value (0-255).
+  - Raises a `RangeError` if the integer is out of the valid range for the specified encoding.
+  - Raises an `ArgumentError` for unknown encoding names.
+
+## Usage Example
+
+```ruby
+# main.rb
+if __ENCODING__ == "UTF-8"
+  s = "helloあ"
+  puts s.encoding  #=> Encoding::UTF_8
+  puts s.valid_encoding? #=> true
+
+  s2 = "\xff".force_encoding("UTF-8")
+  puts s2.valid_encoding? #=> false
+
+  s3 = "world"
+  s3.force_encoding("BINARY")
+  puts s3.encoding #=> Encoding::BINARY
+  puts s3.valid_encoding? #=> true (ASCII-8BIT strings are generally considered valid)
+
+  puts 65.chr #=> "A" (defaults to ASCII-8BIT)
+  puts 230.chr("UTF-8") #=> "æ" (if U+00E6 is æ)
+  # For mruby, this might be different based on actual UTF-8 char mapping
+  # For example, 12354.chr("UTF-8") might be "あ"
+else
+  s = "hello"
+  puts s.encoding #=> Encoding::BINARY (or ASCII-8BIT)
+
+  # Attempting to force to UTF-8 in a non-UTF-8 mruby build might be limited
+  # or behave as ASCII-8BIT depending on mruby's core string handling.
+end
+
+# Force encoding
+my_string = "\xE3\x81\x82" # UTF-8 bytes for "あ"
+puts my_string.encoding # Might be BINARY by default if not created as UTF-8 literal
+
+my_string.force_encoding("UTF-8")
+puts my_string.encoding #=> Encoding::UTF_8
+puts my_string #=> あ
+
+invalid_utf8 = "\xff\xfe"
+invalid_utf8.force_encoding("UTF-8")
+puts invalid_utf8.valid_encoding? #=> false
+
+# Integer#chr
+puts 65.chr # => "A"
+puts 65.chr("BINARY") # => "A"
+
+# When mruby is compiled with MRB_UTF8_STRING
+if Object.const_defined?(:MRB_UTF8_STRING)
+  puts 12354.chr("UTF-8") # => "あ"
+  # puts 0x110000.chr("UTF-8") #=> RangeError
+end
+
+```

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

@@ -0,0 +1,8 @@
+MRuby::Gem::Specification.new('mruby-encoding') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = "Poorman's Encoding for mruby"
+  spec.build.defines << "HAVE_MRUBY_ENCODING_GEM"
+  spec.build.defines << "MRB_UTF8_STRING"
+  spec.add_test_dependency 'mruby-string-ext'
+end

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

@@ -0,0 +1,128 @@
+#include <mruby.h>
+#include <mruby/string.h>
+#include <mruby/variable.h>
+#include <mruby/internal.h>
+#include <mruby/presym.h>
+
+#define ENC_ASCII_8BIT "ASCII-8BIT"
+#define ENC_BINARY     "BINARY"
+#define ENC_UTF8       "UTF-8"
+
+/*
+ * call-seq:
+ *   string.valid_encoding? -> true or false
+ *
+ * Returns true for a string which is encoded correctly.
+ *
+ */
+static mrb_value
+str_valid_enc_p(mrb_state *mrb, mrb_value str)
+{
+#define utf8_islead(c) ((unsigned char)((c)&0xc0) != 0x80)
+
+  struct RString *s = mrb_str_ptr(str);
+  if (RSTR_SINGLE_BYTE_P(s)) return mrb_true_value();
+  if (RSTR_BINARY_P(s)) return mrb_true_value();
+
+  mrb_int byte_len = RSTR_LEN(s);
+  mrb_int utf8_len = 0;
+  const char *p = RSTR_PTR(s);
+  const char *e = p + byte_len;
+  while (p < e) {
+    mrb_int len = mrb_utf8len(p, e);
+
+    if (len == 1 && (*p & 0x80)) return mrb_false_value();
+    p += len;
+    utf8_len++;
+  }
+  if (byte_len == utf8_len) RSTR_SET_SINGLE_BYTE_FLAG(s);
+  return mrb_true_value();
+}
+
+static mrb_value
+get_encoding(mrb_state *mrb, mrb_sym enc)
+{
+  struct RClass *e = mrb_module_get_id(mrb, MRB_SYM(Encoding));
+  return mrb_const_get(mrb, mrb_obj_value(e), enc);
+}
+
+/*
+ * call-seq:
+ *   string.encoding -> encoding
+ *
+ * Returns the Encoding object that represents the encoding of the string.
+ * In mruby, this returns either "UTF-8" or "ASCII-8BIT" (BINARY).
+ *
+ *   "hello".encoding          #=> "UTF-8"
+ *   "\xff\xfe".encoding       #=> "ASCII-8BIT"
+ */
+static mrb_value
+str_encoding(mrb_state *mrb, mrb_value self)
+{
+  struct RString *s = mrb_str_ptr(self);
+  if (RSTR_BINARY_P(s)) {
+    return get_encoding(mrb, MRB_SYM(BINARY));
+  }
+  return get_encoding(mrb, MRB_SYM(UTF_8));
+}
+
+/*
+ * call-seq:
+ *   string.force_encoding(encoding) -> string
+ *
+ * Changes the encoding of the string to the specified encoding.
+ * This method modifies the string in place and returns self.
+ * In mruby, only "UTF-8", "ASCII-8BIT", and "BINARY" are supported.
+ *
+ *   str = "hello"
+ *   str.force_encoding("ASCII-8BIT")  #=> "hello"
+ *   str.encoding                      #=> "ASCII-8BIT"
+ */
+static mrb_value
+str_force_encoding(mrb_state *mrb, mrb_value self)
+{
+  mrb_value enc;
+
+  mrb_get_args(mrb, "S", &enc);
+
+  struct RString *s = mrb_str_ptr(self);
+  if (MRB_STR_CASECMP_P(enc, ENC_ASCII_8BIT) ||
+      MRB_STR_CASECMP_P(enc, ENC_BINARY)) {
+    s->flags |= MRB_STR_BINARY;
+  }
+  else if (MRB_STR_CASECMP_P(enc, ENC_UTF8)) {
+    s->flags &= ~MRB_STR_BINARY;
+  }
+  else {
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "unknown encoding name - %v", enc);
+  }
+  return self;
+}
+
+void
+mrb_mruby_encoding_gem_init(mrb_state* mrb)
+{
+  struct RClass *s = mrb->string_class;
+
+  mrb_define_method_id(mrb, s, MRB_SYM_Q(valid_encoding), str_valid_enc_p,     MRB_ARGS_NONE());
+  mrb_define_method_id(mrb, s, MRB_SYM(encoding),         str_encoding,        MRB_ARGS_NONE());
+  mrb_define_method_id(mrb, s, MRB_SYM(force_encoding),   str_force_encoding,  MRB_ARGS_REQ(1));
+
+  /* Poorman's Encoding
+   *
+   * Encoding - module instead of class
+   * encodings - supports only UTF-8 and ASCII-8BIT (and its alias BINARY)
+   * each Encoding - encoding name string instead of Encoding object
+   *
+   */
+  struct RClass *e = mrb_define_module_id(mrb, MRB_SYM(Encoding));
+  mrb_value b = mrb_str_new_lit_frozen(mrb, ENC_ASCII_8BIT);
+  mrb_define_const_id(mrb, e, MRB_SYM(ASCII_8BIT), b);
+  mrb_define_const_id(mrb, e, MRB_SYM(BINARY), b);
+  mrb_define_const_id(mrb, e, MRB_SYM(UTF_8), mrb_str_new_lit_frozen(mrb, ENC_UTF8));
+}
+
+void
+mrb_mruby_encoding_gem_final(mrb_state* mrb)
+{
+}

data/ext/enclave/mruby/mrbgems/mruby-encoding/test/numeric.rb

@@ -0,0 +1,27 @@
+assert('Integer#chr') do
+  assert_equal("A", 65.chr)
+  assert_equal("B", 0x42.chr)
+  assert_equal("\xab", 171.chr)
+  assert_raise(RangeError) { -1.chr }
+  assert_raise(RangeError) { 256.chr }
+
+  assert_equal("A", 65.chr("ASCII-8BIT"))
+  assert_equal("B", 0x42.chr("BINARY"))
+  assert_equal("\xab", 171.chr("ascii-8bit"))
+  assert_raise(RangeError) { -1.chr("binary") }
+  assert_raise(RangeError) { 256.chr("Ascii-8bit") }
+  assert_raise(ArgumentError) { 65.chr("ASCII") }
+  assert_raise(ArgumentError) { 65.chr("ASCII-8BIT", 2) }
+  assert_raise(TypeError) { 65.chr(:BINARY) }
+
+  if __ENCODING__ == "ASCII-8BIT"
+    assert_raise(ArgumentError) { 65.chr("UTF-8") }
+  else
+    assert_equal("A", 65.chr("UTF-8"))
+    assert_equal("B", 0x42.chr("UTF-8"))
+    assert_equal("«", 171.chr("utf-8"))
+    assert_equal("あ", 12354.chr("Utf-8"))
+    assert_raise(RangeError) { -1.chr("utf-8") }
+    assert_raise(RangeError) { 0x110000.chr.chr("UTF-8") }
+  end
+end

data/ext/enclave/mruby/mrbgems/mruby-encoding/test/string.rb

@@ -0,0 +1,30 @@
+##
+# String(Ext) Test
+
+UTF8STRING = __ENCODING__ == "UTF-8"
+
+assert('String#valid_encoding?') do
+  assert_true "hello".valid_encoding?
+  if UTF8STRING
+    assert_true "あ".valid_encoding?
+    assert_false "\xfe".valid_encoding?
+    assert_false "あ\xfe".valid_encoding?
+    assert_true "あ\xfe".b.valid_encoding?
+  else
+    assert_true "\xfe".valid_encoding?
+  end
+end
+
+assert('String#encoding') do
+  if UTF8STRING
+    a = "あ"
+    assert_equal Encoding::UTF_8, a.encoding
+    assert_equal Encoding::BINARY, a.b.encoding
+    assert_equal a, a.force_encoding(Encoding::BINARY)
+    assert_equal a, a.force_encoding(Encoding::BINARY)
+    assert_equal Encoding::BINARY, a.encoding
+  else
+    a = "hello"
+    assert_equal Encoding::BINARY, a.encoding
+  end
+end

data/ext/enclave/mruby/mrbgems/mruby-enum-chain/README.md

@@ -0,0 +1,80 @@
+# mruby-enum-chain
+
+## Description
+
+This mrbgem provides the `Enumerator::Chain` class, which allows you to chain multiple enumerable objects together, treating them as a single, continuous enumerable.
+
+This is useful when you have multiple collections (e.g., arrays, ranges, or other enumerators) and you want to iterate over all of them sequentially without first concatenating them into a single, larger collection.
+
+## How to Use
+
+There are three main ways to create an `Enumerator::Chain` instance:
+
+### 1. Using `Enumerable#chain`
+
+You can call the `chain` method on any object that includes the `Enumerable` module.
+
+```ruby
+a = [1, 2, 3]
+b = (4..6)
+c = {foo: 7, bar: 8}.each_key # Enumerator for keys
+
+chained_enum = a.chain(b, c)
+chained_enum.to_a # => [1, 2, 3, 4, 5, 6, :foo, :bar]
+```
+
+### 2. Using `Enumerator#+`
+
+You can use the `+` operator on an `Enumerator` instance to chain it with another enumerable object.
+
+```ruby
+enum1 = [1, 2].each
+enum2 = %w(a b).each
+
+chained_enum = enum1 + enum2
+chained_enum.to_a # => [1, 2, "a", "b"]
+
+# You can chain multiple times
+enum3 = (10..11).each
+chained_enum_2 = enum1 + enum2 + enum3
+chained_enum_2.to_a # => [1, 2, "a", "b", 10, 11]
+```
+
+### 3. Using `Enumerator::Chain.new`
+
+You can directly instantiate `Enumerator::Chain` by passing enumerable objects to its constructor.
+
+```ruby
+arr = [10, 20]
+rng = (30..31)
+
+chained_enum = Enumerator::Chain.new(arr, rng)
+chained_enum.to_a # => [10, 20, 30, 31]
+```
+
+## Key Features
+
+- **`each(&block)`**: Iterates through each element of the chained enumerables in the order they were added. Returns an enumerator if no block is given.
+- **`size`**: Returns the total number of elements in all chained enumerables. If any of the chained enumerables do not respond to `size` (e.g., an infinite enumerator or one with an unknown size), this method will return `nil`.
+
+  ```ruby
+  ([1, 2].chain([3, 4])).size # => 4
+  ([1, 2].chain( (1..Float::INFINITY) )).size # => nil
+  ```
+
+- **`rewind`**: Rewinds all of the chained enumerables that respond to the `rewind` method. This resets the iteration state to the beginning.
+
+  ```ruby
+  e = [1,2].chain(3..4)
+  e.next # => 1
+  e.next # => 2
+  e.next # => 3
+  e.rewind
+  e.next # => 1
+  ```
+
+- **`+(other)`**: Creates a new `Enumerator::Chain` by appending another enumerable to the current chain.
+
+## License
+
+MIT License

data/ext/enclave/mruby/mrbgems/mruby-enum-chain/mrbgem.rake

@@ -0,0 +1,6 @@
+MRuby::Gem::Specification.new('mruby-enum-chain') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Enumerator::Chain class'
+  spec.add_dependency('mruby-enumerator', :core => 'mruby-enumerator')
+end

data/ext/enclave/mruby/mrbgems/mruby-enum-chain/mrblib/chain.rb

@@ -0,0 +1,149 @@
+##
+# chain.rb Enumerator::Chain class
+# See Copyright Notice in mruby.h
+
+module Enumerable
+  #
+  # call-seq:
+  #   enum.chain(*enums) -> enumerator_chain
+  #
+  # Returns an Enumerator::Chain object which can enumerate over this
+  # enumerable and the given enumerables in sequence.
+  #
+  #   e = (1..3).chain([4, 5])
+  #   e.to_a  #=> [1, 2, 3, 4, 5]
+  #
+  def chain(*args)
+    Enumerator::Chain.new(self, *args)
+  end
+end
+
+class Enumerator
+  #
+  # call-seq:
+  #   enum + other_enum -> enumerator_chain
+  #
+  # Returns an Enumerator::Chain object which can enumerate over this
+  # enumerator and the given enumerator in sequence.
+  #
+  #   e1 = (1..3).each
+  #   e2 = [4, 5].each
+  #   (e1 + e2).to_a  #=> [1, 2, 3, 4, 5]
+  #
+  def +(other)
+    Chain.new(self, other)
+  end
+
+  class Chain
+    include Enumerable
+
+    #
+    # call-seq:
+    #   Enumerator::Chain.new(*enums) -> enumerator_chain
+    #
+    # Generates a new enumerator which iterates over each one of the
+    # given enumerable objects in sequence.
+    #
+    #   e = Enumerator::Chain.new(1..3, [4, 5])
+    #   e.to_a  #=> [1, 2, 3, 4, 5]
+    #
+    def initialize(*args)
+      @enums = args.freeze
+      @pos = -1
+    end
+
+    #
+    # call-seq:
+    #   chain.each { |obj| block } -> chain
+    #   chain.each                 -> enumerator
+    #
+    # Iterates over the elements of the first enumerable by calling the
+    # each method on it with the given block, then proceeds to the next
+    # enumerable in the chain and continues until the end.
+    #
+    #   e = Enumerator::Chain.new(1..3, [4, 5])
+    #   e.each { |x| puts x }
+    #   # prints: 1, 2, 3, 4, 5
+    #
+    def each(&block)
+      return to_enum(:each) unless block
+
+      i = 0
+      while i < @enums.size
+        @pos = i
+        @enums[i].each(&block)
+        i += 1
+      end
+
+      self
+    end
+
+    #
+    # call-seq:
+    #   chain.size -> integer or nil
+    #
+    # Returns the total size of the enumerator chain if all of the
+    # chained enumerables define size. Otherwise it returns nil.
+    #
+    #   Enumerator::Chain.new(1..3, [4, 5]).size  #=> 5
+    #   Enumerator::Chain.new(1..3, loop).size    #=> nil
+    #
+    def size
+      @enums.reduce(0) do |a, e|
+        return nil unless e.respond_to?(:size)
+        a + e.size
+      end
+    end
+
+    #
+    # call-seq:
+    #   chain.rewind -> chain
+    #
+    # Rewinds the enumerator chain by calling the rewind method on each
+    # enumerable that has been iterated, in reverse order. Each enumerable
+    # that defines a rewind method will be rewound.
+    #
+    #   e = Enumerator::Chain.new((1..3), [4, 5])
+    #   e.next  #=> 1
+    #   e.rewind
+    #   e.next  #=> 1
+    #
+    def rewind
+      while 0 <= @pos && @pos < @enums.size
+        e = @enums[@pos]
+        e.rewind if e.respond_to?(:rewind)
+        @pos -= 1
+      end
+
+      self
+    end
+
+    #
+    # call-seq:
+    #   chain + other_enum -> enumerator_chain
+    #
+    # Returns a new Enumerator::Chain object which will enumerate over the
+    # elements of this chain, followed by the elements of other_enum.
+    #
+    #   e1 = Enumerator::Chain.new(1..3, [4, 5])
+    #   e2 = e1 + [6, 7]
+    #   e2.to_a  #=> [1, 2, 3, 4, 5, 6, 7]
+    #
+    def +(other)
+      self.class.new(self, other)
+    end
+
+    #
+    # call-seq:
+    #   chain.inspect -> string
+    #
+    # Returns a printable version of the enumerator chain.
+    #
+    #   Enumerator::Chain.new(1..3, [4, 5]).inspect
+    #   #=> "#<Enumerator::Chain: [1..3, [4, 5]]>"
+    #
+    def inspect
+      "#<#{self.class}: #{@enums.inspect}>"
+    end
+  end
+end