Merge lp:~marcustomlinson/v8-cpp/lp-1474858 into lp:v8-cpp

[Marcus Tomlinson]

Fixed require() to load modules relative to script path

=== modified file 'example/module.cpp'
--- example/module.cpp	2015-07-08 06:20:26 +0000
+++ example/module.cpp	2015-07-16 14:32:42 +0000
@@ -136,5 +136,5 @@
     exports->SetPrototype(module.create_prototype());
 }
 
-NODE_MODULE(addon, InitAll)
+///!NODE_MODULE(addon, InitAll)
 V8CPP_MODULE(addon, InitAll)
 
=== modified file 'src/internal/class.h'
--- src/internal/class.h	2015-06-23 08:40:22 +0000
+++ src/internal/class.h	2015-07-16 14:32:42 +0000
@@ -192,10 +192,10 @@
                 {
                     return args.GetReturnValue().Set(instance(isolate).export_object(args));
                 }
-                catch (std::exception const& ex)
+                catch (std::exception const& e)
                 {
                     auto exception =
-                        isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, ex.what())));
+                        isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, e.what())));
                     args.GetReturnValue().Set(exception);
                 }
             });
 
=== modified file 'src/internal/class_info.h'
--- src/internal/class_info.h	2015-07-02 09:52:54 +0000
+++ src/internal/class_info.h	2015-07-16 14:32:42 +0000
@@ -42,7 +42,7 @@
 
     using CastFunction = void* (*)(void*);
 
-    void add_base_class(ClassInfo* info, CastFunction cast)
+    inline void add_base_class(ClassInfo* info, CastFunction cast)
     {
         auto it = std::find_if(base_classes_.begin(), base_classes_.end(), [info](BaseClassInfo const& base_class)
                                {
@@ -55,7 +55,7 @@
         }
     }
 
-    bool cast(void*& ptr, size_t type) const
+    inline bool cast(void*& ptr, size_t type) const
     {
         // Type already matches
         if (type == type_)
@@ -111,7 +111,7 @@
     }
 
 protected:
-    static size_t register_class()
+    inline static size_t register_class()
     {
         static size_t next_index = 0;
         return next_index++;
 
=== modified file 'src/internal/function.h'
--- src/internal/function.h	2015-07-16 13:04:34 +0000
+++ src/internal/function.h	2015-07-16 14:32:42 +0000
@@ -102,9 +102,9 @@
     {
         forward_invoke<F>(args);
     }
-    catch (std::exception const& ex)
+    catch (std::exception const& e)
     {
-        auto exception = isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, ex.what())));
+        auto exception = isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, e.what())));
         args.GetReturnValue().Set(exception);
     }
 }
 
=== modified file 'src/internal/require.h'
--- src/internal/require.h	2015-07-16 08:05:48 +0000
+++ src/internal/require.h	2015-07-16 14:32:42 +0000
@@ -29,7 +29,6 @@
 
 using ModuleInitFunc = void(v8::Handle<v8::Object> exports);
 ///!ModuleInitFunc* node_init_func_;
-///!std::shared_ptr<std::string> v8cpp_script_path_;
 
 struct NodeModule
 {
@@ -62,27 +61,29 @@
 public:
     inline static void log(v8::FunctionCallbackInfo<v8::Value> const& args)
     {
+        v8::Isolate* isolate = args.GetIsolate();
+
         for (int i = 0; i < args.Length(); ++i)
         {
             if (args[i]->IsUint32())
             {
-                std::cout << v8cpp::from_v8<unsigned int>(v8::Isolate::GetCurrent(), args[i]);
+                std::cout << v8cpp::from_v8<unsigned int>(isolate, args[i]);
             }
             else if (args[i]->IsInt32())
             {
-                std::cout << v8cpp::from_v8<int>(v8::Isolate::GetCurrent(), args[i]);
+                std::cout << v8cpp::from_v8<int>(isolate, args[i]);
             }
             else if (args[i]->IsNumber())
             {
-                std::cout << v8cpp::from_v8<float>(v8::Isolate::GetCurrent(), args[i]);
+                std::cout << v8cpp::from_v8<float>(isolate, args[i]);
             }
             else if (args[i]->IsBoolean())
             {
-                std::cout << v8cpp::from_v8<bool>(v8::Isolate::GetCurrent(), args[i]);
+                std::cout << v8cpp::from_v8<bool>(isolate, args[i]);
             }
             else if (args[i]->IsString())
             {
-                std::cout << v8cpp::from_v8<std::string>(v8::Isolate::GetCurrent(), args[i]);
+                std::cout << v8cpp::from_v8<std::string>(isolate, args[i]);
             }
         }
         std::cout << std::endl;
@@ -90,50 +91,78 @@
     }
 };
 
