Merge pull request #2 from lib-ruby-parser/use-new-bytes-api

use new bytes api

Author: iliabylich

Makefile

@@ -6,7 +6,7 @@ ifeq ($(UNAME_S),Darwin)
 	PLATFORM = darwin-x86_64
 endif
 
-VERSION = 3.0.0-3.2
+VERSION = 3.0.0-3.3
 
 ifndef BUILD_ENV
 	BUILD_ENV = debug

bytes.h

@@ -0,0 +1,54 @@
+#ifndef LIB_RUBY_PARSER_NODE_BYTES_H
+#define LIB_RUBY_PARSER_NODE_BYTES_H
+
+#include <napi.h>
+#include <variant>
+#include "lib-ruby-parser.h"
+#include "result.h"
+
+namespace lib_ruby_parser_node
+{
+    class Bytes : public lib_ruby_parser::Bytes
+    {
+    public:
+        explicit Bytes(lib_ruby_parser::Bytes bytes)
+        {
+            lib_ruby_parser::Bytes(bytes.into_ptr());
+        }
+
+        Napi::Value to_v8_value(Napi::Env env) const
+        {
+            Napi::TypedArray array = Napi::Uint8Array::New(env, this->size());
+            for (size_t i = 0; i < this->size(); i++)
+            {
+                array.Set(i, this->at(i));
+            }
+            return array;
+        }
+
+        static Result<lib_ruby_parser::Bytes> FromV8(Napi::Value array)
+        {
+            if (!array.IsTypedArray())
+            {
+                return "must be a typed array";
+            }
+
+            auto typed_array = array.As<Napi::TypedArray>();
+            if (typed_array.TypedArrayType() != napi_uint8_array)
+            {
+                return "must be a typed array";
+            }
+
+            auto unit8_array = array.As<Napi::Uint8Array>();
+
+            auto size = unit8_array.ElementLength();
+            auto ptr = (char *)malloc(size * sizeof(char));
+            memcpy(ptr, unit8_array.Data(), size);
+            auto bytes = lib_ruby_parser::Bytes(ptr, size);
+
+            return std::move(bytes);
+        }
+    };
+} // namespace lib_ruby_parser_node
+
+#endif // LIB_RUBY_PARSER_NODE_BYTES_H

convert.h

@@ -239,10 +239,10 @@ namespace lib_ruby_parser_node
 
     Napi::Value convert(lib_ruby_parser::Bytes bytes, Napi::Env env)
     {
-        Napi::Array array = Napi::Array::New(env, bytes.size());
+        Napi::TypedArray array = Napi::Uint8Array::New(env, bytes.size());
         for (size_t i = 0; i < bytes.size(); i++)
         {
-            array.Set(i, Napi::Number::New(env, bytes.at(i)));
+            array.Set(i, bytes.at(i));
         }
         return array;
     }

custom_decoder.h

@@ -3,26 +3,22 @@
 
 #include <napi.h>
 #include "lib-ruby-parser.h"
