Change SDK/DartEditor versioning scheme to semantic versions.

dart/tools/utils.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.
 
 # This file contains a set of utilities functions used by other Python-based
 # scripts.
 
 import commands
 import os
 import platform
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 
+class Version(object):
+  def __init__(self, channel, major, minor, patch, prerelease,
+               prerelease_patch):
+    self.channel = channel
+    self.major = major
+    self.minor = minor
+    self.patch = patch
+    self.prerelease = prerelease
+    self.prerelease_patch = prerelease_patch
 
 # Try to guess the host operating system.
 def GuessOS():
   id = platform.system()
   if id == "Linux":
     return "linux"
   elif id == "Darwin":
     return "macos"
   elif id == "Windows" or id == "Microsoft":
     # On Windows Vista platform.system() can return "Microsoft" with some
@@ skipping 197 matching lines @@
 
 def GetBuildRoot(host_os, mode=None, arch=None, target_os=None):
   build_root = GetBuildDir(host_os, target_os)
   if mode:
     build_root = os.path.join(build_root, GetBuildConf(mode, arch))
   return build_root
 
 def GetBaseDir():
   return BASE_DIR
 
 # Return the base part of the version, Major.Minor.Build.Patch,

[Bob Nystrom, 2013/12/04 22:28:20]

Update this comment.

[kustermann, 2013/12/05 09:27:27]

Removed comment, it's obvious what it returns.

 # without the _revision addition
 def GetShortVersion():
-  (channel, major, minor, build, patch) = ReadVersionFile()
-  # TODO(kustermann/ricow): Add the channel to the version string.
-  return '%s.%s.%s.%s' % (major, minor, build, patch)
+  version = ReadVersionFile()
+  return ('%s.%s.%s.%s.%s' % (
+      version.major, version.minor, version.patch, version.prerelease,
+      version.prerelease_patch))
 
+def GetSemanticSDKVersion():
+  version = ReadVersionFile()
+  if not version:
+    return None
+
+  if version.channel == 'be':
+    postfix = '-edge.%s' % GetSVNRevision()

[kasperl, 2013/12/05 08:29:58]

Why did you choose edge over be in the postfix string here and in the eclipse
version qualifier?

[kustermann, 2013/12/05 09:27:27]

It depends a bit on how we will do releases, but this will guarantee that if we
have a pubspec.yaml file with an sdk constraint as follows:
  environment:
    sdk: ">=1.1.0-dev.2.4"
our bleeding edge builds will satisfy that constraint with
with '1.1.0-edge.42000' since "edge" > "dev" but "1.1.0-be.4200" would not
satisfy this (AFAIK).

(It has of course the disadvantage that all bleeding edge builds with the same
major.minor.patch will be sorted higher than dev, but that is acceptable [the
problem in general is not solvable]).

I don't know if we will see pubspec.yaml files with an dev sdk constraint.


[If that concern is not justified, I'm more than happy to change it to the
channel name 'be']

[kasperl, 2013/12/05 09:44:47]

That makes sense to me. Let's stick to edge. Maybe factor the shared strings out
(edge and dev) and put a comment on why they are chosen that way near the string
definitions?

+  elif version.channel == 'dev':
+    postfix = '-dev.%s.%s' % (version.prerelease, version.prerelease_patch)
+  else:
+    assert version.channel == 'stable'
+    postfix = ''
+
+  return '%s.%s.%s%s' % (version.major, version.minor, version.patch, postfix)
+
+def GetEclipseVersionQualifier():
+  def pad(number, num_digits):
+    number_str = str(number)
+    return '0' * max(0, num_digits - len(number_str)) + number_str
+
+  version = ReadVersionFile()
+  if version.channel == 'be':
+    return 'edge_%s' % pad(GetSVNRevision(), 6)
+  elif version.channel == 'dev':
+    return 'dev_%s_%s' % (pad(version.prerelease, 2),
+                          pad(version.prerelease_patch, 2))
+  else:
+    return 'release'
 
 def GetVersion():