-inline v8::Local<v8::Object> require(std::string const& module_path)
+class Require
 {
-    ///!node_init_func_ = nullptr;
-    std::string script_path; ///! = v8cpp_script_path_ ? *v8cpp_script_path_ : "";
+public:
+    explicit Require(std::string const& script_path)
+        : script_path_(script_path) {}
 
-    // Try append ".node" to module_path
-    std::string suffixed_module_path = script_path + module_path + ".node";
-    auto module = dlopen(suffixed_module_path.c_str(), RTLD_LAZY);
-    if (!module)
+    inline static void require(v8::FunctionCallbackInfo<v8::Value> const& args)
     {
-        // Didn't work, now try append ".so" to module_path
-        suffixed_module_path = script_path + module_path + ".so";
-        module = dlopen(suffixed_module_path.c_str(), RTLD_LAZY);
-        if (!module)
+        v8::Isolate* isolate = args.GetIsolate();
+        v8::EscapableHandleScope scope(isolate);
+
+        try
         {
-            // Still didn't work, just try module_path as is
-            suffixed_module_path = script_path + module_path;
-            module = dlopen(suffixed_module_path.c_str(), RTLD_LAZY);
+            Require* this_ = internal::import_value<Require*>(args.Data());
+
+            std::string module_path = from_v8<std::string>(isolate, args[0], "");
+            if (module_path.empty())
+            {
+                throw std::runtime_error("require() call missing string argument");
+            }
+
+            ///!node_init_func_ = nullptr;
+
+            // Try append ".node" to module_path
+            std::string suffixed_module_path = this_->script_path_ + module_path + ".node";
+            auto module = dlopen(suffixed_module_path.c_str(), RTLD_LAZY);
             if (!module)
             {
-                throw std::runtime_error("dlopen failed: " + std::string(dlerror()));
+                // Didn't work, now try append ".so" to module_path
+                suffixed_module_path = this_->script_path_ + module_path + ".so";
+                module = dlopen(suffixed_module_path.c_str(), RTLD_LAZY);
+                if (!module)
+                {
+                    // Still didn't work, just try module_path as is
+                    suffixed_module_path = this_->script_path_ + module_path;
+                    module = dlopen(suffixed_module_path.c_str(), RTLD_LAZY);
+                    if (!module)
+                    {
+                        throw std::runtime_error("dlopen failed: " + std::string(dlerror()));
+                    }
+                }
             }
+
+            v8::Local<v8::Object> exports = v8::Object::New(isolate);
+
+            ///!if (node_init_func_)
+            ///!{
+            ///!    node_init_func_(exports);
+            ///!}
+            ///!else
+            ///!{
+                auto v8cpp_init_func = (ModuleInitFunc*)dlsym(module, "init_module");
+                if (!v8cpp_init_func)
+                {
+                    throw std::runtime_error("dlsym failed: " + std::string(dlerror()));
+                }
+
+                v8cpp_init_func(exports);
+            ///!}
+
+            args.GetReturnValue().Set(scope.Escape(exports));
+        }
+        catch (std::exception const& e)
+        {
+            auto exception = isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, e.what())));
+            args.GetReturnValue().Set(scope.Escape(exception));
         }
     }
 
-    v8::Local<v8::Object> exports = v8::Object::New(v8::Isolate::GetCurrent());
-
-///!    if (node_init_func_)
-///!    {
-///!        node_init_func_(exports);
-///!    }
-///!    else
-///!    {
-        auto v8cpp_init_func = (ModuleInitFunc*)dlsym(module, "init_module");
-        if (!v8cpp_init_func)
-        {
-            throw std::runtime_error("dlsym failed: " + std::string(dlerror()));
-        }
-
-        v8cpp_init_func(exports);
-///!    }
-
-    return exports;
-}
+private:
+    std::string script_path_;
+};
 
 }  // namespace internal
 }  // namespace v8cpp
 
