Merge remote-tracking branch 'upstream/master' into reference

.github/ISSUE_TEMPLATE/config.yml

+blank_issues_enabled: false
+contact_links:
+ - name: Getting Help on IPFS
+   url: https://ipfs.io/help
+   about: All information about how and where to get help on IPFS.
+ - name: IPFS Official Forum
+   url: https://discuss.ipfs.io
+   about: Please post general questions, support requests, and discussions here.

.github/ISSUE_TEMPLATE/open_an_issue.md

+---
+name: Open an issue
+about: Only for actionable issues relevant to this repository.
+title: ''
+labels: need/triage
+assignees: ''
+
+---
+<!--
+Hello! To ensure this issue is correctly addressed as soon as possible by the IPFS team, please try to make sure:
+
+- This issue is relevant to this repository's topic or codebase.
+
+- A clear description is provided. It should includes as much relevant information as possible and clear scope for the issue to be actionable.
+
+FOR GENERAL DISCUSSION, HELP OR QUESTIONS, please see the options at https://ipfs.io/help or head directly to https://discuss.ipfs.io.
+
+(you can delete this section after reading)
+-->

.github/config.yml

+# Configuration for welcome - https://github.com/behaviorbot/welcome
+
+# Configuration for new-issue-welcome - https://github.com/behaviorbot/new-issue-welcome
+# Comment to be posted to on first time issues
+newIssueWelcomeComment: >
+  Thank you for submitting your first issue to this repository! A maintainer
+  will be here shortly to triage and review.
+
+  In the meantime, please double-check that you have provided all the
+  necessary information to make this process easy! Any information that can
+  help save additional round trips is useful! We currently aim to give
+  initial feedback within **two business days**. If this does not happen, feel
+  free to leave a comment.
+
+  Please keep an eye on how this issue will be labeled, as labels give an
+  overview of priorities, assignments and additional actions requested by the
+  maintainers:
+
+    - "Priority" labels will show how urgent this is for the team.
+    - "Status" labels will show if this is ready to be worked on, blocked, or in progress.
+    - "Need" labels will indicate if additional input or analysis is required.
+
+  Finally, remember to use https://discuss.ipfs.io if you just need general
+  support.
+
+# Configuration for new-pr-welcome - https://github.com/behaviorbot/new-pr-welcome
+# Comment to be posted to on PRs from first time contributors in your repository
+newPRWelcomeComment: >
+  Thank you for submitting this PR!
+
+  A maintainer will be here shortly to review it.
+
+  We are super grateful, but we are also overloaded! Help us by making sure
+  that:
+
+    * The context for this PR is clear, with relevant discussion, decisions
+      and stakeholders linked/mentioned.
+
+    * Your contribution itself is clear (code comments, self-review for the
+      rest) and in its best form. Follow the [code contribution
+      guidelines](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md#code-contribution-guidelines)
+      if they apply.
+
+  Getting other community members to do a review would be great help too on
+  complex PRs (you can ask in the chats/forums). If you are unsure about
+  something, just leave us a comment.
+
+  Next steps:
+
+    * A maintainer will triage and assign priority to this PR, commenting on
+      any missing things and potentially assigning a reviewer for high
+      priority items.
+
+    * The PR gets reviews, discussed and approvals as needed.
+
+    * The PR is merged by maintainers when it has been approved and comments addressed.
+
+  We currently aim to provide initial feedback/triaging within **two business
+  days**. Please keep an eye on any labelling actions, as these will indicate
+  priorities and status of your contribution.
+
+  We are very grateful for your contribution!
+
+
+# Configuration for first-pr-merge - https://github.com/behaviorbot/first-pr-merge
+# Comment to be posted to on pull requests merged by a first time user
+# Currently disabled
+#firstPRMergeComment: ""

.github/workflows/automerge.yml

+# File managed by web3-bot. DO NOT EDIT.
+# See https://github.com/protocol/.github/ for details.
+
+# Automatically merge pull requests opened by web3-bot, as soon as (and only if) all tests pass.
+# This reduces the friction associated with updating with our workflows.
+
+on: [ pull_request ]
+
+jobs:
+  automerge:
+    if: github.event.pull_request.user.login == 'web3-bot'
+    runs-on: ubuntu-latest
+    steps:
+    - name: Wait on tests
+      uses: lewagon/wait-on-check-action@bafe56a6863672c681c3cf671f5e10b20abf2eaa # v0.2
+      with:
+        ref: ${{ github.event.pull_request.head.sha }}
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        wait-interval: 10
+        running-workflow-name: 'automerge' # the name of this job
+    - name: Merge PR
+      uses: pascalgn/automerge-action@741c311a47881be9625932b0a0de1b0937aab1ae # v0.13.1
+      env:
+        GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+        MERGE_LABELS: ""
+        MERGE_METHOD: "squash"
+        MERGE_DELETE_BRANCH: true

.github/workflows/go-check.yml

+# File managed by web3-bot. DO NOT EDIT.
+# See https://github.com/protocol/.github/ for details.
+
+on: [push, pull_request]
+
+jobs:
+  unit:
+    runs-on: ubuntu-latest
+    name: Go checks
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-go@v2
+        with:
+          go-version: "1.16.x"
+      - name: Install staticcheck
+        run: go install honnef.co/go/tools/cmd/staticcheck@be534f007836a777104a15f2456cd1fffd3ddee8 # v2020.2.2
+      - name: Check that go.mod is tidy
+        run: |
+          go mod tidy
+          if [[ -n $(git ls-files --other --exclude-standard --directory -- go.sum) ]]; then
+            echo "go.sum was added by go mod tidy"
+            exit 1
+          fi
+          git diff --exit-code -- go.sum go.mod
+      - name: gofmt
+        if: ${{ success() || failure() }} # run this step even if the previous one failed
+        run: |
+          out=$(gofmt -s -l .)
+          if [[ -n "$out" ]]; then
+            echo $out | awk '{print "::error file=" $0 ",line=0,col=0::File is not gofmt-ed."}'
+            exit 1
+          fi
+      - name: go vet
+        if: ${{ success() || failure() }} # run this step even if the previous one failed
+        run: go vet ./...
+      - name: staticcheck
+        if: ${{ success() || failure() }} # run this step even if the previous one failed
+        run: |
+          set -o pipefail
+          staticcheck ./... | sed -e 's@\(.*\)\.go@./\1.go@g'
+

.github/workflows/go-test.yml

+# File managed by web3-bot. DO NOT EDIT.
+# See https://github.com/protocol/.github/ for details.
+
+on: [push, pull_request]
+
+jobs:
+  unit:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ "ubuntu", "windows", "macos" ]
+        go: [ "1.15.x", "1.16.x" ]
+    runs-on: ${{ matrix.os }}-latest
+    name: Unit tests (${{ matrix.os}}, Go ${{ matrix.go }})
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go }}
+      - name: Go information
+        run: |
+          go version
+          go env
+      - name: Run tests
+        run: go test -v -coverprofile coverage.txt ./...
+      - name: Run tests (32 bit)
+        if: ${{ matrix.os != 'macos' }} # can't run 32 bit tests on OSX.
+        env:
+          GOARCH: 386
+        run: go test -v ./...
+      - name: Run tests with race detector
+        if: ${{ matrix.os == 'ubuntu' }} # speed things up. Windows and OSX VMs are slow
+        run: go test -v -race ./...
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@967e2b38a85a62bd61be5529ada27ebc109948c2 # v1.4.1
+        with:
+          file: coverage.txt
+          env_vars: OS=${{ matrix.os }}, GO=${{ matrix.go }}

.gx/lastpubver

+1.1.41: QmUquHAkyh9phs4ojSuHcHcZnUMGDwDNJZWnRXkNks1qLB

LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2014-2018 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

Makefile

+gx:
+	go get github.com/whyrusleeping/gx
+	go get github.com/whyrusleeping/gx-go
+
+deps: gx
+	gx --verbose install --global
+	gx-go rewrite
+
+publish:
+	gx-go rewrite --undo
+

README.md

-# go-path
+go-path
+==================
 
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/)
+[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
+[![Coverage Status](https://codecov.io/gh/ipfs/go-path/branch/master/graph/badge.svg)](https://codecov.io/gh/ipfs/go-path/branch/master)
+[![Travis CI](https://travis-ci.org/ipfs/go-path.svg?branch=master)](https://travis-ci.org/ipfs/go-path)
+
+> go-path is a helper package that provides utilities for parsing and using ipfs paths
+
+## Lead Maintainer
+
+[Steven Allen](https://github.com/Stebalien)
+
+## Table of Contents
+
+- [API](#api)
+- [Contribute](#contribute)
+- [License](#license)
+
+## TODO
+
+This package could probably be merged into go-ipld, or something along those lines. It
+doesnt really make sense as its own standalone thing.
+
+## Contribute
+
+PRs are welcome!
+
+Small note: If editing the Readme, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+MIT © Juan Batiz-Benet

error.go

+package path
+
+import (
+	"fmt"
+)
+
+// helper type so path parsing errors include the path
+type pathError struct {
+	error error
+	path  string
+}
+
+func (e *pathError) Error() string {
+	return fmt.Sprintf("invalid path %q: %s", e.path, e.error)
+}
+
+func (e *pathError) Unwrap() error {
+	return e.error
+}
+
+func (e *pathError) Path() string {
+	return e.path
+}

go.mod

+module github.com/ipfs/go-path
+
+go 1.15
+
+require (
+	github.com/ipfs/go-cid v0.0.2
+	github.com/ipfs/go-ipld-format v0.0.2
+	github.com/ipfs/go-log v0.0.1
+	github.com/ipfs/go-merkledag v0.0.6
+)

package.json

+{
+  "author": "why",
+  "bugs": {
+    "url": "https://github.com/ipfs/go-path"
+  },
+  "gx": {
+    "dvcsimport": "github.com/ipfs/go-path"
+  },
+  "gxDependencies": [
+    {
+      "author": "why",
+      "hash": "QmY6UwsN3D6uoxrRkYpJ8Wos8R66gwLmdn3wy7jM7CCRQ1",
+      "name": "go-merkledag",
+      "version": "1.1.40"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmZ6nzCLwGLVfRzYLpD7pW6UNuBDKEcA2imJtVpbEx2rxy",
+      "name": "go-ipld-format",
+      "version": "0.8.1"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmTbxNB1NwDesLmKTscr4udL2tVP7MaxvXnD1D9yX7g3PN",
+      "name": "go-cid",
+      "version": "0.9.3"
+    },
+    {
+      "hash": "QmbkT7eMTyXfpeyB3ZMxxcxg7XH8t6uXp49jqzz4HB7BGF",
+      "name": "go-log",
+      "version": "1.5.9"
+    }
+  ],
+  "gxVersion": "0.12.1",
+  "language": "go",
+  "license": "",
+  "name": "go-path",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "1.1.41"
+}
+

path.go

+// Package path contains utilities to work with ipfs paths.
+package path
+
+import (
+	"fmt"
+	"path"
+	"strings"
+
+	cid "github.com/ipfs/go-cid"
+)
+
+// A Path represents an ipfs content path:
+//   * /<cid>/path/to/file
+//   * /ipfs/<cid>
+//   * /ipns/<cid>/path/to/folder
+//   * etc
+type Path string
+
+// ^^^
+// TODO: debate making this a private struct wrapped in a public interface
+// would allow us to control creation, and cache segments.
+
+// FromString safely converts a string type to a Path type.
+func FromString(s string) Path {
+	return Path(s)
+}
+
+// FromCid safely converts a cid.Cid type to a Path type.
+func FromCid(c cid.Cid) Path {
+	return Path("/ipfs/" + c.String())
+}
+
+// Segments returns the different elements of a path
+// (elements are delimited by a /).
+func (p Path) Segments() []string {
+	cleaned := path.Clean(string(p))
+	segments := strings.Split(cleaned, "/")
+
+	// Ignore leading slash
+	if len(segments[0]) == 0 {
+		segments = segments[1:]
+	}
+
+	return segments
+}
+
+// String converts a path to string.
+func (p Path) String() string {
+	return string(p)
+}
+
+// IsJustAKey returns true if the path is of the form <key> or /ipfs/<key>, or
+// /ipld/<key>
+func (p Path) IsJustAKey() bool {
+	parts := p.Segments()
+	return len(parts) == 2 && (parts[0] == "ipfs" || parts[0] == "ipld")
+}
+
+// PopLastSegment returns a new Path without its final segment, and the final
+// segment, separately. If there is no more to pop (the path is just a key),
+// the original path is returned.
+func (p Path) PopLastSegment() (Path, string, error) {
+
+	if p.IsJustAKey() {
+		return p, "", nil
+	}
+
+	segs := p.Segments()
+	newPath, err := ParsePath("/" + strings.Join(segs[:len(segs)-1], "/"))
+	if err != nil {
+		return "", "", err
+	}
+
+	return newPath, segs[len(segs)-1], nil
+}
+
+// FromSegments returns a path given its different segments.
+func FromSegments(prefix string, seg ...string) (Path, error) {
+	return ParsePath(prefix + strings.Join(seg, "/"))
+}
+
+// ParsePath returns a well-formed ipfs Path.
+// The returned path will always be prefixed with /ipfs/ or /ipns/.
+// The prefix will be added if not present in the given string.
+// This function will return an error when the given string is
+// not a valid ipfs path.
+func ParsePath(txt string) (Path, error) {
+	parts := strings.Split(txt, "/")
+	if len(parts) == 1 {
+		kp, err := ParseCidToPath(txt)
+		if err == nil {
+			return kp, nil
+		}
+	}
+
+	// if the path doesnt begin with a '/'
+	// we expect this to start with a hash, and be an 'ipfs' path
+	if parts[0] != "" {
+		if _, err := decodeCid(parts[0]); err != nil {
+			return "", &pathError{error: err, path: txt}
+		}
+		// The case when the path starts with hash without a protocol prefix
+		return Path("/ipfs/" + txt), nil
+	}
+
+	if len(parts) < 3 {
+		return "", &pathError{error: fmt.Errorf("path does not begin with '/'"), path: txt}
+	}
+
+	//TODO: make this smarter
+	switch parts[1] {
+	case "ipfs", "ipld":
+		if parts[2] == "" {
+			return "", &pathError{error: fmt.Errorf("not enough path components"), path: txt}
+		}
+		// Validate Cid.
+		_, err := decodeCid(parts[2])
+		if err != nil {
+			return "", &pathError{error: fmt.Errorf("invalid CID: %s", err), path: txt}
+		}
+	case "ipns":
+		if parts[2] == "" {
+			return "", &pathError{error: fmt.Errorf("not enough path components"), path: txt}
+		}
+	default:
+		return "", &pathError{error: fmt.Errorf("unknown namespace %q", parts[1]), path: txt}
+	}
+
+	return Path(txt), nil
+}
+
+// ParseCidToPath takes a CID in string form and returns a valid ipfs Path.
+func ParseCidToPath(txt string) (Path, error) {
+	if txt == "" {
+		return "", &pathError{error: fmt.Errorf("empty"), path: txt}
+	}
+
+	c, err := decodeCid(txt)
+	if err != nil {
+		return "", &pathError{error: err, path: txt}
+	}
+
+	return FromCid(c), nil
+}
+
+// IsValid checks if a path is a valid ipfs Path.
+func (p *Path) IsValid() error {
+	_, err := ParsePath(p.String())
+	return err
+}
+
+// Join joins strings slices using /
+func Join(pths []string) string {
+	return strings.Join(pths, "/")
+}
+
+// SplitList splits strings usings /
+func SplitList(pth string) []string {
+	return strings.Split(pth, "/")
+}
+
+// SplitAbsPath clean up and split fpath. It extracts the first component (which
+// must be a Multihash) and return it separately.
+func SplitAbsPath(fpath Path) (cid.Cid, []string, error) {
+	parts := fpath.Segments()
+	if parts[0] == "ipfs" || parts[0] == "ipld" {
+		parts = parts[1:]
+	}
+
+	// if nothing, bail.
+	if len(parts) == 0 {
+		return cid.Cid{}, nil, &pathError{error: fmt.Errorf("empty"), path: string(fpath)}
+	}
+
+	c, err := decodeCid(parts[0])
+	// first element in the path is a cid
+	if err != nil {
+		return cid.Cid{}, nil, &pathError{error: fmt.Errorf("invalid CID: %s", err), path: string(fpath)}
+	}
+
+	return c, parts[1:], nil
+}
+
+func decodeCid(cstr string) (cid.Cid, error) {
+	c, err := cid.Decode(cstr)
+	if err != nil && len(cstr) == 46 && cstr[:2] == "qm" { // https://github.com/ipfs/go-ipfs/issues/7792
+		return cid.Cid{}, fmt.Errorf("%v (possible lowercased CIDv0; consider converting to a case-agnostic CIDv1, such as base32)", err)
+	}
+	return c, err
+}

path_test.go

+package path
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestPathParsing(t *testing.T) {
+	cases := map[string]bool{
+		"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":             true,
+		"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a":           true,
+		"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a/b/c/d/e/f": true,
+		"/ipld/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":             true,
+		"/ipld/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a":           true,
+		"/ipld/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a/b/c/d/e/f": true,
+		"/ipns/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a/b/c/d/e/f": true,
+		"/ipns/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":             true,
+		"QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a/b/c/d/e/f":       true,
+		"QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":                   true,
+		"/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":                  false,
+		"/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a":                false,
+		"/ipfs/foo": false,
+		"/ipfs/":    false,
+		"ipfs/":     false,
+		"ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n": false,
+		"/ipld/foo": false,
+		"/ipld/":    false,
+		"ipld/":     false,
+		"ipld/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n": false,
+	}
+
+	for p, expected := range cases {
+		_, err := ParsePath(p)
+		valid := err == nil
+		if valid != expected {
+			t.Fatalf("expected %s to have valid == %t", p, expected)
+		}
+	}
+}
+
+func TestNoComponents(t *testing.T) {
+	for _, s := range []string{
+		"/ipfs/",
+		"/ipns/",
+		"/ipld/",
+	} {
+		_, err := ParsePath(s)
+		if err == nil || !strings.Contains(err.Error(), "not enough path components") || !strings.Contains(err.Error(), s) {
+			t.Error("wrong error")
+		}
+	}
+}
+
+func TestIsJustAKey(t *testing.T) {
+	cases := map[string]bool{
+		"QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":           true,
+		"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":     true,
+		"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a":   false,
+		"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a/b": false,
+		"/ipns/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":     false,
+		"/ipld/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a/b": false,
+		"/ipld/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":     true,
+	}
+
+	for p, expected := range cases {
+		path, err := ParsePath(p)
+		if err != nil {
+			t.Fatalf("ParsePath failed to parse \"%s\", but should have succeeded", p)
+		}
+		result := path.IsJustAKey()
+		if result != expected {
+			t.Fatalf("expected IsJustAKey(%s) to return %v, not %v", p, expected, result)
+		}
+	}
+}
+
+func TestPopLastSegment(t *testing.T) {
+	cases := map[string][]string{
+		"QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":             {"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n", ""},
+		"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n":       {"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n", ""},
+		"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a":     {"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n", "a"},
+		"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a/b":   {"/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/a", "b"},
+		"/ipns/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/x/y/z": {"/ipns/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/x/y", "z"},
+		"/ipld/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/x/y/z": {"/ipld/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n/x/y", "z"},
+	}
+
+	for p, expected := range cases {
+		path, err := ParsePath(p)
+		if err != nil {
+			t.Fatalf("ParsePath failed to parse \"%s\", but should have succeeded", p)
+		}
+		head, tail, err := path.PopLastSegment()
+		if err != nil {
+			t.Fatalf("PopLastSegment failed, but should have succeeded: %s", err)
+		}
+		headStr := head.String()
+		if headStr != expected[0] {
+			t.Fatalf("expected head of PopLastSegment(%s) to return %v, not %v", p, expected[0], headStr)
+		}
+		if tail != expected[1] {
+			t.Fatalf("expected tail of PopLastSegment(%s) to return %v, not %v", p, expected[1], tail)
+		}
+	}
+}
+
+func TestV0ErrorDueToLowercase(t *testing.T) {
+	badb58 := "/ipfs/qmbwqxbekc3p8tqskc98xmwnzrzdtrlmimpl8wbutgsmnr"
+	_, err := ParsePath(badb58)
+	if err == nil {
+		t.Fatal("should have failed to decode")
+	}
+	if !strings.HasSuffix(err.Error(), "(possible lowercased CIDv0; consider converting to a case-agnostic CIDv1, such as base32)") {
+		t.Fatal("should have meaningful info about case-insensitive fix")
+	}
+}

resolver/resolver.go

+// Package resolver implements utilities for resolving paths within ipfs.
+package resolver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	path "github.com/ipfs/go-path"
+
+	cid "github.com/ipfs/go-cid"
+	ipld "github.com/ipfs/go-ipld-format"
+	logging "github.com/ipfs/go-log"
+	dag "github.com/ipfs/go-merkledag"
+)
+
+var log = logging.Logger("pathresolv")
+
+// ErrNoComponents is used when Paths after a protocol
+// do not contain at least one component
+var ErrNoComponents = errors.New(
+	"path must contain at least one component")
+
+// ErrNoLink is returned when a link is not found in a path
+type ErrNoLink struct {
+	Name string
+	Node cid.Cid
+}
+
+// Error implements the Error interface for ErrNoLink with a useful
+// human readable message.
+func (e ErrNoLink) Error() string {
+	return fmt.Sprintf("no link named %q under %s", e.Name, e.Node.String())
+}
+
+// ResolveOnce resolves path through a single node
+type ResolveOnce func(ctx context.Context, ds ipld.NodeGetter, nd ipld.Node, names []string) (*ipld.Link, []string, error)
+
+// Resolver provides path resolution to IPFS
+// It has a pointer to a DAGService, which is uses to resolve nodes.
+// TODO: now that this is more modular, try to unify this code with the
+//       the resolvers in namesys
+type Resolver struct {
+	DAG ipld.NodeGetter
+
+	ResolveOnce ResolveOnce
+}
+
+// NewBasicResolver constructs a new basic resolver.
+func NewBasicResolver(ds ipld.DAGService) *Resolver {
+	return &Resolver{
+		DAG:         ds,
+		ResolveOnce: ResolveSingle,
+	}
+}
+
+// ResolveToLastNode walks the given path and returns the cid of the last node
+// referenced by the path
+func (r *Resolver) ResolveToLastNode(ctx context.Context, fpath path.Path) (cid.Cid, []string, error) {
+	c, p, err := path.SplitAbsPath(fpath)
+	if err != nil {
+		return cid.Cid{}, nil, err
+	}
+
+	if len(p) == 0 {
+		return c, nil, nil
+	}
+
+	nd, err := r.DAG.Get(ctx, c)
+	if err != nil {
+		return cid.Cid{}, nil, err
+	}
+
+	for len(p) > 0 {
+		lnk, rest, err := r.ResolveOnce(ctx, r.DAG, nd, p)
+
+		// Note: have to drop the error here as `ResolveOnce` doesn't handle 'leaf'
+		// paths (so e.g. for `echo '{"foo":123}' | ipfs dag put` we wouldn't be
+		// able to resolve `zdpu[...]/foo`)
+		if lnk == nil {
+			break
+		}
+
+		if err != nil {
+			if err == dag.ErrLinkNotFound {
+				err = ErrNoLink{Name: p[0], Node: nd.Cid()}
+			}
+			return cid.Cid{}, nil, err
+		}
+
+		if len(rest) == 0 {
+			return lnk.Cid, nil, nil
+		}
+
+		next, err := lnk.GetNode(ctx, r.DAG)
+		if err != nil {
+			return cid.Cid{}, nil, err
+		}
+		nd = next
+		p = rest
+	}
+
+	if len(p) == 0 {
+		return nd.Cid(), nil, nil
+	}
+
+	// Confirm the path exists within the object
+	val, rest, err := nd.Resolve(p)
+	if err != nil {
+		if err == dag.ErrLinkNotFound {
+			err = ErrNoLink{Name: p[0], Node: nd.Cid()}
+		}
+		return cid.Cid{}, nil, err
+	}
+
+	if len(rest) > 0 {
+		return cid.Cid{}, nil, errors.New("path failed to resolve fully")
+	}
+	switch val.(type) {
+	case *ipld.Link:
+		return cid.Cid{}, nil, errors.New("inconsistent ResolveOnce / nd.Resolve")
+	default:
+		return nd.Cid(), p, nil
+	}
+}
+
+// ResolvePath fetches the node for given path. It returns the last item
+// returned by ResolvePathComponents.
+func (r *Resolver) ResolvePath(ctx context.Context, fpath path.Path) (ipld.Node, error) {
+	// validate path
+	if err := fpath.IsValid(); err != nil {
+		return nil, err
+	}
+
+	nodes, err := r.ResolvePathComponents(ctx, fpath)
+	if err != nil || nodes == nil {
+		return nil, err
+	}
+	return nodes[len(nodes)-1], err
+}
+
+// ResolveSingle simply resolves one hop of a path through a graph with no
+// extra context (does not opaquely resolve through sharded nodes)
+func ResolveSingle(ctx context.Context, ds ipld.NodeGetter, nd ipld.Node, names []string) (*ipld.Link, []string, error) {
+	return nd.ResolveLink(names)
+}
+
+// ResolvePathComponents fetches the nodes for each segment of the given path.
+// It uses the first path component as a hash (key) of the first node, then
+// resolves all other components walking the links, with ResolveLinks.
+func (r *Resolver) ResolvePathComponents(ctx context.Context, fpath path.Path) ([]ipld.Node, error) {
+	evt := log.EventBegin(ctx, "resolvePathComponents", logging.LoggableMap{"fpath": fpath})
+	defer evt.Done()
+
+	h, parts, err := path.SplitAbsPath(fpath)
+	if err != nil {
+		evt.Append(logging.LoggableMap{"error": err.Error()})
+		return nil, err
+	}
+
+	log.Debug("resolve dag get")
+	nd, err := r.DAG.Get(ctx, h)
+	if err != nil {
+		evt.Append(logging.LoggableMap{"error": err.Error()})
+		return nil, err
+	}
+
+	return r.ResolveLinks(ctx, nd, parts)
+}
+
+// ResolveLinks iteratively resolves names by walking the link hierarchy.
+// Every node is fetched from the DAGService, resolving the next name.
+// Returns the list of nodes forming the path, starting with ndd. This list is
+// guaranteed never to be empty.
+//
+// ResolveLinks(nd, []string{"foo", "bar", "baz"})
+// would retrieve "baz" in ("bar" in ("foo" in nd.Links).Links).Links
+func (r *Resolver) ResolveLinks(ctx context.Context, ndd ipld.Node, names []string) ([]ipld.Node, error) {
+
+	evt := log.EventBegin(ctx, "resolveLinks", logging.LoggableMap{"names": names})
+	defer evt.Done()
+	result := make([]ipld.Node, 0, len(names)+1)
+	result = append(result, ndd)
+	nd := ndd // dup arg workaround
+
+	// for each of the path components
+	for len(names) > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, time.Minute)
+		defer cancel()
+
+		lnk, rest, err := r.ResolveOnce(ctx, r.DAG, nd, names)
+		if err == dag.ErrLinkNotFound {
+			evt.Append(logging.LoggableMap{"error": err.Error()})
+			return result, ErrNoLink{Name: names[0], Node: nd.Cid()}
+		} else if err != nil {
+			evt.Append(logging.LoggableMap{"error": err.Error()})
+			return result, err
+		}
+
+		nextnode, err := lnk.GetNode(ctx, r.DAG)
+		if err != nil {
+			evt.Append(logging.LoggableMap{"error": err.Error()})
+			return result, err
+		}
+
+		nd = nextnode
+		result = append(result, nextnode)
+		names = rest
+	}
+	return result, nil
+}

resolver/resolver_test.go

+package resolver_test
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"testing"
+	"time"
+
+	path "github.com/ipfs/go-path"
+	"github.com/ipfs/go-path/resolver"
+
+	ipld "github.com/ipfs/go-ipld-format"
+	merkledag "github.com/ipfs/go-merkledag"
+	dagmock "github.com/ipfs/go-merkledag/test"
+)
+
+func randNode() *merkledag.ProtoNode {
+	node := new(merkledag.ProtoNode)
+	node.SetData(make([]byte, 32))
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	r.Read(node.Data())
+	return node
+}
+
+func TestRecurivePathResolution(t *testing.T) {
+	ctx := context.Background()
+	dagService := dagmock.Mock()
+
+	a := randNode()
+	b := randNode()
+	c := randNode()
+
+	err := b.AddNodeLink("grandchild", c)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = a.AddNodeLink("child", b)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, n := range []ipld.Node{a, b, c} {
+		err = dagService.Add(ctx, n)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	aKey := a.Cid()
+
+	segments := []string{aKey.String(), "child", "grandchild"}
+	p, err := path.FromSegments("/ipfs/", segments...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resolver := resolver.NewBasicResolver(dagService)
+	node, err := resolver.ResolvePath(ctx, p)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cKey := c.Cid()
+	key := node.Cid()
+	if key.String() != cKey.String() {
+		t.Fatal(fmt.Errorf(
+			"recursive path resolution failed for %s: %s != %s",
+			p.String(), key.String(), cKey.String()))
+	}
+
+	rCid, rest, err := resolver.ResolveToLastNode(ctx, p)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(rest) != 0 {
+		t.Error("expected rest to be empty")
+	}
+
+	if rCid.String() != cKey.String() {
+		t.Fatal(fmt.Errorf(
+			"ResolveToLastNode failed for %s: %s != %s",
+			p.String(), rCid.String(), cKey.String()))
+	}
+
+	p2, err := path.FromSegments("/ipfs/", aKey.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	rCid, rest, err = resolver.ResolveToLastNode(ctx, p2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(rest) != 0 {
+		t.Error("expected rest to be empty")
+	}
+
+	if rCid.String() != aKey.String() {
+		t.Fatal(fmt.Errorf(
+			"ResolveToLastNode failed for %s: %s != %s",
+			p.String(), rCid.String(), cKey.String()))
+	}
+}
+
+func TestResolveToLastNode_NoUnnecessaryFetching(t *testing.T) {
+	ctx := context.Background()
+	dagService := dagmock.Mock()
+
+	a := randNode()
+	b := randNode()
+
+	err := a.AddNodeLink("child", b)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = dagService.Add(ctx, a)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	aKey := a.Cid()
+
+	segments := []string{aKey.String(), "child"}
+	p, err := path.FromSegments("/ipfs/", segments...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resolver := resolver.NewBasicResolver(dagService)
+	resolvedCID, remainingPath, err := resolver.ResolveToLastNode(ctx, p)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(remainingPath) > 0 {
+		t.Fatal("cannot have remaining path")
+	}
+
+	if !resolvedCID.Equals(b.Cid()) {
+		t.Fatal("resolved to the wrong CID")
+	}
+}