v8eval 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1b41852421cf3a98adc4bb3085e0167502f3ac7d
+  data.tar.gz: 87cc44407a717ac6df88cee14a139d57e98fefe6
+SHA512:
+  metadata.gz: 180f31e8c88ff8ef3368132c6a6fce6e1d732f46fc8d078d587d6b72c14b68e572914f13975a9e6ce94142eafdc750d5f39c46f72b6d4aca08b362aa50a83bad
+  data.tar.gz: 65a8814312d975007a0db7932d628622bcb946809324a8011c62b0cc0c930c0b4e4e2c34aca211da76fc094da8b4344f3f29db6b460d06eef5fb79922676a177

data/CMakeLists.txt

@@ -0,0 +1,64 @@
+cmake_minimum_required(VERSION 2.8)
+
+project(v8eval)
+
+option(V8EVAL_TEST "Build tests" OFF)
+
+if(COMMAND cmake_policy)
+    cmake_policy(SET CMP0015 NEW)
+endif(COMMAND cmake_policy)
+
+include_directories(
+    v8
+    v8/include
+    v8/third_party/icu/source/i18n
+    v8/third_party/icu/source/common
+    src
+    test/googletest/googletest/include
+)
+
+if(APPLE)
+    link_directories(
+        v8/out/x64.release
+    )
+endif(APPLE)
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    link_directories(
+        v8/out/x64.release/obj.target/tools/gyp
+        v8/out/x64.release/obj.target/third_party/icu
+    )
+endif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+
+add_library(v8eval STATIC
+   	src/v8eval.cxx
+)
+
+set(v8eval-cflags
+    -Wall
+    -Wendif-labels
+    -Werror
+    -Wno-missing-field-initializers
+    -Wno-unused-parameter
+    -Wshorten-64-to-32
+    -fPIC
+    -fno-exceptions
+    -fno-rtti
+    -fno-strict-aliasing
+    -fno-threadsafe-statics
+    -fstrict-aliasing
+    -fvisibility=hidden
+    -fvisibility-inlines-hidden
+    -gdwarf-2
+    -std=c++11
+)
+
+string(REPLACE ";" " " v8eval-cflags "${v8eval-cflags}")
+
+set_target_properties(v8eval PROPERTIES
+    COMPILE_FLAGS "${v8eval-cflags}"
+)
+
+if(V8EVAL_TEST)
+    add_subdirectory(test)
+endif(V8EVAL_TEST)

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright 2015 Sony Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+# v8eval
+
+[![Build Status](https://travis-ci.org/sony/v8eval.svg)](https://travis-ci.org/sony/v8eval)
+[![PyPI version](https://badge.fury.io/py/v8eval.svg)](http://badge.fury.io/py/v8eval)
+[![GoDoc](https://godoc.org/github.com/sony/v8eval/go/v8eval?status.png)](http://godoc.org/github.com/sony/v8eval/go/v8eval)
+[![Gem Version](https://badge.fury.io/rb/v8eval.svg)](https://badge.fury.io/rb/v8eval)
+
+Multi-language bindings to JavaScript engine V8.
+
+Currently v8eval provides Go, Python and Ruby bindings to the latest V8 4.7 and supports Linux and Mac OS X.
+v8eval uses SWIG and can be extended easily for other languages.
+
+## Pre-installation
+
+#### Linux
+
+See [Dockerfile](https://github.com/sony/v8eval/blob/master/Dockerfile).
+
+#### Mac
+
+See [.travis.yml](https://github.com/sony/v8eval/blob/master/.travis.yml).
+
+## Installation
+
+The installation takes several tens of minutes due to V8 build.
+
+#### Go
+
+```
+git clone https://github.com/sony/v8eval.git $GOPATH/src/github.com/sony/v8eval
+$GOPATH/src/github.com/sony/v8eval/go/build.sh install
+```
+
+#### Python
+
+```
+pip install v8eval
+```
+
+#### Ruby
+
+```
+gem install v8eval
+```
+
+
+## Documentation
+
+#### Go
+
+See [godoc.org](http://godoc.org/github.com/sony/v8eval/go/v8eval).
+
+#### Python
+
+You can create the Sphinx documentation under python/docs.
+
+```
+python/build.sh docs
+```
+#### Ruby
+
+You can create the YARD documentation under ruby/doc.
+
+```
+ruby/build.sh docs
+```
+
+
+## Examples
+
+#### Go
+
+```go
+import "github.com/sony/v8eval/go/v8eval"
+
+func Add(x, y int) int {
+    var v8 = v8eval.NewV8()
+    v8.Eval("var add = (x, y) => x + y;", nil)
+
+    var sum int;
+    v8.Call("add", []int{x, y}, &sum)
+    return sum
+}
+```
+
+#### Python
+
+```python
+import v8eval
+
+def add(x, y):
+    v8 = v8eval.V8()
+    v8.eval('var add = (x, y) => x + y;')
+    return v8.call('add', [x, y])
+```
+
+#### Ruby
+
+```ruby
+require 'v8eval'
+
+def add(x, y)
+  v8 = V8Eval::V8.new
+  v8.eval('function add(x, y) { return x + y; }')
+  v8.call('add', [x, y])
+end
+```
+
+
+
+## License
+
+The MIT License (MIT)
+
+See [LICENSE](https://github.com/sony/v8eval/blob/master/LICENSE) for details.

data/build.sh

@@ -0,0 +1,110 @@
+#!/bin/sh
+
+V8EVAL_ROOT=`cd $(dirname $0) && pwd`
+
+if [ `uname` = "Linux" ] ; then
+  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++
+fi
+
+if [ `uname` = "Darwin" ]; then
+  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"
+fi
+
+install_depot_tools() {
+  export PATH=$V8EVAL_ROOT/depot_tools:$PATH
+  if [ -d $V8EVAL_ROOT/depot_tools ]; then
+    return 0
+  fi
+
+  cd $V8EVAL_ROOT
+  git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
+}
+
+install_googletest() {
+  if [ -d $V8EVAL_ROOT/test/googletest ]; then
+    return 0
+  fi
+
+  cd $V8EVAL_ROOT/test
+  git clone https://github.com/google/googletest.git
+  git checkout release-1.7.0
+}
+
+install_v8() {
+  if [ -d $V8EVAL_ROOT/v8 ]; then
+    return 0
+  fi
+
+  cd $V8EVAL_ROOT
+  fetch v8
+  cd v8
+  git checkout 4.7.68
+  CFLAGS="-fPIC" CXXFLAGS="-fPIC" make x64.release V=1
+}
+
+build() {
+  install_depot_tools
+  install_v8
+
+  cd $V8EVAL_ROOT
+  mkdir -p build
+  cd build
+  cmake -DCMAKE_BUILD_TYPE=Release -DV8EVAL_TEST=OFF ..
+  make VERBOSE=1
+}
+
+build_go() {
+  $V8EVAL_ROOT/go/build.sh
+}
+
+build_python() {
+  $V8EVAL_ROOT/python/build.sh
+}
+
+build_ruby() {
+  $V8EVAL_ROOT/ruby/build.sh
+}
+
+docs() {
+  cd $V8EVAL_ROOT/docs
+  rm -rf ./html
+  doxygen
+
+  $V8EVAL_ROOT/python/build.sh docs
+}
+
+test() {
+  build
+  install_googletest
+
+  cd $V8EVAL_ROOT/build
+  cmake -DCMAKE_BUILD_TYPE=Release -DV8EVAL_TEST=ON ..
+  make VERBOSE=1
+  ./test/v8eval-test || exit 1
+
+  cd ..
+  ./go/build.sh test || exit 1
+  ./python/build.sh test || exit 1
+  ./ruby/build.sh test || exit 1
+}
+
+# dispatch subcommand
+SUBCOMMAND="$1";
+case "${SUBCOMMAND}" in
+  ""       ) build ;;
+  "go"     ) build_go ;;
+  "python" ) build_python ;;
+  "ruby"   ) build_ruby ;;
+  "docs"   ) docs ;;
+  "test"   ) test ;;
+  *        ) echo "unknown subcommand: ${SUBCOMMAND}"; exit 1 ;;
+esac

data/ruby/Gemfile

@@ -0,0 +1,6 @@
+# run `bundle install` on this file to install development dependencies.
+source "https://rubygems.org"
+
+gem 'rspec', '~> 3.0'
+gem 'rake', '~> 10.4.2'
+gem 'yard', '~> 0.8.7.6'

data/ruby/Rakefile

@@ -0,0 +1,28 @@
+# Rakefile
+require 'rake'
+require 'rake/clean'
+require_relative 'lib/setup/extension_builder'
+
+CLEAN.include('ext/**/*{.o,.log,.so,.bundle}')
+CLEAN.include('ext/**/Makefile')
+
+# set path variable
+v8eval_root = File.expand_path('..', Dir.pwd)
+
+# make instance of BuildTool class
+tool = BuildTool.new(v8eval_root)
+
+desc 'task to prepare for the build'
+task :prepare_build do
+  tool.run_swig
+end
+
+desc 'install v8 and build libv8eval.a'
+task :install_v8 do
+  tool.install_v8
+end
+
+desc 'build v8eval{.so,.dll,.bundle}'
+task :build_ext do
+  tool.build_ext
+end

data/ruby/build.sh

@@ -0,0 +1,43 @@
+#!/bin/sh
+
+V8EVAL_ROOT=`cd $(dirname $0)/.. && pwd`
+
+build() {
+	cd $V8EVAL_ROOT/ruby && rake prepare_build
+	cd $V8EVAL_ROOT && gem build v8eval.gemspec
+}
+
+
+install() {
+	cd $V8EVAL_ROOT
+	gem install v8eval-*.gem
+}
+
+docs() {
+	cd $V8EVAL_ROOT/ruby
+	rm -rf ./doc
+	mkdir ./doc
+	yardoc --main ../README.md lib/v8eval.rb
+}
+
+test() {
+	build
+
+	gem install bundle
+	cd $V8EVAL_ROOT/ruby
+	bundle install
+
+	rake install_v8 && rake build_ext
+	rspec
+}
+
+
+# dispatch subcommand
+SUBCOMMAND="$1";
+case "${SUBCOMMAND}" in
+  ""        ) build ;;
+  "install" ) install ;;
+  "docs"    ) docs ;;
+  "test"    ) test ;;
+  *         ) echo "unknown subcommand: ${SUBCOMMAND}"; exit 1 ;;
+esac

