script_core 0.2.3 → 0.3.0

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/test/file.rb

@@ -51,6 +51,8 @@
   assert_equal '', File.extname('foo/.bar')
   assert_equal '', File.extname('foo.txt/bar')
   assert_equal '', File.extname('.foo')
+  assert_equal '.rb', File.extname('.a.rb')
+  assert_equal '.', File.extname('foo.')
 end
 
 assert('File#flock') do
@@ -110,18 +112,22 @@
 end
 
 assert('File.realpath') do
-  if File::ALT_SEPARATOR
-    readme_path = File._getwd + File::ALT_SEPARATOR + "README.md"
-    assert_equal readme_path, File.realpath("README.md")
-  else
-    dir = MRubyIOTestUtil.mkdtemp("mruby-io-test.XXXXXX")
-    begin
-      dir1 = File.realpath($mrbtest_io_rfname)
-      dir2 = File.realpath("./#{dir}//./../#{$mrbtest_io_symlinkname}")
-      assert_equal dir1, dir2
-    ensure
-      MRubyIOTestUtil.rmdir dir
+  dir = MRubyIOTestUtil.mkdtemp("mruby-io-test.XXXXXX")
+  begin
+    sep = File::ALT_SEPARATOR || File::SEPARATOR
+    relative_path = "#{File.basename(dir)}#{sep}realpath_test"
+    path = "#{File._getwd}#{sep}#{relative_path}"
+    File.open(path, "w"){}
+    assert_equal path, File.realpath(relative_path)
+
+    unless MRubyIOTestUtil.win?
+      path1 = File.realpath($mrbtest_io_rfname)
+      path2 = File.realpath($mrbtest_io_symlinkname)
+      assert_equal path1, path2
     end
+  ensure
+    File.delete path rescue nil
+    MRubyIOTestUtil.rmdir dir
   end
 
   assert_raise(ArgumentError) { File.realpath("TO\0DO") }
@@ -129,7 +135,9 @@
 
 assert("File.readlink") do
   begin
-    assert_equal $mrbtest_io_rfname, File.readlink($mrbtest_io_symlinkname)
+    exp = File.basename($mrbtest_io_rfname)
+    act = File.readlink($mrbtest_io_symlinkname)
+    assert_equal exp, act
   rescue NotImplementedError => e
     skip e.message
   end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/test/io.rb

@@ -7,7 +7,7 @@
 def assert_io_open(meth)
   assert "assert_io_open" do
     fd = IO.sysopen($mrbtest_io_rfname)
-    assert_equal Fixnum, fd.class
+    assert_equal Integer, fd.class
     io1 = IO.__send__(meth, fd)
     begin
       assert_equal IO, io1.class
@@ -24,6 +24,9 @@ def assert_io_open(meth)
       end
     end
     io2.close unless meth == :open
+
+    assert_raise(RuntimeError) { IO.__send__(meth, 1023) } # For Windows
+    assert_raise(RuntimeError) { IO.__send__(meth, 1 << 26) }
   end
 end
 
@@ -429,7 +432,7 @@ def io._buf
     $? = nil
     io = IO.popen("#{$cmd}echo mruby-io")
     assert_true io.close_on_exec?
-    assert_equal Fixnum, io.pid.class
+    assert_equal Integer, io.pid.class
 
     out = io.read
     assert_equal out.class, String
@@ -564,6 +567,34 @@ def io._buf
   end
 end
 
+assert('IO#pread') do
+  skip "IO#pread is not implemented on this configuration" unless MRubyIOTestUtil::MRB_WITH_IO_PREAD_PWRITE
+
+  IO.open(IO.sysopen($mrbtest_io_rfname, 'r'), 'r') do |io|
+    assert_equal $mrbtest_io_msg.byteslice(5, 8), io.pread(8, 5)
+    assert_equal 0, io.pos
+    assert_equal $mrbtest_io_msg.byteslice(1, 5), io.pread(5, 1)
+    assert_equal 0, io.pos
+    assert_raise(RuntimeError) { io.pread(20, -9) }
+  end
+end
+
+assert('IO#pwrite') do
+  skip "IO#pwrite is not implemented on this configuration" unless MRubyIOTestUtil::MRB_WITH_IO_PREAD_PWRITE
+
+  IO.open(IO.sysopen($mrbtest_io_wfname, 'w+'), 'w+') do |io|
+    assert_equal 6, io.pwrite("Warld!", 7)
+    assert_equal 0, io.pos
+    assert_equal 7, io.pwrite("Hello, ", 0)
+    assert_equal 0, io.pos
+    assert_equal "Hello, Warld!", io.read
+    assert_equal 6, io.pwrite("world!", 7)
+    assert_equal 13, io.pos
+    io.pos = 0
+    assert_equal "Hello, world!", io.read
+  end
+end
+
 assert('IO.pipe') do
   begin
     called = false

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/test/mruby_io_test.c

