From 371b9da450b741c6dc50cf5427fcbdec4335d0fc Mon Sep 17 00:00:00 2001 From: Sergey Matveev Date: Tue, 28 Sep 2021 15:33:19 +0300 Subject: [PATCH] More beatiful recfile field names --- hr.go | 2 +- json.go | 48 +++++++++++++------------- list.go | 2 +- main.go | 2 +- metadata.go | 98 ++++++++++++++++++++++++++++++++++++++--------------- refresh.go | 80 +++++++++++++++++++++---------------------- upload.go | 32 +++-------------- 7 files changed, 141 insertions(+), 123 deletions(-) diff --git a/hr.go b/hr.go index 286fc2f..b751e4d 100644 --- a/hr.go +++ b/hr.go @@ -153,7 +153,7 @@ func serveHRRoot(w http.ResponseWriter, r *http.Request) { func serveHRPkg(w http.ResponseWriter, r *http.Request) { cols := strings.Split(strings.TrimRight(r.URL.Path, "/"), "/") pkgName := cols[len(cols)-1] - meta, releases, err := getMetadata(pkgName, "") + meta, releases, err := getMD(pkgName, "") if err != nil { if os.IsNotExist(err) { http.NotFound(w, r) diff --git a/json.go b/json.go index a9a21a8..9437480 100644 --- a/json.go +++ b/json.go @@ -30,68 +30,68 @@ import ( "go.cypherpunks.ru/recfile" ) -func getMetadata(pkgName, version string) (*PkgMeta, []*PkgReleaseInfo, error) { +func getMD(pkgName, version string) (*PkgMeta, []*PkgReleaseInfo, error) { serial, releases, err := listDir(pkgName, true) if err != nil { return nil, nil, err } - metadata, err := ioutil.ReadFile(filepath.Join(Root, pkgName, MetadataFile)) + md, err := ioutil.ReadFile(filepath.Join(Root, pkgName, MDFile)) if err != nil { if !os.IsNotExist(err) { return nil, nil, err } } info := PkgInfo{Name: pkgName} - if len(metadata) == 0 { + if len(md) == 0 { info.Version = releases[len(releases)-1].Version } else { - m, err := recfile.NewReader(bytes.NewReader(metadata)).NextMapWithSlice() + m, err := recfile.NewReader(bytes.NewReader(md)).NextMapWithSlice() if err != nil { return nil, nil, err } - if v, ok := m[metadataFieldToRecField(MetadataFieldVersion)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldVersion]]; ok { info.Version = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldSummary)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldSummary]]; ok { info.Summary = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldDescriptionContentType)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldDescriptionContentType]]; ok { info.DescriptionContentType = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldKeywords)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldKeywords]]; ok { info.Keywords = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldHomePage)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldHomePage]]; ok { info.HomePage = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldAuthor)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldAuthor]]; ok { info.Author = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldAuthorEmail)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldAuthorEmail]]; ok { info.AuthorEmail = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldMaintainer)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldMaintainer]]; ok { info.Maintainer = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldMaintainerEmail)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldMaintainerEmail]]; ok { info.MaintainerEmail = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldLicense)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldLicense]]; ok { info.License = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldRequiresPython)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldRequiresPython]]; ok { info.RequiresPython = v[0] } - if v, ok := m[metadataFieldToRecField(MetadataFieldDescription)]; ok { + if v, ok := m[MDFieldToRecField[MDFieldDescription]]; ok { info.Description = v[0] } - info.Classifier = m[metadataFieldToRecField(MetadataFieldClassifier)] - info.Platform = m[metadataFieldToRecField(MetadataFieldPlatform)] - info.SupportedPlatform = m[metadataFieldToRecField(MetadataFieldSupportedPlatform)] - info.RequiresDist = m[metadataFieldToRecField(MetadataFieldRequiresDist)] - info.RequiresExternal = m[metadataFieldToRecField(MetadataFieldRequiresExternal)] - info.ProjectURL = m[metadataFieldToRecField(MetadataFieldProjectURL)] - info.ProvidesExtra = m[metadataFieldToRecField(MetadataFieldProvidesExtra)] + info.Classifier = m[MDFieldToRecField[MDFieldClassifier]] + info.Platform = m[MDFieldToRecField[MDFieldPlatform]] + info.SupportedPlatform = m[MDFieldToRecField[MDFieldSupportedPlatform]] + info.RequiresDist = m[MDFieldToRecField[MDFieldRequiresDist]] + info.RequiresExternal = m[MDFieldToRecField[MDFieldRequiresExternal]] + info.ProjectURL = m[MDFieldToRecField[MDFieldProjectURL]] + info.ProvidesExtra = m[MDFieldToRecField[MDFieldProvidesExtra]] } meta := PkgMeta{ Info: info, @@ -126,7 +126,7 @@ func serveJSON(w http.ResponseWriter, r *http.Request) { } pkgName := parts[0] - meta, _, err := getMetadata(pkgName, version) + meta, _, err := getMD(pkgName, version) if err != nil { if os.IsNotExist(err) { http.NotFound(w, r) diff --git a/list.go b/list.go index 7ca9b18..9c4c291 100644 --- a/list.go +++ b/list.go @@ -213,7 +213,7 @@ func listDir(pkgName string, doSize bool) (int64, []*PkgReleaseInfo, error) { return 0, nil, err } serial := fi.ModTime().Unix() - if fi, err = os.Stat(filepath.Join(dirPath, MetadataFile)); err == nil { + if fi, err = os.Stat(filepath.Join(dirPath, MDFile)); err == nil { serial += fi.ModTime().Unix() } return serial, releases, nil diff --git a/main.go b/main.go index ec07864..46c76b3 100644 --- a/main.go +++ b/main.go @@ -44,7 +44,7 @@ import ( ) const ( - Version = "3.2.0" + Version = "3.3.0" UserAgent = "GoCheese/" + Version ) diff --git a/metadata.go b/metadata.go index 87ff48a..d637bf5 100644 --- a/metadata.go +++ b/metadata.go @@ -17,39 +17,81 @@ along with this program. If not, see . package main -import "strings" - const ( - MetadataFile = ".metadata.rec" + MDFile = ".metadata.rec" // https://packaging.python.org/specifications/core-metadata/ - MetadataVersion = "2.1" - MetadataFieldMetadataVersion = "Metadata-Version" - MetadataFieldName = "Name" - MetadataFieldVersion = "Version" - MetadataFieldDescription = "Description" - MetadataFieldPlatform = "Platform" - MetadataFieldSupportedPlatform = "Supported-Platform" - MetadataFieldSummary = "Summary" - MetadataFieldDescriptionContentType = "Description-Content-Type" - MetadataFieldKeywords = "Keywords" - MetadataFieldHomePage = "Home-page" - MetadataFieldAuthor = "Author" - MetadataFieldAuthorEmail = "Author-email" - MetadataFieldMaintainer = "Maintainer" - MetadataFieldMaintainerEmail = "Maintainer-Email" - MetadataFieldLicense = "License" - MetadataFieldRequiresDist = "Requires-Dist" - MetadataFieldRequiresPython = "Requires-Python" - MetadataFieldRequiresExternal = "Requires-External" - MetadataFieldProjectURL = "Project-URL" - MetadataFieldProvidesExtra = "Provides-Extra" - MetadataFieldClassifier = "Classifier" + MDVersion = "2.1" + MDFieldMetadataVersion = "Metadata-Version" + MDFieldName = "Name" + MDFieldVersion = "Version" + MDFieldDescription = "Description" + MDFieldPlatform = "Platform" + MDFieldSupportedPlatform = "Supported-Platform" + MDFieldSummary = "Summary" + MDFieldDescriptionContentType = "Description-Content-Type" + MDFieldKeywords = "Keywords" + MDFieldHomePage = "Home-page" + MDFieldAuthor = "Author" + MDFieldAuthorEmail = "Author-email" + MDFieldMaintainer = "Maintainer" + MDFieldMaintainerEmail = "Maintainer-email" + MDFieldLicense = "License" + MDFieldRequiresDist = "Requires-Dist" + MDFieldRequiresPython = "Requires-Python" + MDFieldRequiresExternal = "Requires-External" + MDFieldProjectURL = "Project-URL" + MDFieldProvidesExtra = "Provides-Extra" + MDFieldClassifier = "Classifier" ) -func metadataFieldToRecField(f string) string { - return strings.ReplaceAll(f, "-", "") -} +var ( + MDFieldToRecField = map[string]string{ + MDFieldMetadataVersion: "MetadataVersion", + MDFieldName: "Name", + MDFieldVersion: "Version", + MDFieldDescription: "Description", + MDFieldPlatform: "Platform", + MDFieldSupportedPlatform: "SupportedPlatform", + MDFieldSummary: "Summary", + MDFieldDescriptionContentType: "DescriptionContentType", + MDFieldKeywords: "Keywords", + MDFieldHomePage: "HomePage", + MDFieldAuthor: "Author", + MDFieldAuthorEmail: "AuthorEmail", + MDFieldMaintainer: "Maintainer", + MDFieldMaintainerEmail: "MaintainerEmail", + MDFieldLicense: "License", + MDFieldRequiresDist: "RequiresDist", + MDFieldRequiresPython: "RequiresPython", + MDFieldRequiresExternal: "RequiresExternal", + MDFieldProjectURL: "ProjectURL", + MDFieldProvidesExtra: "ProvidesExtra", + MDFieldClassifier: "Classifier", + } + MDFormToRecField = [][2]string{ + {"name", MDFieldToRecField[MDFieldName]}, + {"version", MDFieldToRecField[MDFieldVersion]}, + {"platform", MDFieldToRecField[MDFieldPlatform]}, + {"supported_platform", MDFieldToRecField[MDFieldSupportedPlatform]}, + {"summary", MDFieldToRecField[MDFieldSummary]}, + {"description", MDFieldToRecField[MDFieldDescription]}, + {"description_content_type", MDFieldToRecField[MDFieldDescriptionContentType]}, + {"keywords", MDFieldToRecField[MDFieldKeywords]}, + {"home_page", MDFieldToRecField[MDFieldHomePage]}, + {"author", MDFieldToRecField[MDFieldAuthor]}, + {"author_email", MDFieldToRecField[MDFieldAuthorEmail]}, + {"maintainer", MDFieldToRecField[MDFieldMaintainer]}, + {"maintainer_email", MDFieldToRecField[MDFieldMaintainerEmail]}, + {"license", MDFieldToRecField[MDFieldLicense]}, + {"classifiers", MDFieldToRecField[MDFieldClassifier]}, + {"requires_dist", MDFieldToRecField[MDFieldRequiresDist]}, + {"requires_python", MDFieldToRecField[MDFieldRequiresPython]}, + {"requires_external", MDFieldToRecField[MDFieldRequiresExternal]}, + {"project_url", MDFieldToRecField[MDFieldProjectURL]}, + {"provides_extra", MDFieldToRecField[MDFieldProvidesExtra]}, + } +) // It should follow https://www.python.org/dev/peps/pep-0566/ type PkgInfo struct { diff --git a/refresh.go b/refresh.go index 0138e7d..fcee245 100644 --- a/refresh.go +++ b/refresh.go @@ -124,42 +124,42 @@ func refreshDir( err = json.Unmarshal(body, &meta) if err == nil { for _, m := range [][2]string{ - {MetadataFieldName, meta.Info.Name}, - {MetadataFieldVersion, meta.Info.Version}, - {MetadataFieldSummary, meta.Info.Summary}, - {MetadataFieldDescriptionContentType, meta.Info.DescriptionContentType}, - {MetadataFieldKeywords, meta.Info.Keywords}, - {MetadataFieldHomePage, meta.Info.HomePage}, - {MetadataFieldAuthor, meta.Info.Author}, - {MetadataFieldAuthorEmail, meta.Info.AuthorEmail}, - {MetadataFieldMaintainer, meta.Info.Maintainer}, - {MetadataFieldMaintainerEmail, meta.Info.MaintainerEmail}, - {MetadataFieldLicense, meta.Info.License}, - {MetadataFieldRequiresPython, meta.Info.RequiresPython}, + {MDFieldName, meta.Info.Name}, + {MDFieldVersion, meta.Info.Version}, + {MDFieldSummary, meta.Info.Summary}, + {MDFieldDescriptionContentType, meta.Info.DescriptionContentType}, + {MDFieldKeywords, meta.Info.Keywords}, + {MDFieldHomePage, meta.Info.HomePage}, + {MDFieldAuthor, meta.Info.Author}, + {MDFieldAuthorEmail, meta.Info.AuthorEmail}, + {MDFieldMaintainer, meta.Info.Maintainer}, + {MDFieldMaintainerEmail, meta.Info.MaintainerEmail}, + {MDFieldLicense, meta.Info.License}, + {MDFieldRequiresPython, meta.Info.RequiresPython}, } { recField, jsonField := m[0], m[1] if jsonField == "" { continue } if _, err = wr.WriteFields(recfile.Field{ - Name: metadataFieldToRecField(recField), + Name: MDFieldToRecField[recField], Value: jsonField, }); err != nil { log.Fatalln(err) } } for _, m := range []RecFieldToValuesMap{ - {MetadataFieldClassifier, meta.Info.Classifier}, - {MetadataFieldPlatform, meta.Info.Platform}, - {MetadataFieldSupportedPlatform, meta.Info.SupportedPlatform}, - {MetadataFieldRequiresDist, meta.Info.RequiresDist}, - {MetadataFieldRequiresExternal, meta.Info.RequiresExternal}, - {MetadataFieldProjectURL, meta.Info.ProjectURL}, - {MetadataFieldProvidesExtra, meta.Info.ProvidesExtra}, + {MDFieldClassifier, meta.Info.Classifier}, + {MDFieldPlatform, meta.Info.Platform}, + {MDFieldSupportedPlatform, meta.Info.SupportedPlatform}, + {MDFieldRequiresDist, meta.Info.RequiresDist}, + {MDFieldRequiresExternal, meta.Info.RequiresExternal}, + {MDFieldProjectURL, meta.Info.ProjectURL}, + {MDFieldProvidesExtra, meta.Info.ProvidesExtra}, } { for _, v := range m.jsonFields { if _, err = wr.WriteFields(recfile.Field{ - Name: metadataFieldToRecField(m.recField), + Name: MDFieldToRecField[m.recField], Value: v, }); err != nil { log.Fatalln(err) @@ -180,25 +180,25 @@ func refreshDir( return false } for _, m := range [][2]string{ - {MetadataFieldName, metaStripped.Info.Name}, - {MetadataFieldVersion, metaStripped.Info.Version}, - {MetadataFieldSummary, metaStripped.Info.Summary}, - {MetadataFieldDescriptionContentType, metaStripped.Info.DescriptionContentType}, - {MetadataFieldKeywords, metaStripped.Info.Keywords}, - {MetadataFieldHomePage, metaStripped.Info.HomePage}, - {MetadataFieldAuthor, metaStripped.Info.Author}, - {MetadataFieldAuthorEmail, metaStripped.Info.AuthorEmail}, - {MetadataFieldMaintainer, metaStripped.Info.Maintainer}, - {MetadataFieldMaintainerEmail, metaStripped.Info.MaintainerEmail}, - {MetadataFieldLicense, metaStripped.Info.License}, - {MetadataFieldRequiresPython, metaStripped.Info.RequiresPython}, + {MDFieldName, metaStripped.Info.Name}, + {MDFieldVersion, metaStripped.Info.Version}, + {MDFieldSummary, metaStripped.Info.Summary}, + {MDFieldDescriptionContentType, metaStripped.Info.DescriptionContentType}, + {MDFieldKeywords, metaStripped.Info.Keywords}, + {MDFieldHomePage, metaStripped.Info.HomePage}, + {MDFieldAuthor, metaStripped.Info.Author}, + {MDFieldAuthorEmail, metaStripped.Info.AuthorEmail}, + {MDFieldMaintainer, metaStripped.Info.Maintainer}, + {MDFieldMaintainerEmail, metaStripped.Info.MaintainerEmail}, + {MDFieldLicense, metaStripped.Info.License}, + {MDFieldRequiresPython, metaStripped.Info.RequiresPython}, } { recField, jsonField := m[0], m[1] if jsonField == "" { continue } if _, err = wr.WriteFields(recfile.Field{ - Name: metadataFieldToRecField(recField), + Name: MDFieldToRecField[recField], Value: jsonField, }); err != nil { log.Fatalln(err) @@ -206,12 +206,12 @@ func refreshDir( } for _, m := range []RecFieldToValuesMap{ - {MetadataFieldClassifier, metaStripped.Info.Classifier}, - {MetadataFieldRequiresDist, metaStripped.Info.RequiresDist}, + {MDFieldClassifier, metaStripped.Info.Classifier}, + {MDFieldRequiresDist, metaStripped.Info.RequiresDist}, } { for _, v := range m.jsonFields { if _, err = wr.WriteFields(recfile.Field{ - Name: metadataFieldToRecField(m.recField), + Name: MDFieldToRecField[m.recField], Value: v, }); err != nil { log.Fatalln(err) @@ -224,7 +224,7 @@ func refreshDir( lines := strings.Split(description, "\n") if len(lines) > 0 { if _, err = wr.WriteFieldMultiline( - MetadataFieldDescription, lines, + MDFieldDescription, lines, ); err != nil { log.Fatalln(err) } @@ -233,7 +233,7 @@ func refreshDir( if !mkdirForPkg(w, r, pkgName) { return false } - path := filepath.Join(dirPath, MetadataFile) + path := filepath.Join(dirPath, MDFile) existing, err := ioutil.ReadFile(path) if err != nil || bytes.Compare(existing, buf.Bytes()) != 0 { if err = WriteFileSync(dirPath, path, buf.Bytes(), now); err != nil { @@ -241,7 +241,7 @@ func refreshDir( http.Error(w, err.Error(), http.StatusInternalServerError) return false } - log.Println(r.RemoteAddr, "pypi", pkgName+"/"+MetadataFile, "touch") + log.Println(r.RemoteAddr, "pypi", pkgName+"/"+MDFile, "touch") } } mtimes := make(map[string]time.Time) diff --git a/upload.go b/upload.go index a3daa93..f789fbe 100644 --- a/upload.go +++ b/upload.go @@ -231,40 +231,16 @@ func serveUpload(w http.ResponseWriter, r *http.Request) { var buf bytes.Buffer wr := recfile.NewWriter(&buf) - for _, m := range [][2]string{ - {"name", MetadataFieldName}, - {"version", MetadataFieldVersion}, - {"platform", MetadataFieldPlatform}, - {"supported_platform", MetadataFieldSupportedPlatform}, - {"summary", MetadataFieldSummary}, - {"description", MetadataFieldDescription}, - {"description_content_type", MetadataFieldDescriptionContentType}, - {"keywords", MetadataFieldKeywords}, - {"home_page", MetadataFieldHomePage}, - {"author", MetadataFieldAuthor}, - {"author_email", MetadataFieldAuthorEmail}, - {"maintainer", MetadataFieldMaintainer}, - {"maintainer_email", MetadataFieldMaintainerEmail}, - {"license", MetadataFieldLicense}, - {"classifiers", MetadataFieldClassifier}, - {"requires_dist", MetadataFieldRequiresDist}, - {"requires_python", MetadataFieldRequiresPython}, - {"requires_external", MetadataFieldRequiresExternal}, - {"project_url", MetadataFieldProjectURL}, - {"provides_extra", MetadataFieldProvidesExtra}, - } { + for _, m := range MDFormToRecField { formField, recField := m[0], m[1] if vs, exists := r.MultipartForm.Value[formField]; exists { for _, v := range vs { lines := strings.Split(v, "\n") if len(lines) > 1 { - _, err = wr.WriteFieldMultiline( - metadataFieldToRecField(recField), - lines, - ) + _, err = wr.WriteFieldMultiline(recField, lines) } else { _, err = wr.WriteFields(recfile.Field{ - Name: metadataFieldToRecField(recField), + Name: recField, Value: lines[0], }) } @@ -274,7 +250,7 @@ func serveUpload(w http.ResponseWriter, r *http.Request) { } } } - path := filepath.Join(dirPath, MetadataFile) + path := filepath.Join(dirPath, MDFile) if err = WriteFileSync(dirPath, path, buf.Bytes(), now); err != nil { log.Println("error", r.RemoteAddr, path, err) http.Error(w, err.Error(), http.StatusInternalServerError) -- 2.44.0