mirror of
https://bitbucket.org/chromiumembedded/cef
synced 2024-12-12 17:46:04 +01:00
276 lines
9.9 KiB
Python
276 lines
9.9 KiB
Python
# Copyright (c) 2019 The Chromium Embedded Framework Authors. All rights
|
|
# reserved. Use of this source code is governed by a BSD-style license that
|
|
# can be found in the LICENSE file.
|
|
|
|
from __future__ import absolute_import
|
|
from __future__ import print_function
|
|
from file_util import *
|
|
import git_util as git
|
|
import os
|
|
|
|
|
|
class VersionFormatter:
|
|
""" Formats CEF version information. """
|
|
|
|
def __init__(self, chromium_src_path=None):
|
|
if chromium_src_path is None:
|
|
# Relative to the current directory.
|
|
script_path = os.path.abspath(os.path.dirname(__file__))
|
|
chromium_src_path = os.path.abspath(
|
|
os.path.join(script_path, os.pardir, os.pardir))
|
|
|
|
self.src_path = chromium_src_path
|
|
assert os.path.isdir(self.src_path), self.src_path
|
|
self.cef_path = os.path.join(self.src_path, 'cef')
|
|
assert os.path.isdir(self.cef_path), self.cef_path
|
|
|
|
# Whether to use the old version format by default.
|
|
self._old_format_default = \
|
|
bool(int(os.environ.get('CEF_OLD_VERSION_FORMAT', '0')))
|
|
|
|
self.reset()
|
|
|
|
def reset(self):
|
|
""" Reset internal state. """
|
|
self._chrome_version = {}
|
|
self._cef_version = {}
|
|
self._cef_commit = {}
|
|
self._branch_version = {}
|
|
self._old_version_string = None
|
|
self._old_version_parts = {}
|
|
self._version_string = None
|
|
self._version_parts = {}
|
|
|
|
def get_chrome_version_components(self):
|
|
""" Returns Chrome version components. """
|
|
if not bool(self._chrome_version):
|
|
file_path = os.path.join(self.src_path, 'chrome', 'VERSION')
|
|
assert os.path.isfile(file_path), file_path
|
|
read_version_file(file_path, self._chrome_version)
|
|
return self._chrome_version
|
|
|
|
def get_cef_version_components(self):
|
|
""" Returns CEF version components. """
|
|
if not bool(self._cef_version):
|
|
file_path = os.path.join(self.cef_path, 'VERSION.in')
|
|
assert os.path.isfile(file_path), file_path
|
|
read_version_file(file_path, self._cef_version)
|
|
return self._cef_version
|
|
|
|
def get_cef_commit_components(self):
|
|
""" Returns CEF commit components. """
|
|
if not bool(self._cef_commit):
|
|
hash = git.get_hash(self.cef_path)
|
|
number = git.get_commit_number(self.cef_path)
|
|
self._cef_commit = {'HASH': hash, 'NUMBER': number}
|
|
return self._cef_commit
|
|
|
|
def get_cef_branch_version_components(self):
|
|
""" Computes the CEF branch version. """
|
|
if not bool(self._branch_version):
|
|
minor = 0
|
|
bugfix = 0
|
|
|
|
# Retrieve the list of commits that have been applied on the current
|
|
# branch since branching from origin/master.
|
|
hashes = git.get_branch_hashes(self.cef_path)
|
|
for hash in hashes:
|
|
# Determine if the API hash file was modified by the commit.
|
|
found = False
|
|
files = git.get_changed_files(self.cef_path, hash)
|
|
for file in files:
|
|
if file.find('cef_api_hash.h') >= 0:
|
|
found = True
|
|
break
|
|
|
|
if found:
|
|
minor += 1
|
|
bugfix = 0
|
|
else:
|
|
bugfix += 1
|
|
|
|
self._branch_version = {'MINOR': minor, 'PATCH': bugfix}
|
|
return self._branch_version
|
|
|
|
def get_chromium_version_string(self):
|
|
""" Returns the Chromium version number string. """
|
|
chrome_version = self.get_chrome_version_components()
|
|
return '%s.%s.%s.%s' % (chrome_version['MAJOR'], chrome_version['MINOR'],
|
|
chrome_version['BUILD'], chrome_version['PATCH'])
|
|
|
|
@staticmethod
|
|
def _format_commit_hash(hash):
|
|
return 'g%s' % hash[:7]
|
|
|
|
# Computes old version numbers in the format "X.YYYY.A.gHHHHHHH".
|
|
#
|
|
# Where:
|
|
# - "X" is the CEF major version (currently 3).
|
|
# - "YYYY" is the Chromium branch.
|
|
# - "A" is an incremental number representing the number of commits in the
|
|
# current branch. This is roughly equivalent to the SVN revision number but
|
|
# on a per-branch basis and assists people in quickly determining the order
|
|
# of builds in the same branch (for bug reports, etc).
|
|
# - "gHHHHHHH" is the 7-character abbreviation for the Git commit hash. This
|
|
# facilitates lookup of the relevant commit history in Git.
|
|
#
|
|
# Example: "3.3729.1921.g62d140e"
|
|
def _compute_old_version(self):
|
|
if not self._old_version_string is None:
|
|
return
|
|
|
|
chrome_version = self.get_chrome_version_components()
|
|
cef_version = self.get_cef_version_components()
|
|
cef_commit = self.get_cef_commit_components()
|
|
cef_commit_hash = self._format_commit_hash(cef_commit['HASH'])
|
|
|
|
self._old_version_parts = {
|
|
'MAJOR': int(cef_version['CEF_MAJOR']),
|
|
'MINOR': int(chrome_version['BUILD']),
|
|
'PATCH': int(cef_commit['NUMBER'])
|
|
}
|
|
self._old_version_string = \
|
|
'%s.%s.%s.%s' % (cef_version['CEF_MAJOR'], chrome_version['BUILD'],
|
|
cef_commit['NUMBER'], cef_commit_hash)
|
|
|
|
def _get_old_version_string(self):
|
|
self._compute_old_version()
|
|
return self._old_version_string
|
|
|
|
def _get_old_version_parts(self):
|
|
self._compute_old_version()
|
|
return self._old_version_parts
|
|
|
|
# Computes version numbers in the format:
|
|
# - "X.Y.Z+gHHHHHHH+chromium-A.B.C.D" for release branch builds.
|
|
# - "X.0.0-master.N+gHHHHHHH+chromium-A.B.C.D" for master branch builds.
|
|
#
|
|
# Where:
|
|
# - "X" is the Chromium major version (e.g. 74).
|
|
# - "Y" is an incremental number that starts at 0 when a release branch is
|
|
# created and changes only when the CEF C/C++ API changes (similar to how
|
|
# the CEF_API_HASH_UNIVERSAL value behaves in cef_version.h) (release branch
|
|
# only).
|
|
# - "Z" is an incremental number that starts at 0 when a release branch is
|
|
# created and changes on each commit, with reset to 0 when "Y" changes
|
|
# (release branch only).
|
|
# - "N" is an incremental number representing the number of commits (master
|
|
# branch only).
|
|
# - "gHHHHHHH" is the 7-character abbreviation for the Git commit hash. This
|
|
# facilitates lookup of the relevant commit history in Git.
|
|
# - "A.B.C.D" is the Chromium version (e.g. 74.0.3729.6).
|
|
#
|
|
# Examples:
|
|
# - "74.0.1+g62d140e+chromium-74.0.3729.6" for a release build.
|
|
# - "74.0.0-master.1920+g725ed88+chromium-74.0.3729.0" for a master build.
|
|
def _compute_version(self):
|
|
if not self._version_string is None:
|
|
return
|
|
|
|
chrome_version = self.get_chrome_version_components()
|
|
chrome_major = chrome_version['MAJOR']
|
|
chrome_version_part = 'chromium-' + self.get_chromium_version_string()
|
|
|
|
cef_commit = self.get_cef_commit_components()
|
|
cef_commit_hash = self._format_commit_hash(cef_commit['HASH'])
|
|
|
|
# Determine whether the current commit is on a release branch. For example,
|
|
# if using Chrome build 3683, are we on CEF branch "3683" or "origin/3683"?
|
|
release_branch = chrome_version['BUILD']
|
|
on_release_branch = (
|
|
git.is_ancestor(self.cef_path, 'HEAD', release_branch) or
|
|
git.is_ancestor(self.cef_path, 'HEAD', 'origin/' + release_branch))
|
|
|
|
if not on_release_branch:
|
|
# Not on a commit that is part of an official named release branch. See
|
|
# if we can get the name of the branch we are on (may be just "HEAD").
|
|
cef_branch_name = git.get_branch_name(self.cef_path).split('/')[-1]
|
|
|
|
self._version_parts = {'MAJOR': int(chrome_major), 'MINOR': 0, 'PATCH': 0}
|
|
self._version_string = '%s.0.0-%s.%s+%s+%s' % \
|
|
(chrome_major, cef_branch_name, cef_commit['NUMBER'],
|
|
cef_commit_hash, chrome_version_part)
|
|
else:
|
|
cef_branch = self.get_cef_branch_version_components()
|
|
|
|
self._version_parts = {
|
|
'MAJOR': int(chrome_major),
|
|
'MINOR': cef_branch['MINOR'],
|
|
'PATCH': cef_branch['PATCH']
|
|
}
|
|
self._version_string = '%s.%d.%d+%s+%s' % \
|
|
(chrome_major, cef_branch['MINOR'], cef_branch['PATCH'],
|
|
cef_commit_hash, chrome_version_part)
|
|
|
|
def _get_version_string(self):
|
|
self._compute_version()
|
|
return self._version_string
|
|
|
|
def _get_version_parts(self):
|
|
self._compute_version()
|
|
return self._version_parts
|
|
|
|
def get_version_string(self, oldFormat=None):
|
|
""" Returns the CEF version number string based on current checkout state.
|
|
"""
|
|
if oldFormat is None:
|
|
oldFormat = self._old_format_default
|
|
|
|
if oldFormat:
|
|
return self._get_old_version_string()
|
|
return self._get_version_string()
|
|
|
|
def get_version_parts(self, oldFormat=None):
|
|
""" Returns the CEF version number parts based on current checkout state.
|
|
"""
|
|
if oldFormat is None:
|
|
oldFormat = self._old_format_default
|
|
|
|
if oldFormat:
|
|
return self._get_old_version_parts()
|
|
return self._get_version_parts()
|
|
|
|
def get_plist_version_string(self, oldFormat=None):
|
|
""" Returns the CEF version number string for plist files based on current
|
|
checkout state. """
|
|
parts = self.get_version_parts(oldFormat=oldFormat)
|
|
return "%d.%d.%d.0" % (parts['MAJOR'], parts['MINOR'], parts['PATCH'])
|
|
|
|
def get_dylib_version_string(self, oldFormat=None):
|
|
""" Returns the CEF version number string for dylib files based on current
|
|
checkout state. """
|
|
parts = self.get_version_parts(oldFormat=oldFormat)
|
|
# Dylib format supports a max value of 255 for the 2nd and 3rd components.
|
|
return "%d%d.%d.%d" % (parts['MAJOR'], parts['MINOR'], parts['PATCH'] / 255,
|
|
parts['PATCH'] % 255)
|
|
|
|
|
|
# Test the module.
|
|
if __name__ == "__main__":
|
|
import sys
|
|
|
|
# Optionally specify a format.
|
|
formats = ['current', 'old', 'plist', 'dylib']
|
|
if len(sys.argv) >= 2:
|
|
formats = [sys.argv[1]]
|
|
|
|
# Optionally specify the path to chromium/src.
|
|
chromium_src_path = None
|
|
if len(sys.argv) >= 3:
|
|
chromium_src_path = sys.argv[2]
|
|
|
|
formatter = VersionFormatter(chromium_src_path)
|
|
|
|
for format in formats:
|
|
if len(formats) > 1:
|
|
print(format)
|
|
|
|
if format == 'old':
|
|
print(formatter.get_version_string(True))
|
|
elif format == 'dylib':
|
|
print(formatter.get_dylib_version_string())
|
|
elif format == 'plist':
|
|
print(formatter.get_plist_version_string())
|
|
else:
|
|
print(formatter.get_version_string(False))
|