data/ruby/example/js_add.rb

@@ -0,0 +1,9 @@
+require 'v8eval'
+
+def add(x, y)
+  v8 = V8Eval::V8.new
+  v8.eval('function add(x, y) { return x + y; }')
+  v8.call('add', [x, y])
+end
+
+puts add(1, 2)

data/ruby/ext/v8eval/extconf.rb

@@ -0,0 +1,53 @@
+# extconf.rb
+require 'rbconfig'
+require 'mkmf'
+require_relative '../../lib/setup/extension_builder'
+
+# set path variables
+v8eval_root = File.expand_path('../../..', Dir.pwd)
+v8_dir = v8eval_root + '/v8'
+
+# make instance of BuildTool class
+tool = BuildTool.new(v8eval_root)
+
+# install v8 and build libv8eval.a
+tool.install_v8
+
+# generate v8eval_wrap.cxx
+tool.run_swig
+
+LIBDIR      = RbConfig::CONFIG['libdir']
+INCLUDEDIR  = RbConfig::CONFIG['includedir']
+
+HEADER_DIRS = [
+  v8_dir,
+  v8_dir + '/include',
+  INCLUDEDIR
+]
+
+LIB_DIRS = [
+  v8eval_root + '/build',
+  LIBDIR
+]
+if RUBY_PLATFORM =~ /darwin/
+  LIB_DIRS += [
+    v8_dir + '/out/x64.release'
+  ]
+elsif RUBY_PLATFORM =~ /linux/
+  LIB_DIRS += [
+    v8_dir + '/out/x64.release/obj.target/tools/gyp',
+    v8_dir + '/out/x64.release/obj.target/third_party/icu'
+  ]
+end
+
+dir_config('', HEADER_DIRS, LIB_DIRS)
+
+$LDFLAGS << ' -lv8eval -lv8_libplatform -lv8_base -lv8_libbase -lv8_nosnapshot -licui18n -licuuc -licudata'
+if RUBY_PLATFORM =~ /linux/
+  $LDFLAGS << ' -ldl -lpthread'
+  $CPPFLAGS << ' -g -O3 -std=c++11'
+elsif RUBY_PLATFORM =~ /darwin/
+  $CXXFLAGS << ' -g -O3 -std=c++11'
+end
+
+create_makefile('v8eval/v8eval')

