did

package module
v0.1.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 18, 2018 License: Apache-2.0 Imports: 2 Imported by: 20

README

did

Build Status Go Report Card cover.run GoDoc License

did is a Go package that provides tools to work with Decentralized Identifiers (DIDs).

Install

go get github.com/ockam-network/did

Example

package main

import (
	"fmt"
	"log"

	"github.com/ockam-network/did"
)

func main() {
	d, err := did.Parse("did:example:q7ckgxeq1lxmra0r")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%#v", d)
}

The above example parses the input string according to the rules defined in the DID Grammar and prints the following value of DID type.

&did.DID{
	Method:"example",
	ID:"q7ckgxeq1lxmra0r",
	IDStrings:[]string{"q7ckgxeq1lxmra0r"},
	Path:"",
	PathSegments:[]string(nil),
	Fragment:""
}

The input string may also be a DID Reference with a DID Path:

d, err := did.Parse("did:example:q7ckgxeq1lxmra0r/abc/pqr")

which would result in:

&did.DID{
	Method:"example",
	ID:"q7ckgxeq1lxmra0r",
	IDStrings:[]string{"q7ckgxeq1lxmra0r"},
	Path:"abc/pqr",
	PathSegments:[]string{"abc", "pqr"},
	Fragment:""
}

or a DID Reference with a DID Fragment:

d, err := did.Parse("did:example:q7ckgxeq1lxmra0r#keys-1")
fmt.Println(d.Fragment)
// Output: keys-1

This package also implements the Stringer interface for the DID type. It is easy to convert DID type structures into valid DID strings:

d := &did.DID{Method: "example", ID: "q7ckgxeq1lxmra0r"}
fmt.Println(d.String())
// Output: did:example:q7ckgxeq1lxmra0r

or with a refence with a fragment:

d := &did.DID{Method: "example", ID: "q7ckgxeq1lxmra0r", Fragment: "keys-1"}
fmt.Println(d.String())
// Output: did:example:q7ckgxeq1lxmra0r#keys-1

For more documentation and examples, please see godoc.

Build

To compile the code in this repository, run:

go build

Test

This repository includes a comprehensive suite of tests that check for various edge cases within the DID Grammar.

To run the tests, run:

go test -v -cover

Benchmark

We haven't spent any time tuning the performance of the parser, however this repository includes some benchmarks that compare the speed of did.Parse against Go's url.Parse with inputs of similar length, this is intended as a sanity check to ensure that did.Parse is at least comparable in performance to url.Parse

go test -bench=.

did.Parse included in this package:

BenchmarkParse-8                  	 5000000	       345 ns/op
BenchmarkParseWithPath-8          	 3000000	       477 ns/op
BenchmarkParseWithFragment-8      	 3000000	       542 ns/op

Go's url.Parse:

BenchmarkUrlParse-8               	 3000000	       574 ns/op
BenchmarkUrlParseWithPath-8       	 3000000	       514 ns/op
BenchmarkUrlParseWithFragment-8   	 5000000	       382 ns/op

Contributing

This package is early in its development and we welcome all contributions from the DID community. Please open issues and send pull requests.

We follow the conventions specified in Conventional Commits for our commit messages.

License

This package is licensed under Apache License 2.0.

Documentation

Overview

Package did is a set of tools to work with Decentralized Identifiers (DIDs) as described in the DID spec https://w3c-ccg.github.io/did-spec

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DID 

type DID struct {
	// DID Method
	// https://w3c-ccg.github.io/did-spec#dfn-did-method
	Method string

	// The specific-idstring component of a DID
	ID string

	// specific-idstring may be composed of multiple `:` separated idstrings
	// did = "did:" method ":" specific-idstring
	// specific-idstring = idstring *( ":" idstring )
	IDStrings []string

	// DID Path, the portion of a DID reference that follows the first forward slash character.
	// https://w3c-ccg.github.io/did-spec/#dfn-did-path
	Path string

	// Path may be composed of multiple `/` separated segments
	// did-path = segment-nz *( "/" segment )
	PathSegments []string

	// DID Fragment, the portion of a DID reference that follows the first hash sign character ("#")
	// https://w3c-ccg.github.io/did-spec/#dfn-did-fragment
	Fragment string
}

