v8eval 0.2.4 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5f734c4e621931bf36e036033f04fe51e02e692e
-  data.tar.gz: d56033a1844dda51e71f9b3294b2d6e7e2918ea1
+SHA256:
+  metadata.gz: 7a5dc6e83198eff2e218f3aa5b2f747cc7d96a41d7c181d7b2e64014faec6730
+  data.tar.gz: 3e41fc88040ec1638af5df47c8fcb191c8a0075d0fb184a3233650e6ee478343
 SHA512:
-  metadata.gz: acbf5043b09426f0eacbcd197210a12ea80f67c681aba71805dcff54dcab9385d9861097ff713cd221e6241a2f7525b1d3e13a60ad6afa86e8d15bbd25e5b998
-  data.tar.gz: b8db3d93434102b0afa999198a7640a83804fb73946b99f6026cb2800e50bf5df7e695651c23a327cd9191db2431491dfa52c83afc35bd5f1283023403a92e45
+  metadata.gz: 5f54f5361f29e213ed5ec563b6db662435c390d64687db3489bd8807f30a76a435885dc33d14e46cf8d25396939fd248bd611588a38e66fdb1235b24ef699b8d
+  data.tar.gz: 33266b6f1ee5ca2cd77285536f445e4bd0f9526f5a5d8ff096051bc0dffdf6c25325a32609dbe24621b4372bbaf806e11f6c8ed898c6da328d743ab30de194a2

data/CMakeLists.txt

@@ -11,33 +11,29 @@ endif(COMMAND cmake_policy)
 include_directories(
     v8
     v8/include
-    v8/third_party/icu/source/i18n
-    v8/third_party/icu/source/common
-    uv/include
     src
-    test/googletest/googletest/include
+    v8/third_party/googletest/src/googletest/include
 )
 