data/ruby/lib/setup/extension_builder.rb

@@ -0,0 +1,30 @@
+# BuildTool is a util class that is used to do some build tasks
+class BuildTool
+  def initialize(path)
+    @v8eval_root = path
+    @rb_dir = @v8eval_root + '/ruby'
+    @rb_ext_dir = @rb_dir + '/ext'
+    @rb_ext_v8eval_dir = @rb_ext_dir + '/v8eval'
+  end
+
+  def install_v8
+    Dir.chdir @v8eval_root do
+      system('./build.sh')
+    end
+  end
+
+  def run_swig
+    system('cp ' + @v8eval_root + '/src/v8eval.h ' + @rb_ext_v8eval_dir)
+    system('swig -c++ -ruby -autorename -outdir ' + @rb_ext_v8eval_dir +
+      ' -o ' + @rb_ext_v8eval_dir + '/v8eval_wrap.cxx ' + @v8eval_root +
+      '/src/v8eval.i')
+  end
+
+  def build_ext
+    Dir.chdir @rb_ext_v8eval_dir do
+      system('ruby extconf.rb')
+      system('make')
+      system('make install')
+    end
+  end
+end

data/ruby/lib/v8eval.rb

@@ -0,0 +1,60 @@
+# require 'v8eval/v8eval' loads the V8eval module built by swig-generated extension
+require 'v8eval/v8eval'
+
+require 'json'
+
+module V8Eval
+  # Represents a V8 instance.
+  class V8
+    def initialize
+      @v8 = V8eval::V8.new
+    end
+
+    # Evaluates JavaScript code.
+    # @param [String] src JavaScript code.
+    # @return
+    #   The result of the JavaScript code. The result is marshalled/unmarshalled by using JSON.
+    # @raise [TypeError] If src is not a string.
+    # @raise [RuntimeError] If some JavaScript exception happens.
+    def eval(src)
+      fail TypeError unless src.is_a?(String)
+      res = @v8.eval(src)
+      if res == 'undefined'
+        return nil
+      else
+        begin
+          return JSON.load(res)
+        rescue StandardError => e
+          raise e.message
+        end
+      end
+    end
+
+    # Calls a JavaScript function.
+    # @param [String] func Name of a JavaScript function.
+    # @param [Array] args Argument list to pass.
+    # @return
+    #   The result of the JavaScript code. The result is marshalled/unmarshalled by using JSON.
+    # @raise [TypeError] If either func is not a string or args is not a array.
+    # @raise [RuntimeError] If some JavaScript exception happens.
+    def call(func, args)
+      fail TypeError unless func.is_a?(String)
+      fail TypeError unless args.is_a?(Array)
+
+      args_str = JSON.dump(args)
+      res = @v8.call(func, args_str)
+      if res == 'undefined'
+        return nil
+      else
+        begin
+          return JSON.load(res)
+        rescue StandardError => e
+          raise e.message
+        end
+      end
+    end
+  end
+end
+
+# initialize the V8 runtime environment
+V8eval.initialize

