epub

package

v0.0.7 Latest Latest Go to latest Published: Jun 26, 2024 License: MIT Imports: 7 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/wormggmm/goreader

Links

Open Source Insights

README ¶

epub

Minimal epub library written in Go

Installation

go get github.com/wormggmm/goreader/epub

Basic usage

import "github.com/wormggmm/goreader/epub"

rc, err := epub.OpenReader(os.Args[1])
if err != nil {
	panic(err)
}
defer rc.Close()

// The rootfile (content.opf) lists all of the contents of an epub file.
// There may be multiple rootfiles, although typically there is only one.
book := rc.Rootfiles[0]

// Print book title.
fmt.Println(book.Title)

// List the IDs of files in the book's spine.
for _, item := range book.Spine.Itemrefs {
	fmt.Println(item.ID)
}

Documentation ¶

Overview ¶

Package epub provides basic support for reading EPUB archives.

Index ¶

Variables
type Container
type Item
- func (item *Item) Open() (r io.ReadCloser, err error)
type Itemref
type Manifest
type Metadata
type Package
type ReadCloser
- func OpenReader(name string) (*ReadCloser, error)
- func (rc *ReadCloser) Close()
type Reader
- func NewReader(ra io.ReaderAt, size int64) (*Reader, error)
type Rootfile
type Spine

Constants ¶

This section is empty.

Variables ¶

View Source

var (
	// ErrNoRootfile occurs when there are no rootfile entries found in
	// container.xml.
	ErrNoRootfile = errors.New("epub: no rootfile found in container")

	// ErrBadRootfile occurs when container.xml references a rootfile that does
	// not exist in the zip.
	ErrBadRootfile = errors.New("epub: container references non-existent rootfile")

	// ErrNoItemref occurrs when a content.opf contains a spine without any
	// itemref entries.
	ErrNoItemref = errors.New("epub: no itemrefs found in spine")

	// ErrBadItemref occurs when an itemref entry in content.opf references an
	// item that does not exist in the manifest.
	ErrBadItemref = errors.New("epub: itemref references non-existent item")

	// ErrBadManifest occurs when a manifest in content.opf references an item
	// that does not exist in the zip.
	ErrBadManifest = errors.New("epub: manifest references non-existent item")
)

Functions ¶

This section is empty.

Types ¶

type Container ¶

type Container struct {
	Rootfiles []*Rootfile `xml:"rootfiles>rootfile"`
}

Container serves as a directory of Rootfiles.

type Item ¶

type Item struct {
	ID        string `xml:"id,attr"`
	HREF      string `xml:"href,attr"`
	MediaType string `xml:"media-type,attr"`
	// contains filtered or unexported fields
}

Item represents a file stored in the epub.

func (*Item) Open ¶

func (item *Item) Open() (r io.ReadCloser, err error)

Open returns a ReadCloser that provides access to the Items's contents. Multiple items may be read concurrently.

type Itemref ¶

type Itemref struct {
	IDREF string `xml:"idref,attr"`
	*Item
}

Itemref points to an Item.

type Manifest ¶

type Manifest struct {
	Items []Item `xml:"manifest>item"`
}

Manifest lists every file that is part of the epub.

type Metadata ¶

type Metadata struct {
	Title       string `xml:"metadata>title"`
	Language    string `xml:"metadata>language"`
	Identifier  string `xml:"metadata>idenifier"`
	Creator     string `xml:"metadata>creator"`
	Contributor string `xml:"metadata>contributor"`
	Publisher   string `xml:"metadata>publisher"`
	Subject     string `xml:"metadata>subject"`
	Description string `xml:"metadata>description"`
	Event       []struct {
		Name string `xml:"event,attr"`
		Date string `xml:",innerxml"`
	} `xml:"metadata>date"`
	Type     string `xml:"metadata>type"`
	Format   string `xml:"metadata>format"`
	Source   string `xml:"metadata>source"`
	Relation string `xml:"metadata>relation"`
	Coverage string `xml:"metadata>coverage"`
	Rights   string `xml:"metadata>rights"`
}

Metadata contains publishing information about the epub.

type Package ¶

type Package struct {
	Metadata
	Manifest
	Spine
}

Package represents an epub content.opf file.

type ReadCloser ¶

type ReadCloser struct {
	Reader
	// contains filtered or unexported fields
}

ReadCloser represents a readable epub file that can be closed.

func OpenReader ¶

func OpenReader(name string) (*ReadCloser, error)

OpenReader will open the epub file specified by name and return a ReadCloser.

func (*ReadCloser) Close ¶

func (rc *ReadCloser) Close()

Close closes the epub file, rendering it unusable for I/O.

type Reader ¶

type Reader struct {
	Container
	// contains filtered or unexported fields
}

Reader represents a readable epub file.

func NewReader ¶

func NewReader(ra io.ReaderAt, size int64) (*Reader, error)

NewReader returns a new Reader reading from ra, which is assumed to have the given size in bytes.

type Rootfile ¶

type Rootfile struct {
	FullPath string `xml:"full-path,attr"`
	Package
}

Rootfile contains the location of a content.opf package file.

type Spine ¶

type Spine struct {
	Itemrefs []Itemref `xml:"spine>itemref"`
}

Spine defines the reading order of the epub documents.

Source Files ¶

View all Source files

epub.go

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL