script_core 0.1.1 → 0.2.4

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

@@ -123,8 +123,8 @@ def hash
 
   def write(string)
     str = string.is_a?(String) ? string : string.to_s
-    return str.size unless str.size > 0
-    if 0 < @buf.length
+    return 0 if str.empty?
+    unless @buf.empty?
       # reset real pos ignore buf
       seek(pos, SEEK_SET)
     end
@@ -140,8 +140,8 @@ def <<(str)
   def eof?
     _check_readable
     begin
-      buf = _read_buf
-      return buf.size == 0
+      _read_buf
+      return @buf.empty?
     rescue EOFError
       return true
     end
@@ -150,7 +150,7 @@ def eof?
 
   def pos
     raise IOError if closed?
-    sysseek(0, SEEK_CUR) - @buf.length
+    sysseek(0, SEEK_CUR) - @buf.bytesize
   end
   alias_method :tell, :pos
 
@@ -170,8 +170,13 @@ def seek(i, whence = SEEK_SET)
   end
 
   def _read_buf
-    return @buf if @buf && @buf.size > 0
-    @buf = sysread(BUF_SIZE)
+    return @buf if @buf && @buf.bytesize >= 4 # maximum UTF-8 character is 4 bytes
+    @buf ||= ""
+    begin
+      @buf += sysread(BUF_SIZE)
+    rescue EOFError => e
+      raise e if @buf.empty?
+    end
   end
 
   def ungetc(substr)
@@ -207,9 +212,8 @@ def read(length = nil, outbuf = "")
       end
 
       if length
-        consume = (length <= @buf.size) ? length : @buf.size
-        array.push @buf[0, consume]
-        @buf = @buf[consume, @buf.size - consume]
+        consume = (length <= @buf.bytesize) ? length : @buf.bytesize
+        array.push IO._bufread(@buf, consume)
         length -= consume
         break if length == 0
       else
@@ -226,12 +230,12 @@ def read(length = nil, outbuf = "")
     end
   end
 
-  def readline(arg = $/, limit = nil)
+  def readline(arg = "\n", limit = nil)
     case arg
     when String
       rs = arg
     when Fixnum
-      rs = $/
+      rs = "\n"
       limit = arg
     else
       raise ArgumentError
@@ -242,7 +246,7 @@ def readline(arg = $/, limit = nil)
     end
 
     if rs == ""
-      rs = $/ + $/
+      rs = "\n\n"
     end
 
     array = []
@@ -256,12 +260,12 @@ def readline(arg = $/, limit = nil)
 
       if limit && limit <= @buf.size
         array.push @buf[0, limit]
-        @buf = @buf[limit, @buf.size - limit]
+        @buf[0, limit] = ""
         break
       elsif idx = @buf.index(rs)
         len = idx + rs.size
         array.push @buf[0, len]
-        @buf = @buf[len, @buf.size - len]
+        @buf[0, len] = ""
         break
       else
         array.push @buf
@@ -285,7 +289,7 @@ def gets(*args)
   def readchar
     _read_buf
     c = @buf[0]
-    @buf = @buf[1, @buf.size]
+    @buf[0] = ""
     c
   end
 
@@ -299,6 +303,8 @@ def getc
 
   # 15.2.20.5.3
   def each(&block)
+    return to_enum unless block
+
     while line = self.gets
       block.call(line)
     end
@@ -307,6 +313,8 @@ def each(&block)
 
   # 15.2.20.5.4
   def each_byte(&block)
+    return to_enum(:each_byte) unless block
+
     while char = self.getc
       block.call(char)
     end
@@ -364,25 +372,3 @@ def printf(*args)
 $stdin  = STDIN
 $stdout = STDOUT
 $stderr = STDERR
