chain

README

chain

Chain readers and writers with ease

Documentation

Index

• type NopWriteCloser
  • func (NopWriteCloser) Close() error
• type OS
  • func (o OS) Close() error
  • func (o OS) Create(name string) (io.WriteCloser, error)
  • func (o OS) Open(name string) (io.ReadCloser, error)
• type ReadChain
• type ReadCloser
• type ReadCloser2
  • func (wc ReadCloser2) Close() error
• type ReadFS
• type ReadFSChain
• type ReaderBuilder
  • func ReadingFrom(r io.ReadCloser) *ReaderBuilder
  • func (chain *ReaderBuilder) AsFS(next ReadFSChain) *ReaderFSBuilder
  • func (chain *ReaderBuilder) Finally(next ReadChain) (io.ReadCloser, error)
  • func (chain *ReaderBuilder) Then(next ReadChain) *ReaderBuilder
• type ReaderFSBuilder
  • func ReadingFromFS(fs ReadFS) *ReaderFSBuilder
  • func (chain *ReaderFSBuilder) Finally(next ReadChain) (ReadFS, error)
  • func (chain *ReaderFSBuilder) Open(name string) *ReaderBuilder
  • func (chain *ReaderFSBuilder) Then(next ReadChain) *ReaderFSBuilder
• type WriteChain
• type WriteCloser2
  • func (wc WriteCloser2) Close() error
• type WriteFS
• type WriteFSBuilder
  • func (wc *WriteFSBuilder) Then(next WriteChain) *WriteFSBuilder
  • func (wc *WriteFSBuilder) WritingTo(w io.WriteCloser) (WriteFS, error)
• type WriteFSChain
• type WriterBuilder
  • func NewWriteBuilder(first WriteChain) *WriterBuilder
  • func (wc *WriterBuilder) IntoFS(next WriteFSChain) *WriteFSBuilder
  • func (wc *WriterBuilder) Open(name string) *WriterFileBuilder
  • func (wc *WriterBuilder) Then(next WriteChain) *WriterBuilder
  • func (wc *WriterBuilder) WritingTo(w io.WriteCloser) (io.WriteCloser, error)
  • func (wc *WriterBuilder) WritingToFS(fs WriteFS) WriteFS
• type WriterFileBuilder
  • func (builder *WriterFileBuilder) InFS(next WriteFSChain) *WriterBuilder
  • func (builder *WriterFileBuilder) WritingToFS(fs WriteFS) (io.WriteCloser, error)

Examples

• NewWriteBuilder
• ReaderBuilder.AsFS
• ReaderFSBuilder.Open
• ReadingFromFS
• WriterBuilder.IntoFS

Types

type NopWriteCloser

type NopWriteCloser struct {
	io.Writer
}

func (NopWriteCloser) Close

func (NopWriteCloser) Close() error

type OS

type OS struct {
	RootDir string
}

func (OS) Close

func (o OS) Close() error

func (OS) Create

func (o OS) Create(name string) (io.WriteCloser, error)

func (OS) Open

func (o OS) Open(name string) (io.ReadCloser, error)

type ReadChain

type ReadChain func(io.ReadCloser) (io.ReadCloser, error)

ReadChain represents a common pattern in go packages. For examples, see: https://pkg.go.dev/compress/gzip#NewReader

While this type only expects an io.Reader to be returned, it will detect if the result is a Closer and make sure the types Close function is run.

type ReadCloser

type ReadCloser struct {
	io.Reader
	io.Closer
}

type ReadCloser2

type ReadCloser2 struct {
	io.ReadCloser
	Closer io.Closer
}

func (ReadCloser2) Close

func (wc ReadCloser2) Close() error

type ReadFS

type ReadFS interface {
	Open(path string) (io.ReadCloser, error)
	io.Closer
}

type ReadFSChain

type ReadFSChain func(io.ReadCloser) (ReadFS, error)

type ReaderBuilder

type ReaderBuilder struct {
	// contains filtered or unexported fields
}

ReaderBuilder lets you build a chain of io.Readers in a more natural way