-  version_tuple = ReadVersionFile()
-  if not version_tuple:
-    return None
-
-  (channel, major, minor, build, patch) = version_tuple
-  revision = GetSVNRevision()
-  user = GetUserName()
-  # We don't add username to release builds (or any builds on the bots)
-  if user == 'chrome-bot':
-    user = ''
-
-  user_string = ''
-  revision_string = ''
-  if user:
-    user_string = '_%s' % user
-  if revision:
-    revision_string = '_r%s' % revision
-
-  # TODO(kustermann/ricow): Add the channel to the version string.
-  return ("%s.%s.%s.%s%s%s" %
-          (major, minor, build, patch, revision_string, user_string))
+  return GetSemanticSDKVersion()
 
 def GetChannel():
-  (channel, _, _, _, _) = ReadVersionFile()
-  return channel
+  version = ReadVersionFile()
+  return version.channel
 
 def GetUserName():
   key = 'USER'
   if sys.platform == 'win32':
     key = 'USERNAME'
   return os.environ.get(key, '')
 
 def ReadVersionFile():
+  def match_against(pattern, content):
+    match = re.search(pattern, content, flags=re.MULTILINE)
+    if match:
+      return match.group(1)
+    return None
+
   version_file = os.path.join(DART_DIR, 'tools', 'VERSION')
   try:
     fd = open(version_file)
     content = fd.read()
     fd.close()
   except:
     print "Warning: Couldn't read VERSION file (%s)" % version_file
     return None
-  channel_match = re.search(
-      '^CHANNEL ([A-Za-z0-9]+)$', content, flags=re.MULTILINE)
-  major_match = re.search('^MAJOR (\d+)$', content, flags=re.MULTILINE)
-  minor_match = re.search('^MINOR (\d+)$', content, flags=re.MULTILINE)
-  build_match = re.search('^BUILD (\d+)$', content, flags=re.MULTILINE)
-  patch_match = re.search('^PATCH (\d+)$', content, flags=re.MULTILINE)
-  if (channel_match and
-      major_match and
-      minor_match and
-      build_match and
-      patch_match):
-    return (channel_match.group(1), major_match.group(1), minor_match.group(1),
-            build_match.group(1), patch_match.group(1))
+
+  channel = match_against('^CHANNEL ([A-Za-z0-9]+)$', content)

[kasperl, 2013/12/05 08:29:58]

Looks like this allows the VERSION file to contain comments. Maybe we should add
a few to it to make it clear what PRERELEASE and PRERELEASE_PATCH are supposed
to be used for.

[kustermann, 2013/12/05 09:27:27]

That came to my mind as well, but I wasn't sure if the ant xml files could
handle it, but apparently it works.

I've added some comments, please take a look at them.

+  major = match_against('^MAJOR (\d+)$', content)
+  minor = match_against('^MINOR (\d+)$', content)
+  patch = match_against('^PATCH (\d+)$', content)
+  prerelease = match_against('^PRERELEASE (\d+)$', content)
+  prerelease_patch = match_against('^PRERELEASE_PATCH (\d+)$', content)
+
+  if channel and major and minor and prerelease and prerelease_patch:
+    return Version(
+        channel, major, minor, patch, prerelease, prerelease_patch)
   else:
     print "Warning: VERSION file (%s) has wrong format" % version_file
     return None
 
 def GetSVNRevision():
   # FIXME(kustermann): Make this work for newer SVN versions as well (where
   # we've got only one '.svn' directory)
   custom_env = dict(os.environ)
   custom_env['LC_MESSAGES'] = 'en_GB'
   p = subprocess.Popen(['svn', 'info'], stdout = subprocess.PIPE,
@@ skipping 200 matching lines @@
     os.chdir(self._working_directory)
 
   def __exit__(self, *_):
     print "Enter directory = ", self._old_cwd
     os.chdir(self._old_cwd)
 
 
 if __name__ == "__main__":
   import sys
   Main(sys.argv)