data/ruby/spec/spec_helper.rb

@@ -0,0 +1,96 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/ruby/spec/v8eval_spec.rb

@@ -0,0 +1,58 @@
+require 'v8eval'
+
+RSpec.describe V8Eval, '#eval' do
+  context 'with vaild source code' do
+    it 'should evaluate the source code' do
+      v8 = V8Eval::V8.new
+      expect(v8.eval('1+2')).to eq 3
+      expect(v8.eval('var p = { x: 1.1, y: 2.2 }; p')).to eq('x' => 1.1,
+                                                             'y' => 2.2)
+      expect(v8.eval('')).to eq nil
+
+      expect { v8.eval(nil) }.to raise_exception(TypeError)
+      expect { v8.eval('foo') }.to raise_exception(RuntimeError)
+    end
+  end
+end
+
+RSpec.describe V8Eval, '#call' do
+  context 'with valid function and arguments' do
+    it 'should evaluate the given function' do
+      v8 = V8Eval::V8.new
+      v8.eval('function inc(x) { return x + 1; }')
+      expect(v8.call('inc', [7])).to eq 8
+
+      expect { v8.call(nil, [7]) }.to raise_exception(TypeError)
+      expect { v8.call('inc', nil) }.to raise_exception(TypeError)
+      expect { v8.call('i', [7]) }.to raise_exception(RuntimeError)
+    end
+  end
+end
+
+RSpec.describe V8Eval, '#multithreading' do
+  context 'with multithread execution' do
+    it 'should execute concurrently' do
+      def v8_thread(num)
+        num_repeat = num
+        v8 = V8Eval::V8.new
+        counter = 0
+        thread = Thread.new do
+          v8.eval('function inc(x) { return x + 1; }')
+          num_repeat.times do
+            counter = v8.call('inc', [counter])
+          end
+          expect(counter).to eq(num_repeat)
+        end
+        thread
+      end
+
+      num_repeat = 10_000
+
+      thread1 = v8_thread(num_repeat)
+      thread2 = v8_thread(num_repeat)
+
+      thread1.join
+      thread2.join
+    end
+  end
+end

