added commit and revwalk to the library and worked on test repo

tbranyen · tbranyen · commit 1cd48d71c155 · 2011-02-28T00:52:07.000-05:00
diff --git a/example/raw-repo.js b/example/raw-repo.js
@@ -4,12 +4,12 @@ var repo = new git2.Repo(),
     error = new git2.Error();
 
 // Access existing repository
-repo.open('./.git', function(err, path) {
-    console.log(err, path);
+repo.open('.git', function(err, path) {
+    console.log( error.strError(err), path);
 
     var master = new git2.Ref(repo);
-    repo.lookupRef( master, "refs/heads/master", function( err, ref ) {
-      console.log(err, ref);
+    repo.lookupRef( master, 'refs/heads/master', function( err, ref ) {
+      console.log(err, master);
       var oid = new git2.Oid();
       master.oid(oid);
       console.log( oid.toString(40) );
diff --git a/lib/commit.js b/lib/commit.js
@@ -0,0 +1,12 @@
+var git = require( '../' );
+
+var _Commit = function( repo ) {
+  var self = {};
+
+  // Internal reference to a Git reference
+  self.commit = commit || new git.git2.Commit( repo );
+
+  return self;
+};
+
+exports.commit = _Commit;
diff --git a/lib/index.js b/lib/index.js
@@ -1,10 +1,12 @@
 var repo = require( './repo.js' ).repo,
     error = require( './error.js' ).error,
-    ref = require( './ref.js' ).ref;
-    //commit = require( 'commit.js' );
+    ref = require( './ref.js' ).ref,
+    revwalk = require( './revwalk.js' ).revwalk,
+    commit = require( './commit.js' ).commit;
 
 exports.git2 = require( '../build/default/nodegit2.node' );
 exports.repo = repo;
 exports.ref = ref;
 exports.error = error;
-//exports.commit = commit.commit;
+exports.revwalk = revwalk;
+exports.commit = commit;
diff --git a/lib/repo.js b/lib/repo.js
@@ -21,24 +21,24 @@ var _Repo = function( path, callback ) {
   // Internal reference to a Git repository
   self.repo = new git.git2.Repo();
 
-  // Find all commits under a given repository and optionally filtered further by a Ref
-  //self.commits = function( obj ) {
-  //  obj = obj || "HEAD";
-
-  //  if( commits.length ) {
-  //    return commits;
-  //  }
-  //  else {
-  //    
-  //  }
-  //};
+  // Work with a specific branch
+  self.branch = function( name, callback ) {
+    var branch = new git.git2.Ref( self.repo );
+    
+    self.repo.lookupRef( branch, 'refs/heads/'+ name, function() {
+      var args = Array.prototype.slice.call( arguments );
+      args[0] = error( args[0] );
+
+      callback.apply( branch, args.concat( branch ) );
+    });
+  };
 
   // Find a single commit
   self.commit = function( sha, callback ) {
     var oid = new git.git2.Oid(),
         commit = new git.git2.Commit();
 
-    if(!callback) { return; }
+    if( !callback ) { return; }
 
     oid.mkstr( sha );
 
@@ -54,7 +54,7 @@ var _Repo = function( path, callback ) {
   self.find = function( name, callback ) {
     var ref = new git.git2.Ref();
     
-    if(!callback) { return; }
+    if( !callback ) { return; }
 
     self.repo.lookupRef( ref, name, function() {
       var args = Array.prototype.slice.call( arguments ),
@@ -67,7 +67,7 @@ var _Repo = function( path, callback ) {
   };
 
   self.init = function( path, is_bare, callback ) {
-    if(!callback) { return; }
+    if( !callback ) { return; }
 
     self.repo.init( path, is_bare, function() {
       var args = Array.prototype.slice.call( arguments );
@@ -87,7 +87,7 @@ var _Repo = function( path, callback ) {
 
   // Constructor use
   if( path && callback ) {
-    if(!callback) { return; }
+    if( !callback ) { return; }
 
     self.repo.open( path, function() {
       var args = Array.prototype.slice.call( arguments );
diff --git a/lib/revwalk.js b/lib/revwalk.js
@@ -0,0 +1,28 @@
+var git = require( '../' );
+
+var _RevWalk = function( repo ) {
+  var self = {};
+
+  // Internal reference to a Git reference
+  self.revwalk = revwalk || new git.git2.RevWalk( repo );
+
+  // Walk will map to the next method
+  self.walk = function( commit, callback ) {
+    if( !callback ) { return; }
+
+    self.revwalk.push( commit );
+
+    revwalk.next( commit, function() {
+      var args = Array.prototype.slice.call( arguments );
+
+      args[0] = error( args[0] );
+
+
+      callback.apply( commit, args.concat( commit ) );
+    });
+  };
+
+  return self;
+};
+
+exports.revwalk = _RevWalk;
diff --git a/test/convenience-repo.js b/test/convenience-repo.js
@@ -53,34 +53,42 @@ exports.constructor = function( test ){
 
 // Repo::Init
 exports.init = function( test ) {
-  test.expect( 7 );
+  test.expect( 5 );
 
   // Test for function
   helper.testFunction( test.equals, git.repo().init, 'Repo::Init' );
 
   // Test path argument existence
-  helper.testException( test.ok, function() {
-    git.repo().init();
-  }, 'Throw an exception if no path' );
+  //helper.testException( test.ok, function() {
+  //  git.repo().init();
+  //}, 'Throw an exception if no path' );
  
-  // Test is_bare argument existence
-  helper.testException( test.ok, function() {
-    git.repo().init( 'some/path' );
-  }, 'Throw an exception if no is_bare' );
+  //// Test is_bare argument existence
+  //helper.testException( test.ok, function() {
+  //  git.repo().init( 'some/path' );
+  //}, 'Throw an exception if no is_bare' );
 
   // Cleanup, remove test repo directory - if it exists
   rimraf( './test.git', function() {
     // Create bare repo and test for creation
     git.repo().init( './test.git', true, function( err, path, is_bare ) {
       test.equals( 0, err, 'Successfully created bare repository' );
       // Verify repo exists
-      git.repo('./test.git', function(err, path) {
+      git.repo('./test.git', function(err, path, repo) {
         test.equals( 0, err, 'Valid repository created' );
         test.equals( true, is_bare, 'Returns valid is_bare value' );
+
+        // Test repo branch lookup
+        console.log( repo, repo.__proto__ );
+        repo.branch( 'master', function( err ) {
+          console.log(err);
+          test.done();
+
           // Cleanup, remove test repo directory
           rimraf( './test.git', function() {
-            test.done();
+
           });
+        });
       });
     });
   });
diff --git a/test/index.js b/test/index.js
@@ -37,9 +37,12 @@ reporter.run(
     'raw-repo.js',
     'raw-oid.js',
     'raw-commit.js',
-    'raw-error.js'
+    'raw-error.js',
+    
+    // TODO:
+    //'raw-revwalk.js'
 
     // Convenience API
-    //'convenience-repo.js'
+    'convenience-repo.js'
   ]
 );
diff --git a/test/raw-revwalk.js b/test/raw-revwalk.js
@@ -0,0 +1,96 @@
+var git = require( '../' ).git2,
+    rimraf = require( '../vendor/rimraf' ) || require( 'rimraf' );
+
+var testRepo = new git.Repo();
+
+// Helper functions
+var helper = {
+  // Test if obj is a true function
+  testFunction: function( test, obj, label ) {
+    // The object reports itself as a function
+    test( typeof obj, 'function', label +' reports as a function.' );
+    // This ensures the repo is actually a derivative of the Function [[Class]]
+    test( toString.call( obj ), '[object Function]', label +' [[Class]] is of type function.' );
+  },
+  // Test code and handle exception thrown 
+  testException: function( test, fun, label ) {
+    try {
+      fun();
+      test( false, label );
+    }
+    catch (ex) {
+      test( true, label );
+    }
+  }
+};
+
+// Oid
+exports.constructor = function( test ){
+  test.expect( 3 );
+
+  // Test for function
+  helper.testFunction( test.equals, git.Commit, 'Commit' );
+  
+  // Ensure we get an instance of Oid
+  test.ok( new git.Commit(testRepo) instanceof git.Commit, 'Invocation returns an instance of Commit' );
+
+  test.done();
+};
+
+// Oid::Mkstr
+exports.lookup = function( test ) {
+  var testOid = new git.Oid(),
+      testCommit = new git.Commit(testRepo);
+
+  testOid.mkstr( 'cb09e99e91d41705197e0fb60823fdc7df776691' );
+
+  test.expect( 8 );
+
+  // Test for function
+  helper.testFunction( test.equals, testCommit.lookup, 'Commit::Lookup' );
+
+  // Test repo argument existence
+  helper.testException( test.ok, function() {
+    testCommit.lookup();
+  }, 'Throw an exception if no repo' );
+ 
+  // Test oid argument existence
+  helper.testException( test.ok, function() {
+    testCommit.lookup( testRepo );
+  }, 'Throw an exception if no oid' );
+
+  // Test callback argument existence
+  helper.testException( test.ok, function() {
+    testCommit.lookup( testRepo, testOid );
+  }, 'Throw an exception if no callback' );
+
+  // Test that both arguments result correctly
+  helper.testException( test.ifError, function() {
+    testCommit.lookup( testRepo, testOid, function() {} );
+  }, 'No exception is thrown with proper arguments' );
+
+  testRepo.open( './dummyrepo/.git', function( err, path ) {
+    // Test invalid commit
+    testOid.mkstr( '100644' );
+    testCommit.lookup( testRepo, testOid, function( err, details ) {
+      test.notEqual( 0, err, 'Not a valid commit' );
+ 
+      // Test valid commit
+      testOid.mkstr( '978feacee2432e67051f2714ec7d28ad80e16908' );
+      testCommit.lookup( testRepo, testOid, function( err, details ) {
+        test.equals( 0, err, 'Valid commit');
+
+        //test.equals( 'object', typeof details, 'Details is an object' );
+
+        //test.equals( 'string', typeof details.message, 'Details message is a String' );
+        //if(details.message) {
+        //  test.equals( 'initial commit', details.message.trim(), 'Details has correct message' );
+        //}
+
+        testRepo.free();
+
+        test.done();
+      });
+    });
+  });
+};
diff --git a/test/test.git/HEAD b/test/test.git/HEAD
@@ -0,0 +1 @@
+ref:  refs/heads/master