@@ -1,5 +1,7 @@
+#include <mruby/common.h>
 #include <sys/types.h>
 #include <errno.h>
+#include <string.h>
 
 #if defined(_WIN32) || defined(_WIN64)
 
@@ -7,7 +9,6 @@
 #include <io.h>
 #include <fcntl.h>
 #include <direct.h>
-#include <string.h>
 #include <stdlib.h>
 #include <malloc.h>
 
@@ -18,12 +19,6 @@ typedef int mode_t;
 #define open _open
 #define close _close
 
-#if defined(__MINGW64_VERSION_MAJOR)
-# define MRB_MINGW64_VERSION  (__MINGW64_VERSION_MAJOR * 1000 + __MINGW64_VERSION_MINOR)
-#elif defined(__MINGW32_MAJOR_VERSION)
-# define MRB_MINGW32_VERSION  (__MINGW32_MAJOR_VERSION * 1000 + __MINGW32_MINOR_VERSION)
-#endif
-
 #if defined(_MSC_VER) || \
     (defined(MRB_MINGW32_VERSION) && MRB_MINGW32_VERSION < 3021) || \
     (defined(MRB_MINGW64_VERSION) && MRB_MINGW64_VERSION < 4000)
@@ -58,10 +53,11 @@ mkdtemp(char *temp)
   #include <sys/socket.h>
   #include <unistd.h>
   #include <sys/un.h>
+  #include <fcntl.h>
+  #include <libgen.h>
 #endif
 
 #include <sys/stat.h>
-#include <stdio.h>
 #include <stdlib.h>
 
 #include "mruby.h"
@@ -69,51 +65,55 @@ mkdtemp(char *temp)
 #include "mruby/error.h"
 #include "mruby/string.h"
 #include "mruby/variable.h"
