# License (zlib/libpng): ############################################# # # # Copyright (c) 2019 Zuzu_Typ # #--------------------------------------------# # This software is provided 'as-is', # # without any express or implied warranty. # # In no event will the authors be held # # liable for any damages arising from the # # use of this software. # # # # Permission is granted to anyone to use # # this software for any purpose, including # # commercial applications, and to alter it # ## and redistribute it freely, subject to # ## the following restrictions: # ## # ## 1. The origin of this software must not # ## be misrepresented; you must not claim # ## that you wrote the original software. # ## If you use this software in a product, # ## an acknowledgment in the product # ## documentation would be appreciated but # ## is not required. # ## # ## 2. Altered source versions must be # # # plainly marked as such, and must not # # # be misrepresented as being the # # # original software. # # # # # # 3. This notice may not be removed or # ### altered from any source distribution. # ############################################## from builtins import open as builtins_open import sys, os, traceback, string __version__ = "0.2.0" __welcome__ = f"""\ SlashBack v{__version__} by Zuzu_Typ""" __doc__ = """\ A little editor for my own markup language called SlashBack ( \\SB\\ ).""" __usage__ = """\ Usage: SlashBack.py """ class TextConfig: NO_LIST = 0 ORDERED_LIST = 1 UNORDERED_LIST = 2 NO_TASK = 0 CHECKED_TASK = 1 UNCHECKED_TASK = 2 bold = False italic = False strikethrough = False underline = False quote = False table = False separator = False raw = False ignore = False code = None image = None url = None mention = None reference = None comment = None list = NO_LIST task = NO_TASK header = 0 index = 1 indent = 1 list_indices = {} # only for ordered lists def __init__(self, other_config = None): if other_config: self.bold = other_config.bold self.italic = other_config.italic self.strikethrough = other_config.strikethrough self.underline = other_config.underline self.quote = other_config.quote self.table = other_config.table self.separator = other_config.separator self.raw = other_config.raw self.ignore = other_config.ignore self.code = other_config.code self.image = other_config.image self.url = other_config.url self.mention = other_config.mention self.reference = other_config.reference self.comment = other_config.comment self.list = other_config.list self.task = other_config.task self.header = other_config.header self.index = other_config.index self.indent = other_config.indent self.list_indices = other_config.list_indices.copy() def __str__(self): out = set() if self.comment: out.add(f"/* {self.comment} */") if self.bold: out.add("bold") if self.italic: out.add("italic") if self.strikethrough: out.add("strikethrough") if self.underline: out.add("underline") if self.quote: out.add("quote") if self.table: out.add(f"table at {self.index}") if self.raw: out.add("") if self.code: out.add(f"code {self.code}") if self.image: out.add(f"image {self.image}") if self.url: out.add(f"url {self.url}") if self.mention: out.add(f"mention {self.mention}") if self.reference: out.add(f"reference {self.reference}") if self.list: out.add(("ordered list" if self.list == self.ORDERED_LIST else "unordered list") + f" at {self.index}") if self.task: out.add("checked task" if self.list == self.CHECKED_TASK else "unchecked task") if self.header: out.add(f"h{self.header}") if self.separator: out.add("---") return ", ".join(out) __repr__ = lambda self: self.__str__() class Text: def __init__(self, text, text_config): self.text = text self.text_config = text_config class ParsedText: def __init__(self, text_list): self.text_list = text_list def to_markdown(self): out = [f"[//]: # (generated using SlashBack {__version__})\n\n".encode()] current_text_config = TextConfig() table_signalized = True for text in self.text_list: text_string = text.text this_text_config = text.text_config if this_text_config.raw: out.append(text_string) continue if not this_text_config.code: for char in "\\`*_{}[]()#+-.!": text_string = text_string.replace(char.encode(), f"\\{char}".encode()) for char, replacement in ((b"&", b"&"), (b"<", b"<"), (b">", b">"), (b"~", b"~"), (b"|", b"|"), (b"@", b"@"), (b"`", b"`")): text_string = text_string.replace(char, replacement) if not this_text_config.table: text_string = text_string.replace(b"\t", b" ").replace(b" ", b" " * 2).replace(b"\r\n", b"\n").replace(b"\r", b"\n").replace(b"\n", b" \n") else: pass#text_string = text_string.replace(b"`", b"`") if not table_signalized and b"\n" in text_string: table_signalized = True text_string = text_string.replace(b"\n", b"\n" + b"|".join([b"-"] * (this_text_config.index + 1)) + b"\n") if this_text_config.list and this_text_config.index != 0 and current_text_config.index != this_text_config.index: out.append(b" " * (this_text_config.indent - 1) + ( f"{this_text_config.index}. ".encode() if this_text_config.list == TextConfig.ORDERED_LIST else b"* ")) if current_text_config.table and this_text_config.table and current_text_config.index < this_text_config.index: out.append(b"|") if not current_text_config.bold and this_text_config.bold: out.append(b"**") if not current_text_config.italic and this_text_config.italic: out.append(b"*") if not current_text_config.strikethrough and this_text_config.strikethrough: out.append(b"~~") if not current_text_config.underline and this_text_config.underline: out.append(b"") if not current_text_config.quote and this_text_config.quote: out.append(b">") if not current_text_config.table and this_text_config.table: table_signalized = False if not current_text_config.code and this_text_config.code: out.append(b"``` ") if isinstance(this_text_config.code, bytes): out.append(this_text_config.code) if not current_text_config.image and this_text_config.image: out.append(b"![") if not current_text_config.url and this_text_config.url: out.append(b"[") if not current_text_config.list and this_text_config.list: pass if not current_text_config.task and this_text_config.task: if this_text_config.task == TextConfig.CHECKED_TASK: out.append(b"- [x] ") else: out.append(b"- [ ] ") if not current_text_config.header and this_text_config.header: out.append(b"#" * this_text_config.header + b" ") if not current_text_config.separator and this_text_config.separator: out.append(b"\n---") if not current_text_config.mention and this_text_config.mention: out.append(b"@" + this_text_config.mention) if not current_text_config.reference and this_text_config.reference: out.append(this_text_config.reference) if not current_text_config.comment and this_text_config.comment: out.append(f" [//]: # ({this_text_config.comment.decode()}) ".encode()) # backward # if current_text_config.url and not this_text_config.url: out.append(f"]({current_text_config.url.decode()})".encode()) if current_text_config.image and not this_text_config.image: out.append(f"]({current_text_config.image.decode()})".encode()) if current_text_config.code and not this_text_config.code: out.append(b" ```") if current_text_config.task and not this_text_config.task: out.append(b"\n\n") if current_text_config.quote and not this_text_config.quote: out.append(b"\n\n") if current_text_config.underline and not this_text_config.underline: out.append(b"") if current_text_config.strikethrough and not this_text_config.strikethrough: out.append(b"~~") if current_text_config.italic and not this_text_config.italic: out.append(b"*") if current_text_config.bold and not this_text_config.bold: out.append(b"**") if not (not current_text_config.ignore and this_text_config.ignore): out.append(text_string) current_text_config = this_text_config if current_text_config.url: out.append(f"]({current_text_config.url.decode()})".encode()) if current_text_config.image: out.append(f"]({current_text_config.image.decode()})".encode()) if current_text_config.code: out.append(b" ```") if current_text_config.quote: out.append(b"\n\n") if current_text_config.strikethrough: out.append(b"~~") if current_text_config.italic: out.append(b"*") if current_text_config.bold: out.append(b"**") return b"".join(out) class SlashBackParserError(Exception): pass class SlashBackParser: def __init__(self, path = None, auto_read = True): self.path = path self.read() def read(self): file_ = builtins_open(self.path, "rb") content = file_.read() file_.close() self.parsed_text = self.parse(content) def write(self, path): file_ = builtins_open(path, "wb") file_.write(self.parsed_text.to_markdown()) file_.close() def parse_single(self, command, config): command = command.lstrip((string.whitespace + "!#/:|+.~>_<").encode()).rstrip() if config.separator: config.separator = False if config.reference: config.reference = None if config.mention: config.mention = None if config.comment: config.comment = None if command == b"raw": config.raw = not config.raw elif command == b"h1": config.header = 0 if config.header else 1 elif command == b"h2": config.header = 0 if config.header else 2 elif command == b"h3": config.header = 0 if config.header else 3 elif command == b"h4": config.header = 0 if config.header else 4 elif command == b"h5": config.header = 0 if config.header else 5 elif command == b"h6": config.header = 0 if config.header else 6 elif command == b"b": config.bold = not config.bold elif command == b"i": config.italic = not config.italic elif command in (b"separator", b"sep"): config.separator = True elif command == b"s": config.strikethrough = not config.strikethrough elif command == b"u": config.underline = not config.underline elif command in (b"quote", b"q"): config.quote = not config.quote elif command in (b"table", b"tbl"): if config.list: raise SlashBackParserError("A table can't be created inside a list") config.table = not config.table config.index = 0 elif command in (b"list switch", b"ls", b"sl"): if not config.list: raise SlashBackParserError("There's no list to switch here") config.list = config.ORDERED_LIST if config.list == config.UNORDERED_LIST else config.UNORDERED_LIST config.index = 0 elif command in (b"list ordered", b"lo", b"ol"): if config.table: raise SlashBackParserError("A list can't be created inside a table") config.list = config.NO_LIST if config.list else config.ORDERED_LIST config.index = 0 elif command in (b"list unordered", b"lu", b"ul"): if config.table: raise SlashBackParserError("A list can't be created inside a table") config.list = config.NO_LIST if config.list else config.UNORDERED_LIST config.index = 0 elif command in (b"list", b"lo", b"ol", b"lu", b"ul"): if not config.list: raise SlashBackParseError("Unspecified list type") config.list = config.NO_LIST config.list_indices = {} elif command in (b"task checked", b"tc", b"x"): config.task = config.NO_TASK if config.task else config.CHECKED_TASK elif command in (b"task unchecked", b"tu", b"o"): config.task = config.NO_TASK if config.task else config.UNCHECKED_TASK elif command in (b"task", b"tc", b"tu", b"x", b"o"): if not config.task: raise SlashBackParseError("Unspecified task type") config.task = config.NO_TASK elif command in (b"image", b"img"): if not config.image: raise SlashBackParseError("Unspecified image type") config.image = None elif command == b"url": #TODO if not config.url: raise SlashBackParseError("Unspecified url link") config.url = None elif command.count(b"-") == len(command): if config.list: config.indent = command.count(b"-") for indent in config.list_indices.copy(): if indent > config.indent: del config.list_indices[indent] if config.list == config.ORDERED_LIST: config.index = config.list_indices.get(config.indent, 1) config.list_indices[config.indent] = config.index + 1 else: config.index += 1 elif config.table: config.index += 1 if not config.list and not config.table: raise SlashBackParserError(f"Unexpected \\{command.decode()}\\ token") else: space_index = command.find(b" ") first_command = command[:space_index] if space_index != -1 else command info = command[space_index:].strip() if space_index != -1 else "" if first_command == b"image": config.image = None if config.image else info elif first_command == b"url": config.url = None if config.url else info elif first_command == b"code": config.code = None if config.code else info if info else True elif first_command == b"mention": config.mention = info elif first_command == b"reference": config.reference = info elif first_command in (b"c", b"comment", b"ignore"): config.ignore = not config.ignore elif first_command in (b"ic", b"icomment"): config.comment = info else: raise SlashBackParserError(f"Unknown command \"{first_command.decode()}\"") return config def parse(self, text): if (text.count(b"\\") % 2): raise SlashBackParserError("The amount of backslashes isn't even") index = 0 found = text.find(b"\\", index) second_found = text.find(b"\\", found + 1) out = [] current_text = None current_config = TextConfig() while found != -1: current_command = text[found + 1 : second_found] if not current_command: out.append(Text(text[index : found + 1], TextConfig(current_config))) else: out.append(Text(text[index : found], TextConfig(current_config))) current_config = self.parse_single(current_command, current_config) index = second_found + 1 found = text.find(b"\\", index) second_found = text.find(b"\\", found + 1) if (second_found == -1): raise SlashBackParserError("Error while parsing. Inconsistent amount of backslashes") out.append(Text(text[index :], TextConfig(current_config))) return ParsedText(out) open = lambda path: SlashBackParser(path) if __name__ == "__main__": print(__welcome__) has_processed_files = False if len(sys.argv) != 1: print("") for filename in sys.argv[1:]: if filename[0] == "-": print(f"Invalid option: '{filename}' (ignoring)", file=sys.stderr) elif not os.path.exists(filename): print(f"File not found: '{filename}' (ignoring)", file=sys.stderr) else: has_processed_files = True out_filename = os.path.splitext(filename)[0] + ".md" processing_string = f"Processing file {filename} and saving to {out_filename}..." print(processing_string, end = "") try: sbf = open(filename) sbf.write(out_filename) print(f"\r{processing_string} Done.") except SlashBackParserError as exception: print(f"\nERROR: {exception!s}", file=sys.stderr) except Exception as exception: print("\nUNHANDLED EXCEPTION OCCURED!", file=sys.stderr) traceback.print_exc() if not has_processed_files: print("\n" + __usage__, file=sys.stderr)