-if(APPLE)
-    link_directories(
-        v8/out/x64.release
-    )
-endif(APPLE)
+set(v8eval-linkdirs
+    v8/out.gn/x64.release/obj
+    v8/out.gn/x64.release/obj/third_party/googletest
+)
 
 if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    link_directories(
-        v8/out/x64.release/obj.target/src
-        v8/out/x64.release/obj.target/third_party/icu
+    set(v8eval-linkdirs
+        ${v8eval-linkdirs}
+        v8/out.gn/x64.release/obj/buildtools/third_party/libc++
+        v8/out.gn/x64.release/obj/buildtools/third_party/libc++abi
     )
 endif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
 
 link_directories(
-    uv/.libs/
+    ${v8eval-linkdirs}
 )
 
 add_library(v8eval STATIC
     src/v8eval.cxx
-    src/dbgsrv.cxx
 )
 
 add_library(v8eval_go STATIC
@@ -54,7 +50,6 @@ add_library(v8eval_ruby STATIC
 
 set(v8eval-cflags
     -Wall
-    -Wendif-labels
     -Werror
     -Wno-missing-field-initializers
     -Wno-unused-parameter
@@ -64,13 +59,28 @@ set(v8eval-cflags
     -fno-rtti
     -fno-strict-aliasing
     -fno-threadsafe-statics
-    -fstrict-aliasing
     -fvisibility=hidden
     -fvisibility-inlines-hidden
     -gdwarf-2
-    -std=c++11
+    -std=c++14
 )
 
+if(APPLE)
+    set(v8eval-cflags
+        ${v8eval-cflags}
+        -stdlib=libc++
+    )
+endif(APPLE)
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    set(v8eval-cflags
+        ${v8eval-cflags}
+        -nostdinc++
+        -isystem ${CMAKE_CURRENT_SOURCE_DIR}/v8/buildtools/third_party/libc++/trunk/include
+        -isystem ${CMAKE_CURRENT_SOURCE_DIR}/v8/buildtools/third_party/libc++abi/trunk/include
+    )
+endif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+
 string(REPLACE ";" " " v8eval-cflags "${v8eval-cflags}")
 
 set_target_properties(v8eval PROPERTIES

data/README.md

@@ -2,11 +2,11 @@
 
 [![PyPI version](https://badge.fury.io/py/v8eval.svg)](http://badge.fury.io/py/v8eval)
 [![Gem Version](https://badge.fury.io/rb/v8eval.svg)](https://badge.fury.io/rb/v8eval)
-[![GoDoc](https://godoc.org/github.com/sony/v8eval/go/v8eval?status.png)](http://godoc.org/github.com/sony/v8eval/go/v8eval)
+[![GoDoc](https://godoc.org/github.com/sony/v8eval/go/v8eval?status.svg)](http://godoc.org/github.com/sony/v8eval/go/v8eval)
 
 Multi-language bindings to JavaScript engine V8.
 
-Currently v8eval provides Go, Python and Ruby bindings to the latest V8 5.2 and supports Linux and Mac OS X.
+Currently v8eval provides Go, Python and Ruby bindings to the latest V8 7.1 and supports Linux and Mac OS X.
 v8eval uses SWIG and can be extended easily for other languages.
 
 ## Pre-installation
@@ -25,9 +25,17 @@ The installation takes several tens of minutes due to V8 build.
 
 #### Go
 
+v8eval requires Go 1.10 or later.
+
+```
+git clone https://github.com/sony/v8eval.git ${GOPATH}/src/github.com/sony/v8eval
+${GOPATH}/src/github.com/sony/v8eval/go/build.sh install
+```
+
+In the case of Linux, you need to build your Go program with `build.sh`:
+
 ```
-git clone https://github.com/sony/v8eval.git $GOPATH/src/github.com/sony/v8eval
-$GOPATH/src/github.com/sony/v8eval/go/build.sh install
+${GOPATH}/src/github.com/sony/v8eval/go/build.sh go build
 ```
 
 #### Python

data/build.sh

@@ -1,109 +1,123 @@
 #!/bin/sh
 
-V8EVAL_ROOT=`cd $(dirname $0) && pwd`
+V8EVAL_ROOT=`cd $(dirname ${0}) && pwd`
 
 PLATFORM=`uname`
-if [ $PLATFORM = "Linux" ] ; then
-  NUM_CPU_CORES=`cat /proc/cpuinfo | grep cores | grep -o '[0-9]\+' | awk '{total=total+$1}; END{print total}'`
-
-  export CC=$V8EVAL_ROOT/v8/third_party/llvm-build/Release+Asserts/bin/clang
-  export CXX=$V8EVAL_ROOT/v8/third_party/llvm-build/Release+Asserts/bin/clang++
-elif [ $PLATFORM = "Darwin" ]; then
-  NUM_CPU_CORES=`sysctl -n hw.ncpu`
-
-  export CC=`which clang`
-  export CXX=`which clang++`
-  export CPP="`which clang` -E"
-  export LINK="`which clang++`"
-  export CC_host=`which clang`
-  export CXX_host=`which clang++`
-  export CPP_host="`which clang` -E"
-  export LINK_host=`which clang++`
-  export GYP_DEFINES="clang=1 mac_deployment_target=10.10"
-else
+if [ ! ${PLATFORM} = "Linux" -a ! ${PLATFORM} = "Darwin" ]; then
   echo "unsupported platform: ${PLATFORM}"
   exit 1
 fi
 
-install_depot_tools() {
-  export PATH=$V8EVAL_ROOT/depot_tools:$PATH
-  if [ -d $V8EVAL_ROOT/depot_tools ]; then
-    return 0
-  fi
+export CC=${V8EVAL_ROOT}/v8/third_party/llvm-build/Release+Asserts/bin/clang
+export CXX=${V8EVAL_ROOT}/v8/third_party/llvm-build/Release+Asserts/bin/clang++
 
-  cd $V8EVAL_ROOT
-  git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
-}
+if [ ${PLATFORM} = "Linux" ]; then
+  export PATH=${V8EVAL_ROOT}/v8/third_party/binutils/Linux_x64/Release/bin:${PATH}
+fi
 
-install_googletest() {
-  if [ -d $V8EVAL_ROOT/test/googletest ]; then
+install_depot_tools() {
+  export PATH=${V8EVAL_ROOT}/depot_tools:${PATH}
+  if [ -d ${V8EVAL_ROOT}/depot_tools ]; then
     return 0
   fi
 
-  cd $V8EVAL_ROOT/test
-  git clone https://github.com/google/googletest.git
-  git checkout release-1.7.0
+  cd ${V8EVAL_ROOT}
+  git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
 }
 
 install_v8() {
-  if [ -d $V8EVAL_ROOT/v8 ]; then
+  if [ -d ${V8EVAL_ROOT}/v8 ]; then
     return 0
   fi
 
-  cd $V8EVAL_ROOT
+  cd ${V8EVAL_ROOT}
   fetch v8
   cd v8
-  git checkout 5.2.163
-  CFLAGS="-fPIC -Wno-unknown-warning-option" CXXFLAGS="-fPIC -Wno-unknown-warning-option" make x64.release -j$NUM_CPU_CORES V=1
+  git checkout 7.1.177
+  gclient sync
+  if [ ${PLATFORM} = "Linux" ]; then
+    ./build/install-build-deps.sh
+  fi
+  tools/dev/v8gen.py x64.release -- v8_use_snapshot=false v8_enable_i18n_support=false
+  ninja -v -C out.gn/x64.release
 }
 
-install_libuv() {
-  if [ -d $V8EVAL_ROOT/uv ]; then
+archive_lib() {
+  if [ -f ${1}/lib${2}.a ]; then
     return 0
   fi
 
-  cd $V8EVAL_ROOT
-  git clone https://github.com/libuv/libuv.git uv
-  cd uv
-  git checkout v1.7.5
-  sh autogen.sh
-  ./configure --with-pic --disable-shared
-  make V=1
+  if [ `echo ${2} | cut -c 1-3` = "lib" ]; then
+    ar cr ${1}/${2}.a ${1}/${2}/*.o
+  else
+    ar cr ${1}/lib${2}.a ${1}/${2}/*.o
+  fi
+}
+
+V8_OUT=${V8EVAL_ROOT}/v8/out.gn/x64.release/obj
+
+archive_v8() {
+  archive_lib ${V8_OUT} v8_base
+  archive_lib ${V8_OUT} v8_libsampler
+  archive_lib ${V8_OUT} v8_init
+  archive_lib ${V8_OUT} v8_initializers
+  archive_lib ${V8_OUT} v8_nosnapshot
+  archive_lib ${V8_OUT} torque_generated_initializers
+}
+
+archive_libcxx() {
+  archive_lib ${V8_OUT}/buildtools/third_party/libc++ libc++
+}
+
+archive_libcxxabi() {
+  archive_lib ${V8_OUT}/buildtools/third_party/libc++abi libc++abi
+}
+
+archive_googletest() {
+  archive_lib ${V8_OUT}/third_party/googletest gtest
+  archive_lib ${V8_OUT}/third_party/googletest gtest_main
 }
 
 build() {
   install_depot_tools
   install_v8
-  install_libuv
+  archive_v8
+  if [ ${PLATFORM} = "Linux" ]; then
+    archive_libcxx
+    archive_libcxxabi
+  fi
 
-  cd $V8EVAL_ROOT
+  cd ${V8EVAL_ROOT}
   mkdir -p build
   cd build
   cmake -DCMAKE_BUILD_TYPE=Release -DV8EVAL_TEST=OFF ..
   make VERBOSE=1
+
+  cd ${V8EVAL_ROOT}
+  rm -rf old_v8_tools_luci-go.git
 }
 
 docs() {
-  cd $V8EVAL_ROOT/docs
+  cd ${V8EVAL_ROOT}/docs
   rm -rf ./html
   doxygen
 }
 
 test() {
   build
-  install_googletest
+  archive_googletest
 
-  cd $V8EVAL_ROOT/build
+  cd ${V8EVAL_ROOT}/build
   cmake -DCMAKE_BUILD_TYPE=Release -DV8EVAL_TEST=ON ..
   make VERBOSE=1
   ./test/v8eval-test
 }
 
-# dispatch subcommand
-SUBCOMMAND="$1";
-case "${SUBCOMMAND}" in
-  ""       ) build ;;
-  "docs"   ) docs ;;
-  "test"   ) test ;;
-  *        ) echo "unknown subcommand: ${SUBCOMMAND}"; exit 1 ;;
+# dispatch subcommands
+SUBCOMMAND=${1}
+case ${SUBCOMMAND} in
+  ""     ) build ;;
+  "docs" ) docs ;;
+  "test" ) test ;;
+  *      ) echo "unknown subcommand: ${SUBCOMMAND}"; exit 1 ;;
 esac

data/ruby/Gemfile

@@ -2,5 +2,5 @@
 source 'https://rubygems.org'
 
 gem 'rspec', '~> 3.0'
-gem 'rake', '~> 10.4.2'
-gem 'yard', '~> 0.8.7.6'
+gem 'rake', '>= 12.3.3'
+gem 'yard', '>= 0.9.11'

data/ruby/build.sh

@@ -1,21 +1,21 @@
 #!/bin/sh
 
-V8EVAL_ROOT=`cd $(dirname $0)/.. && pwd`
+V8EVAL_ROOT=`cd $(dirname ${0})/.. && pwd`
 
 build() {
-  cd $V8EVAL_ROOT/ruby
+  cd ${V8EVAL_ROOT}/ruby
   rake prepare_build
   rake build_ext
 }
 
 install() {
-  cd $V8EVAL_ROOT
+  cd ${V8EVAL_ROOT}
   gem build v8eval.gemspec
   gem install v8eval-*.gem
 }
 
 docs() {
-  cd $V8EVAL_ROOT/ruby
+  cd ${V8EVAL_ROOT}/ruby
   rm -rf ./doc
   mkdir ./doc
   yardoc --main ../README.md lib/v8eval.rb
@@ -24,16 +24,16 @@ docs() {
 test() {
   build
 
-  gem install bundle
-  cd $V8EVAL_ROOT/ruby
+  gem install bundler -v 1.14.5
+  cd ${V8EVAL_ROOT}/ruby
   bundle install
 
-  rspec --init
-  rspec
+  bundle exec rspec --init
+  bundle exec rspec
 }
 
 # dispatch subcommand
-SUBCOMMAND="$1";
+SUBCOMMAND="${1}";
 case "${SUBCOMMAND}" in
   ""        ) build ;;
   "install" ) install ;;

data/ruby/ext/v8eval/extconf.rb

@@ -6,7 +6,6 @@ require_relative '../../lib/setup/extension_builder'
 # set path variables
 v8eval_root = File.expand_path('../../..', Dir.pwd)
 v8_dir = v8eval_root + '/v8'
-uv_dir = v8eval_root + '/uv'
 
 # make instance of BuildTool class
 tool = BuildTool.new(v8eval_root)
@@ -23,33 +22,45 @@ INCLUDEDIR  = RbConfig::CONFIG['includedir']
 header_dirs = [
   v8_dir,
   v8_dir + '/include',
-  uv_dir + '/include',
   INCLUDEDIR
 ]
 
 lib_dirs = [
   v8eval_root + '/build',
-  uv_dir + '/.libs',
+  v8_dir + '/out.gn/x64.release/obj',
   LIBDIR
 ]
 
-if RUBY_PLATFORM =~ /darwin/
+if RUBY_PLATFORM =~ /linux/
   lib_dirs += [
-    v8_dir + '/out/x64.release'
-  ]
-elsif RUBY_PLATFORM =~ /linux/
-  lib_dirs += [
-    v8_dir + '/out/x64.release/obj.target/src',
-    v8_dir + '/out/x64.release/obj.target/third_party/icu'
+    v8_dir + '/out.gn/x64.release/obj/buildtools/third_party/libc++',
+    v8_dir + '/out.gn/x64.release/obj/buildtools/third_party/libc++abi'
   ]
+end
 
+dir_config('', header_dirs, lib_dirs)
+
+if RUBY_PLATFORM =~ /linux/
   RbConfig::MAKEFILE_CONFIG['CC'] = v8_dir + '/third_party/llvm-build/Release+Asserts/bin/clang'
   RbConfig::MAKEFILE_CONFIG['CXX'] = v8_dir + '/third_party/llvm-build/Release+Asserts/bin/clang++'
 end
 
-dir_config('', header_dirs, lib_dirs)
+$LDFLAGS << ' -lv8eval' +
+  ' -lv8eval_ruby' +
+  ' -lv8_libplatform' +
+  ' -lv8_base' +
+  ' -lv8_libbase' +
+  ' -lv8_libsampler' +
+  ' -lv8_init' +
+  ' -lv8_initializers' +
+  ' -lv8_nosnapshot' +
+  ' -ltorque_generated_initializers'
+$CPPFLAGS << ' -O3 -std=c++14 -stdlib=libc++'
 
-$LDFLAGS << ' -lv8eval -lv8eval_ruby -lv8_libplatform -lv8_base -lv8_libbase -lv8_nosnapshot -licui18n -licuuc -licudata -luv'
-$CPPFLAGS << ' -g -O3 -std=c++11'
+if RUBY_PLATFORM =~ /linux/
+  $LDFLAGS << ' -lrt -lc++ -lc++abi'
+  $CPPFLAGS << ' -isystem' + v8_dir + '/buildtools/third_party/libc++/trunk/include' +
+               ' -isystem' + v8_dir + '/buildtools/third_party/libc++abi/trunk/include'
+end
 
 create_makefile('v8eval/v8eval')

data/ruby/lib/v8eval.rb

@@ -58,22 +58,6 @@ module V8Eval
         end
       end
     end
-
-    # Starts a debug server associated with the V8 instance.
-    # @param [Integer] port TCP/IP port the server will listen, at localhost.
-    # @return nil.
-    # @raise [TypeError] If port is not an int.
-    # @raise [V8Error] If failing to start the debug server.
-    def enable_debugger(port)
-      fail TypeError, 'port not integer' unless port.is_a?(Integer)
-      fail V8Error, 'failed to start debug server' unless @v8.enable_debugger(port)
-    end
-
-    # Stops the debug server, if running.
-    # @return nil.
-    def disable_debugger
-      @v8.disable_debugger
-    end
   end
 end
 

data/ruby/spec/v8eval_spec.rb

@@ -55,20 +55,3 @@ RSpec.describe V8Eval, '#multithreading' do
     end
   end
 end
-
-RSpec.describe V8Eval, '#test_debugger' do
-  context 'with debugging functionality' do
-    it 'should enable and disable debugger properly' do
-      v8 = V8Eval::V8.new
-      expect { v8.enable_debugger(0.1) }.to raise_exception(TypeError)
-      expect { v8.enable_debugger(-1) }.to raise_exception(V8Eval::V8Error)
-
-      port = 12_345
-      expect(v8.enable_debugger(port)).to be nil
-      expect { v8.enable_debugger(port) }.to raise_exception(V8Eval::V8Error)
-      expect(v8.disable_debugger).to be nil
-      expect(v8.enable_debugger(port)).to be nil
-      expect(v8.disable_debugger).to be nil
-    end
-  end
-end

data/src/v8eval.cxx

@@ -1,8 +1,8 @@
 #include "v8eval.h"
-#include "dbgsrv.h"
 
-#include <stdlib.h>
-#include <string.h>
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
 
 #include "libplatform/libplatform.h"
 
@@ -10,15 +10,15 @@ namespace v8eval {
 
 static v8::Platform* platform = nullptr;
 
+void set_flags(const std::string& flags) {
+  v8::V8::SetFlagsFromString(flags.c_str(), static_cast<int>(flags.length()));
+}
+
 bool initialize() {
   if (platform) {
     return false;
   }
 
-  if (!v8::V8::InitializeICU()) {
-    return false;
-  }
-
   platform = v8::platform::CreateDefaultPlatform();
   v8::V8::InitializePlatform(platform);
 
@@ -39,39 +39,12 @@ bool dispose() {
   return true;
 }
 
-class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
- public:
-  virtual void* Allocate(size_t length) {
-    void* data = AllocateUninitialized(length);
-    return data == NULL ? data : memset(data, 0, length);
-  }
-
-  virtual void* AllocateUninitialized(size_t length) {
-    return malloc(length);
-  }
-
-  virtual void Free(void* data, size_t) {
-    free(data);
-  }
-};
-
-static ArrayBufferAllocator allocator;
-
 _V8::_V8() {
   v8::Isolate::CreateParams create_params;
-  create_params.array_buffer_allocator = &allocator;
+  create_params.array_buffer_allocator =
+      v8::ArrayBuffer::Allocator::NewDefaultAllocator();
   isolate_ = v8::Isolate::New(create_params);
 
-  dbg_server_ = nullptr;
-  dbg_isolate_ = nullptr;
-  callback_ = nullptr;
-  callback_opq_ = nullptr;
-
-  // Use Isolate's local storage to store a pointer to the associated
-  // V8 instance. This is retrieved in the V8 debugger's callback, as
-  // the instance pointer is the only context we get from the caller.
-  isolate_->SetData(0, this);
-
   v8::Locker locker(isolate_);
 
   v8::Isolate::Scope isolate_scope(isolate_);
@@ -80,20 +53,20 @@ _V8::_V8() {
 }
 
 _V8::~_V8() {
-  if (dbg_server_) {
-    delete dbg_server_;
-  }
-
-  context_.Reset();
   isolate_->Dispose();
 }
 
-v8::Local<v8::Context> _V8::new_context() {
-  if (context_.IsEmpty()) {
+v8::Local<v8::Context> _V8::context() {
+  assert(context_.IsEmpty());
+  return v8::Local<v8::Context>::New(isolate_, context_);
+}
+
+v8::Local<v8::Context> _V8::new_context(v8::Local<v8::ObjectTemplate> global_tmpl, v8::Local<v8::Value> global_obj) {
+  if (global_tmpl.IsEmpty() && global_obj.IsEmpty()) {
     v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate_);
     return v8::Context::New(isolate_, nullptr, global);
   } else {
-    return v8::Local<v8::Context>::New(isolate_, context_);
+    return v8::Context::New(isolate_, nullptr, global_tmpl, global_obj);
   }
 }
 
@@ -101,14 +74,14 @@ v8::Local<v8::String> _V8::new_string(const char* str) {
   return v8::String::NewFromUtf8(isolate_, str ? str : "", v8::NewStringType::kNormal).ToLocalChecked();
 }
 
-static std::string to_std_string(v8::Local<v8::Value> value) {
-  v8::String::Utf8Value str(value);
+std::string _V8::to_std_string(v8::Local<v8::Value> value) {
+  v8::String::Utf8Value str(isolate_, value);
   return *str ? *str : "Error: Cannot convert to string";
 }
 
 v8::Local<v8::Value> _V8::json_parse(v8::Local<v8::Context> context, v8::Local<v8::String> str) {
   v8::Local<v8::Object> global = context->Global();
-  v8::Local<v8::Object> json = global->Get(context, new_string("JSON")).ToLocalChecked()->ToObject();
+  v8::Local<v8::Object> json = global->Get(context, new_string("JSON")).ToLocalChecked()->ToObject(isolate_);
   v8::Local<v8::Function> parse = v8::Local<v8::Function>::Cast(json->Get(context, new_string("parse")).ToLocalChecked());
 
   v8::Local<v8::Value> result;
@@ -122,14 +95,14 @@ v8::Local<v8::Value> _V8::json_parse(v8::Local<v8::Context> context, v8::Local<v
 
 v8::Local<v8::String> _V8::json_stringify(v8::Local<v8::Context> context, v8::Local<v8::Value> value) {
   v8::Local<v8::Object> global = context->Global();
-  v8::Local<v8::Object> json = global->Get(context, new_string("JSON")).ToLocalChecked()->ToObject();
+  v8::Local<v8::Object> json = global->Get(context, new_string("JSON")).ToLocalChecked()->ToObject(isolate_);
   v8::Local<v8::Function> stringify = v8::Local<v8::Function>::Cast(json->Get(context, new_string("stringify")).ToLocalChecked());
 
   v8::Local<v8::Value> result;
   if (!stringify->Call(context, json, 1, &value).ToLocal(&result)) {
     return new_string("");
   } else {
-    return result->ToString();
+    return result->ToString(isolate_);
   }
 }
 
@@ -139,7 +112,7 @@ std::string _V8::eval(const std::string& src) {
   v8::Isolate::Scope isolate_scope(isolate_);
   v8::HandleScope handle_scope(isolate_);
 
-  v8::Local<v8::Context> context = new_context();
+  v8::Local<v8::Context> context = this->context();
   v8::Context::Scope context_scope(context);
 
   v8::TryCatch try_catch(isolate_);
@@ -155,7 +128,12 @@ std::string _V8::eval(const std::string& src) {
   } else {
     v8::Local<v8::Value> result;
     if (!script->Run(context).ToLocal(&result)) {
-      return to_std_string(try_catch.Exception());
+      v8::Local<v8::Value> stack;
+      if (!try_catch.StackTrace(context).ToLocal(&stack)) {
+        return to_std_string(try_catch.Exception());
+      } else {
+        return to_std_string(stack);
+      }
     } else {
       return to_std_string(json_stringify(context, result));
     }
@@ -168,7 +146,7 @@ std::string _V8::call(const std::string& func, const std::string& args) {
   v8::Isolate::Scope isolate_scope(isolate_);
   v8::HandleScope handle_scope(isolate_);
 
-  v8::Local<v8::Context> context = new_context();
+  v8::Local<v8::Context> context = this->context();
   v8::Context::Scope context_scope(context);
 
   v8::TryCatch try_catch(isolate_);
@@ -196,93 +174,36 @@ std::string _V8::call(const std::string& func, const std::string& args) {
   }
 }
 
-bool _V8::enable_debugger(int port) {
-  if (dbg_server_) {
-    return false;
-  }
+void Heap(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
 
-  dbg_server_ = new DbgSrv(*this);
-  if (!dbg_server_->start(port)) {
-    delete dbg_server_;
-    dbg_server_ = nullptr;
-    return false;
-  }
-
-  return true;
-}
-
-void _V8::disable_debugger() {
-  if (dbg_server_) {
-    delete dbg_server_;
-    dbg_server_ = nullptr;
-  }
-}
+  v8::HeapStatistics s;
+  isolate->GetHeapStatistics(&s);
 
-void _V8::debugger_message_handler(const v8::Debug::Message& message) {
-  v8::Isolate* isolate = message.GetIsolate();
-  _V8 *_v8 = (v8eval::_V8*)isolate->GetData(0);
-  std::string string = *v8::String::Utf8Value(message.GetJSON());
+  v8::Local<v8::Object> obj = v8::Object::New(isolate);
+  obj->Set(v8::String::NewFromUtf8(isolate, "totalHeapSize"), v8::Number::New(isolate, s.total_heap_size()));
+  obj->Set(v8::String::NewFromUtf8(isolate, "totalHeapSizeExecutable"), v8::Number::New(isolate, s.total_heap_size_executable()));
+  obj->Set(v8::String::NewFromUtf8(isolate, "totalPhysicalSize"), v8::Number::New(isolate, s.total_physical_size()));
+  obj->Set(v8::String::NewFromUtf8(isolate, "totalAvailableSize"), v8::Number::New(isolate, s.total_available_size()));
+  obj->Set(v8::String::NewFromUtf8(isolate, "usedHeapSize"), v8::Number::New(isolate, s.used_heap_size()));
+  obj->Set(v8::String::NewFromUtf8(isolate, "heapSizeLimit"), v8::Number::New(isolate, s.heap_size_limit()));
+  obj->Set(v8::String::NewFromUtf8(isolate, "mallocedMemory"), v8::Number::New(isolate, s.malloced_memory()));
+  obj->Set(v8::String::NewFromUtf8(isolate, "peakMallocedMemory"), v8::Number::New(isolate, s.peak_malloced_memory()));
+  obj->Set(v8::String::NewFromUtf8(isolate, "doesZapGarbage"), v8::Number::New(isolate, s.does_zap_garbage()));
 
-  if (_v8->callback_) {
-    _v8->callback_(string, _v8->callback_opq_);
-  }
+  args.GetReturnValue().Set(obj);
 }
 
-bool _V8::debugger_init(debugger_cb cb, void *cbopq) {
-  v8::Isolate::CreateParams create_params;
-  create_params.array_buffer_allocator = &allocator;
-  dbg_isolate_ = v8::Isolate::New(create_params);
-
-  if (callback_) {
-    return false;
-  }
-
-  callback_ = cb;
-  callback_opq_ = cbopq;
-
-  // Set Debuger callback.
+void _V8::enable_heap_report() {
   v8::Locker locker(isolate_);
-  v8::Isolate::Scope isolate_scope(isolate_);
-  v8::HandleScope handle_scope(isolate_);
-  v8::Debug::SetMessageHandler(debugger_message_handler);
 
-  return true;
-}
-
-void _V8::debugger_process() {
-  // Process debug messages on behalf of the V8 instance.
-  v8::Locker locker(isolate_);
   v8::Isolate::Scope isolate_scope(isolate_);
   v8::HandleScope handle_scope(isolate_);
 
-  v8::Debug::ProcessDebugMessages();
-}
-
-bool _V8::debugger_send(const std::string& cmd) {
-  v8::Locker locker(dbg_isolate_);
-  v8::Isolate::Scope isolate_scope(dbg_isolate_);
-  v8::HandleScope handle_scope(dbg_isolate_);
-
-  if (!callback_) {
-    return false;
-  }
-
-  v8::Local<v8::String> vstr = v8::String::NewFromUtf8(dbg_isolate_, cmd.c_str(), v8::NewStringType::kNormal).ToLocalChecked();
-  v8::String::Value v(vstr);
-  v8::Debug::SendCommand(isolate_, *v, v.length());
-  return true;
-}
-
-void _V8::debugger_stop() {
-  v8::Locker locker(isolate_);
-  v8::Isolate::Scope isolate_scope(isolate_);
-  v8::HandleScope handle_scope(isolate_);
-  v8::Debug::SetMessageHandler(nullptr);
+  v8::Local<v8::Context> context = this->context();
+  v8::Context::Scope context_scope(context);
 
-  callback_ = nullptr;
-  callback_opq_ = nullptr;
-  dbg_isolate_->Dispose();
-  dbg_isolate_ = nullptr;
+  context->Global()->Set(new_string("heap"), v8::FunctionTemplate::New(isolate_, Heap)->GetFunction());
 }
 
 }  // namespace v8eval

data/src/v8eval.h

@@ -4,14 +4,14 @@
 #include <string>
 
 #include "v8.h"
-#include "v8-debug.h"
 
 /// \file
 namespace v8eval {
 
-class DbgSrv;
-
-typedef void (*debugger_cb)(std::string&, void *opq);
+/// \brief Set the given V8 flags
+///
+/// This method sets the given V8 flags.
+void set_flags(const std::string& flags);
 
 /// \brief Initialize the V8 runtime environment
 /// \return success or not as boolean
@@ -53,45 +53,21 @@ class _V8 {
   /// If some JavaScript exception happens in runtime, the exception message is returned.
   std::string call(const std::string& func, const std::string& args);
 
-  /// \brief Start a debug server associated with the V8 instance
-  /// \param port The TCP/IP port the debugger will listen, at localhost
-  /// \return success or not as boolean
-  ///
-  /// After the debugger is successfully started, it will be possible to
-  /// send commands and receive events at the specified port. When the
-  /// debugger is started, the Javascript's "debugger" statement will
-  /// cause the V8 instance to halt and wait for instructions through
-  /// the debugger port.
-  bool enable_debugger(int port);
-
-  /// \brief Stop the debug server, if running.
-  ///
-  /// The debug server, if currently running, will be stopped, causing
-  /// connections to remote debuggers to be dropped.
-  void disable_debugger();
+ protected:
+  void enable_heap_report();
 
- private:
-  static void debugger_message_handler(const v8::Debug::Message& message);
-  v8::Local<v8::Context> new_context();
+  v8::Local<v8::Context> context();
+  v8::Local<v8::Context> new_context(
+      v8::Local<v8::ObjectTemplate> global_tmpl = v8::Local<v8::ObjectTemplate>(),
+      v8::Local<v8::Value> global_obj = v8::Local<v8::Value>());
   v8::Local<v8::String> new_string(const char* str);
   v8::Local<v8::Value> json_parse(v8::Local<v8::Context> context, v8::Local<v8::String> str);
   v8::Local<v8::String> json_stringify(v8::Local<v8::Context> context, v8::Local<v8::Value> value);
-
-  bool debugger_init(debugger_cb cb, void *cbopq);
-  bool debugger_send(const std::string& cmd);
-  void debugger_process();
-  void debugger_stop();
+  std::string to_std_string(v8::Local<v8::Value> value);
 
  private:
   v8::Isolate* isolate_;
   v8::Persistent<v8::Context> context_;
-
-  DbgSrv* dbg_server_;
-  v8::Isolate* dbg_isolate_;
-  debugger_cb callback_;
-  void* callback_opq_;
-
-  friend class DbgSrv;
 };
 
 }  // namespace v8eval

data/src/v8eval_go.cxx

@@ -2,7 +2,9 @@
 
 namespace v8eval {
 
-_GoV8::_GoV8() {}
+_GoV8::_GoV8() {
+  enable_heap_report();
+}
 
 _GoV8::~_GoV8() {}
 

data/v8eval.gemspec

@@ -1,12 +1,12 @@
 Gem::Specification.new 'v8eval', '1.0' do |s|
   s.name = 'v8eval'
-  s.version = '0.2.4'
+  s.version = '0.3.2'
   s.licenses = ['MIT']
   s.description = 'Run JavaScript engine V8 in Ruby'
-  s.summary = 'v8eval gem is ruby binding to the latest V8 4.7 and supports
+  s.summary = 'v8eval gem is ruby binding to the latest V8 and supports
                Linux and Mac OS X.'
-  s.authors = ['Prateek Papriwal']
-  s.email = 'prateek.papriwal@jp.sony.com'
+  s.authors = ['Prateek Papriwal', 'Yoshiyuki Mineo']
+  s.email = 'Yoshiyuki.Mineo@sony.com'
   s.homepage = 'https://github.com/sony/v8eval'
   s.extra_rdoc_files = ['README.md']
 
@@ -17,9 +17,9 @@ Gem::Specification.new 'v8eval', '1.0' do |s|
   s.require_paths = ['ruby/lib', 'ruby/ext']
   s.extensions = Dir['ruby/ext/**/extconf.rb']
 
-  s.add_development_dependency 'rake', '~> 10.4', '>= 10.4.2'
+  s.add_development_dependency 'rake', '>= 12.3.3'
   s.add_development_dependency 'rspec', '~> 3.0'
-  s.add_development_dependency 'yard', '0.8.7.6'
+  s.add_development_dependency 'yard', '>= 0.9.11'
 
   s.required_ruby_version = '>= 2.0.0'
 end

metadata

@@ -1,35 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: v8eval
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.2
 platform: ruby
 authors:
 - Prateek Papriwal
+- Yoshiyuki Mineo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-29 00:00:00.000000000 Z
+date: 2020-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 10.4.2
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 10.4.2
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -48,18 +43,18 @@ dependencies:
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.7.6
+        version: 0.9.11
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.7.6
+        version: 0.9.11
 description: Run JavaScript engine V8 in Ruby
-email: prateek.papriwal@jp.sony.com
+email: Yoshiyuki.Mineo@sony.com
 executables: []
 extensions:
 - ruby/ext/v8eval/extconf.rb
@@ -79,8 +74,6 @@ files:
 - ruby/lib/setup/extension_builder.rb
 - ruby/lib/v8eval.rb
 - ruby/spec/v8eval_spec.rb
-- src/dbgsrv.cxx
-- src/dbgsrv.h
 - src/v8eval.cxx
 - src/v8eval.h
 - src/v8eval_go.cxx
@@ -110,11 +103,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
-summary: v8eval gem is ruby binding to the latest V8 4.7 and supports Linux and Mac
-  OS X.
+summary: v8eval gem is ruby binding to the latest V8 and supports Linux and Mac OS
+  X.
 test_files: []
-has_rdoc: 

data/src/dbgsrv.cxx

@@ -1,211 +0,0 @@
-#include "dbgsrv.h"
-#include "v8eval.h"
-
-namespace v8eval {
-
-//
-// DbgSrv
-//
-
-// container_of helper function
-//
-// libuv does not accept opaque values in its callbacks, so we have to
-// recover the instance of the debug server (and associated v8 vm)
-// through a C++ version of offsetof().
-template<class A, class B, class C>
-A* container_of(B* ptr, const C A::* member) {
-  size_t offset = (size_t) &(reinterpret_cast<A*>(0)->*member);
-  return (A*)((char *)ptr - offset);
-}
-
-DbgSrv::DbgSrv(_V8& v8) : v8_(v8) {
-  dbgsrv_port_ = 0;
-  uv_loop_init(&dbgsrv_loop_);
-
-  // Start up the Debugger Processing Loop
-  uv_loop_init(&dbgproc_loop_);
-  uv_async_init(&dbgproc_loop_, &dbgproc_proc_, dbgproc_do_proc);
-  uv_async_init(&dbgproc_loop_, &dbgproc_stop_, dbgproc_do_stop);
-  uv_thread_create(&dbgproc_thread_, dbgproc, this);
-
-  status_ = dbgsrv_offline;
-}
-
-DbgSrv::~DbgSrv() {
-  if (status_ != dbgsrv_offline) {
-    v8_.debugger_stop();
-    uv_async_send(&dbgsrv_stop_);
-    uv_thread_join(&dbgsrv_thread_);
-  }
-  uv_loop_close(&dbgsrv_loop_);
-
-  uv_async_send(&dbgproc_stop_);
-  uv_thread_join(&dbgproc_thread_);
-  uv_loop_close(&dbgproc_loop_);
-}
-
-static void end_write(uv_write_t *req, int status) {
-  if (status) {
-    fprintf(stderr, "write: %s\n", uv_strerror(status));
-  }
-  free(req);
-}
-
-void DbgSrv::dbgsrv_do_send(uv_async_t *async) {
-  DbgSrv *db = container_of(async, &DbgSrv::dbgsrv_send_);
-  uv_buf_t buf;
-  uv_write_t *wreq;
-
-  while (!db->msg_queue_.empty()) {
-    std::string& str = db->msg_queue_.back();
-
-    buf = uv_buf_init((char *)str.c_str(), (unsigned int)str.size());
-    wreq = (uv_write_t *)malloc(sizeof(*wreq));
-    uv_write(wreq, (uv_stream_t *)&db->dbgsrv_clnt_, &buf, 1, end_write);
-    db->msg_queue_.pop_back();
-  }
-}
-
-void DbgSrv::dbgsrv_do_clnt(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
-  DbgSrv *db = container_of(client, &DbgSrv::dbgsrv_clnt_);
-
-  if (nread == 0) return;
-
-  if (nread < 0) {
-    // Close the client
-    uv_close((uv_handle_t *)&db->dbgsrv_send_, NULL);
-    uv_close((uv_handle_t *)&db->dbgsrv_clnt_, NULL);
-    db->status_ = dbgsrv_started;
-    return;
-  }
-
-  const std::string string(buf->base, nread);
-  db->v8_.debugger_send(string);
-  free(buf->base);
-
-  uv_async_send(&db->dbgproc_proc_);
-}
-
-static void alloc_buffer(uv_handle_t *handle, size_t size, uv_buf_t *buf) {
-  buf->len = size;
-  buf->base = (char*) malloc(size);
-}
-
-void DbgSrv::dbgsrv_do_serv(uv_stream_t *server, int status) {
-  DbgSrv *db = container_of(server, &DbgSrv::dbgsrv_serv_);
-
-  if (status < 0) {
-    return;
-  }
-
-  // Connect with the client.
-  uv_tcp_init(&db->dbgsrv_loop_, &db->dbgsrv_clnt_);
-  if (uv_accept(server, (uv_stream_t *)&db->dbgsrv_clnt_)) {
-    uv_close((uv_handle_t *)&db->dbgsrv_clnt_, NULL);
-    return;
-  }
-
-  // Setup async R/W callbacks.
-  uv_async_init(&db->dbgsrv_loop_, &db->dbgsrv_send_, dbgsrv_do_send);
-  uv_read_start((uv_stream_t *)&db->dbgsrv_clnt_, alloc_buffer, dbgsrv_do_clnt);
-
-  db->status_ = dbgsrv_connected;
-}
-
-void DbgSrv::dbgsrv_do_stop(uv_async_t *async) {
-  DbgSrv *db = container_of(async, &DbgSrv::dbgsrv_stop_);
-
-  // Stop Server Loop
-  if (db->status_ == dbgsrv_connected) {
-    uv_close((uv_handle_t *)&db->dbgsrv_send_, NULL);
-    uv_close((uv_handle_t *)&db->dbgsrv_clnt_, NULL);
-    db->status_ = dbgsrv_started;
-  }
-  if (db->status_ == dbgsrv_started) {
-    uv_close((uv_handle_t *)&db->dbgsrv_serv_, NULL);
-    uv_close((uv_handle_t *)&db->dbgsrv_stop_, NULL);
-  }
-}
-
-void DbgSrv::dbgsrv(void *ptr) {
-  DbgSrv *db = (DbgSrv*)ptr;
-
-  uv_run(&db->dbgsrv_loop_, UV_RUN_DEFAULT);
-}
-
-void DbgSrv::dbgproc_do_stop(uv_async_t *async) {
-  DbgSrv *db = container_of(async, &DbgSrv::dbgproc_stop_);
-
-  uv_close((uv_handle_t *)&db->dbgproc_proc_, NULL);
-  uv_close((uv_handle_t *)&db->dbgproc_stop_, NULL);
-}
-
-void DbgSrv::dbgproc_do_proc(uv_async_t *async) {
-  DbgSrv *db = container_of(async, &DbgSrv::dbgproc_proc_);
-
-  db->v8_.debugger_process();
-}
-
-void DbgSrv::dbgproc(void *ptr) {
-  DbgSrv *db = (DbgSrv*)ptr;
-
-  uv_run(&db->dbgproc_loop_, UV_RUN_DEFAULT);
-}
-
-void DbgSrv::recv_from_debugger(std::string& string, void *opq) {
-  DbgSrv *db = (DbgSrv *)opq;
-
-  db->msg_queue_.push_front(string);
-  uv_async_send(&db->dbgsrv_send_);
-}
-
-bool DbgSrv::start(int port) {
-  struct sockaddr_in addr;
-
-  if (status_ != dbgsrv_offline) {
-    return false;
-  }
-
-  if (port != (uint16_t)port) {
-    return false;
-  }
-
-  // Set up the TCP Connection.
-  uv_tcp_init(&dbgsrv_loop_, &dbgsrv_serv_);
-  uv_ip4_addr("127.0.0.1", port, &addr);
-  if (uv_tcp_bind(&dbgsrv_serv_, (const struct sockaddr*)&addr, 0)) {
-    uv_close((uv_handle_t *)&dbgsrv_serv_, NULL);
-    perror("bind");
-    return false;
-  }
-
-  if (port == 0) {
-    int addrlen = sizeof(addr);
-    if (uv_tcp_getsockname(&dbgsrv_serv_, (struct sockaddr*)&addr, &addrlen)) {
-      uv_close((uv_handle_t *)&dbgsrv_serv_, NULL);
-      perror("getsockname");
-      return false;
-    }
-    dbgsrv_port_ = ntohs(addr.sin_port);
-  } else {
-    dbgsrv_port_ = port;
-  }
-
-  if (uv_listen((uv_stream_t *)&dbgsrv_serv_, 0, dbgsrv_do_serv)) {
-    uv_close((uv_handle_t *)&dbgsrv_serv_, NULL);
-    perror("listen");
-    return false;
-  }
-
-  // Start V8 debugger
-  v8_.debugger_init(recv_from_debugger, this);
-
-  // Start the Debug Server Loop
-  uv_async_init(&dbgsrv_loop_, &dbgsrv_stop_, dbgsrv_do_stop);
-  uv_thread_create(&dbgsrv_thread_, dbgsrv, this);
-
-  status_ = dbgsrv_started;
-  return true;
-}
-
-}  // namespace v8eval

data/src/dbgsrv.h

@@ -1,72 +0,0 @@
-#ifndef DBGSRV_H_
-#define DBGSRV_H_
-
-#include "uv.h"
-#include <string>
-#include <list>
-
-namespace v8eval {
-
-class _V8;
-
-/// \class DbgSrv
-///
-/// A debugger server is associated to a _V8 instance and accepts
-/// TCP/IP connections to exchange messages in the V8 debugger
-/// protocol.
-class DbgSrv {
- public:
-  DbgSrv(_V8& v8);
-  ~DbgSrv();
-
-  /// \brief Starts a debugger server
-  /// \param port TCP/IP port the server will listen
-  /// \return success or not as boolean
-  ///
-  /// The port can be set to 0 to have a port automatically assigned.
-  bool start(int port);
-
-  /// \brief Get the TCP/IP port the system is currently listening from
-  /// \return A TCP/IP port or 0 if not currently set.
-  inline int get_port() { return dbgsrv_port_; }
-
- private:
-  static void recv_from_debugger(std::string& string, void *opq);
-
-  static void dbgsrv_do_clnt(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf);
-  static void dbgsrv_do_send(uv_async_t *async);
-  static void dbgsrv_do_serv(uv_stream_t *server, int status);
-  static void dbgsrv_do_stop(uv_async_t *async);
-  static void dbgsrv(void *);
-
-  static void dbgproc_do_proc(uv_async_t *);
-  static void dbgproc_do_stop(uv_async_t *);
-  static void dbgproc(void *);
-
- private:
-  _V8& v8_;
-
-  enum {
-    dbgsrv_offline,
-    dbgsrv_started,
-    dbgsrv_connected
-  } status_;
-  std::list<std::string> msg_queue_;
-
-  int dbgsrv_port_;
-  uv_tcp_t dbgsrv_serv_;
-  uv_tcp_t dbgsrv_clnt_;
-  uv_async_t dbgsrv_send_;
-  uv_async_t dbgsrv_stop_;
-  uv_thread_t dbgsrv_thread_;
-  uv_loop_t dbgsrv_loop_;
-
-  uv_async_t dbgproc_proc_;
-  uv_async_t dbgproc_stop_;
-  uv_thread_t dbgproc_thread_;
-  uv_loop_t dbgproc_loop_;
-};
-
-}  // namespace v8eval
-
-#endif  // DBGSRV_H_