2021-10-14 23:39:48 +00:00
|
|
|
package file
|
|
|
|
|
|
|
|
import (
|
|
|
|
"archive/zip"
|
|
|
|
"io"
|
|
|
|
"io/fs"
|
|
|
|
"strings"
|
|
|
|
)
|
|
|
|
|
|
|
|
const zipSeparator = "\x00"
|
|
|
|
|
|
|
|
type zipFile struct {
|
|
|
|
zipPath string
|
|
|
|
zf *zip.File
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *zipFile) Open() (io.ReadCloser, error) {
|
|
|
|
return f.zf.Open()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *zipFile) Path() string {
|
|
|
|
// TODO - fix this
|
|
|
|
return ZipFilename(f.zipPath, f.zf.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *zipFile) FileInfo() fs.FileInfo {
|
|
|
|
return f.zf.FileInfo()
|
|
|
|
}
|
|
|
|
|
|
|
|
func ZipFile(zipPath string, zf *zip.File) SourceFile {
|
|
|
|
return &zipFile{
|
|
|
|
zipPath: zipPath,
|
|
|
|
zf: zf,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func ZipFilename(zipFilename, filenameInZip string) string {
|
|
|
|
return zipFilename + zipSeparator + filenameInZip
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsZipPath returns true if the path includes the zip separator byte,
|
|
|
|
// indicating it is within a zip file.
|
|
|
|
func IsZipPath(p string) bool {
|
|
|
|
return strings.Contains(p, zipSeparator)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ZipPathDisplayName converts an zip path for display. It translates the zip
|
|
|
|
// file separator character into '/', since this character is also used for
|
|
|
|
// path separators within zip files. It returns the original provided path
|
|
|
|
// if it does not contain the zip file separator character.
|
|
|
|
func ZipPathDisplayName(path string) string {
|
Enable gocritic (#1848)
* Don't capitalize local variables
ValidCodecs -> validCodecs
* Capitalize deprecation markers
A deprecated marker should be capitalized.
* Use re.MustCompile for static regexes
If the regex fails to compile, it's a programmer error, and should be
treated as such. The regex is entirely static.
* Simplify else-if constructions
Rewrite
else { if cond {}}
to
else if cond {}
* Use a switch statement to analyze formats
Break an if-else chain. While here, simplify code flow.
Also introduce a proper static error for unsupported image formats,
paving the way for being able to check against the error.
* Rewrite ifElse chains into switch statements
The "Effective Go" https://golang.org/doc/effective_go#switch document
mentions it is more idiomatic to write if-else chains as switches when
it is possible.
Find all the plain rewrite occurrences in the code base and rewrite.
In some cases, the if-else chains are replaced by a switch scrutinizer.
That is, the code sequence
if x == 1 {
..
} else if x == 2 {
..
} else if x == 3 {
...
}
can be rewritten into
switch x {
case 1:
..
case 2:
..
case 3:
..
}
which is clearer for the compiler: it can decide if the switch is
better served by a jump-table then a branch-chain.
* Rewrite switches, introduce static errors
Introduce two new static errors:
* `ErrNotImplmented`
* `ErrNotSupported`
And use these rather than forming new generative errors whenever the
code is called. Code can now test on the errors (since they are static
and the pointers to them wont change).
Also rewrite ifElse chains into switches in this part of the code base.
* Introduce a StashBoxError in configuration
Since all stashbox errors are the same, treat them as such in the code
base. While here, rewrite an ifElse chain.
In the future, it might be beneifical to refactor configuration errors
into one error which can handle missing fields, which context the error
occurs in and so on. But for now, try to get an overview of the error
categories by hoisting them into static errors.
* Get rid of an else-block in transaction handling
If we succesfully `recover()`, we then always `panic()`. This means the
rest of the code is not reachable, so we can avoid having an else-block
here.
It also solves an ifElse-chain style check in the code base.
* Use strings.ReplaceAll
Rewrite
strings.Replace(s, o, n, -1)
into
strings.ReplaceAll(s, o, n)
To make it consistent and clear that we are doing an all-replace in the
string rather than replacing parts of it. It's more of a nitpick since
there are no implementation differences: the stdlib implementation is
just to supply -1.
* Rewrite via gocritic's assignOp
Statements of the form
x = x + e
is rewritten into
x += e
where applicable.
* Formatting
* Review comments handled
Stash-box is a proper noun.
Rewrite a switch into an if-chain which returns on the first error
encountered.
* Use context.TODO() over context.Background()
Patch in the same vein as everything else: use the TODO() marker so we
can search for it later and link it into the context tree/tentacle once
it reaches down to this level in the code base.
* Tell the linter to ignore a section in manager_tasks.go
The section is less readable, so mark it with a nolint for now. Because
the rewrite enables a ifElseChain, also mark that as nolint for now.
* Use strings.ReplaceAll over strings.Replace
* Apply an ifElse rewrite
else { if .. { .. } } rewrite into else if { .. }
* Use switch-statements over ifElseChains
Rewrite chains of if-else into switch statements. Where applicable,
add an early nil-guard to simplify case analysis. Also, in
ScanTask's Start(..), invert the logic to outdent the whole block, and
help the reader: if it's not a scene, the function flow is now far more
local to the top of the function, and it's clear that the rest of the
function has to do with scene management.
* Enable gocritic on the code base.
Disable appendAssign for now since we aren't passing that check yet.
* Document the nolint additions
* Document StashBoxBatchPerformerTagInput
2021-10-18 03:12:40 +00:00
|
|
|
return strings.ReplaceAll(path, zipSeparator, "/")
|
2021-10-14 23:39:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func ZipFilePath(path string) (zipFilename, filename string) {
|
|
|
|
nullIndex := strings.Index(path, zipSeparator)
|
|
|
|
if nullIndex != -1 {
|
|
|
|
zipFilename = path[0:nullIndex]
|
|
|
|
filename = path[nullIndex+1:]
|
|
|
|
} else {
|
|
|
|
filename = path
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|