+#include "bytes.h"
+#include <iostream>
 
 namespace lib_ruby_parser_node
 {
 
     class JsCustomDecoder : public lib_ruby_parser::CustomDecoder
     {
     public:
-        struct DecodeError
-        {
-            bool has_error;
-            std::string error;
-        };
-
         Napi::FunctionReference callback;
-        std::shared_ptr<DecodeError> error;
+        std::shared_ptr<std::string> error;
 
-        JsCustomDecoder(const Napi::Function &callback, std::shared_ptr<DecodeError> error)
+        JsCustomDecoder(const Napi::Function &callback)
         {
             this->callback = Napi::Persistent(callback);
-            this->error = error;
+            this->error = std::shared_ptr<std::string>(nullptr);
         }
 
         Napi::Env env()
@@ -32,54 +28,33 @@ namespace lib_ruby_parser_node
 
         virtual Result rewrite(std::string encoding, lib_ruby_parser::Bytes input)
         {
-            Napi::Value raw_response = callback.Call({
+            Napi::Value response = this->callback.Call({
                 Napi::String::New(env(), encoding),
                 convert(std::move(input), env()),
             });
-            if (!raw_response.IsObject())
-                return JsError("response must be an object");
-
-            Napi::Object response = raw_response.As<Napi::Object>();
-
-            Napi::Value success = response.Get("success");
-            if (!success.IsBoolean())
-                return JsError("'success' field must be true/false");
 
-            if (success.ToBoolean().Value())
+            if (response.IsString())
             {
-                // success, consume 'output' field
-                if (!response.Get("output").IsArray())
-                    return JsError("'output' field must be an array");
-
-                Napi::Array output = response.Get("output").As<Napi::Array>();
-                auto ptr = (char *)malloc(output.Length());
-                for (size_t i = 0; i < output.Length(); i++)
-                {
-                    Napi::Value byte = output[i];
-                    if (!byte.IsNumber())
-                    {
-                        return JsError("'output' field contains invalid byte");
-                    }
-                    ptr[i] = byte.ToNumber().Int32Value();
-                }
-                return Result::Ok(lib_ruby_parser::Bytes(ptr, output.Length()));
+                // error
+                Napi::String js_error = Napi::String::New(env(), response.ToString().Utf8Value());
+                return JsError(js_error);
             }
-            else
+            // success
+            auto bytes_result = Bytes::FromV8(response);
+            if (bytes_result.is_err())
             {
-                // error, consume 'error' field
-                if (!response.Get("error").IsString())
-                    return JsError("'error' field must be a string");
-
-                Napi::String error = Napi::String::New(env(), response.Get("error").ToString().Utf8Value());
-                return Result::Error(error);
+                return JsError("custom decoder output: " + bytes_result.get_err());
             }
+
+            auto bytes = bytes_result.get();
+            return Result::Ok(std::move(bytes));
         }
         virtual ~JsCustomDecoder() {}
 
         Result JsError(std::string message)
         {
-            this->error->has_error = true;
-            this->error->error = "custom_rewriter: " + message;
+            auto new_error = new std::string("custom_rewriter: " + message);
+            this->error.reset(new_error);
             return Result::Error(message);
         }
     };

node_bindings.cc

@@ -2,97 +2,110 @@
 #include "lib-ruby-parser.h"
 #include "convert.h"
 #include "custom_decoder.h"
+#include "bytes.h"
+#include "result.h"
 #include <iostream>
 #include <variant>
 #include <tuple>
 
 namespace lib_ruby_parser_node
 {
-    Napi::Value JsThrow(Napi::Env env, std::string message)
+    Napi::Value JsThrow(Napi::Env env, const std::string &message)
     {
         Napi::TypeError::New(env, message).ThrowAsJavaScriptException();
         return env.Null();
     }
 
-    using SharedDecodeError = std::shared_ptr<JsCustomDecoder::DecodeError>;
-    using BuildParserOptionsSuccess = std::tuple<lib_ruby_parser::ParserOptions, SharedDecodeError>;
-    using BuildParserOptionsResult = std::variant<BuildParserOptionsSuccess, std::string>;
-
-    BuildParserOptionsResult BuildParserOptions(Napi::Object &object)
+    class ParserOptions : public lib_ruby_parser::ParserOptions
     {
-        lib_ruby_parser::ParserOptions options;
-        options.record_tokens = object.Get("record_tokens").ToBoolean().Value();
-        options.debug = object.Get("debug").ToBoolean().Value();
-        Napi::Value buffer_name = object.Get("buffer_name");
-        if (buffer_name.IsString())
-        {
-            options.buffer_name = buffer_name.As<Napi::String>().Utf8Value();
-        }
-        else if (buffer_name.IsUndefined())
-        {
-            // ok, default is used
-        }
-        else
-        {
-            return "buffer_name must be string/undefined";
-        }
-        SharedDecodeError decode_error = std::make_shared<JsCustomDecoder::DecodeError>();
-        Napi::Value custom_decoder = object.Get("custom_decoder");
-        if (custom_decoder.IsFunction())
-        {
-            options.custom_decoder = std::make_unique<JsCustomDecoder>(custom_decoder.As<Napi::Function>(), decode_error);
-        }
-        else if (custom_decoder.IsUndefined())
-        {
-            // ok, default is used
-        }
-        else
+    public:
+        std::shared_ptr<std::string> decode_error;
+
+        static Result<ParserOptions> FromV8(Napi::Value value)
         {
-            return "custom_decoder must be function/undefined";
+            if (!value.IsObject())
+            {
+                return "parser_options must be an object";
+            }
+            Napi::Object object = value.As<Napi::Object>();
+            ParserOptions options;
+
+            options.record_tokens = object.Get("record_tokens").ToBoolean().Value();
+            options.debug = object.Get("debug").ToBoolean().Value();
+
+            Napi::Value buffer_name = object.Get("buffer_name");
+            if (buffer_name.IsString())
+            {
+                options.buffer_name = buffer_name.As<Napi::String>().Utf8Value();
+            }
+            else if (buffer_name.IsUndefined())
+            {
+                // ok, default is used
+            }
+            else
+            {
+                return "buffer_name must be string/undefined";
+            }
+
+            Napi::Value custom_decoder = object.Get("custom_decoder");
+            if (custom_decoder.IsFunction())
+            {
+                auto decoder = std::make_unique<JsCustomDecoder>(custom_decoder.As<Napi::Function>());
+                options.decode_error = decoder->error;
+                options.custom_decoder = std::move(decoder);
+            }
+            else if (custom_decoder.IsUndefined())
+            {
+                // ok, default is used
+            }
+            else
+            {
+                return "custom_decoder must be function/undefined";
+            }
+
+            return std::move(options);
         }
+    };
 
-        return std::make_tuple(std::move(options), decode_error);
-    }
-
-    Napi::Value parse(const Napi::CallbackInfo &info)
+    Result<std::unique_ptr<lib_ruby_parser::ParserResult>> parse(const Napi::CallbackInfo &info)
     {
         Napi::Env env = info.Env();
 
         if (info.Length() != 2)
-            return JsThrow(env, "Wrong number of arguments (expected 2)");
+        {
+            return "Wrong number of arguments (expected 2)";
+        }
+
+        UNWRAP_RESULT(bytes, Bytes::FromV8(info[0]));
+        UNWRAP_RESULT(options, ParserOptions::FromV8(info[1]));
 
-        if (!info[0].IsString())
-            return JsThrow(env, "The first argument must be a string");
-        std::string source = info[0].As<Napi::String>().Utf8Value();
+        auto decode_error = options.decode_error;
 
-        if (!info[1].IsObject())
-            return JsThrow(env, "The second argument must be an object");
-        Napi::Object js_options = info[1].As<Napi::Object>();
+        auto result = lib_ruby_parser::ParserResult::from_source(std::move(bytes), std::move(options));
 
-        auto build_result = BuildParserOptions(js_options);
-        if (auto error = std::get_if<std::string>(&build_result))
+        if (decode_error)
         {
-            return JsThrow(env, *error);
+            return std::string(*(decode_error.get()));
         }
-        auto tuple = std::get<BuildParserOptionsSuccess>(std::move(build_result));
-        auto decode_error = std::get<1>(tuple);
-        auto options = std::get<0>(std::move(tuple));
+        return std::move(result);
+    }
 
-        auto result = lib_ruby_parser::ParserResult::from_source(source, std::move(options));
+    Napi::Value js_parse(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
 
-        if (decode_error->has_error)
+        auto result = parse(info);
+        if (result.is_err())
         {
-            Napi::TypeError::New(env, decode_error->error)
-                .ThrowAsJavaScriptException();
-            return env.Null();
+            return JsThrow(env, result.get_err());
         }
-        return convert(std::move(result), env);
+        return convert(result.get(), env);
     }
 
     Napi::Object Init(Napi::Env env, Napi::Object exports)
     {
         exports.Set(Napi::String::New(env, "parse"),
-                    Napi::Function::New(env, parse));
+                    Napi::Function::New(env, js_parse));
 
         InitCustomTypes(env, exports);
         InitNodeTypes(env, exports);

result.h

@@ -0,0 +1,51 @@
+#ifndef LIB_RUBY_PARSER_NODE_RESULT_H
+#define LIB_RUBY_PARSER_NODE_RESULT_H
+
+#include <variant>
+#include <string>
+
+namespace lib_ruby_parser_node
+{
+#define UNWRAP_RESULT(var, call)       \
+    auto result_##var = (call);        \
+    if (result_##var.is_err())         \
+    {                                  \
+        return result_##var.get_err(); \
+    }                                  \
+    auto var = result_##var.get();
+
+    template <typename T>
+    class Result
+    {
+        std::variant<std::string, T> data;
+
+    public:
+        Result() = default;
+        Result(T value) : data(std::move(value)){};
+        Result(std::string error) : data(error){};
+        Result(const char *error) : data(error){};
+
+        bool is_ok()
+        {
+            return std::holds_alternative<T>(data);
+        }
+
+        bool is_err()
+        {
+            return std::holds_alternative<std::string>(data);
+        }
+
+        T
+        get()
+        {
+            return std::move(std::get<T>(data));
+        }
+
+        std::string get_err()
+        {
+            return std::get<std::string>(data);
+        }
+    }; // namespace lib_ruby_parser_node
+} // namespace lib_ruby_parser_node
+
+#endif // LIB_RUBY_PARSER_NODE_RESULT_H