def initial(nvim: Nvim, specs: Sequence[RpcSpec]) -> Settings:
artifacts: Artifact = decode(Artifact, safe_load(ARTIFACT.read_bytes()))
user_config = nvim.vars.get(SETTINGS_VAR, {})
config: _UserConfig = decode(
_UserConfig,
merge(safe_load(CONFIG_YML.read_bytes()),
hydrate(user_config),
replace=True),
)
options, view, theme = config.options, config.view, config.theme
icons, hl_context = load_theme(
nvim,
artifact=artifacts,
particular_mappings=theme.highlights,
discrete_colours=theme.discrete_colour_map,
icon_set=theme.icon_glyph_set,
icon_colour_set=theme.icon_colour_set,
text_colour_set=theme.text_colour_set,
)
view_opts = ViewOptions(
hl_context=hl_context,
icons=icons,
sort_by=view.sort_by,
use_icons=theme.icon_glyph_set is not IconGlyphSetEnum.ascii,
time_fmt=view.time_format,
)
keymap = {f"CHAD{k}": v for k, v in config.keymap.items()}
legal_keys = {name for name, _ in specs}
extra_keys = keymap.keys() - legal_keys
if extra_keys:
raise DecodeError(
path=(_UserOptions, _key_sort(legal_keys)),
actual=None,
missing_keys=(),
extra_keys=_key_sort(extra_keys),
)
settings = Settings(
follow=options.follow,
ignores=config.ignore,
keymap=keymap,
lang=options.lang,
mime=options.mimetypes,
open_left=view.open_direction is _OpenDirection.left,
page_increment=options.page_increment,
polling_rate=float(options.polling_rate),
session=options.session,
show_hidden=options.show_hidden,
version_ctl=options.version_control,
view=view_opts,
width=view.width,
win_local_opts=view.window_options,
)
return settings
def maybe_install(nvim: Nvim) -> None:
UPDATE_LOG.parent.mkdir(parents=True, exist_ok=True)
try:
coded = UPDATE_LOG.read_text()
before: datetime = decode(datetime,
coded,
decoders=(datetime_str_decoder, ))
except (FileNotFoundError, DecodeError):
before = datetime(year=1949, month=9, day=21, tzinfo=timezone.utc)
now = datetime.now(tz=timezone.utc)
diff = now - before
if diff.days > 7:
ans = ask_mc(
nvim,
question=LANG("update?"),
answers=LANG("ask yes/no"),
answer_key={
1: 1,
2: 2
},
)
if ans:
coded = encode(now, encoders=(datetime_str_encoder, ))
UPDATE_LOG.write_text(coded)
if ans == 1:
open_term(nvim, executable, INSTALL_SCRIPT, "deps", "packages")
def load_text_decors() -> Tuple[IconGlyphSet, TextColourSet]:
yaml = safe_load(_ICON_BASE.read_bytes())
json = loads(docker_run(_DOCKERFILE))
data = merge(json, yaml)
icon_spec: IconGlyphSet = decode(IconGlyphSet, data, strict=False)
icon_set = IconGlyphSet(
ascii=_process_icons(icon_spec.ascii),
devicons=_process_icons(icon_spec.devicons),
emoji=_process_icons(icon_spec.emoji),
)
colour_spec: TextColourSet = decode(TextColourSet, data, strict=False)
colour_set = TextColourSet(
nerdtree_syntax_light=_make_lightmode(_process_colours(colour_spec.nerdtree_syntax_light)),
nerdtree_syntax_dark=_process_colours(colour_spec.nerdtree_syntax_dark),
)
return icon_set, colour_set
def _find_root(nvim: Nvim, _pattern: Any, filename: str,
bufnr: int) -> Optional[str]:
pattern: RootPattern = decode(RootPattern, _pattern)
path = Path(filename)
for parent in path.parents:
for member in parent.iterdir():
name = member.name
if name in pattern.exact:
return str(parent)
else:
for glob in pattern.glob:
if fnmatch(name, glob):
return str(parent)
else:
if pattern.fallback is RPFallback.none:
return None
elif pattern.fallback is RPFallback.cwd:
return get_cwd(nvim)
elif pattern.fallback is RPFallback.home:
return str(Path.home())
elif pattern.fallback is RPFallback.parent:
return str(path.parent)
else:
never(pattern)
def _update(nvim: Nvim, buf: Buffer, ns: int, derived: Derived) -> Atomic:
n_hash = derived.hashed
try:
p_hash: Sequence[str] = decode(
Sequence[str], buf_get_var(nvim, buf=buf, key=_FM_HASH_VAR))
except DecodeError:
p_hash = ("", )
atomic = Atomic()
for (i1, i2), (j1, j2) in trans_inplace(src=p_hash,
dest=n_hash,
unifying=10):
atomic.buf_clear_namespace(buf, ns, i1, i2)
atomic.buf_set_lines(buf, i1, i2, True, derived.lines[j1:j2])
for idx, highlights in enumerate(derived.highlights[j1:j2], start=i1):
for hl in highlights:
atomic.buf_add_highlight(buf, ns, hl.group, idx, hl.begin,
hl.end)
for idx, badges in enumerate(derived.badges[j1:j2], start=i1):
vtxt = tuple((bdg.text, bdg.group) for bdg in badges)
atomic.buf_set_virtual_text(buf, ns, idx, vtxt, {})
atomic.buf_set_var(buf, _FM_HASH_VAR, n_hash)
return atomic
def load_icon_colours() -> IconColourSet:
raw = _fetch(_LINGUIST)
yaml: _GithubSpec = decode(_GithubSpec, safe_load(raw), strict=False)
github: IconColours = {
ext: spec.color
for spec in yaml.values() for ext in spec.extensions if spec.color
}
colours = IconColourSet(github=github)
return colours
def send_req(server: str, req: Req) -> Resp:
srv = urlparse(server)
url = urlunparse((srv.scheme, srv.netloc, "/v2/check", None, None, None))
data = _encode_eq(req)
try:
with urlopen(Request(url=url, data=data)) as resp:
reply = resp.read().decode()
json = loads(reply)
linted: Resp = decode(Resp, json, strict=False)
except (URLError, HTTPError, JSONDecodeError, DecodeError):
raise
else:
return linted
def load_session(cwd: str) -> Session:
load_path = _session_path(cwd)
try:
return decode(Session, _load_json(load_path))
except Exception:
return Session(index=None, show_hidden=None, enable_vc=None)
from dataclasses import dataclass
from enum import Enum, auto
from typing import AbstractSet, Sequence
from std2.pickle import decode
from yaml import safe_load
from ..consts import CONF_FMT
from .install import InstallSpec
class FmtType(Enum):
stream = auto()
fs = auto()
lsp = auto()
@dataclass(frozen=True)
class FmtAttrs:
bin: str
type: FmtType
filetypes: AbstractSet[str]
args: Sequence[str] = ()
exit_code: int = 0
install: InstallSpec = InstallSpec()
FmtSpecs = Sequence[FmtAttrs]
fmt_specs: FmtSpecs = decode(FmtSpecs, safe_load(CONF_FMT.open()))
from typing import Sequence from std2.pickle import decode from yaml import safe_load from ..consts import CONF_TOOL from .install import InstallSpec ToolSpecs = Sequence[InstallSpec] tool_specs: ToolSpecs = decode(ToolSpecs, safe_load(CONF_TOOL.open()))
from dataclasses import dataclass
from enum import Enum, auto
from typing import AbstractSet, Sequence
from std2.pickle import decode
from yaml import safe_load
from ..consts import CONF_LINT
from .install import InstallSpec
class LinterType(Enum):
stream = auto()
fs = auto()
@dataclass(frozen=True)
class LinterAttrs:
bin: str
type: LinterType
filetypes: AbstractSet[str]
args: Sequence[str] = ()
exit_code: int = 0
install: InstallSpec = InstallSpec()
LinterSpecs = Sequence[LinterAttrs]
linter_specs: LinterSpecs = decode(LinterSpecs, safe_load(CONF_LINT.open()))
def load_ls_colours() -> LSColourSet:
json = loads(docker_run(_DOCKERFILE))
lsc: LSColourSet = decode(LSColourSet, json)
return lsc
from ..consts import CONF_PKGS
from .install import ScriptSpec
@dataclass(frozen=True)
class GitPkgSpec:
uri: str
branch: Optional[str] = None
script: ScriptSpec = ScriptSpec()
@dataclass(frozen=True)
class KeymapSpec:
modes: str
maps: Mapping[str, str]
opts: KeymapOpts = KeymapOpts()
@dataclass(frozen=True)
class PkgAttrs:
git: GitPkgSpec
keys: Sequence[KeymapSpec] = ()
vals: Mapping[str, Any] = field(default_factory=dict)
lua: str = ""
viml: str = ""
PkgSpecs = Sequence[PkgAttrs]
pkg_specs: PkgSpecs = decode(PkgSpecs, safe_load(CONF_PKGS.open()))
class RPFallback(Enum):
none = auto()
cwd = auto()
home = auto()
parent = auto()
@dataclass(frozen=True)
class RootPattern:
fallback: RPFallback = RPFallback.cwd
exact: AbstractSet[str] = frozenset()
glob: Sequence[str] = ()
@dataclass(frozen=True)
class LspAttrs:
server: str
bin: str
args: Optional[Sequence[str]] = None
filetypes: AbstractSet[str] = frozenset()
root: Optional[RootPattern] = None
init_options: Mapping[str, Any] = field(default_factory=dict)
settings: Mapping[str, Any] = field(default_factory=dict)
install: InstallSpec = InstallSpec()
LspSpecs = Sequence[LspAttrs]
lsp_specs: LspSpecs = decode(LspSpecs, safe_load(CONF_LSP.open()))
