From 2fe9f14d5689fdba7ace0f0178f2a784c83b28b5 Mon Sep 17 00:00:00 2001 From: Micah Jerome Ellison Date: Sat, 25 Mar 2023 14:30:02 -0700 Subject: [PATCH] Mediate template arg vs. config in controller then read template text in editor and unify those two use cases. Some tests still failing --- jrnl/controller.py | 35 ++++++++++------ jrnl/editor.py | 88 +++++++++++++--------------------------- jrnl/messages/MsgText.py | 14 +++---- 3 files changed, 57 insertions(+), 80 deletions(-) diff --git a/jrnl/controller.py b/jrnl/controller.py index d1094538..997b5d32 100644 --- a/jrnl/controller.py +++ b/jrnl/controller.py @@ -141,26 +141,22 @@ def append_mode(args: "Namespace", config: dict, journal: "Journal", **kwargs) - """ logging.debug("Append mode: starting") - if args.template or config["template"]: - logging.debug(f"Append mode: template CLI arg detected: {args.template}") - # Read template file and pass as raw text into the composer - template_data = read_template_file(args.template, config["template"]) - raw = _write_in_editor(config, template_data) - if raw == template_data: - logging.error("Append mode: raw text was the same as the template") - raise JrnlException(Message(MsgText.NoChangesToTemplate, MsgStyle.NORMAL)) - elif args.text: + template_text = _get_template(args, config) + + if args.text: logging.debug(f"Append mode: cli text detected: {args.text}") raw = " ".join(args.text).strip() if args.edit: raw = _write_in_editor(config, raw) - elif not sys.stdin.isatty(): logging.debug("Append mode: receiving piped text") raw = sys.stdin.read() - else: - raw = _write_in_editor(config) + raw = _write_in_editor(config, template_text) + + if template_text is not None and raw == template_text: + logging.error("Append mode: raw text was the same as the template") + raise JrnlException(Message(MsgText.NoChangesToTemplate, MsgStyle.NORMAL)) if not raw or raw.isspace(): logging.error("Append mode: couldn't get raw text or entry was empty") @@ -182,6 +178,21 @@ def append_mode(args: "Namespace", config: dict, journal: "Journal", **kwargs) - logging.debug("Append mode: completed journal.write()") +def _get_template(args, config) -> str: + # Read template file and pass as raw text into the composer + logging.debug( + f"Get template:\n--template: {args.template}\nfrom config: {config.get('template')}" + ) + template_path = args.template or config.get("template") + + template_text = None + + if (template_path): + template_text = read_template_file(template_path) + + return template_text + + def search_mode(args: "Namespace", journal: "Journal", **kwargs) -> None: """ Search for entries in a journal, and return the diff --git a/jrnl/editor.py b/jrnl/editor.py index 2277a940..47634c89 100644 --- a/jrnl/editor.py +++ b/jrnl/editor.py @@ -77,69 +77,39 @@ def get_text_from_stdin() -> str: return raw -def read_template_file(template_arg: str, template_path_from_config: str) -> str: +def read_template_file(template_path: str) -> str: """ - This function is called when either a template file is passed with --template, or config.template is set. + Reads the template file given a template path in this order: - The processing logic is: - If --template was not used: Load the global template file. - If --template was used: - * Check $XDG_DATA_HOME/jrnl/templates/template_arg. - * Check template_arg as an absolute / relative path. + * Check $XDG_DATA_HOME/jrnl/templates/template_path. + * Check template_arg as an absolute / relative path. - If a file is found, its contents are returned as a string. - If not, a JrnlException is raised. + If a file is found, its contents are returned as a string. + If not, a JrnlException is raised. """ - logging.debug( - "Append mode: Either a template arg was passed, or the global config is set." - ) - # If filename is unset, we are in this flow due to a global template being configured - if not template_arg: - logging.debug("Append mode: Global template configuration detected.") - global_template_path = absolute_path(template_path_from_config) - try: - with open(global_template_path, encoding="utf-8") as f: - template_data = f.read() - return template_data - except FileNotFoundError: - raise JrnlException( - Message( - MsgText.CantReadTemplateGlobalConfig, - MsgStyle.ERROR, - { - "global_template_path": global_template_path, - }, - ) - ) - else: # A template CLI arg was passed. - logging.debug("Trying to load template from $XDG_DATA_HOME/jrnl/templates/") - jrnl_template_dir = get_templates_path() - logging.debug(f"Append mode: jrnl templates directory: {jrnl_template_dir}") - template_path = jrnl_template_dir / template_arg - try: - with open(template_path, encoding="utf-8") as f: - template_data = f.read() - return template_data - except FileNotFoundError: - logging.debug( - f"Couldn't open {template_path}. Treating --template argument like a local / abs path." - ) - pass + jrnl_template_dir = get_templates_path() - normalized_template_arg_filepath = absolute_path(template_arg) - try: - with open(normalized_template_arg_filepath, encoding="utf-8") as f: - template_data = f.read() - return template_data - except FileNotFoundError: - raise JrnlException( - Message( - MsgText.CantReadTemplateCLIArg, - MsgStyle.ERROR, - { - "normalized_template_arg_filepath": normalized_template_arg_filepath, - "jrnl_template_dir": template_path, - }, - ) + actual_template_path = jrnl_template_dir / template_path + if not (actual_template_path).exists(): + logging.debug( + f"Couldn't open {actual_template_path}. Treating template path like a local / abs path." + ) + actual_template_path = absolute_path(template_path) + + try: + with open(actual_template_path, encoding="utf-8") as f: + template_data = f.read() + return template_data + except FileNotFoundError: + raise JrnlException( + Message( + MsgText.CantReadTemplate, + MsgStyle.ERROR, + { + "template_path": template_path, + "actual_template_path": actual_template_path, + "jrnl_template_dir": str(jrnl_template_dir) + os.sep, + }, ) + ) diff --git a/jrnl/messages/MsgText.py b/jrnl/messages/MsgText.py index 1310231b..c8ac5b04 100644 --- a/jrnl/messages/MsgText.py +++ b/jrnl/messages/MsgText.py @@ -105,16 +105,12 @@ class MsgText(Enum): KeyboardInterruptMsg = "Aborted by user" - CantReadTemplateGlobalConfig = """ - Could not read template file defined in config: - {global_template_path} - """ + CantReadTemplate = """ + Unable to find a template file {template_path}. - CantReadTemplateCLIArg = """ - Unable to find a template file based on the passed arg, and no global template was detected. - The following filepaths were checked: - jrnl XDG Template Directory : {jrnl_template_dir} - Local Filepath : {normalized_template_arg_filepath} + The following paths were checked: + * {jrnl_template_dir}{template_path} + * {actual_template_path} """ NoNamedJournal = "No '{journal_name}' journal configured\n{journals}"