More beatiful recfile field names

diff --git a/hr.go b/hr.go
index 286fc2f0dc8ecc89fe4ab6a93da4f1380d4462e0..b751e4dd2ccd9aae55c33fdc8ddf3bcbc7caf928 100644 (file)
--- 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 a9a21a8024e97470c47a9aa0f0e47d15f4c29c8f..94374801468cfd729b468a603dc2e19cc54173b1 100644 (file)
--- 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 7ca9b18f08e8bda641173b42d57c4dac3c97d988..9c4c2912cb65e0d133df894441fa7145087e8b09 100644 (file)
--- 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 ec0786403e3d90acf78b52c1dfecd5e218fd35d5..46c76b307c9a9baf2c945a06ccf6a77a4e396b87 100644 (file)
--- 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 87ff48a1df93d96e6f75881f6676f5c0bc0ac43c..d637bf5ac7d0bc7d3c894280281623957b2d28bb 100644 (file)
--- a/metadata.go
+++ b/metadata.go
@@ -17,39 +17,81 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 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 0138e7ddfbf6f93e29e13f318ee025064ac6b640..fcee245b93d15fce58322dcf1c16c72d8770cd1c 100644 (file)
--- 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 a3daa9357e97cc336cf1c02f633b0be5aea3bdff..f789fbe3ded1a831a3b707c1c8c5df53aa14b70f 100644 (file)
--- 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)