exporter: exposing name and depth

Author: pgte

src/exporter/dir-flat.js

@@ -6,24 +6,29 @@ const cat = require('pull-cat')
 // Logic to export a unixfs directory.
 module.exports = dirExporter
 
-function dirExporter (node, path, pathRest, resolve) {
+function dirExporter (node, name, path, pathRest, resolve, dag, parent, depth) {
   const accepts = pathRest[0]
 
   const dir = {
+    name: name,
+    depth: depth,
     path: path,
-    hash: node.multihash
+    hash: node.multihash,
+    type: 'dir'
   }
 
   const streams = [
     pull(
       pull.values(node.links),
       pull.map((link) => ({
+        depth: depth + 1,
         size: link.size,
         name: link.name,
         path: path + '/' + link.name,
         multihash: link.multihash,
         linkName: link.name,
-        pathRest: pathRest.slice(1)
+        pathRest: pathRest.slice(1),
+        type: 'dir'
       })),
       pull.filter((item) => accepts === undefined || item.linkName === accepts),
       resolve

src/exporter/dir-hamt-sharded.js

@@ -7,13 +7,16 @@ const cleanHash = require('./clean-multihash')
 // Logic to export a unixfs directory.
 module.exports = shardedDirExporter
 
-function shardedDirExporter (node, path, pathRest, resolve, dag, parent) {
+function shardedDirExporter (node, name, path, pathRest, resolve, dag, parent, depth) {
   let dir
-  if (!parent || parent.path !== path) {
-    dir = [{
+  if (!parent || (parent.path !== path)) {
+    dir = {
+      name: name,
+      depth: depth,
       path: path,
-      hash: cleanHash(node.multihash)
-    }]
+      hash: cleanHash(node.multihash),
+      type: 'dir'
+    }
   }
 
   const streams = [
@@ -24,20 +27,18 @@ function shardedDirExporter (node, path, pathRest, resolve, dag, parent) {
         const p = link.name.substring(2)
         const pp = p ? path + '/' + p : path
         let accept = true
-        let fromPathRest = false
 
         if (p && pathRest.length) {
-          fromPathRest = true
           accept = (p === pathRest[0])
         }
         if (accept) {
           return {
-            fromPathRest: fromPathRest,
+            depth: depth + 1,
             name: p,
             path: pp,
             multihash: link.multihash,
             pathRest: p ? pathRest.slice(1) : pathRest,
-            parent: (dir && dir[0]) || parent
+            parent: dir || parent
           }
         } else {
           return ''
@@ -49,7 +50,7 @@ function shardedDirExporter (node, path, pathRest, resolve, dag, parent) {
   ]
 
   if (!pathRest.length) {
-    streams.unshift(pull.values(dir))
+    streams.unshift(pull.values([dir]))
   }
 
   return cat(streams)

src/exporter/file.js

@@ -7,7 +7,7 @@ const pull = require('pull-stream')
 const paramap = require('pull-paramap')
 
 // Logic to export a single (possibly chunked) unixfs file.
-module.exports = (node, path, pathRest, resolve, dag) => {
+module.exports = (node, name, path, pathRest, resolve, dag, parent, depth) => {
   function getData (node) {
     try {
       const file = UnixFS.unmarshal(node.data)
@@ -38,9 +38,12 @@ module.exports = (node, path, pathRest, resolve, dag) => {
 
   const file = UnixFS.unmarshal(node.data)
   return pull.values([{
+    depth: depth,
     content: content,
+    name: name,
     path: path,
     hash: node.multihash,
-    size: file.fileSize()
+    size: file.fileSize(),
+    type: 'file'
   }])
 }

src/exporter/index.js

@@ -57,17 +57,22 @@ module.exports = (path, dag, _options) => {
       multihash: new CID(dPath.base),
       name: dPath.base,
       path: dPath.base,
-      pathRest: dPath.rest
+      pathRest: dPath.rest,
+      depth: 0
     }]),
     createResolver(dag, options),
-    pull.map((node) => ({
-      name: node.name,
-      path: finalPathFor(node),
-      size: node.size,
-      hash: node.hash || node.multihash,
-      content: node.content,
-      type: node.type
-    }))
+    pull.filter(Boolean),
+    pull.map((node) => {
+      return {
+        depth: node.depth,
+        name: node.name,
+        path: finalPathFor(node),
+        size: node.size,
+        hash: node.hash || node.multihash,
+        content: node.content,
+        type: node.type
+      }
+    })
   )
 
   function finalPathFor (node) {

src/exporter/object.js

@@ -3,18 +3,20 @@
 const CID = require('cids')
 const pull = require('pull-stream')
 
-module.exports = (node, name, pathRest, resolve, dag, parent) => {
+module.exports = (node, name, path, pathRest, resolve, dag, parent, depth) => {
   let newNode
   if (pathRest.length) {
     const pathElem = pathRest[0]
     newNode = node[pathElem]
-    const newName = name + '/' + pathElem
+    const newName = path + '/' + pathElem
     if (!newNode) {
       return pull.error('not found')
     }
     const isCID = CID.isCID(newNode)
     return pull(
       pull.values([{
+        depth: depth,
+        name: pathElem,
         path: newName,
         pathRest: pathRest.slice(1),
         multihash: isCID && newNode,

src/exporter/resolve.js

@@ -28,28 +28,37 @@ function createResolver (dag, options, depth, parent) {
 
   return pull(
     paramap((item, cb) => {
+      if ((typeof item.depth) !== 'number') {
+        return pull.error(new Error('no depth'))
+      }
       if (item.object) {
-        return cb(null, resolve(item.object, item.path, item.pathRest, dag, item.parent || parent))
+        return cb(null, resolveItem(item.object, item))
       }
       dag.get(new CID(item.multihash), (err, node) => {
         if (err) {
           return cb(err)
         }
-        const name = item.fromPathRest ? item.name : item.path
-        cb(null, resolve(node.value, name, item.pathRest, dag, item.parent || parent))
+        // const name = item.fromPathRest ? item.name : item.path
+        cb(null, resolveItem(node.value, item))
       })
     }),
-    pull.flatten()
+    pull.flatten(),
+    pull.filter(Boolean),
+    pull.filter((node) => node.depth <= options.maxDepth)
   )
 
-  function resolve (node, path, pathRest, parentNode) {
+  function resolveItem (node, item) {
+    return resolve(node, item.name, item.path, item.pathRest, dag, item.parent || parent, item.depth)
+  }
+
+  function resolve (node, name, path, pathRest, dag, parentNode, depth) {
     const type = typeOf(node)
     const nodeResolver = resolvers[type]
     if (!nodeResolver) {
       return pull.error(new Error('Unkown node type ' + type))
     }
-    const resolveDeep = createResolver(dag, options, depth + 1, node)
-    return nodeResolver(node, path, pathRest, resolveDeep, dag, parentNode)
+    const resolveDeep = createResolver(dag, options, depth, node)
+    return nodeResolver(node, name, path, pathRest, resolveDeep, dag, parentNode, depth)
   }
 }