blob: 1a0756d708b96a580993756541d32e3a4f6adacb [file] [log] [blame]
# Copyright (C) 2017-2021 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import re
from webkitcorepy import Version
from webkitpy.common.memoized import memoized
PUBLIC_TABLE = 'public'
INTERNAL_TABLE = 'internal'
class VersionNameMap(object):
# Allows apple_additions to define a custom mapping
@staticmethod
@memoized
def map(platform=None):
from webkitpy.port.config import apple_additions
if apple_additions():
return apple_additions().version_name_mapping(platform)
return VersionNameMap(platform=platform)
def __init__(self, platform=None):
if platform is None:
from webkitpy.common.system.systemhost import SystemHost
platform = SystemHost().platform
self.mapping = {}
self.default_system_platform = platform.os_name
self.mapping[PUBLIC_TABLE] = {
'mac': {
'Leopard': Version(10, 5),
'Snow Leopard': Version(10, 6),
'Lion': Version(10, 7),
'Mountain Lion': Version(10, 8),
'Mavericks': Version(10, 9),
'Yosemite': Version(10, 10),
'El Capitan': Version(10, 11),
'Sierra': Version(10, 12),
'High Sierra': Version(10, 13),
'Mojave': Version(10, 14),
'Catalina': Version(10, 15),
'Big Sur': Version(11, 0),
'Monterey': Version(12, 0),
'Ventura': Version(13, 0),
},
'ios': self._automap_to_major_version('iOS', minimum=Version(10), maximum=Version(16)),
'tvos': self._automap_to_major_version('tvOS', minimum=Version(10), maximum=Version(16)),
'watchos': self._automap_to_major_version('watchOS', minimum=Version(1), maximum=Version(9)),
'win': {
'Win10': Version(10),
'8.1': Version(6, 3),
'8': Version(6, 2),
'7sp0': Version(6, 1, 7600),
'Vista': Version(6),
'XP': Version(5, 1),
},
# This entry avoids hitting the assert in mapping_for_platform() on Linux,
# but otherwise shouldn't contain any useful key-value pairs.
'linux': {},
}
# wincairo uses the same versions as Windows
self.mapping[PUBLIC_TABLE]['wincairo'] = self.mapping[PUBLIC_TABLE]['win']
# FTW uses the same versions as Windows
self.mapping[PUBLIC_TABLE]['ftw'] = self.mapping[PUBLIC_TABLE]['win']
@classmethod
def _automap_to_major_version(cls, prefix, minimum=Version(1), maximum=Version(1)):
result = {}
assert minimum <= maximum
for i in range((maximum.major + 1) - minimum.major):
result['{} {}'.format(prefix, str(Version(minimum.major + i)))] = Version(minimum.major + i)
return result
def to_name(self, version, platform=None, table=PUBLIC_TABLE):
closest_match = (None, None)
for os_name, os_version in self.mapping_for_platform(platform, table).items():
if version == os_version:
return os_name
elif version in os_version:
if closest_match[1] and closest_match[1] in os_version:
continue
closest_match = (os_name, os_version)
return closest_match[0]
def max_public_version(self, platform=None):
found_max_version = None
for os_name, os_version in self.mapping_for_platform(platform, PUBLIC_TABLE).items():
if os_version > found_max_version:
found_max_version = os_version
return found_max_version
@staticmethod
def strip_name_formatting(name):
# <OS> major.minor.tiny should map to <OS> major
if ' ' in name:
try:
name = '{}{}'.format(''.join(name.split(' ')[:-1]), Version.from_string(name.split(' ')[-1]).major)
except ValueError:
pass
else:
try:
split = re.split(r'\d', name)
name = '{}{}'.format(split[0], Version.from_string(name[(len(split) - 1):]).major)
except ValueError:
pass
# Strip out any spaces, make everything lower-case
result = name.replace(' ', '').lower()
return result
def from_name(self, name):
# Exact match
for _, map in self.mapping.items():
for os_name, os_map in map.items():
if name in os_map:
return (os_name, os_map[name])
# It's not an exact match, let's try unifying formatting
unformatted = self.strip_name_formatting(name)
for _, map in self.mapping.items():
for os_name, os_map in map.items():
for version_name, version in os_map.items():
if self.strip_name_formatting(version_name) == unformatted:
return (os_name, version)
return (None, None)
def names(self, platform=None, table=PUBLIC_TABLE):
"""return list of os_name for platform"""
mapping = self.mapping_for_platform(platform, table)
names = [os_name for os_name in mapping]
return sorted(names, key=lambda os_name: mapping[os_name])
def mapping_for_platform(self, platform=None, table=PUBLIC_TABLE):
# Alias macos to mac here. Adding a separate entry to the table
# would cause from_name() to return either 'mac' or 'macos'.
if platform == 'macos':
platform = 'mac'
"""return proper os_name: os_version mapping for platform"""
platform = self.default_system_platform if platform is None else platform
return self.mapping.get(table, {}).get(platform, {})