func ReadingFrom

func ReadingFrom(r io.ReadCloser) *ReaderBuilder

ReadingFrom creates a new ReaderBuilder where the contents of the chain comes from the given io.Reader

If r is an io.ReadCloser, the resulting Reader after building the chain will call r.Close for you

func (*ReaderBuilder) AsFS

func (chain *ReaderBuilder) AsFS(next ReadFSChain) *ReaderFSBuilder

Example

package main

import (
	"encoding/base64"
	"io"
	"os"

	"github.com/conradludgate/chain"
	"github.com/conradludgate/chain/archive"
	"github.com/conradludgate/chain/encoding"
)

func main() {
	zip := archive.ZipConfig{}
	b64 := encoding.Base64Config{Encoding: base64.RawStdEncoding}

	fs, _ := chain.ReadingFromFS(chain.OS{RootDir: "./example"}).
		Open("archive.zip").
		AsFS(zip.FSReader).
		Finally(b64.Decode)
	defer fs.Close()

	r, _ := fs.Open("hello.txt")
	defer r.Close()
	_, _ = io.Copy(os.Stdout, r)
}

func (*ReaderBuilder) Finally

func (chain *ReaderBuilder) Finally(next ReadChain) (io.ReadCloser, error)

Finally adds the last ReadChain to the current builder chain, then builds it into an io.ReadCloser

func (*ReaderBuilder) Then

func (chain *ReaderBuilder) Then(next ReadChain) *ReaderBuilder

Then adds the next ReadChain to the current builder chain

type ReaderFSBuilder

type ReaderFSBuilder struct {
	// contains filtered or unexported fields
}

func ReadingFromFS

func ReadingFromFS(fs ReadFS) *ReaderFSBuilder

Example

package main

import (
	"encoding/base64"
	"io"
	"os"

	"github.com/conradludgate/chain"
	"github.com/conradludgate/chain/encoding"
)

func main() {
	b64 := encoding.Base64Config{Encoding: base64.RawStdEncoding}

	fs, _ := chain.ReadingFromFS(chain.OS{RootDir: "./example"}).Finally(b64.Decode)
	defer fs.Close()

	r, _ := fs.Open("hello.txt")
	defer r.Close()
	_, _ = io.Copy(os.Stdout, r)
}

func (*ReaderFSBuilder) Finally

func (chain *ReaderFSBuilder) Finally(next ReadChain) (ReadFS, error)

func (*ReaderFSBuilder) Open

func (chain *ReaderFSBuilder) Open(name string) *ReaderBuilder

Example

package main

import (
	"encoding/base64"
	"io"
	"os"

	"github.com/conradludgate/chain"
	"github.com/conradludgate/chain/archive"
	"github.com/conradludgate/chain/encoding"
)

func main() {
	zip := archive.ZipConfig{}
	b64 := encoding.Base64Config{Encoding: base64.RawStdEncoding}

	r, _ := chain.ReadingFromFS(chain.OS{RootDir: "./example"}).
		Open("archive.zip").
		AsFS(zip.FSReader).
		Open("hello.txt").
		Finally(b64.Decode)

	defer r.Close()
	_, _ = io.Copy(os.Stdout, r)
}

func (*ReaderFSBuilder) Then

func (chain *ReaderFSBuilder) Then(next ReadChain) *ReaderFSBuilder

type WriteChain

type WriteChain func(io.WriteCloser) (io.WriteCloser, error)

WriteChain represents a common pattern in go packages. For examples, see: https://pkg.go.dev/compress/gzip#NewWriter https://pkg.go.dev/golang.org/x/crypto/openpgp#Encrypt

While this type only expects an io.Writer to be returned, it will detect if the result is a Closer and make sure the types Close function is run.

type WriteCloser2

type WriteCloser2 struct {
	io.WriteCloser
	Closer io.Closer
}

func (WriteCloser2) Close

func (wc WriteCloser2) Close() error

type WriteFS

type WriteFS interface {
	Create(path string) (io.WriteCloser, error)
	io.Closer
}

