Add Symbol class (#27)

 - Add abstract Name class that is the base for String and Symbol classes
 - Add Symbol class
 - Add unit tests for both String and Symbol classes

Author: jasongin

napi-inl.h

@@ -343,6 +343,16 @@ inline double Number::DoubleValue() const {
   return result;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Name class
+////////////////////////////////////////////////////////////////////////////////
+
+inline Name::Name() : Value() {
+}
+
+inline Name::Name(napi_env env, napi_value value) : Value(env, value) {
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // String class
 ////////////////////////////////////////////////////////////////////////////////
@@ -383,10 +393,10 @@ inline String String::New(napi_env env, const char16_t* val, size_t length) {
   return String(env, value);
 }
 
-inline String::String() : Value() {
+inline String::String() : Name() {
 }
 
-inline String::String(napi_env env, napi_value value) : Value(env, value) {
+inline String::String(napi_env env, napi_value value) : Name(env, value) {
 }
 
 inline String::operator std::string() const {
@@ -421,6 +431,39 @@ inline std::u16string String::Utf16Value() const {
   return value;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Symbol class
+////////////////////////////////////////////////////////////////////////////////
+
+inline Symbol Symbol::New(napi_env env, const char* description) {
+  napi_value descriptionValue = description != nullptr ?
+    String::New(env, description) : static_cast<napi_value>(nullptr);
+  return Symbol::New(env, descriptionValue);
+}
+
+inline Symbol Symbol::New(napi_env env, const std::string& description) {
+  napi_value descriptionValue = String::New(env, description);
+  return Symbol::New(env, descriptionValue);
+}
+
+inline Symbol Symbol::New(napi_env env, String description) {
+  napi_value descriptionValue = description;
+  return Symbol::New(env, descriptionValue);
+}
+
+inline Symbol Symbol::New(napi_env env, napi_value description) {
+  napi_value value;
+  napi_status status = napi_create_symbol(env, description, &value);
+  if (status != napi_ok) throw Error::New(env);
+  return Symbol(env, value);
+}
+
+inline Symbol::Symbol() : Name() {
+}
+
+inline Symbol::Symbol(napi_env env, napi_value value) : Name(env, value) {
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Object class
 ////////////////////////////////////////////////////////////////////////////////

napi.h

@@ -151,7 +151,13 @@ namespace Napi {
     double DoubleValue() const;
   };
 
-  class String : public Value {
+  class Name : public Value {
+  protected:
+    Name();
+    Name(napi_env env, napi_value value);
+  };
+
+  class String : public Name {
   public:
     static String New(napi_env env, const std::string& value);
     static String New(napi_env env, const std::u16string& value);
@@ -169,6 +175,17 @@ namespace Napi {
     std::u16string Utf16Value() const;
   };
 
+  class Symbol : public Name {
+  public:
+    static Symbol New(napi_env env, const char* description = nullptr);
+    static Symbol New(napi_env env, const std::string& description);
+    static Symbol New(napi_env env, String description);
+    static Symbol New(napi_env env, napi_value description);
+
+    Symbol();
+    Symbol(napi_env env, napi_value value);
+  };
+
   class Object : public Value {
   public:
     static Object New(napi_env env);

test/binding.cc

@@ -4,10 +4,12 @@ using namespace Napi;
 
 Object InitError(Env env);
 Object InitFunction(Env env);
+Object InitName(Env env);
 
 void Init(Env env, Object exports, Object module) {
   exports.Set("error", InitError(env));
   exports.Set("function", InitFunction(env));
+  exports.Set("name", InitName(env));
 }
 
 NODE_API_MODULE(addon, Init)

test/binding.gyp

@@ -6,6 +6,7 @@
         'binding.cc',
         'error.cc',
         'function.cc',
+        'name.cc',
       ],
       'include_dirs': ["<!(node -p \"require('../').include\")"],
       'dependencies': ["<!(node -p \"require('../').gyp\")"],

test/index.js

@@ -3,6 +3,7 @@
 let testModules = [
    'error',
    'function',
+   'name',
 ];
 
 testModules.forEach(name => {

test/name.cc

@@ -0,0 +1,78 @@
+#include "napi.h"
+
+using namespace Napi;
+
+const char* testValueUtf8 = "123456789";
+const char16_t* testValueUtf16 = u"123456789";
+
+Value CreateString(const CallbackInfo& info) {
+  String encoding = info[0].As<String>();
+  Number length = info[1].As<Number>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    if (length.IsUndefined()) {
+      return String::New(info.Env(), testValueUtf8);
+    } else {
+      return String::New(info.Env(), testValueUtf8, length.Uint32Value());
+    }
+  } else if (encoding.Utf8Value() == "utf16") {
+    if (length.IsUndefined()) {
+      return String::New(info.Env(), testValueUtf16);
+    } else {
+      return String::New(info.Env(), testValueUtf16, length.Uint32Value());
+    }
+  } else {
+    throw Error::New(info.Env(), "Invalid encoding.");
+  }
+}
+
+Value CheckString(const CallbackInfo& info) {
+  String value = info[0].As<String>();
+  String encoding = info[1].As<String>();
+  Number length = info[2].As<Number>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    std::string testValue = testValueUtf8;
+    if (!length.IsUndefined()) {
+      testValue = testValue.substr(0, length.Uint32Value());
+    }
+
+    std::string stringValue = value;
+    return Boolean::New(info.Env(), stringValue == testValue);
+  } else if (encoding.Utf8Value() == "utf16") {
+    std::u16string testValue = testValueUtf16;
+    if (!length.IsUndefined()) {
+      testValue = testValue.substr(0, length.Uint32Value());
+    }
+
+    std::u16string stringValue = value;
+    return Boolean::New(info.Env(), stringValue == testValue);
+  } else {
+    throw Error::New(info.Env(), "Invalid encoding.");
+  }
+}
+
+Value CreateSymbol(const CallbackInfo& info) {
+  String description = info[0].As<String>();
+
+  if (!description.IsUndefined()) {
+    return Symbol::New(info.Env(), description);
+  } else {
+    return Symbol::New(info.Env());
+  }
+}
+
+Value CheckSymbol(const CallbackInfo& info) {
+  return Boolean::New(info.Env(), info[0].Type() == napi_symbol);
+}
+
+Object InitName(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createString"] = Function::New(env, CreateString);
+  exports["checkString"] = Function::New(env, CheckString);
+  exports["createSymbol"] = Function::New(env, CreateSymbol);
+  exports["checkSymbol"] = Function::New(env, CheckSymbol);
+
+  return exports;
+}

test/name.js

@@ -0,0 +1,42 @@
+'use strict';
+const buildType = process.config.target_defaults.default_configuration;
+const binding = require(`./build/${buildType}/binding.node`);
+const assert = require('assert');
+
+const expected = '123456789';
+
+assert.ok(binding.name.checkString(expected, 'utf8'));
+assert.ok(binding.name.checkString(expected, 'utf16'));
+assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf8', 3));
+assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf16', 3));
+
+const str1 = binding.name.createString('utf8');
+assert.strictEqual(str1, expected);
+assert.ok(binding.name.checkString(str1, 'utf8'));
+assert.ok(binding.name.checkString(str1, 'utf16'));
+
+const substr1 = binding.name.createString('utf8', 3);
+assert.strictEqual(substr1, expected.substr(0, 3));
+assert.ok(binding.name.checkString(substr1, 'utf8', 3));
+assert.ok(binding.name.checkString(substr1, 'utf16', 3));
+
+const str2 = binding.name.createString('utf16');
+assert.strictEqual(str1, expected);
+assert.ok(binding.name.checkString(str2, 'utf8'));
+assert.ok(binding.name.checkString(str2, 'utf16'));
+
+const substr2 = binding.name.createString('utf16', 3);
+assert.strictEqual(substr1, expected.substr(0, 3));
+assert.ok(binding.name.checkString(substr2, 'utf8', 3));
+assert.ok(binding.name.checkString(substr2, 'utf16', 3));
+
+assert.ok(binding.name.checkSymbol(Symbol()));
+assert.ok(binding.name.checkSymbol(Symbol('test')));
+
+const sym1 = binding.name.createSymbol();
+assert.strictEqual(typeof sym1, 'symbol');
+assert.ok(binding.name.checkSymbol(sym1));
+
+const sym2 = binding.name.createSymbol('test');
+assert.strictEqual(typeof sym2, 'symbol');
+assert.ok(binding.name.checkSymbol(sym1));