=== modified file 'src/module.h'
--- src/module.h	2015-06-18 12:32:56 +0000
+++ src/module.h	2015-07-16 14:32:42 +0000
@@ -53,12 +53,12 @@
     }
 
     // Create an instance of this module in V8
-    v8::Local<v8::Object> create_prototype()
+    inline v8::Local<v8::Object> create_prototype()
     {
         return object_template_->NewInstance();
     }
 
-    v8::Handle<v8::ObjectTemplate> object_template()
+    inline v8::Handle<v8::ObjectTemplate> object_template()
     {
         return object_template_;
     }
 
=== modified file 'src/run.h'
--- src/run.h	2015-07-15 13:18:16 +0000
+++ src/run.h	2015-07-16 14:32:42 +0000
@@ -45,8 +45,6 @@
         delete instances;
         isolate->SetData(0, nullptr);
         isolate->Dispose();
-
-        ///!internal::v8cpp_script_path_.reset();
     });
 
     // Create an isolate scope.
@@ -67,13 +65,17 @@
         v8::Context::Scope context_scope(v8::Context::New(isolate.get()));
 
         // Store the script filename for use in require() later
+        std::string script_path;
         std::size_t found = filename.find_last_of("/");
         if (found != std::string::npos)
         {
-            ///!internal::v8cpp_script_path_ = std::make_shared<std::string>(filename.substr(0, found) + "/");
+            script_path = filename.substr(0, found) + "/";
         }
 
-        module.add_function("require", &internal::require);
+        v8::Handle<v8::Value> require = internal::export_value(isolate.get(), new internal::Require(script_path));
+        module.object_template()->Set(isolate.get(), "require",
+                                      v8::FunctionTemplate::New(isolate.get(), internal::Require::require, require));
+
         module.add_class("console", console);
     }
     v8::Local<v8::Context> context = v8::Context::New(isolate.get(), nullptr, module.object_template());
@@ -82,7 +84,8 @@
     v8::Context::Scope context_scope(context);
 
     // Compile the script.
-    v8::Local<v8::Script> script = v8::Script::Compile(v8cpp::to_v8(isolate.get(), source), v8cpp::to_v8(isolate.get(), filename));
+    v8::Local<v8::Script> script = v8::Script::Compile(v8cpp::to_v8(isolate.get(), source),
+                                                       v8cpp::to_v8(isolate.get(), filename));
 
     // Run the script.
     if (script.IsEmpty())
 
=== modified file 'tests/errors/test.cpp'
--- tests/errors/test.cpp	2015-07-08 09:29:21 +0000
+++ tests/errors/test.cpp	2015-07-16 14:32:42 +0000
@@ -22,6 +22,26 @@
 
 #include <gtest/gtest.h>
 
+TEST(Test, empty_module_path)
+{
+    try
+    {
+        v8cpp::run_script("require()");
+    }
+    catch (std::exception const& e)
+    {
+        EXPECT_STREQ(e.what(), "Uncaught Error: require() call missing string argument");
+    }
+    try
+    {
+        v8cpp::run_script("require('')");
+    }
+    catch (std::exception const& e)
+    {
+        EXPECT_STREQ(e.what(), "Uncaught Error: require() call missing string argument");
+    }
+}
+
 TEST(Test, non_existent_module)
 {
     try
 
=== modified file 'tests/run/scripts/test.js'
--- tests/run/scripts/test.js	2015-07-15 13:18:16 +0000
+++ tests/run/scripts/test.js	2015-07-16 14:32:42 +0000
@@ -16,6 +16,6 @@
  * Authored by: Marcus Tomlinson <[e-mail]>
  */
 
-var module = require("./test-run-module"); ///! ../
+var module = require("../test-run-module");
 var test_object = new module.TestClass(1, 2);
 test_object;
 
=== modified file 'tests/run/scripts/test2.js'
--- tests/run/scripts/test2.js	2015-07-15 13:18:16 +0000
+++ tests/run/scripts/test2.js	2015-07-16 14:32:42 +0000
@@ -21,5 +21,5 @@
 console.log(true, " > ", false);
 console.log("hello", " ", "there");
 
-var module = require("./test-run-module"); ///! ../
+var module = require("../test-run-module");
 new module.TestClass(3, 4);