olog/symconf
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity

large refactor (break up ConfigManager), add more tests

Browse Source
This commit is contained in:
Sam G.
2024-08-10 23:48:35 -07:00
parent cb1dd52833
commit bf311d57a5
26 changed files with 1066 additions and 611 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
symconf/__init__.py
View File

@@ -1,7 +1,12 @@
from symconf.config import ConfigManager
from symconf.runner import Runner
from symconf.reader import DictReader
from symconf.config import ConfigManager
from symconf.matching import Matcher, FilePart
from symconf.template import Template, FileTemplate, TOMLTemplate
from symconf import config
from symconf import matching
from symconf import reader
from symconf import template
from symconf import theme
from symconf import util

8
symconf/__main__.py
View File

@@ -43,12 +43,12 @@ def add_update_subparser(subparsers):
parser.set_defaults(func=update_apps)
def add_config_subparser(subparsers):
def config_apps(args):
def configure_apps(args):
cm = ConfigManager(args.config_dir)
cm.config_apps(
cm.configure_apps(
apps=args.apps,
scheme=args.scheme,
palette=args.palette,
style=args.palette,
)
parser = subparsers.add_parser(
@@ -82,7 +82,7 @@ def add_config_subparser(subparsers):
action=util.KVPair,
help='Groups to use when populating templates, in the form group=value'
)
parser.set_defaults(func=config_apps)
parser.set_defaults(func=configure_apps)
# central argparse entry point

893
symconf/config.py
View File

File diff suppressed because it is too large Load Diff

251
symconf/matching.py Normal file
View File

@@ -0,0 +1,251 @@
'''
Top-level definitions
Config files are expected to have names matching the following spec:
<style>-<scheme>.<config_pathname>
- ``config_pathname``: refers to a concrete filename, typically that which is expected by
the target app (e.g., ``kitty.conf``). In the context of ``config_map`` in the registry,
however, it merely serves as an identifier, as it can be mapped onto any path.
- ``scheme``: indicates the lightness mode ("light" or "dark")
- ``style``: general identifier capturing the stylizations applied to the config file.
This is typically of the form ``<variant>-<palette>``, i.e., including a reference to a
particular color palette.
For example
```sh
soft-gruvbox-dark.kitty.conf
```
gets mapped to
```sh
style -> "soft-gruvbox"
scheme -> "dark"
pathname -> "kitty.conf"
```
'''
from pathlib import Path
from symconf import util
class FilePart:
def __init__(self, path: str | Path):
self.path = util.absolute_path(path)
self.pathname = self.path.name
parts = str(self.pathname).split('.')
if len(parts) < 2:
raise ValueError(f'Filename "{pathname}" incorrectly formatted, ignoring')
self.theme = parts[0]
self.conf = '.'.join(parts[1:])
theme_split = self.theme.split('-')
self.scheme = theme_split[-1]
self.style = '-'.join(theme_split[:-1])
self.index = -1
def set_index(self, idx: int):
self.index = idx
class Matcher:
def get_file_parts(
self,
paths: list[str | Path],
) -> list[FilePart]:
'''
Split pathnames into parts for matching.
Pathnames should be of the format
```sh
<style>-<scheme>.<config_pathname>
```
where ``style`` is typically itself of the form ``<variant>-<palette>``.
'''
file_parts = []
for path in paths:
try:
config_file = FilePart(path)
file_parts.append(config_file)
except ValueError as e:
print(f'Filename "{pathname}" incorrectly formatted, ignoring')
return file_parts
def prefix_order(
self,
scheme,
style,
strict=False,
) -> list[tuple[str, str]]:
'''
Determine the order of concrete config pathname parts to match, given the
``scheme`` and ``style`` inputs.
There is a unique preferred match order when ``style``, ``scheme``, both, or none
are ``any``. In general, when ``any`` is provided for a given factor, it is
best matched by a config file that expresses indifference under that factor.
'''
# explicit cases are the most easily managed here, even if a little redundant
if strict:
theme_order = [
(style, scheme),
]
else:
# inverse order of match relaxation; intention being to overwrite with
# results from increasingly relevant groups given the conditions
if style == 'any' and scheme == 'any':
# prefer both be "none", with preference for specific scheme
theme_order = [
(style , scheme),
(style , 'none'),
('none' , scheme),
('none' , 'none'),
]
elif style == 'any':
# prefer style to be "none", then specific, then relax specific scheme
# to "none"
theme_order = [
(style , 'none'),
('none' , 'none'),
(style , scheme),
('none' , scheme),
]
elif scheme == 'any':
# prefer scheme to be "none", then specific, then relax specific style
# to "none"
theme_order = [
('none' , scheme),
('none' , 'none'),
(style , scheme),
(style , 'none'),
]
else:
# neither component is any; prefer most specific
theme_order = [
('none' , 'none'),
('none' , scheme),
(style , 'none'),
(style , scheme),
]
return theme_order
def match_paths(
self,
paths: list[str | Path],
prefix_order: list[tuple[str, str]],
) -> list[FilePart]:
'''
Find and return FilePart matches according to the provided prefix order.
The prefix order specifies all valid style-scheme combos that can be considered as
"consistent" with some user input (and is computed external to this method). For
example, it could be
```py
[
('none', 'none')
('none', 'dark')
]
```
indicating that either ``none-none.<config>`` or ``none-dark.<config>`` would be
considered matching pathnames, with the latter being preferred.
This method exists because we need a way to allow any of the combos in the prefix
order to match the candidate files. We don't know a priori how good of a match
will be available, so we consider each file for each of the prefixes, and take the
latest/best match for each unique config pathname (allowing for a "soft" match).
.. admonition: Checking for matches
When thinking about how best to structure this method, it initially felt like
indexing factors of the FileParts would make the most sense, preventing the
inner loop that needs to inspect each FilePart for each element of the prefix
order. But indexing the file parts and checking against prefixes isn't so
straightforward, as we'd still need to check matches by factor. For instance,
if we index by style-scheme, either are allowed to be "any," so we'd need to
check for the 4 valid combos and join the matching lists. If we index by both
factors individually, we may have several files associated with a given key,
and then need to coordinate the checks across both to ensure they belong to
the same file.
In any case, you should be able to do this in a way that's a bit more
efficient, but the loop and the simple conditionals is just much simpler to
follow. We're also talking about at most 10s of files, so it really doesn't
matter.
Parameters:
pathnames:
scheme:
style:
prefix_order:
strict:
'''
file_parts = self.get_file_parts(paths)
ordered_matches = []
for i, (style_prefix, scheme_prefix) in enumerate(prefix_order):
for fp in file_parts:
style_match = style_prefix == fp.style or style_prefix == 'any'
scheme_match = scheme_prefix == fp.scheme or scheme_prefix == 'any'
if style_match and scheme_match:
fp.set_index(i+1)
ordered_matches.append(fp)
return ordered_matches
def relaxed_match(
self,
match_list: list[FilePart]
) -> list[FilePart]:
'''
Isolate the best match in a match list and find its relaxed variants.
This method allows us to use the ``match_paths()`` method for matching templates
rather than direct user config files. In the latter case, we want to symlink the
single best config file match for each stem, across all stems with matching
prefixes (e.g., ``none-dark.config.a`` and ``solarized-dark.config.b`` have two
separate stems with prefixes that could match ``scheme=dark, style=any`` query).
We can find these files by just indexing the ``match_path`` outputs (i.e., all
matches) by config pathname and taking the one that appears latest (under the
prefix order) for each unique value.
In the template matching case, we want only a single best file match, period
(there's really no notion of "config stems," it's just the prefixes). Once that
match has been found, we can then "relax" either the scheme or style (or both) to
``none``, and if the corresponding files exist, we use those as parts of the
template keys. For example, if we match ``solarized-dark.toml``, we would also
consider the values in ``none-dark.toml`` if available. The TOML values that are
defined in the most specific (i.e., better under the prefix order) match are
loaded "on top of" those less specific matches, overwriting keys when there's a
conflict. ``none-dark.toml``, for instance, might define a general dark scheme
background color, but a more specific definition in ``solarized-dark.toml`` would
take precedent. These TOML files would be stacked before using the resulting
dictionary to populate config templates.
'''
if not match_list:
return []
relaxed_map = {}
match = match_list[-1]
for fp in match_list:
style_match = fp.style == match.style or fp.style == 'none'
scheme_match = fp.scheme == match.scheme or fp.scheme == 'none'
if style_match and scheme_match:
relaxed_map[fp.pathname] = fp
return list(relaxed_map.values())

61
symconf/runner.py Normal file
View File

@@ -0,0 +1,61 @@
import stat
import subprocess
from pathlib import Path
from colorama import Fore, Back, Style
from symconf.util import printc, color_text
class Runner:
def run_script(
self,
script: str | Path,
):
script_path = Path(script)
if script_path.stat().st_mode & stat.S_IXUSR == 0:
print(
color_text("│", Fore.BLUE),
color_text(
f' > script "{script_path.name}" missing execute permissions, skipping',
Fore.RED + Style.DIM
)
)
return
print(
color_text("│", Fore.BLUE),
color_text(
f' > running script "{script_path.name}"',
Fore.BLUE
)
)
output = subprocess.check_output(str(script_path), shell=True)
if output:
fmt_output = output.decode().strip().replace(
'\n',
f'\n{Fore.BLUE}{Style.NORMAL}│{Style.DIM} '
)
print(
color_text("│", Fore.BLUE),
color_text(
f' captured script output "{fmt_output}"',
Fore.BLUE + Style.DIM
)
)
return output
def run_many(
self,
script_list: list[str | Path],
):
outputs = []
for script in script_list:
output = self.run_script(script)
outputs.append(output)
return outputs

70
symconf/template.py Normal file
View File

@@ -0,0 +1,70 @@
import re
import tomllib
from pathlib import Path
from symconf import util
from symconf.reader import DictReader
class Template:
def __init__(
self,
template_str : str,
pattern : str = r'f{{(\S+?)}}',
):
self.template_str = template_str
self.pattern = pattern
def fill(
self,
template_dict : dict,
) -> str:
dr = DictReader.from_dict(template_dict)
return re.sub(
self.pattern,
lambda m: str(dr.get(m.group(1))),
self.template_str
)
class FileTemplate(Template):
def __init__(
self,
path : Path,
pattern : str = r'f{{(\S+)}}',
):
super().__init__(
path.open('r').read(),
pattern=pattern
)
class TOMLTemplate(FileTemplate):
def __init__(
self,
toml_path : Path,
pattern : str = r'f{{(\S+)}}',
):
super().__init__(
toml_path,
pattern=pattern
)
def fill(
self,
template_dict : dict,
) -> str:
filled_template = super().fill(template_dict)
toml_dict = tomllib.loads(filled_template)
return toml_dict
@staticmethod
def stack_toml(
path_list: list[Path]
) -> dict:
stacked_dict = {}
for toml_path in path_list:
updated_map = tomllib.load(toml_path.open('rb'))
stacked_dict = util.deep_update(stacked_dict, updated_map)
return stacked_dict

50
symconf/util.py
View File

@@ -1,13 +1,61 @@
import re
import argparse
from pathlib import Path
from xdg import BaseDirectory
from xdg import BaseDirectory
from colorama import Fore, Back, Style
from colorama.ansi import AnsiFore, AnsiBack, AnsiStyle
def color_text(text, *colorama_args):
'''
Colorama text helper function
Note: we attempt to preserve expected nested behavior by only resetting the groups
(Fore, Back, Style) affected the styles passed in. This works when an outer call is
changing styles in one group, and an inner call is changing styles in another, but
_not_ when affected groups overlap.
For example, if an outer call is setting the foreground color (e.g., ``Fore.GREEN``),
nested calls on the text being passed into the function can modify and reset the
background or style with affecting the foreground. The primary use case here is
styling a group of text a single color, but applying ``BRIGHT`` or ``DIM`` styles only
to some text elements within. If we didn't reset by group, the outer coloration
request will be "canceled out" as soon as the first inner call is made (since the
unconditional behavior just employs ``Style.RESET_ALL``).
'''
# reverse map colorama Ansi codes
resets = []
for carg in colorama_args:
match = re.match(r'.*\[(\d+)m', carg)
if match:
intv = int(match.group(1))
if (intv >= 30 and intv <= 39) or (intv >= 90 and intv <= 97):
resets.append(Fore.RESET)
elif (intv >= 40 and intv <= 49) or (intv >= 100 and intv <= 107):
resets.append(Back.RESET)
elif (intv >= 0 and intv <= 2) or intv == 22:
resets.append(Style.NORMAL)
return f"{''.join(colorama_args)}{text}{''.join(resets)}"
def printc(text, *colorama_args):
print(color_text(text, *colorama_args))
def absolute_path(path: str | Path) -> Path:
return Path(path).expanduser().absolute()
def xdg_config_path():
return Path(BaseDirectory.save_config_path('symconf'))
def to_tilde_path(path: Path) -> Path:
'''
Abbreviate an absolute path by replacing HOME with "~", if applicable.
'''
try:
return Path(f"~/{path.relative_to(Path.home())}")
except ValueError:
return path
def deep_update(mapping: dict, *updating_mappings: dict) -> dict:
'''Code adapted from pydantic'''