-
-module Kernel
-  def print(*args)
-    $stdout.print(*args)
-  end
-
-  def puts(*args)
-    $stdout.puts(*args)
-  end
-
-  def printf(*args)
-    $stdout.printf(*args)
-  end
-
-  def gets(*args)
-    $stdin.gets(*args)
-  end
-
-  def getc(*args)
-    $stdin.getc(*args)
-  end
-end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/mrblib/kernel.rb

@@ -12,4 +12,20 @@ def open(file, *rest, &block)
       File.open(file, *rest, &block)
     end
   end
+
+  def print(*args)
+    $stdout.print(*args)
+  end
+
+  def puts(*args)
+    $stdout.puts(*args)
+  end
+
+  def printf(*args)
+    $stdout.printf(*args)
+  end
+
+  def gets(*args)
+    $stdin.gets(*args)
+  end
 end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/src/file.c

@@ -7,12 +7,7 @@
 #include "mruby/data.h"
 #include "mruby/string.h"
 #include "mruby/ext/io.h"
-
-#if MRUBY_RELEASE_NO < 10000
-#include "error.h"
-#else
 #include "mruby/error.h"
-#endif
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -70,7 +65,15 @@
 #define LOCK_UN 8
 #endif
 
-#define STAT(p, s)        stat(p, s)
+#ifndef _WIN32
+typedef struct stat         mrb_stat;
+# define mrb_stat(path, sb) stat(path, sb)
+# define mrb_fstat(fd, sb)  fstat(fd, sb)
+#else
+typedef struct __stat64     mrb_stat;
+# define mrb_stat(path, sb) _stat64(path, sb)
+# define mrb_fstat(fd, sb)  _fstat64(fd, sb)
+#endif
 
 #ifdef _WIN32
 static int
@@ -116,7 +119,7 @@ mrb_file_s_unlink(mrb_state *mrb, mrb_value obj)
   for (i = 0; i < argc; i++) {
     const char *utf8_path;
     pathv = mrb_ensure_string_type(mrb, argv[i]);
-    utf8_path = mrb_string_value_cstr(mrb, &pathv);
+    utf8_path = RSTRING_CSTR(mrb, pathv);
     path = mrb_locale_from_utf8(utf8_path, -1);
     if (UNLINK(path) < 0) {
       mrb_locale_free(path);
@@ -134,8 +137,8 @@ mrb_file_s_rename(mrb_state *mrb, mrb_value obj)
   char *src, *dst;
 
   mrb_get_args(mrb, "SS", &from, &to);
-  src = mrb_locale_from_utf8(mrb_string_value_cstr(mrb, &from), -1);
-  dst = mrb_locale_from_utf8(mrb_string_value_cstr(mrb, &to), -1);
+  src = mrb_locale_from_utf8(RSTRING_CSTR(mrb, from), -1);
+  dst = mrb_locale_from_utf8(RSTRING_CSTR(mrb, to), -1);
   if (rename(src, dst) < 0) {
 #if defined(_WIN32) || defined(_WIN64)
     if (CHMOD(dst, 0666) == 0 && UNLINK(dst) == 0 && rename(src, dst) == 0) {
@@ -146,7 +149,8 @@ mrb_file_s_rename(mrb_state *mrb, mrb_value obj)
 #endif
     mrb_locale_free(src);
     mrb_locale_free(dst);
-    mrb_sys_fail(mrb, mrb_str_to_cstr(mrb, mrb_format(mrb, "(%S, %S)", from, to)));
+    mrb_sys_fail(mrb, RSTRING_CSTR(mrb, mrb_format(mrb, "(%v, %v)", from, to)));
+    return mrb_fixnum_value(-1); /* not reached */
   }
   mrb_locale_free(src);
   mrb_locale_free(dst);
@@ -159,12 +163,12 @@ mrb_file_dirname(mrb_state *mrb, mrb_value klass)
 #if defined(_WIN32) || defined(_WIN64)
   char dname[_MAX_DIR], vname[_MAX_DRIVE];
   char buffer[_MAX_DRIVE + _MAX_DIR];
+  const char *utf8_path;
   char *path;
   size_t ridx;
-  mrb_value s;
-  mrb_get_args(mrb, "S", &s);
-  path = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, s), -1);
-  _splitpath((const char*)path, vname, dname, NULL, NULL);
+  mrb_get_args(mrb, "z", &utf8_path);
+  path = mrb_locale_from_utf8(utf8_path, -1);
+  _splitpath(path, vname, dname, NULL, NULL);
   snprintf(buffer, _MAX_DRIVE + _MAX_DIR, "%s%s", vname, dname);
   mrb_locale_free(path);
   ridx = strlen(buffer);
@@ -248,11 +252,12 @@ mrb_file_realpath(mrb_state *mrb, mrb_value klass)
     s = mrb_str_append(mrb, s, pathname);
     pathname = s;
   }
-  cpath = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, pathname), -1);
+  cpath = mrb_locale_from_utf8(RSTRING_CSTR(mrb, pathname), -1);
   result = mrb_str_buf_new(mrb, PATH_MAX);
   if (realpath(cpath, RSTRING_PTR(result)) == NULL) {
     mrb_locale_free(cpath);
     mrb_sys_fail(mrb, cpath);
+    return result;              /* not reached */
   }
   mrb_locale_free(cpath);
   mrb_str_resize(mrb, result, strlen(RSTRING_PTR(result)));
@@ -300,14 +305,14 @@ mrb_file__gethome(mrb_state *mrb, mrb_value klass)
       mrb_raise(mrb, E_ARGUMENT_ERROR, "non-absolute home");
     }
   } else {
-    const char *cuser = mrb_str_to_cstr(mrb, username);
+    const char *cuser = RSTRING_CSTR(mrb, username);
     struct passwd *pwd = getpwnam(cuser);
     if (pwd == NULL) {
       return mrb_nil_value();
     }
     home = pwd->pw_dir;
     if (!mrb_file_is_absolute_path(home)) {
-      mrb_raisef(mrb, E_ARGUMENT_ERROR, "non-absolute home of ~%S", username);
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "non-absolute home of ~%v", username);
     }
   }
   home = mrb_locale_from_utf8(home, -1);
@@ -342,7 +347,7 @@ mrb_file_mtime(mrb_state *mrb, mrb_value self)
   int fd;
 
   obj = mrb_obj_value(mrb_class_get(mrb, "Time"));
-  fd = (int)mrb_fixnum(mrb_io_fileno(mrb, self));
+  fd = mrb_io_fileno(mrb, self);
   if (fstat(fd, &st) == -1)
     return mrb_false_value();
   return mrb_funcall(mrb, obj, "at", 1, mrb_fixnum_value(st.st_mtime));
@@ -358,7 +363,7 @@ mrb_file_flock(mrb_state *mrb, mrb_value self)
   int fd;
 
   mrb_get_args(mrb, "i", &operation);
-  fd = (int)mrb_fixnum(mrb_io_fileno(mrb, self));
+  fd = mrb_io_fileno(mrb, self);
 
   while (flock(fd, (int)operation) == -1) {
     switch (errno) {
@@ -382,6 +387,95 @@ mrb_file_flock(mrb_state *mrb, mrb_value self)
   return mrb_fixnum_value(0);
 }
 
+static mrb_value
+mrb_file_size(mrb_state *mrb, mrb_value self)
+{
+  mrb_stat st;
+  int fd;
+
+  fd = mrb_io_fileno(mrb, self);
+  if (mrb_fstat(fd, &st) == -1) {
+    mrb_raise(mrb, E_RUNTIME_ERROR, "fstat failed");
+  }
+
+  if (st.st_size > MRB_INT_MAX) {
+#ifdef MRB_WITHOUT_FLOAT
+    mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_WITHOUT_FLOAT");
+#else
+    return mrb_float_value(mrb, st.st_size);
+#endif
+  }
+
+  return mrb_fixnum_value(st.st_size);
+}
+
+static int
+mrb_ftruncate(int fd, int64_t length)
+{
+#ifndef _WIN32
+  return ftruncate(fd, (off_t)length);
+#else
+  HANDLE file;
+  __int64 cur;
+
+  file = (HANDLE)_get_osfhandle(fd);
+  if (file == INVALID_HANDLE_VALUE) {
+    return -1;
+  }
+
+  cur = _lseeki64(fd, 0, SEEK_CUR);
+  if (cur == -1) return -1;
+
+  if (_lseeki64(fd, (__int64)length, SEEK_SET) == -1) return -1;
+
+  if (!SetEndOfFile(file)) {
+    errno = EINVAL; /* TODO: GetLastError to errno */
+    return -1;
+  }
+
+  if (_lseeki64(fd, cur, SEEK_SET) == -1) return -1;
+
+  return 0;
+#endif /* _WIN32 */
+}
+
+static mrb_value
+mrb_file_truncate(mrb_state *mrb, mrb_value self)
+{
+  int fd;
+  int64_t length;
+  mrb_value lenv;
+
+  fd = mrb_io_fileno(mrb, self);
+  mrb_get_args(mrb, "o", &lenv);
+  switch (mrb_type(lenv)) {
+#ifndef MRB_WITHOUT_FLOAT
+    case MRB_TT_FLOAT:
+      {
+        mrb_float lenf = mrb_float(lenv);
+        if (lenf > INT64_MAX) {
+          mrb_raise(mrb, E_ARGUMENT_ERROR, "length too large");
+        }
+        length = (int64_t)lenf;
+      }
+      break;
+#endif
+    case MRB_TT_FIXNUM:
+    default:
+      {
+        mrb_int leni = mrb_int(mrb, lenv);
+        length = (int64_t)leni;
+      }
+      break;
+  }
+
+  if (mrb_ftruncate(fd, length) != 0) {
+    mrb_raise(mrb, E_IO_ERROR, "ftruncate failed");
+  }
+
+  return mrb_fixnum_value(0);
+}
+
 static mrb_value
 mrb_file_s_symlink(mrb_state *mrb, mrb_value klass)
 {
@@ -393,13 +487,12 @@ mrb_file_s_symlink(mrb_state *mrb, mrb_value klass)
   int ai = mrb_gc_arena_save(mrb);
 
   mrb_get_args(mrb, "SS", &from, &to);
-  src = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, from), -1);
-  dst = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, to), -1);
-
+  src = mrb_locale_from_utf8(RSTRING_CSTR(mrb, from), -1);
+  dst = mrb_locale_from_utf8(RSTRING_CSTR(mrb, to), -1);
   if (symlink(src, dst) == -1) {
     mrb_locale_free(src);
     mrb_locale_free(dst);
-    mrb_sys_fail(mrb, mrb_str_to_cstr(mrb, mrb_format(mrb, "(%S, %S)", from, to)));
+    mrb_sys_fail(mrb, RSTRING_CSTR(mrb, mrb_format(mrb, "(%v, %v)", from, to)));
   }
   mrb_locale_free(src);
   mrb_locale_free(dst);
@@ -417,16 +510,16 @@ mrb_file_s_chmod(mrb_state *mrb, mrb_value klass) {
 
   mrb_get_args(mrb, "i*", &mode, &filenames, &argc);
   for (i = 0; i < argc; i++) {
-    const char *utf8_path = mrb_str_to_cstr(mrb, filenames[i]);
+    const char *utf8_path = RSTRING_CSTR(mrb, filenames[i]);
     char *path = mrb_locale_from_utf8(utf8_path, -1);
     if (CHMOD(path, mode) == -1) {
       mrb_locale_free(path);
       mrb_sys_fail(mrb, utf8_path);
     }
     mrb_locale_free(path);
+    mrb_gc_arena_restore(mrb, ai);
   }
 
-  mrb_gc_arena_restore(mrb, ai);
   return mrb_fixnum_value(argc);
 }
 
@@ -473,7 +566,7 @@ mrb_init_file(mrb_state *mrb)
   io   = mrb_class_get(mrb, "IO");
   file = mrb_define_class(mrb, "File", io);
   MRB_SET_INSTANCE_TT(file, MRB_TT_DATA);
-  mrb_define_class_method(mrb, file, "umask",  mrb_file_s_umask, MRB_ARGS_REQ(1));
+  mrb_define_class_method(mrb, file, "umask",  mrb_file_s_umask, MRB_ARGS_OPT(1));
   mrb_define_class_method(mrb, file, "delete", mrb_file_s_unlink, MRB_ARGS_ANY());
   mrb_define_class_method(mrb, file, "unlink", mrb_file_s_unlink, MRB_ARGS_ANY());
   mrb_define_class_method(mrb, file, "rename", mrb_file_s_rename, MRB_ARGS_REQ(2));
@@ -489,6 +582,8 @@ mrb_init_file(mrb_state *mrb)
 
   mrb_define_method(mrb, file, "flock", mrb_file_flock, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, file, "mtime", mrb_file_mtime, MRB_ARGS_NONE());
+  mrb_define_method(mrb, file, "size", mrb_file_size, MRB_ARGS_NONE());
+  mrb_define_method(mrb, file, "truncate", mrb_file_truncate, MRB_ARGS_REQ(1));
 
   cnst = mrb_define_module_under(mrb, file, "Constants");
   mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH));

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/src/file_test.c

@@ -1,5 +1,5 @@
 /*
-** file.c - File class
+** file_test.c - FileTest class
 */
 
 #include "mruby.h"
@@ -7,12 +7,7 @@
 #include "mruby/data.h"
 #include "mruby/string.h"
 #include "mruby/ext/io.h"
-
-#if MRUBY_RELEASE_NO < 10000
-#include "error.h"
-#else
 #include "mruby/error.h"
-#endif
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -42,16 +37,9 @@ extern struct mrb_data_type mrb_io_type;
 static int
 mrb_stat0(mrb_state *mrb, mrb_value obj, struct stat *st, int do_lstat)
 {
-  mrb_value tmp;
-  mrb_value io_klass, str_klass;
-
-  io_klass  = mrb_obj_value(mrb_class_get(mrb, "IO"));
-  str_klass = mrb_obj_value(mrb_class_get(mrb, "String"));
-
-  tmp = mrb_funcall(mrb, obj, "is_a?", 1, io_klass);
-  if (mrb_test(tmp)) {
+  if (mrb_obj_is_kind_of(mrb, obj, mrb_class_get(mrb, "IO"))) {
     struct mrb_io *fptr;
-    fptr = (struct mrb_io *)mrb_get_datatype(mrb, obj, &mrb_io_type);
+    fptr = (struct mrb_io *)mrb_data_get_ptr(mrb, obj, &mrb_io_type);
 
     if (fptr && fptr->fd >= 0) {
       return fstat(fptr->fd, st);
@@ -60,10 +48,8 @@ mrb_stat0(mrb_state *mrb, mrb_value obj, struct stat *st, int do_lstat)
     mrb_raise(mrb, E_IO_ERROR, "closed stream");
     return -1;
   }
-
-  tmp = mrb_funcall(mrb, obj, "is_a?", 1, str_klass);
-  if (mrb_test(tmp)) {
-    char *path = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, obj), -1);
+  else {
+    char *path = mrb_locale_from_utf8(RSTRING_CSTR(mrb, obj), -1);
     int ret;
     if (do_lstat) {
       ret = LSTAT(path, st);
@@ -73,8 +59,6 @@ mrb_stat0(mrb_state *mrb, mrb_value obj, struct stat *st, int do_lstat)
     mrb_locale_free(path);
     return ret;
   }
-
-  return -1;
 }
 
 static int