A DID represents a parsed DID or a DID Reference

func Parse 

func Parse(input string) (*DID, error)

Parse parses the input string into a DID structure.

Example 
package main

import (
	"fmt"
	"log"

	"github.com/ockam-network/did"
)

func main() {
	d, err := did.Parse("did:example:q7ckgxeq1lxmra0r")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Method - %s, ID - %s", d.Method, d.ID)
}

Output:

Method - example, ID - q7ckgxeq1lxmra0r
Example (WithFragment) 
package main

import (
	"fmt"
	"log"

	"github.com/ockam-network/did"
)

func main() {
	d, err := did.Parse("did:example:q7ckgxeq1lxmra0r#keys-1")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Method - %s, ID - %s, Fragment - %s", d.Method, d.ID, d.Fragment)
}

Output:

Method - example, ID - q7ckgxeq1lxmra0r, Fragment - keys-1
Example (WithPath) 
package main

import (
	"fmt"
	"log"

	"github.com/ockam-network/did"
)

func main() {
	d, err := did.Parse("did:example:q7ckgxeq1lxmra0r/a/b")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Method - %s, ID - %s, Path - %s", d.Method, d.ID, d.Path)
}

Output:

Method - example, ID - q7ckgxeq1lxmra0r, Path - a/b

func (*DID) IsReference 

func (d *DID) IsReference() bool

IsReference returns true if a DID has a Path or a Fragment https://w3c-ccg.github.io/did-spec/#dfn-did-reference

Example (NoPathOrFragment) 
package main

import (
	"fmt"

	"github.com/ockam-network/did"
)

func main() {
	d := &did.DID{Method: "example", ID: "q7ckgxeq1lxmra0r"}
	fmt.Println(d.IsReference())
}

Output:

false
Example (WithFragment) 
package main

import (
	"fmt"

	"github.com/ockam-network/did"
)

func main() {
	d := &did.DID{Method: "example", ID: "q7ckgxeq1lxmra0r", Fragment: "keys-1"}
	fmt.Println(d.IsReference())
}

Output:

true
Example (WithPath) 
package main

import (
	"fmt"

	"github.com/ockam-network/did"
)

func main() {
	d := &did.DID{Method: "example", ID: "q7ckgxeq1lxmra0r", Path: "a/b"}
	fmt.Println(d.IsReference())
}

Output:

true

func (*DID) String 

func (d *DID) String() string

String encodes a DID struct into a valid DID string.

Example 
package main

import (
	"fmt"

	"github.com/ockam-network/did"
)

func main() {
	d := &did.DID{Method: "example", ID: "q7ckgxeq1lxmra0r"}
	fmt.Println(d.String())
}

Output:

did:example:q7ckgxeq1lxmra0r
Example (WithFragment) 
package main

import (
	"fmt"

	"github.com/ockam-network/did"
)

func main() {
	d := &did.DID{Method: "example", ID: "q7ckgxeq1lxmra0r", Fragment: "keys-1"}
	fmt.Println(d.String())
}

Output:

did:example:q7ckgxeq1lxmra0r#keys-1
Example (WithPath) 
package main

import (
	"fmt"

	"github.com/ockam-network/did"
)

func main() {
	d := &did.DID{Method: "example", ID: "q7ckgxeq1lxmra0r", Path: "a/b"}
	fmt.Println(d.String())
}

Output:

did:example:q7ckgxeq1lxmra0r/a/b
Example (WithPathSegments) 
package main

import (
	"fmt"

	"github.com/ockam-network/did"
)

func main() {
	d := &did.DID{Method: "example", ID: "q7ckgxeq1lxmra0r", PathSegments: []string{"a", "b"}}
	fmt.Println(d.String())
}

Output:

did:example:q7ckgxeq1lxmra0r/a/b

Source Files

View all Source files
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.