feat: resolver.tree and resolver.multicodec

package.json

@@ -2,7 +2,7 @@
  "name": "ipld-dag-cbor",
  "version": "0.6.0",
  "description": "JavaScript implementation of the IPLD (InterpPlanetary Linked Data)",
- "main": "lib/index.js",
+ "main": "src/index.js",
  "jsnext:main": "src/index.js",
  "scripts": {
  "test": "aegir-test",

src/resolver.js

@@ -1,14 +1,17 @@
 'use strict'
 
+const util = require('./util')
+
 exports = module.exports
 
 exports.multicodec = 'dag-cbor'
 
 /*
  * resolve: receives a path and a block and returns the value on path,
- * throw if not possible. `block` is an IPFS Block instance (contains data+key)
+ * throw if not possible. `block` is an IPFS Block instance (contains data + key)
  */
 exports.resolve = (block, path) => {
+
 }
 
 /*
@@ -19,10 +22,57 @@ exports.tree = (block, options) => {
  if (!options) {
  options = {}
  }
+
+ const node = util.deserialize(block.data)
+ const flatObj = flattenObject(node)
+ const paths = Object.keys(flatObj)
+ .map((key) => {
+ return {
+ path: key,
+ value: flatObj[key]
+ }
+ })
+ return paths
 }
 
 // TODO recheck this API
 /*
  * patch: modifies or adds value on path, yields a new block with that change
  */
 exports.patch = (block, path, value) => {}
+
+function flattenObject (obj, delimiter) {
+ if (!delimiter) {
+ delimiter = '/'
+ }
+
+ let toReturn = {}
+ let flatObject
+ for (let i in obj) {
+ if (!obj.hasOwnProperty(i)) {
+ continue
+ }
+
+ if (Array.isArray(obj[i])) {
+ continue
+ }
+
+ if ((typeof obj[i]) === 'object') {
+ flatObject = flattenObject(obj[i])
+ for (let x in flatObject) {
+ if (!flatObject.hasOwnProperty(x)) {
+ continue
+ }
+
+ if (flatObject[x] && Array === flatObject.constructor) {
+ continue
+ }
+
+ toReturn[i + (isNaN(x) ? delimiter + x : '')] = flatObject[x]
+ }
+ } else {
+ toReturn[i] = obj[i]
+ }
+ }
+ return toReturn
+}

test/resolver.spec.js

@@ -0,0 +1,83 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+const dagCBOR = require('../src')
+const resolver = dagCBOR.resolver
+const Block = require('ipfs-block')
+
+describe('IPLD format resolver (local)', () => {
+ let emptyNodeBlock
+ let nodeBlock
+
+ before(() => {
+ const emptyNode = {}
+ const node = {
+ name: 'I am a node',
+ someLink: { '/': 'LINK' },
+ nest: {
+ foo: {
+ bar: 'baz'
+ }
+ },
+ array: [
+ { a: 'b' },
+ 2
+ ]
+
+ }
+
+ emptyNodeBlock = new Block(dagCBOR.util.serialize(emptyNode))
+ nodeBlock = new Block(dagCBOR.util.serialize(node))
+ })
+
+ it('multicodec is dag-cbor', () => {
+ expect(resolver.multicodec).to.equal('dag-cbor')
+ })
+
+ describe('empty node', () => {
+ describe('resolver.resolve', () => {
+ it.skip('path', () => {
+ })
+ })
+
+ it('resolver.tree', () => {
+ const paths = resolver.tree(emptyNodeBlock)
+ expect(paths).to.eql([])
+ })
+
+ it.skip('resolver.patch', (done) => {})
+ })
+
+ describe('node', () => {
+ describe.skip('resolver.resolve', () => {
+ it('path', () => {
+ })
+ })
+
+ it('resolver.tree', () => {
+ const paths = resolver.tree(nodeBlock)
+ expect(paths).to.eql([{
+ path: 'name',
+ value: 'I am a node'
+ }, {
+ // TODO confirm how to represent links in tree
+ path: 'someLink//',
+ value: 'LINK'
+ }, {
+ path: 'nest/foo/bar',
+ value: 'baz'
+ }
+ // TODO fix array in .tree
+ /*, {
+ path: 'array/0/a',
+ value: 'b'
+ }, {
+ path: 'array/1',
+ value: '2'
+ } */])
+ })
+
+ it.skip('resolver.patch', () => {})
+ })
+})