v8eval 0.2.3 → 0.3.1

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.3'
+  s.version = '0.3.1'
   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.3
+  version: 0.3.1
 platform: ruby
 authors:
 - Prateek Papriwal
+- Yoshiyuki Mineo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-27 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
@@ -74,20 +69,11 @@ files:
 - ruby/Rakefile
 - ruby/build.sh
 - ruby/example/js_add.rb
-- ruby/ext/v8eval/Makefile
 - ruby/ext/v8eval/extconf.rb
-- ruby/ext/v8eval/v8eval.h
 - ruby/ext/v8eval/v8eval.i
-- ruby/ext/v8eval/v8eval_wrap.cxx
 - ruby/lib/setup/extension_builder.rb
 - ruby/lib/v8eval.rb
-- ruby/lib/v8eval/Makefile
-- ruby/lib/v8eval/extconf.rb
-- ruby/lib/v8eval/v8eval.h
-- ruby/lib/v8eval/v8eval_wrap.cxx
 - ruby/spec/v8eval_spec.rb
-- src/dbgsrv.cxx
-- src/dbgsrv.h
 - src/v8eval.cxx
 - src/v8eval.h
 - src/v8eval_go.cxx
@@ -117,11 +103,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+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: