feat: return mtime as Date object

Author: achingbrain

src/index.js

@@ -94,10 +94,9 @@ function Data (type, data) {
 
     let mtime
 
-    if (!isNaN(this.mtime)) {
+    if (this.mtime) {
       mtime = {
-        seconds: this.mtime,
-        hrValue: []
+        seconds: Math.round(this.mtime.getTime() / 1000)
       }
     }
 
@@ -115,8 +114,8 @@ function Data (type, data) {
 }
 
 // decode from protobuf https://github.com/ipfs/go-ipfs/blob/master/unixfs/format.go#L24
-Data.unmarshal = (marsheled) => {
-  const decoded = unixfsData.decode(marsheled)
+Data.unmarshal = (marshaled) => {
+  const decoded = unixfsData.decode(marshaled)
 
   if (!decoded.Data) {
     decoded.Data = undefined
@@ -130,7 +129,7 @@ Data.unmarshal = (marsheled) => {
   }
 
   if (decoded.mtime) {
-    obj.mtime = decoded.mtime.seconds
+    obj.mtime = new Date(decoded.mtime.seconds * 1000)
   }
 
   return obj

src/unixfs.proto.js

@@ -30,5 +30,4 @@ message Mode {
 
 message Mtime {
   required int64 seconds = 1;
-  repeated int64 hrValue = 2;
 }`

test/unixfs-format.spec.js

@@ -17,66 +17,66 @@ const Buffer = require('safe-buffer').Buffer
 describe('unixfs-format', () => {
   it('raw', () => {
     const data = new UnixFS('raw', Buffer.from('bananas'))
-    const marshalled = data.marshal()
-    const unmarshalled = UnixFS.unmarshal(marshalled)
-    expect(data.type).to.equal(unmarshalled.type)
-    expect(data.data).to.deep.equal(unmarshalled.data)
-    expect(data.blockSizes).to.deep.equal(unmarshalled.blockSizes)
-    expect(data.fileSize()).to.deep.equal(unmarshalled.fileSize())
+    const marshaled = data.marshal()
+    const unmarshaled = UnixFS.unmarshal(marshaled)
+    expect(data.type).to.equal(unmarshaled.type)
+    expect(data.data).to.deep.equal(unmarshaled.data)
+    expect(data.blockSizes).to.deep.equal(unmarshaled.blockSizes)
+    expect(data.fileSize()).to.deep.equal(unmarshaled.fileSize())
   })
 
   it('directory', () => {
     const data = new UnixFS('directory')
-    const marshalled = data.marshal()
-    const unmarshalled = UnixFS.unmarshal(marshalled)
-    expect(data.type).to.equal(unmarshalled.type)
-    expect(data.data).to.deep.equal(unmarshalled.data)
-    expect(data.blockSizes).to.deep.equal(unmarshalled.blockSizes)
-    expect(data.fileSize()).to.deep.equal(unmarshalled.fileSize())
+    const marshaled = data.marshal()
+    const unmarshaled = UnixFS.unmarshal(marshaled)
+    expect(data.type).to.equal(unmarshaled.type)
+    expect(data.data).to.deep.equal(unmarshaled.data)
+    expect(data.blockSizes).to.deep.equal(unmarshaled.blockSizes)
+    expect(data.fileSize()).to.deep.equal(unmarshaled.fileSize())
   })
 
   it('hamt-sharded-directory', () => {
     const data = new UnixFS('hamt-sharded-directory')
-    const marshalled = data.marshal()
-    const unmarshalled = UnixFS.unmarshal(marshalled)
-    expect(data.type).to.equal(unmarshalled.type)
-    expect(data.data).to.deep.equal(unmarshalled.data)
-    expect(data.blockSizes).to.deep.equal(unmarshalled.blockSizes)
-    expect(data.fileSize()).to.deep.equal(unmarshalled.fileSize())
+    const marshaled = data.marshal()
+    const unmarshaled = UnixFS.unmarshal(marshaled)
+    expect(data.type).to.equal(unmarshaled.type)
+    expect(data.data).to.deep.equal(unmarshaled.data)
+    expect(data.blockSizes).to.deep.equal(unmarshaled.blockSizes)
+    expect(data.fileSize()).to.deep.equal(unmarshaled.fileSize())
   })
 
   it('file', () => {
     const data = new UnixFS('file', Buffer.from('batata'))
-    const marshalled = data.marshal()
-    const unmarshalled = UnixFS.unmarshal(marshalled)
-    expect(data.type).to.equal(unmarshalled.type)
-    expect(data.data).to.deep.equal(unmarshalled.data)
-    expect(data.blockSizes).to.deep.equal(unmarshalled.blockSizes)
-    expect(data.fileSize()).to.deep.equal(unmarshalled.fileSize())
+    const marshaled = data.marshal()
+    const unmarshaled = UnixFS.unmarshal(marshaled)
+    expect(data.type).to.equal(unmarshaled.type)
+    expect(data.data).to.deep.equal(unmarshaled.data)
+    expect(data.blockSizes).to.deep.equal(unmarshaled.blockSizes)
+    expect(data.fileSize()).to.deep.equal(unmarshaled.fileSize())
   })
 
   it('file add blocksize', () => {
     const data = new UnixFS('file')
     data.addBlockSize(256)
-    const marshalled = data.marshal()
-    const unmarshalled = UnixFS.unmarshal(marshalled)
-    expect(data.type).to.equal(unmarshalled.type)
-    expect(data.data).to.deep.equal(unmarshalled.data)
-    expect(data.blockSizes).to.deep.equal(unmarshalled.blockSizes)
-    expect(data.fileSize()).to.deep.equal(unmarshalled.fileSize())
+    const marshaled = data.marshal()
+    const unmarshaled = UnixFS.unmarshal(marshaled)
+    expect(data.type).to.equal(unmarshaled.type)
+    expect(data.data).to.deep.equal(unmarshaled.data)
+    expect(data.blockSizes).to.deep.equal(unmarshaled.blockSizes)
+    expect(data.fileSize()).to.deep.equal(unmarshaled.fileSize())
   })
 
   it('file add and remove blocksize', () => {
     const data = new UnixFS('file')
     data.addBlockSize(256)
-    const marshalled = data.marshal()
-    const unmarshalled = UnixFS.unmarshal(marshalled)
-    expect(data.type).to.equal(unmarshalled.type)
-    expect(data.data).to.deep.equal(unmarshalled.data)
-    expect(data.blockSizes).to.deep.equal(unmarshalled.blockSizes)
-    expect(data.fileSize()).to.deep.equal(unmarshalled.fileSize())
-    unmarshalled.removeBlockSize(0)
-    expect(data.blockSizes).to.not.deep.equal(unmarshalled.blockSizes)
+    const marshaled = data.marshal()
+    const unmarshaled = UnixFS.unmarshal(marshaled)
+    expect(data.type).to.equal(unmarshaled.type)
+    expect(data.data).to.deep.equal(unmarshaled.data)
+    expect(data.blockSizes).to.deep.equal(unmarshaled.blockSizes)
+    expect(data.fileSize()).to.deep.equal(unmarshaled.fileSize())
+    unmarshaled.removeBlockSize(0)
+    expect(data.blockSizes).to.not.deep.equal(unmarshaled.blockSizes)
   })
 
   it('mode', () => {
@@ -92,12 +92,12 @@ describe('unixfs-format', () => {
     const data = new UnixFS('file')
     data.mode = mode
 
-    const unmarshalled = UnixFS.unmarshal(data.marshal())
-    expect(unmarshalled).to.have.property('mode', mode)
+    const unmarshaled = UnixFS.unmarshal(data.marshal())
+    expect(unmarshaled).to.have.property('mode', mode)
 
-    delete unmarshalled.mode
+    delete unmarshaled.mode
 
-    expect(UnixFS.unmarshal(unmarshalled.marshal())).to.not.have.property('mode')
+    expect(UnixFS.unmarshal(unmarshaled.marshal())).to.not.have.property('mode')
   })
 
   it('sets mode to 0', () => {
@@ -109,46 +109,46 @@ describe('unixfs-format', () => {
   })
 
   it('mtime', () => {
-    const mtime = parseInt(Date.now() / 1000)
+    const mtime = new Date()
     const data = new UnixFS('file')
     data.mtime = mtime
-    const marshalled = data.marshal()
-    const unmarshalled = UnixFS.unmarshal(marshalled)
-    expect(unmarshalled.mtime).to.equal(mtime)
+    const marshaled = data.marshal()
+    const unmarshaled = UnixFS.unmarshal(marshaled)
+    expect(unmarshaled.mtime).to.deep.equal(new Date(Math.round(mtime.getTime() / 1000) * 1000))
   })
 
   it('removes mtime', () => {
-    const mtime = parseInt(Date.now() / 1000)
+    const mtime = new Date()
     const data = new UnixFS('file')
     data.mtime = mtime
 
-    const unmarshalled = UnixFS.unmarshal(data.marshal())
-    expect(unmarshalled).to.have.property('mtime', mtime)
+    const unmarshaled = UnixFS.unmarshal(data.marshal())
+    expect(unmarshaled).to.have.deep.property('mtime', new Date(Math.round(mtime.getTime() / 1000) * 1000))
 
-    delete unmarshalled.mtime
+    delete unmarshaled.mtime
 
-    expect(UnixFS.unmarshal(unmarshalled.marshal())).to.not.have.property('mtime')
+    expect(UnixFS.unmarshal(unmarshaled.marshal())).to.not.have.property('mtime')
   })
 
   it('sets mtime to 0', () => {
-    const mtime = 0
+    const mtime = new Date(0)
     const data = new UnixFS('file')
     data.mtime = mtime
 
-    expect(UnixFS.unmarshal(data.marshal())).to.have.property('mtime', mtime)
+    expect(UnixFS.unmarshal(data.marshal())).to.have.deep.property('mtime', new Date(Math.round(mtime.getTime() / 1000) * 1000))
   })
 
   // figuring out what is this metadata for https://github.com/ipfs/js-ipfs-data-importing/issues/3#issuecomment-182336526
   it.skip('metadata', () => {})
 
   it('symlink', () => {
     const data = new UnixFS('symlink')
-    const marshalled = data.marshal()
-    const unmarshalled = UnixFS.unmarshal(marshalled)
-    expect(data.type).to.equal(unmarshalled.type)
-    expect(data.data).to.deep.equal(unmarshalled.data)
-    expect(data.blockSizes).to.deep.equal(unmarshalled.blockSizes)
-    expect(data.fileSize()).to.deep.equal(unmarshalled.fileSize())
+    const marshaled = data.marshal()
+    const unmarshaled = UnixFS.unmarshal(marshaled)
+    expect(data.type).to.equal(unmarshaled.type)
+    expect(data.data).to.deep.equal(unmarshaled.data)
+    expect(data.blockSizes).to.deep.equal(unmarshaled.blockSizes)
+    expect(data.fileSize()).to.deep.equal(unmarshaled.fileSize())
   })
   it('wrong type', (done) => {
     let data
@@ -163,42 +163,42 @@ describe('unixfs-format', () => {
 
   describe('interop', () => {
     it('raw', () => {
-      const unmarshalled = UnixFS.unmarshal(raw)
-      expect(unmarshalled.data).to.eql(Buffer.from('Hello UnixFS\n'))
-      expect(unmarshalled.type).to.equal('file')
-      expect(unmarshalled.marshal()).to.deep.equal(raw)
+      const unmarshaled = UnixFS.unmarshal(raw)
+      expect(unmarshaled.data).to.eql(Buffer.from('Hello UnixFS\n'))
+      expect(unmarshaled.type).to.equal('file')
+      expect(unmarshaled.marshal()).to.deep.equal(raw)
     })
 
     it('directory', () => {
-      const unmarshalled = UnixFS.unmarshal(directory)
-      expect(unmarshalled.data).to.deep.equal(undefined)
-      expect(unmarshalled.type).to.equal('directory')
-      expect(unmarshalled.marshal()).to.deep.equal(directory)
+      const unmarshaled = UnixFS.unmarshal(directory)
+      expect(unmarshaled.data).to.deep.equal(undefined)
+      expect(unmarshaled.type).to.equal('directory')
+      expect(unmarshaled.marshal()).to.deep.equal(directory)
     })
 
     it('file', () => {
-      const unmarshalled = UnixFS.unmarshal(file)
-      expect(unmarshalled.data).to.deep.equal(Buffer.from('Hello UnixFS\n'))
-      expect(unmarshalled.type).to.equal('file')
-      expect(unmarshalled.marshal()).to.deep.equal(file)
+      const unmarshaled = UnixFS.unmarshal(file)
+      expect(unmarshaled.data).to.deep.equal(Buffer.from('Hello UnixFS\n'))
+      expect(unmarshaled.type).to.equal('file')
+      expect(unmarshaled.marshal()).to.deep.equal(file)
     })
 
     it.skip('metadata', () => {
     })
 
     it('symlink', () => {
-      const unmarshalled = UnixFS.unmarshal(symlink)
-      expect(unmarshalled.data).to.deep.equal(Buffer.from('file.txt'))
-      expect(unmarshalled.type).to.equal('symlink')
+      const unmarshaled = UnixFS.unmarshal(symlink)
+      expect(unmarshaled.data).to.deep.equal(Buffer.from('file.txt'))
+      expect(unmarshaled.type).to.equal('symlink')
       // TODO: waiting on https://github.com/ipfs/js-ipfs-data-importing/issues/3#issuecomment-182440079
-      // expect(unmarshalled.marshal()).to.deep.equal(symlink)
+      // expect(unmarshaled.marshal()).to.deep.equal(symlink)
     })
   })
 
   it('empty', () => {
     const data = new UnixFS('file')
-    const marshalled = data.marshal()
+    const marshaled = data.marshal()
 
-    expect(marshalled).to.deep.equal(Buffer.from([0x08, 0x02, 0x18, 0x00]))
+    expect(marshaled).to.deep.equal(Buffer.from([0x08, 0x02, 0x18, 0x00]))
   })
 })