mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-11 04:15:43 +00:00
862e0f0951
Usage is: ./profile rm <profile> [<file>] The file is a list of prefs, one per line, to remove. The file defaults to stdin, so the culmination of the last three commits is the ability to do: ./profile diff reftest common -f names -k same | ./profile rm reftest The above command will remove from the reftest profile, the prefs that are identical in both reftest and common. This method is quicker and less error prone than doing it manually (which was how I was doing this previously). MozReview-Commit-ID: Je0JjFXoora --HG-- extra : rebase_source : 38dae2dcdc3986910cfcd5091f7fc968bf8cc22a
303 lines
8.9 KiB
Bash
Executable File
303 lines
8.9 KiB
Bash
Executable File
#!/bin/sh
|
|
# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
|
|
# vim: set filetype=python:
|
|
|
|
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
# The beginning of this script is both valid shell and valid python,
|
|
# such that the script starts with the shell and is reexecuted python
|
|
'''which' mach > /dev/null 2>&1 && exec mach python "$0" "$@" ||
|
|
echo "mach not found, either add it to your \$PATH or run this script via ./mach python testing/profiles/profile"; exit # noqa
|
|
'''
|
|
|
|
from __future__ import absolute_import, unicode_literals, print_function
|
|
|
|
"""This script can be used to:
|
|
|
|
1) Show all preferences for a given suite
|
|
2) Diff preferences between two suites or profiles
|
|
3) Sort preference files alphabetically for a given profile
|
|
|
|
To use, either make sure that `mach` is on your $PATH, or run:
|
|
$ ./mach python testing/profiles/profile <args>
|
|
|
|
For more details run:
|
|
$ ./profile -- --help
|
|
"""
|
|
|
|
import json
|
|
import os
|
|
import sys
|
|
from argparse import ArgumentParser
|
|
from itertools import chain
|
|
|
|
from mozprofile import Profile
|
|
from mozprofile.prefs import Preferences
|
|
|
|
here = os.path.abspath(os.path.dirname(__file__))
|
|
|
|
try:
|
|
import jsondiff
|
|
except ImportError:
|
|
from mozbuild.base import MozbuildObject
|
|
build = MozbuildObject.from_environment(cwd=here)
|
|
build.virtualenv_manager.install_pip_package("jsondiff")
|
|
import jsondiff
|
|
|
|
|
|
FORMAT_STRINGS = {
|
|
'names': (
|
|
'{pref}',
|
|
'{pref}',
|
|
),
|
|
'pretty': (
|
|
'{pref}: {value}',
|
|
'{pref}: {value_a} => {value_b}'
|
|
),
|
|
}
|
|
|
|
|
|
def read_prefs(profile, pref_files=None):
|
|
"""Read and return all preferences set in the given profile.
|
|
|
|
:param profile: Profile name relative to this `here`.
|
|
:returns: A dictionary of preferences set in the profile.
|
|
"""
|
|
pref_files = pref_files or Profile.preference_file_names
|
|
prefs = {}
|
|
for name in pref_files:
|
|
path = os.path.join(here, profile, name)
|
|
if not os.path.isfile(path):
|
|
continue
|
|
|
|
try:
|
|
prefs.update(Preferences.read_json(path))
|
|
except ValueError:
|
|
prefs.update(Preferences.read_prefs(path))
|
|
return prefs
|
|
|
|
|
|
def get_profiles(key):
|
|
"""Return a list of profile names for key."""
|
|
with open(os.path.join(here, 'profiles.json'), 'r') as fh:
|
|
profiles = json.load(fh)
|
|
|
|
if '+' in key:
|
|
keys = key.split('+')
|
|
else:
|
|
keys = [key]
|
|
|
|
names = set()
|
|
for key in keys:
|
|
if key in profiles:
|
|
names.update(profiles[key])
|
|
elif os.path.isdir(os.path.join(here, key)):
|
|
names.add(key)
|
|
|
|
if not names:
|
|
raise ValueError('{} is not a recognized suite or profile'.format(key))
|
|
return names
|
|
|
|
|
|
def read(key):
|
|
"""Read preferences relevant to either a profile or suite.
|
|
|
|
:param key: Can either be the name of a profile, or the name of
|
|
a suite as defined in suites.json.
|
|
"""
|
|
prefs = {}
|
|
for profile in get_profiles(key):
|
|
prefs.update(read_prefs(profile))
|
|
return prefs
|
|
|
|
|
|
def format_diff(diff, fmt, limit_key):
|
|
"""Format a diff."""
|
|
indent = ' '
|
|
if limit_key:
|
|
diff = {limit_key: diff[limit_key]}
|
|
indent = ''
|
|
|
|
if fmt == 'json':
|
|
print(json.dumps(diff, sort_keys=True, indent=2))
|
|
return 0
|
|
|
|
lines = []
|
|
for key, prefs in sorted(diff.items()):
|
|
if not limit_key:
|
|
lines.append("{}:".format(key))
|
|
|
|
for pref, value in sorted(prefs.items()):
|
|
context = {'pref': pref, 'value': repr(value)}
|
|
|
|
if isinstance(value, list):
|
|
context['value_a'] = repr(value[0])
|
|
context['value_b'] = repr(value[1])
|
|
text = FORMAT_STRINGS[fmt][1].format(**context)
|
|
else:
|
|
text = FORMAT_STRINGS[fmt][0].format(**context)
|
|
|
|
lines.append('{}{}'.format(indent, text))
|
|
lines.append('')
|
|
print('\n'.join(lines).strip())
|
|
|
|
|
|
def diff(a, b, fmt, limit_key):
|
|
"""Diff two profiles or suites.
|
|
|
|
:param a: The first profile or suite name.
|
|
:param b: The second profile or suite name.
|
|
"""
|
|
prefs_a = read(a)
|
|
prefs_b = read(b)
|
|
res = jsondiff.diff(prefs_a, prefs_b, syntax='symmetric')
|
|
if not res:
|
|
return 0
|
|
|
|
if isinstance(res, list) and len(res) == 2:
|
|
res = {
|
|
jsondiff.Symbol('delete'): res[0],
|
|
jsondiff.Symbol('insert'): res[1],
|
|
}
|
|
|
|
# Post process results to make them JSON compatible and a
|
|
# bit more clear. Also calculate identical prefs.
|
|
results = {}
|
|
results['change'] = {k: v for k, v in res.items() if not isinstance(k, jsondiff.Symbol)}
|
|
|
|
symbols = [(k, v) for k, v in res.items() if isinstance(k, jsondiff.Symbol)]
|
|
results['insert'] = {k: v for sym, pref in symbols for k, v in pref.items()
|
|
if sym.label == 'insert'}
|
|
results['delete'] = {k: v for sym, pref in symbols for k, v in pref.items()
|
|
if sym.label == 'delete'}
|
|
|
|
same = set(prefs_a.keys()) - set(chain(*results.values()))
|
|
results['same'] = {k: v for k, v in prefs_a.items() if k in same}
|
|
return format_diff(results, fmt, limit_key)
|
|
|
|
|
|
def read_with_comments(path):
|
|
with open(path, 'r') as fh:
|
|
lines = fh.readlines()
|
|
|
|
result = []
|
|
buf = []
|
|
for line in lines:
|
|
line = line.strip()
|
|
if not line:
|
|
continue
|
|
|
|
if line.startswith('//'):
|
|
buf.append(line)
|
|
continue
|
|
|
|
if buf:
|
|
result.append(buf + [line])
|
|
buf = []
|
|
continue
|
|
|
|
result.append([line])
|
|
return result
|
|
|
|
|
|
def sort_file(path):
|
|
"""Sort the given pref file alphabetically, preserving preceding comments
|
|
that start with '//'.
|
|
|
|
:param path: Path to the preference file to sort.
|
|
"""
|
|
result = read_with_comments(path)
|
|
result = sorted(result, key=lambda x: x[-1])
|
|
result = chain(*result)
|
|
|
|
with open(path, 'w') as fh:
|
|
fh.write('\n'.join(result) + '\n')
|
|
|
|
|
|
def sort(profile):
|
|
"""Sort all prefs in the given profile alphabetically. This will preserve
|
|
comments on preceding lines.
|
|
|
|
:param profile: The name of the profile to sort.
|
|
"""
|
|
pref_files = Profile.preference_file_names
|
|
|
|
for name in pref_files:
|
|
path = os.path.join(here, profile, name)
|
|
if os.path.isfile(path):
|
|
sort_file(path)
|
|
|
|
|
|
def show(suite):
|
|
"""Display all prefs set in profiles used by the given suite.
|
|
|
|
:param suite: The name of the suite to show preferences for. This must
|
|
be a key in suites.json.
|
|
"""
|
|
for k, v in sorted(read(suite).items()):
|
|
print("{}: {}".format(k, repr(v)))
|
|
|
|
|
|
def rm(profile, pref_file):
|
|
if pref_file == '-':
|
|
lines = sys.stdin.readlines()
|
|
else:
|
|
with open(pref_file, 'r') as fh:
|
|
lines = fh.readlines()
|
|
|
|
lines = [l.strip() for l in lines if l.strip()]
|
|
if not lines:
|
|
return
|
|
|
|
def filter_line(content):
|
|
return not any(line in content[-1] for line in lines)
|
|
|
|
path = os.path.join(here, profile, 'user.js')
|
|
contents = read_with_comments(path)
|
|
contents = filter(filter_line, contents)
|
|
contents = chain(*contents)
|
|
with open(path, 'w') as fh:
|
|
fh.write('\n'.join(contents))
|
|
|
|
|
|
def cli(args=sys.argv[1:]):
|
|
parser = ArgumentParser()
|
|
subparsers = parser.add_subparsers()
|
|
|
|
diff_parser = subparsers.add_parser('diff')
|
|
diff_parser.add_argument('a', metavar='A',
|
|
help="Path to the first profile or suite name to diff.")
|
|
diff_parser.add_argument('b', metavar='B',
|
|
help="Path to the second profile or suite name to diff.")
|
|
diff_parser.add_argument('-f', '--format', dest='fmt', default='pretty',
|
|
choices=['pretty', 'json', 'names'],
|
|
help="Format to dump diff in (default: pretty)")
|
|
diff_parser.add_argument('-k', '--limit-key', default=None,
|
|
choices=['change', 'delete', 'insert', 'same'],
|
|
help="Restrict diff to the specified key.")
|
|
diff_parser.set_defaults(func=diff)
|
|
|
|
sort_parser = subparsers.add_parser('sort')
|
|
sort_parser.add_argument('profile', help="Path to profile to sort preferences.")
|
|
sort_parser.set_defaults(func=sort)
|
|
|
|
show_parser = subparsers.add_parser('show')
|
|
show_parser.add_argument('suite', help="Name of suite to show arguments for.")
|
|
show_parser.set_defaults(func=show)
|
|
|
|
rm_parser = subparsers.add_parser('rm')
|
|
rm_parser.add_argument('profile', help="Name of the profile to remove prefs from.")
|
|
rm_parser.add_argument('--pref-file', default='-', help="File containing a list of pref "
|
|
"substrings to delete (default: stdin)")
|
|
rm_parser.set_defaults(func=rm)
|
|
|
|
args = vars(parser.parse_args(args))
|
|
func = args.pop('func')
|
|
func(**args)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(cli())
|