src/leap/common/_version.py

   1 # This file helps to compute a version number in source trees obtained from
   2 # git-archive tarball (such as those provided by githubs download-from-tag
   3 # feature). Distribution tarballs (build by setup.py sdist) and build
   4 # directories (produced by setup.py build) will contain a much shorter file
   5 # that just contains the computed version number.
   6
   7 # This file is released into the public domain. Generated by
   8 # versioneer-0.7+ (https://github.com/warner/python-versioneer)
   9
  10 # these strings will be replaced by git during git-archive
  11
  12 import subprocess
  13 import sys
  14 import re
  15 import os.path
  16
  17 IN_LONG_VERSION_PY = True
  18 git_refnames = "$Format:%d$"
  19 git_full = "$Format:%H$"
  20
  21
  22 def run_command(args, cwd=None, verbose=False):
  23     try:
  24         # remember shell=False, so use git.cmd on windows, not just git
  25         p = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd)
  26     except EnvironmentError:
  27         e = sys.exc_info()[1]
  28         if verbose:
  29             print("unable to run %s" % args[0])
  30             print(e)
  31         return None
  32     stdout = p.communicate()[0].strip()
  33     if sys.version >= '3':
  34         stdout = stdout.decode()
  35     if p.returncode != 0:
  36         if verbose:
  37             print("unable to run %s (error)" % args[0])
  38         return None
  39     return stdout
  40
  41
  42 def get_expanded_variables(versionfile_source):
  43     # the code embedded in _version.py can just fetch the value of these
  44     # variables. When used from setup.py, we don't want to import
  45     # _version.py, so we do it with a regexp instead. This function is not
  46     # used from _version.py.
  47     variables = {}
  48     try:
  49         f = open(versionfile_source, "r")
  50         for line in f.readlines():
  51             if line.strip().startswith("git_refnames ="):
  52                 mo = re.search(r'=\s*"(.*)"', line)
  53                 if mo:
  54                     variables["refnames"] = mo.group(1)
  55             if line.strip().startswith("git_full ="):
  56                 mo = re.search(r'=\s*"(.*)"', line)
  57                 if mo:
  58                     variables["full"] = mo.group(1)
  59         f.close()
  60     except EnvironmentError:
  61         pass
  62     return variables
  63
  64
  65 def versions_from_expanded_variables(variables, tag_prefix, verbose=False):
  66     refnames = variables["refnames"].strip()
  67     if refnames.startswith("$Format"):
  68         if verbose:
  69             print("variables are unexpanded, not using")
  70         return {}  # unexpanded, so not in an unpacked git-archive tarball
  71     refs = set([r.strip() for r in refnames.strip("()").split(",")])
  72     # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
  73     # just "foo-1.0". If we see a "tag: " prefix, prefer those.
  74     TAG = "tag: "
  75     tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
  76     if not tags:
  77         # Either we're using git < 1.8.3, or there really are no tags. We use
  78         # a heuristic: assume all version tags have a digit. The old git %d
  79         # expansion behaves like git log --decorate=short and strips out the
  80         # refs/heads/ and refs/tags/ prefixes that would let us distinguish
  81         # between branches and tags. By ignoring refnames without digits, we
  82         # filter out many common branch names like "release" and
  83         # "stabilization", as well as "HEAD" and "master".
  84         tags = set([r for r in refs if re.search(r'\d', r)])
  85         if verbose:
  86             print("discarding '%s', no digits" % ",".join(refs - tags))
  87     if verbose:
  88         print("likely tags: %s" % ",".join(sorted(tags)))
  89     for ref in sorted(tags):
  90         # sorting will prefer e.g. "2.0" over "2.0rc1"
  91         if ref.startswith(tag_prefix):
  92             r = ref[len(tag_prefix):]
  93             if verbose:
  94                 print("picking %s" % r)
  95             return {"version": r,
  96                     "full": variables["full"].strip()}
  97     # no suitable tags, so we use the full revision id
  98     if verbose:
  99         print("no suitable tags, using full revision id")
 100     return {"version": variables["full"].strip(),
 101             "full": variables["full"].strip()}
 102
 103
 104 def versions_from_vcs(tag_prefix, versionfile_source, verbose=False):
 105     # this runs 'git' from the root of the source tree. That either means
 106     # someone ran a setup.py command (and this code is in versioneer.py, so
 107     # IN_LONG_VERSION_PY=False, thus the containing directory is the root of
 108     # the source tree), or someone ran a project-specific entry point (and
 109     # this code is in _version.py, so IN_LONG_VERSION_PY=True, thus the
 110     # containing directory is somewhere deeper in the source tree). This only
 111     # gets called if the git-archive 'subst' variables were *not* expanded,
 112     # and _version.py hasn't already been rewritten with a short version
 113     # string, meaning we're inside a checked out source tree.
 114
 115     try:
 116         here = os.path.abspath(__file__)
 117     except NameError:
 118         # some py2exe/bbfreeze/non-CPython implementations don't do __file__
 119         return {}  # not always correct
 120
 121     # versionfile_source is the relative path from the top of the source tree
 122     # (where the .git directory might live) to this file. Invert this to find
 123     # the root from __file__.
 124     root = here
 125     if IN_LONG_VERSION_PY:
 126         for i in range(len(versionfile_source.split("/"))):
 127             root = os.path.dirname(root)
 128     else:
 129         root = os.path.dirname(here)
 130     if not os.path.exists(os.path.join(root, ".git")):
 131         if verbose:
 132             print("no .git in %s" % root)
 133         return {}
 134
 135     GIT = "git"
 136     if sys.platform == "win32":
 137         GIT = "git.cmd"
 138     stdout = run_command([GIT, "describe", "--tags", "--dirty", "--always"],
 139                          cwd=root)
 140     if stdout is None:
 141         return {}
 142     if not stdout.startswith(tag_prefix):
 143         if verbose:
 144             print("tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix))
 145         return {}
 146     tag = stdout[len(tag_prefix):]
 147     stdout = run_command([GIT, "rev-parse", "HEAD"], cwd=root)
 148     if stdout is None:
 149         return {}
 150     full = stdout.strip()
 151     if tag.endswith("-dirty"):
 152         full += "-dirty"
 153     return {"version": tag, "full": full}
 154
 155
 156 def versions_from_parentdir(parentdir_prefix, versionfile_source, verbose=False):
 157     if IN_LONG_VERSION_PY:
 158         # We're running from _version.py. If it's from a source tree
 159         # (execute-in-place), we can work upwards to find the root of the
 160         # tree, and then check the parent directory for a version string. If
 161         # it's in an installed application, there's no hope.
 162         try:
 163             here = os.path.abspath(__file__)
 164         except NameError:
 165             # py2exe/bbfreeze/non-CPython don't have __file__
 166             return {}  # without __file__, we have no hope
 167         # versionfile_source is the relative path from the top of the source
 168         # tree to _version.py. Invert this to find the root from __file__.
 169         root = here
 170         for i in range(len(versionfile_source.split("/"))):
 171             root = os.path.dirname(root)
 172     else:
 173         # we're running from versioneer.py, which means we're running from
 174         # the setup.py in a source tree. sys.argv[0] is setup.py in the root.
 175         here = os.path.abspath(sys.argv[0])
 176         root = os.path.dirname(here)
 177
 178     # Source tarballs conventionally unpack into a directory that includes
 179     # both the project name and a version string.
 180     dirname = os.path.basename(root)
 181     if not dirname.startswith(parentdir_prefix):
 182         if verbose:
 183             print("guessing rootdir is '%s', but '%s' doesn't start with prefix '%s'" %
 184                   (root, dirname, parentdir_prefix))
 185         return None
 186     return {"version": dirname[len(parentdir_prefix):], "full": ""}
 187
 188 tag_prefix = ""
 189 parentdir_prefix = "leap.common-"
 190 versionfile_source = "src/leap/common/_version.py"
 191
 192
 193 def get_versions(default={"version": "unknown", "full": ""}, verbose=False):
 194     variables = {"refnames": git_refnames, "full": git_full}
 195     ver = versions_from_expanded_variables(variables, tag_prefix, verbose)
 196     if not ver:
 197         ver = versions_from_vcs(tag_prefix, versionfile_source, verbose)
 198     if not ver:
 199         ver = versions_from_parentdir(parentdir_prefix, versionfile_source,
 200                                       verbose)
 201     if not ver:
 202         ver = default
 203     return ver