Add string versions of User/Pickled objects to datastore models

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 16 matching lines @@
 
     version = VersionProperty(required=True)
     """The version of the package."""
 
     pubspec = PubspecProperty(required=True, indexed=False)
     """The package version's pubspec file."""
 
     readme = ReadmeProperty()
     """The README file."""
 
+    readmeFilename = db.StringProperty(indexed=False)
+    """The README filename."""
+
+    readmeContent = db.TextProperty()
+    """The README file as a string."""
+
     changelog = ReadmeProperty()
     """The CHANGELOG file."""
 
+    changelogFilename = db.StringProperty(indexed=False)
+    """The CHANGELOG filename."""
+
+    changelogContent = db.TextProperty()
+    """The CHANGELOG file as a string."""
+
     libraries = db.ListProperty(str)
     """All libraries that can be imported from this package version."""
 
     package = db.ReferenceProperty(Package,
                                    required=True,
                                    collection_name = "version_set")
     """The Package model for this package version."""
 
     # The following properties are not parsed from the package archive. They
     # need to be manually copied over to new PackageVersions in
     # handlers.PackageVersions._reload_version.
 
     created = db.DateTimeProperty(auto_now_add=True)
     """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()
+    """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:

[Søren Gjesse, 2014/12/18 14:47:37]

Not related to this change, but in general we don't in any way control the
encoding of the README and CHANGELOG files in the tar. I guess we are hoping for
UTF-8?

[kustermann, 2014/12/18 15:04:41]

We're not just hoping, we're assuming:
 41         filename = min(readmes, key=lambda(n): (n.count('.'), n))
 42         text = unicode(tar.extractfile(filename).read(),
 43                        encoding='utf-8', errors='replace')
 44         return Readme(text, filename)


I've changed the code now to write it definitly as utf-8.

+        self.readmeFilename = self.readme.filename
+        self.readmeContent =  self.readme.text
+
+      if self.changelog:
+        self.changelogFilename = self.changelog.filename
+        self.changelogContent = self.changelog.text
+
     @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 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):
         """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.
@@ skipping 143 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.uploader.email()
             })
 
         return value