597e2e4cd8863a9110a2a6a32b875536cb94f444
[leap_pycommon.git] / src / leap / common / _version.py
1
2 IN_LONG_VERSION_PY = True
3 # This file helps to compute a version number in source trees obtained from
4 # git-archive tarball (such as those provided by githubs download-from-tag
5 # feature). Distribution tarballs (build by setup.py sdist) and build
6 # directories (produced by setup.py build) will contain a much shorter file
7 # that just contains the computed version number.
8
9 # This file is released into the public domain. Generated by
10 # versioneer-0.7+ (https://github.com/warner/python-versioneer)
11
12 # these strings will be replaced by git during git-archive
13 git_refnames = "$Format:%d$"
14 git_full = "$Format:%H$"
15
16
17 import subprocess
18 import sys
19
20 def run_command(args, cwd=None, verbose=False):
21     try:
22         # remember shell=False, so use git.cmd on windows, not just git
23         p = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd)
24     except EnvironmentError:
25         e = sys.exc_info()[1]
26         if verbose:
27             print("unable to run %s" % args[0])
28             print(e)
29         return None
30     stdout = p.communicate()[0].strip()
31     if sys.version >= '3':
32         stdout = stdout.decode()
33     if p.returncode != 0:
34         if verbose:
35             print("unable to run %s (error)" % args[0])
36         return None
37     return stdout
38
39
40 import sys
41 import re
42 import os.path
43
44 def get_expanded_variables(versionfile_source):
45     # the code embedded in _version.py can just fetch the value of these
46     # variables. When used from setup.py, we don't want to import
47     # _version.py, so we do it with a regexp instead. This function is not
48     # used from _version.py.
49     variables = {}
50     try:
51         f = open(versionfile_source,"r")
52         for line in f.readlines():
53             if line.strip().startswith("git_refnames ="):
54                 mo = re.search(r'=\s*"(.*)"', line)
55                 if mo:
56                     variables["refnames"] = mo.group(1)
57             if line.strip().startswith("git_full ="):
58                 mo = re.search(r'=\s*"(.*)"', line)
59                 if mo:
60                     variables["full"] = mo.group(1)
61         f.close()
62     except EnvironmentError:
63         pass
64     return variables
65
66 def versions_from_expanded_variables(variables, tag_prefix, verbose=False):
67     refnames = variables["refnames"].strip()
68     if refnames.startswith("$Format"):
69         if verbose:
70             print("variables are unexpanded, not using")
71         return {} # unexpanded, so not in an unpacked git-archive tarball
72     refs = set([r.strip() for r in refnames.strip("()").split(",")])
73     # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
74     # just "foo-1.0". If we see a "tag: " prefix, prefer those.
75     TAG = "tag: "
76     tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
77     if not tags:
78         # Either we're using git < 1.8.3, or there really are no tags. We use
79         # a heuristic: assume all version tags have a digit. The old git %d
80         # expansion behaves like git log --decorate=short and strips out the
81         # refs/heads/ and refs/tags/ prefixes that would let us distinguish
82         # between branches and tags. By ignoring refnames without digits, we
83         # filter out many common branch names like "release" and
84         # "stabilization", as well as "HEAD" and "master".
85         tags = set([r for r in refs if re.search(r'\d', r)])
86         if verbose:
87             print("discarding '%s', no digits" % ",".join(refs-tags))
88     if verbose:
89         print("likely tags: %s" % ",".join(sorted(tags)))
90     for ref in sorted(tags):
91         # sorting will prefer e.g. "2.0" over "2.0rc1"
92         if ref.startswith(tag_prefix):
93             r = ref[len(tag_prefix):]
94             if verbose:
95                 print("picking %s" % r)
96             return { "version": r,
97                      "full": variables["full"].strip() }
98     # no suitable tags, so we use the full revision id
99     if verbose:
100         print("no suitable tags, using full revision id")
101     return { "version": variables["full"].strip(),
102              "full": variables["full"].strip() }
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 def get_versions(default={"version": "unknown", "full": ""}, verbose=False):
193     variables = { "refnames": git_refnames, "full": git_full }
194     ver = versions_from_expanded_variables(variables, tag_prefix, verbose)
195     if not ver:
196         ver = versions_from_vcs(tag_prefix, versionfile_source, verbose)
197     if not ver:
198         ver = versions_from_parentdir(parentdir_prefix, versionfile_source,
199                                       verbose)
200     if not ver:
201         ver = default
202     return ver
203