impl + partial tests, next: more tests

Author: daviddias

package.json

@@ -4,7 +4,7 @@
   "description": "JavaScript implementation of IPFS' unixfs (a Unix FileSystem representation on top of a MerkleDAG)",
   "main": "src/index.js",
   "scripts": {
-    "test": "mocha tests/*-test.js"
+    "test": "mocha tests/test-*.js"
   },
   "repository": {
     "type": "git",
@@ -24,5 +24,8 @@
     "mocha": "^2.4.5",
     "pre-commit": "^1.1.2",
     "standard": "^6.0.4"
+  },
+  "dependencies": {
+    "protocol-buffers": "^3.1.5"
   }
 }

src/index.js

@@ -0,0 +1 @@
+exports.format = require('./unixfs-format.js')

src/unixfs-format.js

@@ -0,0 +1,81 @@
+const fs = require('fs')
+const path = require('path')
+const protobuf = require('protocol-buffers')
+const schema = fs.readFileSync(path.resolve(__dirname, 'unixfs.proto'))
+const pb = protobuf(schema)
+const unixfsData = pb.Data // encode/decode
+// const unixfsMetadata = pb.MetaData // encode/decode
+
+const types = [
+  'raw',
+  'directory',
+  'file',
+  'metadata',
+  'symlink'
+]
+
+exports = module.exports = Data
+
+function Data (type, data) {
+  if (!(this instanceof Data)) {
+    return new Data(type, data)
+  }
+  if (types.indexOf(type) === -1) {
+    throw new Error('Type: ' + type + ' is not valid')
+  }
+
+  this.type = type
+  this.data = data
+  this.blockSizes = []
+
+  this.addBlockSize = (size) => {
+    this.blockSizes.push(size)
+  }
+
+  this.removeBlockSize = (index) => {
+    this.blockSizes.splice(index, 1)
+  }
+
+  // data.length + blockSizes
+  this.fileSize = () => {
+    var sum = 0
+    this.blockSizes.forEach((size) => {
+      sum += size
+    })
+    if (data) {
+      sum += data.length
+    }
+    return sum
+  }
+
+  // encode to protobuf
+  this.marshal = () => {
+    var type
+
+    switch (this.type) {
+      case 'raw': type = unixfsData.DataType.Raw; break
+      case 'directory': type = unixfsData.DataType.Directory; break
+      case 'file': type = unixfsData.DataType.File; break
+      case 'metadata': type = unixfsData.DataType.Metadata; break
+      case 'symlink': type = unixfsData.DataType.Symlink; break
+    }
+
+    return unixfsData.encode({
+      Type: type,
+      Data: this.data,
+      filesize: this.fileSize(),
+      blocksizes: this.blockSizes
+    })
+  }
+}
+
+// decode from protobuf https://github.com/ipfs/go-ipfs/blob/master/unixfs/format.go#L24
+exports.unmarshal = (marsheled) => {
+  const decoded = unixfsData.decode(marsheled)
+  if (!decoded.Data) {
+    decoded.Data = undefined
+  }
+  const obj = new Data(types[decoded.Type], decoded.Data)
+  obj.blockSizes = decoded.blocksizes
+  return obj
+}

src/unixfs.proto

@@ -0,0 +1,18 @@
+message Data {
+	enum DataType {
+		Raw = 0;
+		Directory = 1;
+		File = 2;
+		Metadata = 3;
+		Symlink = 4;
+	}
+
+	required DataType Type = 1;
+	optional bytes Data = 2;
+	optional uint64 filesize = 3;
+	repeated uint64 blocksizes = 4;
+}
+
+message Metadata {
+	required string MimeType = 1;
+}

tests/test-unixfs-format.js

@@ -0,0 +1,63 @@
+/* globals describe, it */
+
+const expect = require('chai').expect
+
+const UnixfsFormat = require('../src').format
+
+describe('unixfs-format', () => {
+  it('raw', (done) => {
+    const data = new UnixfsFormat('raw', new Buffer('bananas'))
+    const marsheled = data.marshal()
+    const unmarsheled = UnixfsFormat.unmarshal(marsheled)
+    expect(data.type).to.equal(unmarsheled.type)
+    expect(data.data).to.deep.equal(unmarsheled.data)
+    expect(data.blockSizes).to.deep.equal(unmarsheled.blockSizes)
+    expect(data.fileSize()).to.deep.equal(unmarsheled.fileSize())
+    done()
+  })
+
+  it('directory', (done) => {
+    const data = new UnixfsFormat('directory')
+    const marsheled = data.marshal()
+    const unmarsheled = UnixfsFormat.unmarshal(marsheled)
+    expect(data.type).to.equal(unmarsheled.type)
+    expect(data.data).to.deep.equal(unmarsheled.data)
+    expect(data.blockSizes).to.deep.equal(unmarsheled.blockSizes)
+    expect(data.fileSize()).to.deep.equal(unmarsheled.fileSize())
+    done()
+  })
+
+  it('file', (done) => {
+    const data = new UnixfsFormat('file', new Buffer('batata'))
+    const marsheled = data.marshal()
+    const unmarsheled = UnixfsFormat.unmarshal(marsheled)
+    expect(data.type).to.equal(unmarsheled.type)
+    expect(data.data).to.deep.equal(unmarsheled.data)
+    expect(data.blockSizes).to.deep.equal(unmarsheled.blockSizes)
+    expect(data.fileSize()).to.deep.equal(unmarsheled.fileSize())
+    done()
+  })
+
+  it.skip('file add blocksize', (done) => {})
+  it.skip('file add and remove blocksize', (done) => {})
+  it.skip('metadata', (done) => {})
+  it.skip('symlink', (done) => {})
+  it('wrong type', (done) => {
+    var data
+    try {
+      data = new UnixfsFormat('bananas')
+    } catch (err) {
+      expect(err).to.exist
+      expect(data).to.not.exist
+      done()
+    }
+  })
+
+  describe('interop', () => {
+    it.skip('raw', (done) => {})
+    it.skip('directory', (done) => {})
+    it.skip('file', (done) => {})
+    it.skip('metadata', (done) => {})
+    it.skip('symlink', (done) => {})
+  })
+})