pj-nodegit 0.27.1 → 0.28.2

package/src/blame_hunk.cc

@@ -12,7 +12,6 @@ extern "C" {
 #include "../include/functions/copy.h"
 #include "../include/blame_hunk.h"
 #include "nodegit_wrapper.cc"
-#include "../include/async_libgit2_queue_worker.h"
 
   #include "../include/oid.h"
   #include "../include/signature.h"
@@ -29,46 +28,47 @@ using namespace node;
     // way of knowing to free these values.
    }
 
-  void GitBlameHunk::InitializeComponent(v8::Local<v8::Object> target) {
+  void GitBlameHunk::InitializeComponent(v8::Local<v8::Object> target, nodegit::Context *nodegitContext) {
     Nan::HandleScope scope;
 
-    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
+    v8::Local<v8::External> nodegitExternal = Nan::New<v8::External>(nodegitContext);
+    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction, nodegitExternal);
 
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
     tpl->SetClassName(Nan::New("BlameHunk").ToLocalChecked());
 
-         Nan::SetPrototypeMethod(tpl, "linesInHunk", LinesInHunk);
-         Nan::SetPrototypeMethod(tpl, "finalCommitId", FinalCommitId);
-         Nan::SetPrototypeMethod(tpl, "finalStartLineNumber", FinalStartLineNumber);
-         Nan::SetPrototypeMethod(tpl, "finalSignature", FinalSignature);
-         Nan::SetPrototypeMethod(tpl, "origCommitId", OrigCommitId);
-         Nan::SetPrototypeMethod(tpl, "origPath", OrigPath);
-         Nan::SetPrototypeMethod(tpl, "origStartLineNumber", OrigStartLineNumber);
-         Nan::SetPrototypeMethod(tpl, "origSignature", OrigSignature);
+         Nan::SetPrototypeMethod(tpl, "linesInHunk", LinesInHunk, nodegitExternal);
+         Nan::SetPrototypeMethod(tpl, "finalCommitId", FinalCommitId, nodegitExternal);
+         Nan::SetPrototypeMethod(tpl, "finalStartLineNumber", FinalStartLineNumber, nodegitExternal);
+         Nan::SetPrototypeMethod(tpl, "finalSignature", FinalSignature, nodegitExternal);
+         Nan::SetPrototypeMethod(tpl, "origCommitId", OrigCommitId, nodegitExternal);
+         Nan::SetPrototypeMethod(tpl, "origPath", OrigPath, nodegitExternal);
+         Nan::SetPrototypeMethod(tpl, "origStartLineNumber", OrigStartLineNumber, nodegitExternal);
+         Nan::SetPrototypeMethod(tpl, "origSignature", OrigSignature, nodegitExternal);
   
     InitializeTemplate(tpl);
 
-    v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-    constructor_template.Reset(_constructor_template);
-    Nan::Set(target, Nan::New("BlameHunk").ToLocalChecked(), _constructor_template);
+    v8::Local<Function> constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+    nodegitContext->SaveToPersistent("GitBlameHunk::Template", constructor_template);
+    Nan::Set(target, Nan::New("BlameHunk").ToLocalChecked(), constructor_template);
   }
 
       // start field block
     NAN_METHOD(GitBlameHunk::LinesInHunk) {
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 
             size_t
            lines_in_hunk =
           Nan::ObjectWrap::Unwrap<GitBlameHunk>(info.This())->GetValue()->lines_in_hunk;
  // start convert_to_v8 block
-     to = Nan::New<Number>( lines_in_hunk);
+     v8ConversionSlot = Nan::New<Number>( lines_in_hunk);
   // end convert_to_v8 block
-      info.GetReturnValue().Set(to);
+      info.GetReturnValue().Set(v8ConversionSlot);
     }
     // end field block
      // start field block
     NAN_METHOD(GitBlameHunk::FinalCommitId) {
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 
             git_oid
 *            final_commit_id =
@@ -78,35 +78,35 @@ using namespace node;
     if (final_commit_id != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
          Nan::Set(owners, owners->Length(), info.This());
-          to = GitOid::New(
+          v8ConversionSlot = GitOid::New(
         final_commit_id,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      info.GetReturnValue().Set(to);
+      info.GetReturnValue().Set(v8ConversionSlot);
     }
     // end field block
      // start field block
     NAN_METHOD(GitBlameHunk::FinalStartLineNumber) {
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 
             size_t
            final_start_line_number =
           Nan::ObjectWrap::Unwrap<GitBlameHunk>(info.This())->GetValue()->final_start_line_number;
  // start convert_to_v8 block
-     to = Nan::New<Number>( final_start_line_number);
+     v8ConversionSlot = Nan::New<Number>( final_start_line_number);
   // end convert_to_v8 block
-      info.GetReturnValue().Set(to);
+      info.GetReturnValue().Set(v8ConversionSlot);
     }
     // end field block
      // start field block
     NAN_METHOD(GitBlameHunk::FinalSignature) {
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 
             git_signature *
             final_signature =
@@ -115,22 +115,22 @@ using namespace node;
     if (final_signature != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
          Nan::Set(owners, owners->Length(), info.This());
-          to = GitSignature::New(
+          v8ConversionSlot = GitSignature::New(
         final_signature,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      info.GetReturnValue().Set(to);
+      info.GetReturnValue().Set(v8ConversionSlot);
     }
     // end field block
      // start field block
     NAN_METHOD(GitBlameHunk::OrigCommitId) {
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 
             git_oid
 *            orig_commit_id =
@@ -140,54 +140,54 @@ using namespace node;
     if (orig_commit_id != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
          Nan::Set(owners, owners->Length(), info.This());
-          to = GitOid::New(
+          v8ConversionSlot = GitOid::New(
         orig_commit_id,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      info.GetReturnValue().Set(to);
+      info.GetReturnValue().Set(v8ConversionSlot);
     }
     // end field block
      // start field block
     NAN_METHOD(GitBlameHunk::OrigPath) {
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 
             const char *
            orig_path =
           Nan::ObjectWrap::Unwrap<GitBlameHunk>(info.This())->GetValue()->orig_path;
  // start convert_to_v8 block
   if (orig_path){
-       to = Nan::New<v8::String>(orig_path).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(orig_path).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-      info.GetReturnValue().Set(to);
+      info.GetReturnValue().Set(v8ConversionSlot);
     }
     // end field block
      // start field block
     NAN_METHOD(GitBlameHunk::OrigStartLineNumber) {
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 
             size_t
            orig_start_line_number =
           Nan::ObjectWrap::Unwrap<GitBlameHunk>(info.This())->GetValue()->orig_start_line_number;
  // start convert_to_v8 block
-     to = Nan::New<Number>( orig_start_line_number);
+     v8ConversionSlot = Nan::New<Number>( orig_start_line_number);
   // end convert_to_v8 block
-      info.GetReturnValue().Set(to);
+      info.GetReturnValue().Set(v8ConversionSlot);
     }
     // end field block
      // start field block
     NAN_METHOD(GitBlameHunk::OrigSignature) {
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 
             git_signature *
             orig_signature =
@@ -196,17 +196,17 @@ using namespace node;
     if (orig_signature != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
          Nan::Set(owners, owners->Length(), info.This());
-          to = GitSignature::New(
+          v8ConversionSlot = GitSignature::New(
         orig_signature,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      info.GetReturnValue().Set(to);
+      info.GetReturnValue().Set(v8ConversionSlot);
     }
     // end field block
   // force base class template instantiation, to make sure we get all the

package/src/blame_options.cc

@@ -1,5 +1,6 @@
 // This is a generated file, modify: generate/templates/templates/struct_content.cc
 
+// generated from struct_content.cc
 #include <nan.h>
 #include <string.h>
 #ifdef WIN32
@@ -25,180 +26,143 @@ using namespace v8;
 using namespace node;
 using namespace std;
 
-
-// generated from struct_content.cc
-GitBlameOptions::GitBlameOptions() : NodeGitWrapper<GitBlameOptionsTraits>(NULL, true, v8::Local<v8::Object>())
-{
-        git_blame_options wrappedValue = GIT_BLAME_OPTIONS_INIT;
-      this->raw = (git_blame_options*) malloc(sizeof(git_blame_options));
-      memcpy(this->raw, &wrappedValue, sizeof(git_blame_options));
-  
-  this->ConstructFields();
-}
-
-GitBlameOptions::GitBlameOptions(git_blame_options* raw, bool selfFreeing, v8::Local<v8::Object> owner)
- : NodeGitWrapper<GitBlameOptionsTraits>(raw, selfFreeing, owner)
+ 
+ConfigurableGitBlameOptions::ConfigurableGitBlameOptions(nodegit::Context *nodegitContext)
+  : nodegit::ConfigurableClassWrapper<GitBlameOptionsTraits>(nodegitContext)
 {
-  this->ConstructFields();
-}
-
-GitBlameOptions::~GitBlameOptions() {
-                   this->newest_commit.Reset();
-             this->oldest_commit.Reset();
-          }
+     git_blame_options  wrappedValue = GIT_BLAME_OPTIONS_INIT;
+    this->raw = (git_blame_options*) malloc(sizeof(git_blame_options ));
+    memcpy(this->raw, &wrappedValue, sizeof(git_blame_options ));
+ }
 
-void GitBlameOptions::ConstructFields() {
-                   v8::Local<Object> newest_commitTemp = Nan::To<v8::Object>(GitOid::New(
-&this->raw->newest_commit,
-            false
-          )).ToLocalChecked();
-          this->newest_commit.Reset(newest_commitTemp);
+ConfigurableGitBlameOptions::~ConfigurableGitBlameOptions() {
+               }
 
-             v8::Local<Object> oldest_commitTemp = Nan::To<v8::Object>(GitOid::New(
-&this->raw->oldest_commit,
-            false
-          )).ToLocalChecked();
-          this->oldest_commit.Reset(oldest_commitTemp);
+nodegit::ConfigurableClassWrapper<GitBlameOptionsTraits>::v8ConversionResult ConfigurableGitBlameOptions::fromJavascript(nodegit::Context *nodegitContext, v8::Local<v8::Value> input) {
+  if (!input->IsObject()) {
+    return {
+      "Must pass object for ConfigurableGitBlameOptions"
+    };
+  }
 
-          }
-
-void GitBlameOptions::InitializeComponent(v8::Local<v8::Object> target) {
   Nan::HandleScope scope;
-
-  v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
-
-  tpl->InstanceTemplate()->SetInternalFieldCount(1);
-  tpl->SetClassName(Nan::New("BlameOptions").ToLocalChecked());
-
-      Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("version").ToLocalChecked(), GetVersion, SetVersion);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("flags").ToLocalChecked(), GetFlags, SetFlags);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("minMatchCharacters").ToLocalChecked(), GetMinMatchCharacters, SetMinMatchCharacters);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("newestCommit").ToLocalChecked(), GetNewestCommit, SetNewestCommit);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("oldestCommit").ToLocalChecked(), GetOldestCommit, SetOldestCommit);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("minLine").ToLocalChecked(), GetMinLine, SetMinLine);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("maxLine").ToLocalChecked(), GetMaxLine, SetMaxLine);
-   
-  InitializeTemplate(tpl);
-
-  v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-  constructor_template.Reset(_constructor_template);
-  Nan::Set(target, Nan::New("BlameOptions").ToLocalChecked(), _constructor_template);
-}
-
-    NAN_GETTER(GitBlameOptions::GetVersion) {
-
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-        info.GetReturnValue().Set(Nan::New<Number>(wrapper->GetValue()->version));
-     }
-
-    NAN_SETTER(GitBlameOptions::SetVersion) {
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-         if (value->IsNumber()) {
-          wrapper->GetValue()->version = (unsigned int) Nan::To<int32_t>(value).FromJust();
+  v8::Local<v8::Object> inputObj = input.As<v8::Object>();
+  std::shared_ptr<ConfigurableGitBlameOptions> output(new ConfigurableGitBlameOptions(nodegitContext));
+
+  // unpack the data into the correct fields
+         {
+          v8::Local<v8::Value> maybeNumber = nodegit::safeGetField(inputObj, "version");
+          if (!maybeNumber.IsEmpty() && !maybeNumber->IsUndefined() && !maybeNumber->IsNull()) {
+            if (!maybeNumber->IsNumber()) {
+              return {
+                "Must pass Int32 to version"
+              };
+            }
+
+            output->raw->version = static_cast<unsigned int>(maybeNumber->Int32Value(Nan::GetCurrentContext()).FromJust());
+          }
         }
-     }
-
-      NAN_GETTER(GitBlameOptions::GetFlags) {
-
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-        info.GetReturnValue().Set(Nan::New<Number>(wrapper->GetValue()->flags));
-     }
-
-    NAN_SETTER(GitBlameOptions::SetFlags) {
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-         if (value->IsNumber()) {
-          wrapper->GetValue()->flags = (uint32_t) Nan::To<int32_t>(value).FromJust();
+           {
+          v8::Local<v8::Value> maybeNumber = nodegit::safeGetField(inputObj, "flags");
+          if (!maybeNumber.IsEmpty() && !maybeNumber->IsUndefined() && !maybeNumber->IsNull()) {
+            if (!maybeNumber->IsNumber()) {
+              return {
+                "Must pass Int32 to flags"
+              };
+            }
+
+            output->raw->flags = static_cast<uint32_t>(maybeNumber->Int32Value(Nan::GetCurrentContext()).FromJust());
+          }
         }
-     }
-
-      NAN_GETTER(GitBlameOptions::GetMinMatchCharacters) {
-
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-        info.GetReturnValue().Set(Nan::New<Number>(wrapper->GetValue()->min_match_characters));
-     }
-
-    NAN_SETTER(GitBlameOptions::SetMinMatchCharacters) {
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-         if (value->IsNumber()) {
-          wrapper->GetValue()->min_match_characters = (uint16_t) Nan::To<int32_t>(value).FromJust();
+           {
+          v8::Local<v8::Value> maybeNumber = nodegit::safeGetField(inputObj, "minMatchCharacters");
+          if (!maybeNumber.IsEmpty() && !maybeNumber->IsUndefined() && !maybeNumber->IsNull()) {
+            if (!maybeNumber->IsNumber()) {
+              return {
+                "Must pass Int32 to minMatchCharacters"
+              };
+            }
+
+            output->raw->min_match_characters = static_cast<uint16_t>(maybeNumber->Int32Value(Nan::GetCurrentContext()).FromJust());
+          }
         }
-     }
-
-      NAN_GETTER(GitBlameOptions::GetNewestCommit) {
-
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-        info.GetReturnValue().Set(Nan::New(wrapper->newest_commit));
-
-     }
-
-    NAN_SETTER(GitBlameOptions::SetNewestCommit) {
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-        v8::Local<Object> newest_commit(Nan::To<v8::Object>(value).ToLocalChecked());
-
-        wrapper->newest_commit.Reset(newest_commit);
-
-        wrapper->raw->newest_commit = *  Nan::ObjectWrap::Unwrap<GitOid>(Nan::To<v8::Object>(newest_commit).ToLocalChecked())->GetValue() ;
-
-     }
-
-      NAN_GETTER(GitBlameOptions::GetOldestCommit) {
-
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-        info.GetReturnValue().Set(Nan::New(wrapper->oldest_commit));
-
-     }
-
-    NAN_SETTER(GitBlameOptions::SetOldestCommit) {
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-        v8::Local<Object> oldest_commit(Nan::To<v8::Object>(value).ToLocalChecked());
-
-        wrapper->oldest_commit.Reset(oldest_commit);
-
-        wrapper->raw->oldest_commit = *  Nan::ObjectWrap::Unwrap<GitOid>(Nan::To<v8::Object>(oldest_commit).ToLocalChecked())->GetValue() ;
-
-     }
-
-      NAN_GETTER(GitBlameOptions::GetMinLine) {
-
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-        info.GetReturnValue().Set(Nan::New<Number>(wrapper->GetValue()->min_line));
-     }
-
-    NAN_SETTER(GitBlameOptions::SetMinLine) {
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-         if (value->IsNumber()) {
-          wrapper->GetValue()->min_line = (size_t) Nan::To<int32_t>(value).FromJust();
+            {
+            v8::Local<v8::Value> maybeOid = nodegit::safeGetField(inputObj, "newestCommit");
+            if (!maybeOid.IsEmpty() && !maybeOid->IsUndefined() && !maybeOid->IsNull()) {
+              if (maybeOid->IsString()) {
+                Nan::Utf8String oidString(maybeOid.As<v8::String>());
+                if (git_oid_fromstr(&output->raw->newest_commit, *oidString) != GIT_OK) {
+                  return {
+                    git_error_last()->message
+                  };
+                }
+              } else if (maybeOid->IsObject()) {
+                if (git_oid_cpy(&output->raw->newest_commit, Nan::ObjectWrap::Unwrap<GitOid>(maybeOid.As<v8::Object>())->GetValue()) != GIT_OK) {
+                  return {
+                    git_error_last()->message
+                  };
+                }
+              } else {
+                return {
+                  "Must pass String or NodeGit.Oid to newestCommit"
+                };
+              }
+            }
+          }
+             {
+            v8::Local<v8::Value> maybeOid = nodegit::safeGetField(inputObj, "oldestCommit");
+            if (!maybeOid.IsEmpty() && !maybeOid->IsUndefined() && !maybeOid->IsNull()) {
+              if (maybeOid->IsString()) {
+                Nan::Utf8String oidString(maybeOid.As<v8::String>());
+                if (git_oid_fromstr(&output->raw->oldest_commit, *oidString) != GIT_OK) {
+                  return {
+                    git_error_last()->message
+                  };
+                }
+              } else if (maybeOid->IsObject()) {
+                if (git_oid_cpy(&output->raw->oldest_commit, Nan::ObjectWrap::Unwrap<GitOid>(maybeOid.As<v8::Object>())->GetValue()) != GIT_OK) {
+                  return {
+                    git_error_last()->message
+                  };
+                }
+              } else {
+                return {
+                  "Must pass String or NodeGit.Oid to oldestCommit"
+                };
+              }
+            }
+          }
+            {
+          v8::Local<v8::Value> maybeNumber = nodegit::safeGetField(inputObj, "minLine");
+          if (!maybeNumber.IsEmpty() && !maybeNumber->IsUndefined() && !maybeNumber->IsNull()) {
+            if (!maybeNumber->IsNumber()) {
+              return {
+                "Must pass Int32 to minLine"
+              };
+            }
+
+            output->raw->min_line = static_cast<size_t>(maybeNumber->Int32Value(Nan::GetCurrentContext()).FromJust());
+          }
         }
-     }
-
-      NAN_GETTER(GitBlameOptions::GetMaxLine) {
-
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-        info.GetReturnValue().Set(Nan::New<Number>(wrapper->GetValue()->max_line));
-     }
-
-    NAN_SETTER(GitBlameOptions::SetMaxLine) {
-      GitBlameOptions *wrapper = Nan::ObjectWrap::Unwrap<GitBlameOptions>(info.This());
-
-         if (value->IsNumber()) {
-          wrapper->GetValue()->max_line = (size_t) Nan::To<int32_t>(value).FromJust();
+           {
+          v8::Local<v8::Value> maybeNumber = nodegit::safeGetField(inputObj, "maxLine");
+          if (!maybeNumber.IsEmpty() && !maybeNumber->IsUndefined() && !maybeNumber->IsNull()) {
+            if (!maybeNumber->IsNumber()) {
+              return {
+                "Must pass Int32 to maxLine"
+              };
+            }
+
+            output->raw->max_line = static_cast<size_t>(maybeNumber->Int32Value(Nan::GetCurrentContext()).FromJust());
+          }
         }
-     }
+    
+  return {
+    output
+  };
+}
 
-   
+               
 // force base class template instantiation, to make sure we get all the
 // methods, statics, etc.
-template class NodeGitWrapper<GitBlameOptionsTraits>;
+template class nodegit::ConfigurableClassWrapper<GitBlameOptionsTraits>;