v8eval 0.2.4 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f734c4e621931bf36e036033f04fe51e02e692e
-  data.tar.gz: d56033a1844dda51e71f9b3294b2d6e7e2918ea1
+  metadata.gz: cd3a65a1288166c5c433ceb7981e7d01b7c0a2ff
+  data.tar.gz: 3b9aefd54850cc461f59aa07863b0122d18e5113
 SHA512:
-  metadata.gz: acbf5043b09426f0eacbcd197210a12ea80f67c681aba71805dcff54dcab9385d9861097ff713cd221e6241a2f7525b1d3e13a60ad6afa86e8d15bbd25e5b998
-  data.tar.gz: b8db3d93434102b0afa999198a7640a83804fb73946b99f6026cb2800e50bf5df7e695651c23a327cd9191db2431491dfa52c83afc35bd5f1283023403a92e45
+  metadata.gz: cbfb3232413f1a115d035e8a8149de25360167be6edd6b9546039a18821877eaffb90cd86219dda7063822868dd928212bc8e410ae69cab3d29f55ba2f0966ee
+  data.tar.gz: 4f84bbbe86f67b9ef29ff3b69a0725b2ecf178fc832a57f1b66c33e44cafe6b6fbafc614b487c4fd8989596e1fd92a5d2778defd5ee055cf8874e6d105215836

data/CMakeLists.txt

@@ -11,8 +11,6 @@ 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
@@ -27,7 +25,6 @@ endif(APPLE)
 if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     link_directories(
         v8/out/x64.release/obj.target/src
-        v8/out/x64.release/obj.target/third_party/icu
     )
 endif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
 

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 5.6 and supports Linux and Mac OS X.
 v8eval uses SWIG and can be extended easily for other languages.
 
 ## Pre-installation

data/build.sh

@@ -3,7 +3,7 @@
 V8EVAL_ROOT=`cd $(dirname $0) && pwd`
 
 PLATFORM=`uname`
-if [ $PLATFORM = "Linux" ] ; then
+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
@@ -50,11 +50,24 @@ install_v8() {
     return 0
   fi
 
+  PY_VER=`python -c 'import sys; print(sys.version_info[0])'`
+  if [ $PY_VER = 3 ]; then
+    OLD_PATH=$PATH
+    export PATH=$V8EVAL_ROOT/python/bin:$PATH
+  fi
+
   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 5.6.142
+  if [ $PY_VER = 3 ]; then
+    sed -i -e 's/python -c/python2 -c/' Makefile
+  fi
+  CFLAGS="-fPIC -Wno-unknown-warning-option" CXXFLAGS="-fPIC -Wno-unknown-warning-option" make x64.release -j$NUM_CPU_CORES i18nsupport=off V=1
+
+  if [ $PY_VER = 3 ]; then
+    export PATH=$OLD_PATH
+  fi
 }
 
 install_libuv() {

data/ruby/ext/v8eval/extconf.rb

@@ -39,8 +39,7 @@ if RUBY_PLATFORM =~ /darwin/
   ]
 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/x64.release/obj.target/src'
   ]
 
   RbConfig::MAKEFILE_CONFIG['CC'] = v8_dir + '/third_party/llvm-build/Release+Asserts/bin/clang'
@@ -49,7 +48,7 @@ end
 
 dir_config('', header_dirs, lib_dirs)
 
-$LDFLAGS << ' -lv8eval -lv8eval_ruby -lv8_libplatform -lv8_base -lv8_libbase -lv8_nosnapshot -licui18n -licuuc -licudata -luv'
+$LDFLAGS << ' -lv8eval -lv8eval_ruby -lv8_libplatform -lv8_base -lv8_libbase -lv8_libsampler -lv8_nosnapshot -luv'
 $CPPFLAGS << ' -g -O3 -std=c++11'
 
 create_makefile('v8eval/v8eval')

data/src/v8eval.cxx

@@ -1,8 +1,9 @@
 #include "v8eval.h"
 #include "dbgsrv.h"
 
-#include <stdlib.h>
-#include <string.h>
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
 
 #include "libplatform/libplatform.h"
 
@@ -10,15 +11,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);
 
@@ -88,12 +89,17 @@ _V8::~_V8() {
   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);
   }
 }
 
@@ -139,7 +145,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 +161,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 +179,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_);
@@ -244,7 +255,7 @@ bool _V8::debugger_init(debugger_cb cb, void *cbopq) {
   v8::Locker locker(isolate_);
   v8::Isolate::Scope isolate_scope(isolate_);
   v8::HandleScope handle_scope(isolate_);
-  v8::Debug::SetMessageHandler(debugger_message_handler);
+  v8::Debug::SetMessageHandler(isolate_, debugger_message_handler);
 
   return true;
 }
@@ -255,7 +266,7 @@ void _V8::debugger_process() {
   v8::Isolate::Scope isolate_scope(isolate_);
   v8::HandleScope handle_scope(isolate_);
 
-  v8::Debug::ProcessDebugMessages();
+  v8::Debug::ProcessDebugMessages(isolate_);
 }
 
 bool _V8::debugger_send(const std::string& cmd) {
@@ -277,7 +288,7 @@ void _V8::debugger_stop() {
   v8::Locker locker(isolate_);
   v8::Isolate::Scope isolate_scope(isolate_);
   v8::HandleScope handle_scope(isolate_);
-  v8::Debug::SetMessageHandler(nullptr);
+  v8::Debug::SetMessageHandler(isolate_, nullptr);
 
   callback_ = nullptr;
   callback_opq_ = nullptr;
@@ -285,4 +296,36 @@ void _V8::debugger_stop() {
   dbg_isolate_ = nullptr;
 }
 
+void Heap(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
+
+  v8::HeapStatistics s;
+  isolate->GetHeapStatistics(&s);
+
+  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()));
+
+  args.GetReturnValue().Set(obj);
+}
+
+void _V8::enable_heap_report() {
+  v8::Locker locker(isolate_);
+
+  v8::Isolate::Scope isolate_scope(isolate_);
+  v8::HandleScope handle_scope(isolate_);
+
+  v8::Local<v8::Context> context = this->context();
+  v8::Context::Scope context_scope(context);
+
+  context->Global()->Set(new_string("heap"), v8::FunctionTemplate::New(isolate_, Heap)->GetFunction());
+}
+
 }  // namespace v8eval

data/src/v8eval.h

@@ -13,6 +13,11 @@ 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
 ///
@@ -70,13 +75,20 @@ class _V8 {
   /// connections to remote debuggers to be dropped.
   void disable_debugger();
 
- private:
-  static void debugger_message_handler(const v8::Debug::Message& message);
-  v8::Local<v8::Context> new_context();
+ protected:
+  void enable_heap_report();
+
+  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);
 
+ private:
+  static void debugger_message_handler(const v8::Debug::Message& message);
+
   bool debugger_init(debugger_cb cb, void *cbopq);
   bool debugger_send(const std::string& cmd);
   void debugger_process();

data/src/v8eval_go.cxx

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

data/v8eval.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new 'v8eval', '1.0' do |s|
   s.name = 'v8eval'
-  s.version = '0.2.4'
+  s.version = '0.2.6'
   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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: v8eval
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.6
 platform: ruby
 authors:
 - Prateek Papriwal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-29 00:00:00.000000000 Z
+date: 2016-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -111,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: v8eval gem is ruby binding to the latest V8 4.7 and supports Linux and Mac