+#include <mruby/ext/io.h>
 
 static mrb_value
 mrb_io_test_io_setup(mrb_state *mrb, mrb_value self)
 {
-  char rfname[]      = "tmp.mruby-io-test-r.XXXXXXXX";
-  char wfname[]      = "tmp.mruby-io-test-w.XXXXXXXX";
-  char symlinkname[] = "tmp.mruby-io-test-l.XXXXXXXX";
-  char socketname[]  = "tmp.mruby-io-test-s.XXXXXXXX";
+#define GVNAME(n) "$mrbtest_io_" #n "name"
+  enum {IDX_READ, IDX_WRITE, IDX_LINK, IDX_SOCKET, IDX_COUNT};
+  const char *gvnames[] = {GVNAME(rf), GVNAME(wf), GVNAME(symlink), GVNAME(socket)};
+  char *fnames[IDX_COUNT];
+  int fds[IDX_COUNT];
   char msg[] = "mruby io test\n";
   mode_t mask;
-  int fd0, fd1;
   FILE *fp;
-
+  int i;
 #if !defined(_WIN32) && !defined(_WIN64)
-  int fd2, fd3;
-  struct sockaddr_un sun0;
+  struct sockaddr_un sun0 = { 0 }; /* Initialize them all because it is environment dependent */
 #endif
 
-  mask = umask(077);
-  fd0 = mkstemp(rfname);
-  fd1 = mkstemp(wfname);
-  if (fd0 == -1 || fd1 == -1) {
-    mrb_raise(mrb, E_RUNTIME_ERROR, "can't create temporary file");
-    return mrb_nil_value();
-  }
-  close(fd0);
-  close(fd1);
+  mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_msg"), mrb_str_new_cstr(mrb, msg));
 
+  mask = umask(077);
+  for (i = 0; i < IDX_COUNT; i++) {
+    mrb_value fname = mrb_str_new_capa(mrb, 0);
 #if !defined(_WIN32) && !defined(_WIN64)
-  fd2 = mkstemp(symlinkname);
-  fd3 = mkstemp(socketname);
-  if (fd2 == -1 || fd3 == -1) {
-    mrb_raise(mrb, E_RUNTIME_ERROR, "can't create temporary file");
-    return mrb_nil_value();
-  }
+    /*
+     * Workaround for not being able to bind a socket to some file systems
+     * (e.g. vboxsf, NFS). [#4981]
+     */
+    char *tmpdir = getenv("TMPDIR");
+    if (tmpdir && strlen(tmpdir) > 0) {
+      mrb_str_cat_cstr(mrb, fname, tmpdir);
+      if (*(RSTRING_END(fname)-1) != '/') mrb_str_cat_lit(mrb, fname, "/");
+    } else {
+      mrb_str_cat_lit(mrb, fname, "/tmp/");
+    }
 #endif
+    mrb_str_cat_cstr(mrb, fname, gvnames[i]+1);
+    mrb_str_cat_cstr(mrb, fname, ".XXXXXXXX");
+    fnames[i] = RSTRING_PTR(fname);
+    fds[i] = mkstemp(fnames[i]);
+    if (fds[i] == -1) {
+      mrb_raise(mrb, E_RUNTIME_ERROR, "can't create temporary file");
+    }
+    close(fds[i]);
+    mrb_gv_set(mrb, mrb_intern_cstr(mrb, gvnames[i]), fname);
+  }
   umask(mask);
 
-  mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_rfname"), mrb_str_new_cstr(mrb, rfname));
-  mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_wfname"), mrb_str_new_cstr(mrb, wfname));
-  mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_symlinkname"), mrb_str_new_cstr(mrb, symlinkname));
-  mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_socketname"), mrb_str_new_cstr(mrb, socketname));
-  mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_msg"), mrb_str_new_cstr(mrb, msg));
-
-  fp = fopen(rfname, "wb");
+  fp = fopen(fnames[IDX_READ], "wb");
   if (fp == NULL) {
     mrb_raise(mrb, E_RUNTIME_ERROR, "can't open temporary file");
     return mrb_nil_value();
@@ -121,7 +121,7 @@ mrb_io_test_io_setup(mrb_state *mrb, mrb_value self)
   fputs(msg, fp);
   fclose(fp);
 
-  fp = fopen(wfname, "wb");
+  fp = fopen(fnames[IDX_WRITE], "wb");
   if (fp == NULL) {
     mrb_raise(mrb, E_RUNTIME_ERROR, "can't open temporary file");
     return mrb_nil_value();
@@ -129,29 +129,29 @@ mrb_io_test_io_setup(mrb_state *mrb, mrb_value self)
   fclose(fp);
 
 #if !defined(_WIN32) && !defined(_WIN64)
-  unlink(symlinkname);
-  close(fd2);
-  if (symlink(rfname, symlinkname) == -1) {
+  unlink(fnames[IDX_LINK]);
+  if (symlink(basename(fnames[IDX_READ]), fnames[IDX_LINK]) == -1) {
     mrb_raise(mrb, E_RUNTIME_ERROR, "can't make a symbolic link");
   }
 
-  unlink(socketname);
-  close(fd3);
-  fd3 = socket(AF_UNIX, SOCK_STREAM, 0);
-  if (fd3 == -1) {
+  unlink(fnames[IDX_SOCKET]);
+  fds[IDX_SOCKET] = socket(AF_UNIX, SOCK_STREAM, 0);
+  if (fds[IDX_SOCKET] == -1) {
     mrb_raise(mrb, E_RUNTIME_ERROR, "can't make a socket");
   }
   sun0.sun_family = AF_UNIX;
-  snprintf(sun0.sun_path, sizeof(sun0.sun_path), "%s", socketname);
-  if (bind(fd3, (struct sockaddr *)&sun0, sizeof(sun0)) == -1) {
+  strncpy(sun0.sun_path, fnames[IDX_SOCKET], sizeof(sun0.sun_path)-1);
+  sun0.sun_path[sizeof(sun0.sun_path)-1] = 0;
+  if (bind(fds[IDX_SOCKET], (struct sockaddr *)&sun0, sizeof(sun0)) == -1) {
     mrb_raisef(mrb, E_RUNTIME_ERROR, "can't bind AF_UNIX socket to %s: %d",
                sun0.sun_path,
                errno);
   }
-  close(fd3);
+  close(fds[IDX_SOCKET]);
 #endif
 
   return mrb_true_value();
+#undef GVNAME
 }
 
 static mrb_value
@@ -210,7 +210,7 @@ mrb_io_test_rmdir(mrb_state *mrb, mrb_value klass)
   return mrb_true_value();
 }
 
-mrb_value
+static mrb_value
 mrb_io_win_p(mrb_state *mrb, mrb_value klass)
 {
 #if defined(_WIN32) || defined(_WIN64)
@@ -224,6 +224,12 @@ mrb_io_win_p(mrb_state *mrb, mrb_value klass)
 #endif
 }
 
+#ifdef MRB_WITH_IO_PREAD_PWRITE
+# define MRB_WITH_IO_PREAD_PWRITE_ENABLED TRUE
+#else
+# define MRB_WITH_IO_PREAD_PWRITE_ENABLED FALSE
+#endif
+
 void
 mrb_mruby_io_gem_test(mrb_state* mrb)
 {
@@ -234,4 +240,6 @@ mrb_mruby_io_gem_test(mrb_state* mrb)
   mrb_define_class_method(mrb, io_test, "mkdtemp", mrb_io_test_mkdtemp, MRB_ARGS_REQ(1));
   mrb_define_class_method(mrb, io_test, "rmdir", mrb_io_test_rmdir, MRB_ARGS_REQ(1));
   mrb_define_class_method(mrb, io_test, "win?", mrb_io_win_p, MRB_ARGS_NONE());
+
+  mrb_define_const(mrb, io_test, "MRB_WITH_IO_PREAD_PWRITE", mrb_bool_value(MRB_WITH_IO_PREAD_PWRITE_ENABLED));
 }

data/ext/enterprise_script_service/mruby/mrbgems/mruby-kernel-ext/src/kernel.c

@@ -3,6 +3,7 @@
 #include <mruby/array.h>
 #include <mruby/hash.h>
 #include <mruby/range.h>
+#include <mruby/presym.h>
 
 static mrb_value
 mrb_f_caller(mrb_state *mrb, mrb_value self)
@@ -57,7 +58,7 @@ mrb_f_caller(mrb_state *mrb, mrb_value self)
     return mrb_ary_new(mrb);
   }
 
-  return mrb_funcall(mrb, bt, "[]", 2, mrb_fixnum_value(lev), mrb_fixnum_value(n));
+  return mrb_funcall_id(mrb, bt, MRB_OPSYM(aref), 2, mrb_fixnum_value(lev), mrb_fixnum_value(n));
 }
 
 /*
@@ -84,7 +85,7 @@ mrb_f_method(mrb_state *mrb, mrb_value self)
  *  call-seq:
  *     Integer(arg,base=0)    -> integer
  *
- *  Converts <i>arg</i> to a <code>Fixnum</code>.
+ *  Converts <i>arg</i> to a <code>Integer</code>.
  *  Numeric types are converted directly (with floating point numbers
  *  being truncated).    <i>base</i> (0, or between 2 and 36) is a base for
  *  integer string representation.  If <i>arg</i> is a <code>String</code>,
@@ -112,7 +113,7 @@ mrb_f_integer(mrb_state *mrb, mrb_value self)
   return mrb_convert_to_integer(mrb, arg, base);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /*
  *  call-seq:
  *     Float(arg)    -> float
@@ -128,9 +129,8 @@ mrb_f_integer(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_f_float(mrb_state *mrb, mrb_value self)
 {
-  mrb_value arg;
+  mrb_value arg = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &arg);
   return mrb_Float(mrb, arg);
 }
 #endif
@@ -149,10 +149,10 @@ mrb_f_float(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_f_string(mrb_state *mrb, mrb_value self)
 {
-  mrb_value arg, tmp;
+  mrb_value arg = mrb_get_arg1(mrb);
+  mrb_value tmp;
 
-  mrb_get_args(mrb, "o", &arg);
-  tmp = mrb_convert_type(mrb, arg, MRB_TT_STRING, "String", "to_s");
+  tmp = mrb_type_convert(mrb, arg, MRB_TT_STRING, MRB_SYM(to_s));
   return tmp;
 }
 
@@ -168,10 +168,10 @@ mrb_f_string(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_f_array(mrb_state *mrb, mrb_value self)
 {
-  mrb_value arg, tmp;
+  mrb_value arg = mrb_get_arg1(mrb);
+  mrb_value tmp;
 
-  mrb_get_args(mrb, "o", &arg);
-  tmp = mrb_check_convert_type(mrb, arg, MRB_TT_ARRAY, "Array", "to_a");
+  tmp = mrb_type_convert_check(mrb, arg, MRB_TT_ARRAY, MRB_SYM(to_a));
   if (mrb_nil_p(tmp)) {
     return mrb_ary_new_from_values(mrb, 1, &arg);
   }
@@ -196,9 +196,8 @@ mrb_f_array(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_f_hash(mrb_state *mrb, mrb_value self)
 {
-  mrb_value arg;
+  mrb_value arg = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &arg);
   if (mrb_nil_p(arg) || (mrb_array_p(arg) && RARRAY_LEN(arg) == 0)) {
     return mrb_hash_new(mrb);
   }
@@ -214,7 +213,7 @@ mrb_mruby_kernel_ext_gem_init(mrb_state *mrb)
   mrb_define_module_function(mrb, krn, "caller", mrb_f_caller, MRB_ARGS_OPT(2));
   mrb_define_method(mrb, krn, "__method__", mrb_f_method, MRB_ARGS_NONE());
   mrb_define_module_function(mrb, krn, "Integer", mrb_f_integer, MRB_ARGS_ARG(1,1));
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_define_module_function(mrb, krn, "Float", mrb_f_float, MRB_ARGS_REQ(1));
 #endif
   mrb_define_module_function(mrb, krn, "String", mrb_f_string, MRB_ARGS_REQ(1));

data/ext/enterprise_script_service/mruby/mrbgems/mruby-math/src/math.c

@@ -4,20 +4,21 @@
 ** See Copyright Notice in mruby.h
 */
 
-#ifdef MRB_WITHOUT_FLOAT
-# error Math conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb'
+#include <mruby.h>
+
+#ifdef MRB_NO_FLOAT
+# error Math conflicts with 'MRB_NO_FLOAT' configuration
 #endif
 
-#include <mruby.h>
 #include <mruby/array.h>
-
+#include <mruby/presym.h>
 #include <math.h>
 
 static void
 domain_error(mrb_state *mrb, const char *func)
 {
-  struct RClass *math = mrb_module_get(mrb, "Math");
-  struct RClass *domainerror = mrb_class_get_under(mrb, math, "DomainError");
+  struct RClass *math = mrb_module_get_id(mrb, MRB_SYM(Math));
+  struct RClass *domainerror = mrb_class_get_under_id(mrb, math, MRB_SYM(DomainError));
   mrb_raisef(mrb, domainerror, "Numerical argument is out of domain - %s", func);
 }
 
@@ -629,7 +630,7 @@ math_cbrt(mrb_state *mrb, mrb_value obj)
  *     Math.frexp(numeric)    -> [ fraction, exponent ]
  *
  *  Returns a two-element array containing the normalized fraction (a
- *  <code>Float</code>) and exponent (a <code>Fixnum</code>) of
+ *  <code>Float</code>) and exponent (a <code>Integer</code>) of
  *  <i>numeric</i>.
  *
  *     fraction, exponent = Math.frexp(1234)   #=> [0.6025390625, 11]
@@ -730,18 +731,18 @@ mrb_mruby_math_gem_init(mrb_state* mrb)
   struct RClass *mrb_math;
   mrb_math = mrb_define_module(mrb, "Math");
 
-  mrb_define_class_under(mrb, mrb_math, "DomainError", mrb->eStandardError_class);
+  mrb_define_class_under_id(mrb, mrb_math, MRB_SYM(DomainError), mrb->eStandardError_class);
 
 #ifdef M_PI
-  mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, M_PI));
+  mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, M_PI));
 #else
-  mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, atan(1.0)*4.0));
+  mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, atan(1.0)*4.0));
 #endif
 
 #ifdef M_E
-  mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, M_E));
+  mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, M_E));
 #else
-  mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, exp(1.0)));
+  mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, exp(1.0)));
 #endif
 
   mrb_define_module_function(mrb, mrb_math, "sin", math_sin, MRB_ARGS_REQ(1));