move epubzip outside epub

pkg/epub/epub.go

@@ -20,8 +20,8 @@ import (
 	epuboptions "github.com/celogeek/go-comic-converter/v2/pkg/epub/options"
 	epubtemplates "github.com/celogeek/go-comic-converter/v2/pkg/epub/templates"
 	epubtree "github.com/celogeek/go-comic-converter/v2/pkg/epub/tree"
-	epubzip "github.com/celogeek/go-comic-converter/v2/pkg/epub/zip"
 	"github.com/celogeek/go-comic-converter/v2/pkg/epubprogress"
+	"github.com/celogeek/go-comic-converter/v2/pkg/epubzip"
 	"github.com/gofrs/uuid"
 )
 
@@ -199,7 +199,7 @@ func (e *ePub) writeTitleImage(wz *epubzip.EPUBZip, img *epubimage.Image, title
 }
 
 // extract image and split it into part
-func (e *ePub) getParts() (parts []*epubPart, imgStorage *epubzip.EPUBZipStorageImageReader, err error) {
+func (e *ePub) getParts() (parts []*epubPart, imgStorage *epubzip.EPUBZipImageReader, err error) {
 	images, err := e.imageProcessor.Load()
 
 	if err != nil {
@@ -228,7 +228,7 @@ func (e *ePub) getParts() (parts []*epubPart, imgStorage *epubzip.EPUBZipStorage
 		return parts, nil, nil
 	}
 
-	imgStorage, err = epubzip.NewEPUBZipStorageImageReader(e.ImgStorage())
+	imgStorage, err = epubzip.NewImageReader(e.ImgStorage())
 	if err != nil {
 		return nil, nil, err
 	}

pkg/epub/imageprocessor/imageprocessor.go

@@ -14,8 +14,8 @@ import (
 	epubimage "github.com/celogeek/go-comic-converter/v2/pkg/epub/image"
 	epubimagefilters "github.com/celogeek/go-comic-converter/v2/pkg/epub/imagefilters"
 	epuboptions "github.com/celogeek/go-comic-converter/v2/pkg/epub/options"
-	epubzip "github.com/celogeek/go-comic-converter/v2/pkg/epub/zip"
 	"github.com/celogeek/go-comic-converter/v2/pkg/epubprogress"
+	"github.com/celogeek/go-comic-converter/v2/pkg/epubzip"
 	"github.com/disintegration/gift"
 )
 
@@ -62,7 +62,7 @@ func (e *EPUBImageProcessor) Load() (images []*epubimage.Image, err error) {
 	})
 	wg := &sync.WaitGroup{}
 
-	imgStorage, err := epubzip.NewEPUBZipStorageImageWriter(e.ImgStorage(), e.Image.Format)
+	imgStorage, err := epubzip.NewImageWriter(e.ImgStorage(), e.Image.Format)
 	if err != nil {
 		bar.Close()
 		return nil, err
@@ -323,7 +323,7 @@ func (e *EPUBImageProcessor) Cover16LevelOfGray(bounds image.Rectangle) draw.Ima
 }
 
 // create a title page with the cover
-func (e *EPUBImageProcessor) CoverTitleData(o *CoverTitleDataOptions) (*epubzip.ZipImage, error) {
+func (e *EPUBImageProcessor) CoverTitleData(o *CoverTitleDataOptions) (*epubzip.EPUBZipImage, error) {
 	// Create a blur version of the cover
 	g := gift.New(epubimagefilters.CoverTitle(o.Text, o.Align, o.PctWidth, o.PctMargin, o.MaxFontSize, o.BorderSize))
 	var dst draw.Image

pkg/epub/zip/epub_zip_storage_image.go

@@ -1,100 +0,0 @@
-package epubzip
-
-import (
-	"archive/zip"
-	"image"
-	"os"
-	"sync"
-)
-
-type EPUBZipStorageImageWriter struct {
-	fh     *os.File
-	fz     *zip.Writer
-	format string
-	mut    *sync.Mutex
-}
-
-func NewEPUBZipStorageImageWriter(filename string, format string) (*EPUBZipStorageImageWriter, error) {
-	fh, err := os.Create(filename)
-	if err != nil {
-		return nil, err
-	}
-	fz := zip.NewWriter(fh)
-	return &EPUBZipStorageImageWriter{fh, fz, format, &sync.Mutex{}}, nil
-}
-
-func (e *EPUBZipStorageImageWriter) Close() error {
-	if err := e.fz.Close(); err != nil {
-		e.fh.Close()
-		return err
-	}
-	return e.fh.Close()
-}
-
-func (e *EPUBZipStorageImageWriter) Add(filename string, img image.Image, quality int) error {
-	zipImage, err := CompressImage(filename, e.format, img, quality)
-	if err != nil {
-		return err
-	}
-
-	e.mut.Lock()
-	defer e.mut.Unlock()
-	fh, err := e.fz.CreateRaw(zipImage.Header)
-	if err != nil {
-		return err
-	}
-	_, err = fh.Write(zipImage.Data)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-type EPUBZipStorageImageReader struct {
-	filename string
-	fh       *os.File
-	fz       *zip.Reader
-
-	files map[string]*zip.File
-}
-
-func NewEPUBZipStorageImageReader(filename string) (*EPUBZipStorageImageReader, error) {
-	fh, err := os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-	s, err := fh.Stat()
-	if err != nil {
-		return nil, err
-	}
-	fz, err := zip.NewReader(fh, s.Size())
-	if err != nil {
-		return nil, err
-	}
-	files := map[string]*zip.File{}
-	for _, z := range fz.File {
-		files[z.Name] = z
-	}
-	return &EPUBZipStorageImageReader{filename, fh, fz, files}, nil
-}
-
-func (e *EPUBZipStorageImageReader) Get(filename string) *zip.File {
-	return e.files[filename]
-}
-
-func (e *EPUBZipStorageImageReader) Size(filename string) uint64 {
-	img := e.Get(filename)
-	if img != nil {
-		return img.CompressedSize64 + 30 + uint64(len(img.Name))
-	}
-	return 0
-}
-
-func (e *EPUBZipStorageImageReader) Close() error {
-	return e.fh.Close()
-}
-
-func (e *EPUBZipStorageImageReader) Remove() error {
-	return os.Remove(e.filename)
-}

pkg/epubzip/epubzip.go

@@ -63,7 +63,7 @@ func (e *EPUBZip) Copy(fz *zip.File) error {
 }
 
 // Write image. They are already compressed, so we write them down directly.
-func (e *EPUBZip) WriteRaw(raw *ZipImage) error {
+func (e *EPUBZip) WriteRaw(raw *EPUBZipImage) error {
 	m, err := e.wz.CreateRaw(raw.Header)
 	if err != nil {
 		return err

pkg/epubzip/epubzip_image.go

@@ -12,13 +12,13 @@ import (
 	"time"
 )
 
-type ZipImage struct {
+type EPUBZipImage struct {
 	Header *zip.FileHeader
 	Data   []byte
 }
 
 // create gzip encoded jpeg
-func CompressImage(filename string, format string, img image.Image, quality int) (*ZipImage, error) {
+func CompressImage(filename string, format string, img image.Image, quality int) (*EPUBZipImage, error) {
 	var (
 		data, cdata bytes.Buffer
 		err         error
@@ -52,7 +52,7 @@ func CompressImage(filename string, format string, img image.Image, quality int)
 	}
 
 	t := time.Now()
-	return &ZipImage{
+	return &EPUBZipImage{
 		&zip.FileHeader{
 			Name:               filename,
 			CompressedSize64:   uint64(cdata.Len()),

pkg/epubzip/epubzip_image_reader.go

@@ -0,0 +1,54 @@
+package epubzip
+
+import (
+	"archive/zip"
+	"os"
+)
+
+type EPUBZipImageReader struct {
+	filename string
+	fh       *os.File
+	fz       *zip.Reader
+
+	files map[string]*zip.File
+}
+
+func NewImageReader(filename string) (*EPUBZipImageReader, error) {
+	fh, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	s, err := fh.Stat()
+	if err != nil {
+		return nil, err
+	}
+	fz, err := zip.NewReader(fh, s.Size())
+	if err != nil {
+		return nil, err
+	}
+	files := map[string]*zip.File{}
+	for _, z := range fz.File {
+		files[z.Name] = z
+	}
+	return &EPUBZipImageReader{filename, fh, fz, files}, nil
+}
+
+func (e *EPUBZipImageReader) Get(filename string) *zip.File {
+	return e.files[filename]
+}
+
+func (e *EPUBZipImageReader) Size(filename string) uint64 {
+	img := e.Get(filename)
+	if img != nil {
+		return img.CompressedSize64 + 30 + uint64(len(img.Name))
+	}
+	return 0
+}
+
+func (e *EPUBZipImageReader) Close() error {
+	return e.fh.Close()
+}
+
+func (e *EPUBZipImageReader) Remove() error {
+	return os.Remove(e.filename)
+}

pkg/epubzip/epubzip_image_writer.go

@@ -0,0 +1,52 @@
+package epubzip
+
+import (
+	"archive/zip"
+	"image"
+	"os"
+	"sync"
+)
+
+type EPUBZipImageWriter struct {
+	fh     *os.File
+	fz     *zip.Writer
+	format string
+	mut    *sync.Mutex
+}
+
+func NewImageWriter(filename string, format string) (*EPUBZipImageWriter, error) {
+	fh, err := os.Create(filename)
+	if err != nil {
+		return nil, err
+	}
+	fz := zip.NewWriter(fh)
+	return &EPUBZipImageWriter{fh, fz, format, &sync.Mutex{}}, nil
+}
+
+func (e *EPUBZipImageWriter) Close() error {
+	if err := e.fz.Close(); err != nil {
+		e.fh.Close()
+		return err
+	}
+	return e.fh.Close()
+}
+
+func (e *EPUBZipImageWriter) Add(filename string, img image.Image, quality int) error {
+	zipImage, err := CompressImage(filename, e.format, img, quality)
+	if err != nil {
+		return err
+	}
+
+	e.mut.Lock()
+	defer e.mut.Unlock()
+	fh, err := e.fz.CreateRaw(zipImage.Header)
+	if err != nil {
+		return err
+	}
+	_, err = fh.Write(zipImage.Data)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}