data/src/v8eval.cxx

@@ -0,0 +1,185 @@
+#include "v8eval.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "libplatform/libplatform.h"
+
+namespace v8eval {
+
+static v8::Platform* platform = nullptr;
+
+bool initialize() {
+  if (platform) {
+    return false;
+  }
+
+  if (!v8::V8::InitializeICU()) {
+    return false;
+  }
+
+  platform = v8::platform::CreateDefaultPlatform();
+  v8::V8::InitializePlatform(platform);
+
+  return v8::V8::Initialize();
+}
+
+bool dispose() {
+  if (!platform) {
+    return false;
+  }
+
+  v8::V8::Dispose();
+
+  v8::V8::ShutdownPlatform();
+  delete platform;
+  platform = nullptr;
+
+  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;
+  isolate_ = v8::Isolate::New(create_params);
+
+  v8::Locker locker(isolate_);
+
+  v8::Isolate::Scope isolate_scope(isolate_);
+  v8::HandleScope handle_scope(isolate_);
+  context_.Reset(isolate_, new_context());
+}
+
+_V8::~_V8() {
+  context_.Reset();
+
+  isolate_->Dispose();
+}
+
+v8::Local<v8::Context> _V8::new_context() {
+  if (context_.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_);
+  }
+}
+
+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);
+  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::Function> parse = v8::Local<v8::Function>::Cast(json->Get(context, new_string("parse")).ToLocalChecked());
+
+  v8::Local<v8::Value> result;
+  v8::Local<v8::Value> value = str;
+  if (!parse->Call(context, json, 1, &value).ToLocal(&result)) {
+    return v8::Local<v8::Value>();  // empty
+  } else {
+    return result;
+  }
+}
+
+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::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();
+  }
+}
+
+std::string _V8::eval(const std::string& src) {
+  v8::Locker locker(isolate_);
+
+  v8::Isolate::Scope isolate_scope(isolate_);
+  v8::HandleScope handle_scope(isolate_);
+
+  v8::Local<v8::Context> context = new_context();
+  v8::Context::Scope context_scope(context);
+
+  v8::TryCatch try_catch(isolate_);
+
+  v8::Local<v8::String> source = new_string(src.c_str());
+
+  v8::Local<v8::String> name = new_string("v8eval");
+  v8::ScriptOrigin origin(name);
+
+  v8::Local<v8::Script> script;
+  if (!v8::Script::Compile(context, source, &origin).ToLocal(&script)) {
+    return to_std_string(try_catch.Exception());
+  } else {
+    v8::Local<v8::Value> result;
+    if (!script->Run(context).ToLocal(&result)) {
+      return to_std_string(try_catch.Exception());
+    } else {
+      return to_std_string(json_stringify(context, result));
+    }
+  }
+}
+
+std::string _V8::call(const std::string& func, const std::string& args) {
+  v8::Locker locker(isolate_);
+
+  v8::Isolate::Scope isolate_scope(isolate_);
+  v8::HandleScope handle_scope(isolate_);
+
+  v8::Local<v8::Context> context = new_context();
+  v8::Context::Scope context_scope(context);
+
+  v8::TryCatch try_catch(isolate_);
+
+  v8::Local<v8::Object> global = context->Global();
+  v8::Local<v8::Value> result;
+  if (!global->Get(context, new_string(func.c_str())).ToLocal(&result)) {
+    return to_std_string(try_catch.Exception());
+  } else if (!result->IsFunction()) {
+    return "TypeError: '" + func + "' is not a function";
+  }
+
+  v8::Local<v8::Function> function = v8::Handle<v8::Function>::Cast(result);
+  v8::Local<v8::Function> apply = v8::Handle<v8::Function>::Cast(function->Get(context, new_string("apply")).ToLocalChecked());
+  v8::Local<v8::Value> arguments = json_parse(context, new_string(args.c_str()));
+  if (arguments.IsEmpty() || !arguments->IsArray()) {
+    return "TypeError: '" + args + "' is not an array";
+  }
+
+  v8::Local<v8::Value> values[] = { function, arguments };
+  if (!apply->Call(context, function, 2, values).ToLocal(&result)) {
+    return to_std_string(try_catch.Exception());
+  } else {
+    return to_std_string(json_stringify(context, result));
+  }
+}
+
+}  // namespace v8eval

data/src/v8eval.h

@@ -0,0 +1,64 @@
+#ifndef V8EVAL_H_
+#define V8EVAL_H_
+
+#include <string>
+
+#include "v8.h"
+
+/// \file
+namespace v8eval {
+
+/// \brief Initialize the V8 runtime environment
+/// \return success or not as boolean
+///
+/// This method initializes the V8 runtime environment. It must be called before creating any V8 instance.
+bool initialize();
+
+/// \brief Dispose the V8 runtime environment
+/// \return success or not as boolean
+///
+/// This method disposes the V8 runtime environment.
+bool dispose();
+
+/// \class _V8
+///
+/// _V8 instances can be used in multiple threads.
+/// But each _V8 instance can be used in only one thread at a time.
+class _V8 {
+ public:
+  _V8();
+  virtual ~_V8();
+
+  /// \brief Evaluate JavaScript code
+  /// \param src JavaScript code
+  /// \return JSON-encoded result or exception message
+  ///
+  /// This method evaluates the given JavaScript code 'src' and returns the result in JSON.
+  /// If some JavaScript exception happens in runtime, the exception message is returned.
+  std::string eval(const std::string& src);
+
+  /// \brief Call a JavaScript function
+  /// \param func Name of a JavaScript function
+  /// \param args JSON-encoded argument array
+  /// \return JSON-encoded result or exception message
+  ///
+  /// This method calls the JavaScript function specified by 'func'
+  /// with the JSON-encoded argument array 'args'
+  /// and returns the result in JSON.
+  /// If some JavaScript exception happens in runtime, the exception message is returned.
+  std::string call(const std::string& func, const std::string& args);
+
+ private:
+  v8::Local<v8::Context> new_context();
+  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:
+  v8::Isolate* isolate_;
+  v8::Persistent<v8::Context> context_;
+};
+
+}  // namespace v8eval
+
+#endif  // V8EVAL_H_

data/src/v8eval.i

@@ -0,0 +1,9 @@
+%module v8eval
+%include "std_string.i"
+
+%{
+#define SWIG_FILE_WITH_INIT
+#include "v8eval.h"
+%}
+
+%include "v8eval.h"

data/v8eval.gemspec

@@ -0,0 +1,26 @@
+
+
+Gem::Specification.new 'v8eval', '1.0' do |s|
+  s.name = 'v8eval'
+  s.version = '0.1.3'
+  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 Linux and Mac OS X.'
+  s.authors = ['Prateek Papriwal']
+  s.email = 'papriwalprateek@gmail.com'
+  s.homepage = 'https://github.com/sony/v8eval'
+  s.extra_rdoc_files = ['README.md']
+
+  s.files = Dir['ruby/**/*'] + Dir['src/**/*'] + Dir['build.sh']
+  s.files += Dir['LICENSE'] + Dir['README.md'] + Dir['CMakeLists.txt'] + Dir['v8eval.gemspec']
+  s.platform = Gem::Platform::RUBY
+  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 'rspec', '~> 3.0'
+  s.add_development_dependency 'yard', '0.8.7.6'
+
+  s.required_ruby_version = '>= 2.0.0'
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: v8eval
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Prateek Papriwal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-14 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
+  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
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+description: Run JavaScript engine V8 in Ruby
+email: papriwalprateek@gmail.com
+executables: []
+extensions:
+- ruby/ext/v8eval/extconf.rb
+extra_rdoc_files:
+- README.md
+files:
+- CMakeLists.txt
+- LICENSE
+- README.md
+- build.sh
+- ruby/Gemfile
+- ruby/Rakefile
+- ruby/build.sh
+- ruby/example/js_add.rb
+- ruby/ext/v8eval/extconf.rb
+- ruby/lib/setup/extension_builder.rb
+- ruby/lib/v8eval.rb
+- ruby/spec/spec_helper.rb
+- ruby/spec/v8eval_spec.rb
+- src/v8eval.cxx
+- src/v8eval.h
+- src/v8eval.i
+- v8eval.gemspec
+homepage: https://github.com/sony/v8eval
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- ruby/lib
+- ruby/ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: v8eval gem is ruby binding to the latest V8 4.7 and supports Linux and Mac
+  OS X.
+test_files: []
+has_rdoc: