Remove legacy Package.uploaders PackageVersion.{uploader,readme,changelog} properties

app/models/package_version.py

 # Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 import copy
 import json
 import tarfile
 
 from google.appengine.api import memcache
 from google.appengine.ext import db
@@ skipping 54 matching lines @@
     """When this package version was created."""
 
     downloads = db.IntegerProperty(required=True, default=0)
     """The number of times this package version has been downloaded."""
 
     sort_order = db.IntegerProperty(default=-1)
     """The sort order for this version.
 
     Lower numbers indicate earlier versions."""
 
-    uploader = db.UserProperty(required=True)
-    """The user who uploaded this package version."""
-
-    uploaderEmail = db.StringProperty()
+    uploaderEmail = db.StringProperty(required=True)
     """The user email who uploaded this package version."""
 
-    def temp_synchronize_uploader_to_uploaderemail_and_pickles(self):
-      """ Will synchronize properties.
-
-      uploader/readme/changelog -> uploaderEmail/readmeString/changelogString
-      """
-      if self.uploader is None:
-        self.uploaderEmail = None
-      else:
-        self.uploaderEmail = self.uploader.email()
-
-      if self.readme:
-        self.readmeFilename = self.readme.filename
-        self.readmeContent = db.Text(self.readme.text)
-
-      if self.changelog:
-        self.changelogFilename = self.changelog.filename
-        self.changelogContent = db.Text(self.changelog.text)
-
     @property
     def readme_obj(self):
       if self.readmeFilename:
         return Readme(self.readmeContent, self.readmeFilename)
       else:
         return None
 
     @property
     def changelog_obj(self):
-      if self.readmeFilename:
+      if self.changelogFilename:
         return Readme(self.changelogContent, self.changelogFilename)
       else:
         return None
 
     @classmethod
     def new(cls, **kwargs):
         """Construct a new package version.
 
         Unlike __init__, this infers some properties from others. In particular:
 
         - The version is inferred from the pubspec.
         - The key name is set to the version.
         - The parent entity is set to the package.
         """
 
         if 'pubspec' in kwargs and 'version' not in kwargs:
             kwargs['version'] = kwargs['pubspec'].required('version')
 
         if 'version' in kwargs and \
                 not isinstance(kwargs['version'], SemanticVersion):
             kwargs['version'] = SemanticVersion(kwargs['version'])
 
+        if 'readme' in kwargs and kwargs['readme']:
+            kwargs['readmeFilename'] = kwargs['readme'].filename
+            kwargs['readmeContent'] = kwargs['readme'].text
+            del kwargs['readme']
+
+        if 'changelog' in kwargs and kwargs['changelog']:
+            kwargs['changelogFilename'] = kwargs['changelog'].filename
+            kwargs['changelogContent'] = kwargs['changelog'].text
+            del kwargs['changelog']
+
         if not 'key_name' in kwargs and not 'key' in kwargs:
             kwargs['key_name'] = str(kwargs['version'].canonical)
 
         if not 'parent' in kwargs:
             kwargs['parent'] = kwargs['package']
 
         version = cls(**kwargs)
         version._validate_fields_match_pubspec()
         return version
 
-    # TODO(kustermann): When we have string emails, this needs to be changed
-    # to read uploaderEmails instead of uploaders.
     @classmethod
-    def from_archive(cls, file, uploader):
+    def from_archive(cls, file, uploaderEmail):
         """Load a package version from a .tar.gz archive.
 
         If the package specified in the archive already exists, it will be
         loaded and assigned as the package version's package. If it doesn't, a
         new package will be created.
 
         Arguments:
           file: An open file object containing a .tar.gz archive.
-          uploader: The user who uploaded this package archive.
+          uploaderEmail: The user email who uploaded this package archive.
 
         Returns: Both the Package object and the PackageVersion object.
         """
         try:
             tar = tarfile.open(mode="r:gz", fileobj=file)
             changelog = Readme.from_archive(tar, name='CHANGELOG')
             readme = Readme.from_archive(tar)
             pubspec = Pubspec.from_archive(tar)
             name = pubspec.required('name')
             package = Package.get_by_key_name(name)
             if not package:
-                assert uploader is not None
-                package = Package.new(name=name, uploaders=[uploader])
+                assert uploaderEmail is not None
+                package = Package.new(name=name, uploaderEmails=[uploaderEmail])
 
             libraries = sorted(name[4:] for name in tar.getnames()
                                if name.startswith('lib/') and
                                    not name.startswith('lib/src/') and
                                    name.endswith('.dart'))
 
             return PackageVersion.new(
                 package=package, changelog=changelog, readme=readme,
-                pubspec=pubspec, libraries=libraries, uploader=uploader)
+                pubspec=pubspec, libraries=libraries,
+                uploaderEmail=uploaderEmail)
         except (tarfile.TarError, KeyError) as err:
             raise db.BadValueError(
                 "Error parsing package archive: %s" % err)
 
     @classmethod
     def get_by_name_and_version(cls, package_name, version):
         """Looks up a package version by its package name and version."""
         parent_key = db.Key.from_path('Package', package_name)
         return cls.get_by_key_name(
             SemanticVersion(version).canonical, parent=parent_key)
@@ skipping 110 matching lines @@
                 'Version "%s" in pubspec doesn\'t match version "%s"' %
                 (version_in_pubspec._key(), self.version._key()))
     @property
     def url(self):
         """The API URL for this package version."""
         return models.url(controller='api.versions',
                           action='show',
                           package_id=self.package.name,
                           id=str(self.version))
 
-    # TODO(kustermann): When we have string emails, this needs to be changed
-    # to read uploaderEmails instead of uploaders.
     def as_dict(self, full=False):
         """Returns the dictionary representation of this package version.
 
         This is used to represent the package in API responses. Normally this
         just includes URLs and the pubspec, but if full is True, it will include
         all available information about the package version.
         """
 
         value = {
             'version': str(self.version),
@@ skipping 12 matching lines @@
 
         if full:
             value.update({
                 'created': self.created.isoformat(),
                 'downloads': self.downloads,
                 'libraries': self.libraries,
                 'uploader': self.uploaderEmail
             })
 
         return value