type WriteFSBuilder

type WriteFSBuilder struct {
	// contains filtered or unexported fields
}

func (*WriteFSBuilder) Then

func (wc *WriteFSBuilder) Then(next WriteChain) *WriteFSBuilder

func (*WriteFSBuilder) WritingTo

func (wc *WriteFSBuilder) WritingTo(w io.WriteCloser) (WriteFS, error)

type WriteFSChain

type WriteFSChain func(io.WriteCloser) (WriteFS, error)

type WriterBuilder

type WriterBuilder struct {
	// contains filtered or unexported fields
}

WriterBuilder lets you build a chain of io.Writers in a more natural way

func NewWriteBuilder

func NewWriteBuilder(first WriteChain) *WriterBuilder

NewWriteBuilder creates a new WriteBuilder with the given WriteChain being the first in the chain

Example

package main

import (
	"bytes"
	"encoding/hex"
	"io"
	"os"

	"github.com/conradludgate/chain"
	"github.com/conradludgate/chain/cipher"
	"github.com/conradludgate/chain/compress"
)

func main() {
	key, _ := hex.DecodeString("6368616e676520746869732070617373")
	aes := cipher.AESConfig{Key: key}
	gzip := compress.GZIPConfig{}

	output := bytes.NewBuffer(nil)

	w, _ := chain.NewWriteBuilder(aes.Encrypt).
		Then(gzip.Compress).
		WritingTo(chain.NopWriteCloser{Writer: output})

	_, _ = io.WriteString(w, "hello world")
	w.Close()

	r, _ := chain.ReadingFrom(io.NopCloser(output)).
		Then(gzip.Decompress).
		Finally(aes.Decrypt)

	_, _ = io.Copy(os.Stdout, r)
	r.Close()

}

Output:

hello world

func (*WriterBuilder) IntoFS

func (wc *WriterBuilder) IntoFS(next WriteFSChain) *WriteFSBuilder

Example

package main

import (
	"bytes"
	"encoding/hex"
	"io"
	"os"

	"github.com/conradludgate/chain"
	"github.com/conradludgate/chain/archive"
	"github.com/conradludgate/chain/cipher"
)

func main() {
	key, _ := hex.DecodeString("6368616e676520746869732070617373")
	aes := cipher.AESConfig{Key: key}
	zip := archive.ZipConfig{}

	output := bytes.NewBuffer(nil)

	w, _ := chain.NewWriteBuilder(aes.Encrypt).
		Open("hello.txt").
		InFS(zip.FSWriter).
		WritingTo(chain.NopWriteCloser{Writer: output})

	_, _ = io.WriteString(w, "hello world")
	w.Close()

	r, _ := chain.ReadingFrom(io.NopCloser(output)).
		AsFS(zip.FSReader).
		Open("hello.txt").
		Finally(aes.Decrypt)

	_, _ = io.Copy(os.Stdout, r)
	r.Close()

}

Output:

hello world

func (*WriterBuilder) Open

func (wc *WriterBuilder) Open(name string) *WriterFileBuilder

func (*WriterBuilder) Then

func (wc *WriterBuilder) Then(next WriteChain) *WriterBuilder

Then adds the next WriteChain to the current builder chain. Returns self

func (*WriterBuilder) WritingTo

func (wc *WriterBuilder) WritingTo(w io.WriteCloser) (io.WriteCloser, error)

WritingTo builds the chain. The resulting data from the chain is written to the io.Writer provided.

If w is a Closer type too, calling the returned writer's Close function will also close w.

func (*WriterBuilder) WritingToFS

func (wc *WriterBuilder) WritingToFS(fs WriteFS) WriteFS

type WriterFileBuilder

type WriterFileBuilder struct {
	// contains filtered or unexported fields
}

func (*WriterFileBuilder) InFS

func (builder *WriterFileBuilder) InFS(next WriteFSChain) *WriterBuilder

func (*WriterFileBuilder) WritingToFS

func (builder *WriterFileBuilder) WritingToFS(fs WriteFS) (io.WriteCloser, error)