Added library

Author: markqvist

sbapp/md2bbcode/__init__.py

@@ -0,0 +1,132 @@
+# converts some HTML tags to BBCode
+# pass --debug to save the output to readme.finalpass
+# may be better off replacing this with html to markdown (and then to bbcode). Lepture recommeds a JS html to markdown converter: sundown
+from bs4 import BeautifulSoup, NavigableString
+import argparse
+
+def handle_font_tag(tag, replacements):
+    """Handles the conversion of <font> tag with attributes like color and size."""
+    attributes = []
+    if 'color' in tag.attrs:
+        attributes.append(f"COLOR={tag['color']}")
+    if 'size' in tag.attrs:
+        attributes.append(f"SIZE={tag['size']}")
+    if 'face' in tag.attrs:
+        attributes.append(f"FONT={tag['face']}")
+
+    inner_content = ''.join(recursive_html_to_bbcode(child, replacements) for child in tag.children)
+    if attributes:
+        # Nest all attributes. Example: [COLOR=red][SIZE=5]content[/SIZE][/COLOR]
+        for attr in reversed(attributes):
+            inner_content = f"[{attr}]{inner_content}[/{attr.split('=')[0]}]"
+    return inner_content
+
+def handle_style_tag(tag, replacements):
+    """Handles the conversion of tags with style attributes like color, size, and font."""
+    attributes = []
+    style = tag.attrs.get('style', '')
+
+    # Extracting CSS properties
+    css_properties = {item.split(':')[0].strip(): item.split(':')[1].strip() for item in style.split(';') if ':' in item}
+
+    # Mapping CSS properties to BBCode
+    if 'color' in css_properties:
+        attributes.append(f"COLOR={css_properties['color']}")
+    if 'font-size' in css_properties:
+        attributes.append(f"SIZE={css_properties['font-size']}")
+    if 'font-family' in css_properties:
+        attributes.append(f"FONT={css_properties['font-family']}")
+    if 'text-decoration' in css_properties and 'line-through' in css_properties['text-decoration']:
+        attributes.append("S")  # Assume strike-through
+    if 'text-decoration' in css_properties and 'underline' in css_properties['text-decoration']:
+        attributes.append("U")
+    if 'font-weight' in css_properties:
+        if css_properties['font-weight'].lower() == 'bold' or (css_properties['font-weight'].isdigit() and int(css_properties['font-weight']) >= 700):
+            attributes.append("B")  # Assume bold
+
+    inner_content = ''.join(recursive_html_to_bbcode(child, replacements) for child in tag.children)
+    if attributes:
+        # Nest all attributes
+        for attr in reversed(attributes):
+            if '=' in attr:  # For attributes with values
+                inner_content = f"[{attr}]{inner_content}[/{attr.split('=')[0]}]"
+            else:  # For simple BBCode tags like [B], [I], [U], [S]
+                inner_content = f"[{attr}]{inner_content}[/{attr}]"
+    return inner_content
+
+def recursive_html_to_bbcode(element):
+    """Recursively convert HTML elements to BBCode."""
+    bbcode = ''
+
+    if isinstance(element, NavigableString):
+        bbcode += str(element)
+    elif element.name == 'details':
+        # Handle <details> tag
+        summary = element.find('summary')
+        spoiler_title = ''
+        if summary:
+            # Get the summary content and remove the summary element
+            spoiler_title = '=' + ''.join([recursive_html_to_bbcode(child) for child in summary.contents])
+            summary.decompose()
+        
+        # Process remaining content
+        content = ''.join([recursive_html_to_bbcode(child) for child in element.contents])
+        bbcode += f'[SPOILER{spoiler_title}]{content}[/SPOILER]'
+    elif element.name == 'summary':
+        # Skip summary tag as it's handled in details
+        return ''
+    else:
+        # Handle other tags or pass through
+        content = ''.join([recursive_html_to_bbcode(child) for child in element.contents])
+        bbcode += content
+
+    return bbcode
+
+def html_to_bbcode(html):
+    replacements = {
+        'b': 'B',
+        'strong': 'B',
+        'i': 'I',
+        'em': 'I',
+        'u': 'U',
+        's': 'S',
+        'sub': 'SUB',
+        'sup': 'SUP',
+        'p': '',  # Handled by default
+        'ul': 'LIST',
+        'ol': 'LIST=1',
+        'li': '*',  # Special handling in recursive function
+        'font': '',  # To be handled for attributes
+        'blockquote': 'QUOTE',
+        'pre': 'CODE',
+        'code': 'ICODE',
+        'a': 'URL',  # Special handling for attributes
+        'img': 'IMG'  # Special handling for attributes
+    }
+
+    soup = BeautifulSoup(html, 'html.parser')
+    return recursive_html_to_bbcode(soup)
+
+def process_html(input_html, debug=False, output_file=None):
+    converted_bbcode = html_to_bbcode(input_html)
+
+    if debug:
+        with open(output_file, 'w', encoding='utf-8') as file:
+            file.write(converted_bbcode)
+    else:
+        return converted_bbcode
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Convert HTML to BBCode with optional debugging output.")
+    parser.add_argument('input_file', type=str, help='Input HTML file path')
+    parser.add_argument('--debug', action='store_true', help='Save output to readme.finalpass for debugging')
+    
+    args = parser.parse_args()
+    input_file = args.input_file
+    output_file = 'readme.finalpass' if args.debug else None
+
+    with open(input_file, 'r', encoding='utf-8') as file:
+        html_content = file.read()
+
+    # Call the processing function
+    process_html(html_content, debug=args.debug, output_file=output_file)

sbapp/md2bbcode/html2bbcode.py

@@ -0,0 +1,67 @@
+# uses a custom mistune renderer to convert Markdown to BBCode. The custom renderer is defined in the bbcode.py file.
+# pass --debug to save the output to readme.1stpass (main.py) and readme.finalpass (html2bbcode)
+# for further debugging, you can convert the markdown file to AST using md2ast.py. Remember to load the plugin(s) you want to test.
+
+#standard library
+import argparse
+import sys
+
+# mistune
+import mistune
+from mistune.plugins.formatting import strikethrough, mark, superscript, subscript, insert
+from mistune.plugins.table import table, table_in_list
+from mistune.plugins.footnotes import footnotes
+from mistune.plugins.task_lists import task_lists
+from mistune.plugins.def_list import def_list
+from mistune.plugins.abbr import abbr
+from mistune.plugins.spoiler import spoiler
+
+# local
+from md2bbcode.plugins.merge_lists import merge_ordered_lists
+from md2bbcode.renderers.bbcode import BBCodeRenderer
+from md2bbcode.html2bbcode import process_html
+
+def convert_markdown_to_bbcode(markdown_text, domain):
+    # Create a Markdown parser instance using the custom BBCode renderer
+    markdown_parser = mistune.create_markdown(renderer=BBCodeRenderer(domain=domain), plugins=[strikethrough, mark, superscript, subscript, insert, table, footnotes, task_lists, def_list, abbr, spoiler, table_in_list, merge_ordered_lists])
+
+    # Convert Markdown text to BBCode
+    return markdown_parser(markdown_text)
+
+def process_readme(markdown_text, domain=None, debug=False):
+    # Convert Markdown to BBCode
+    bbcode_text = convert_markdown_to_bbcode(markdown_text, domain)
+
+    # If debug mode, save intermediate BBCode
+    if debug:
+        with open('readme.1stpass', 'w', encoding='utf-8') as file:
+            file.write(bbcode_text)
+
+    # Convert BBCode formatted as HTML to final BBCode
+    final_bbcode = process_html(bbcode_text, debug, 'readme.finalpass')
+
+    return final_bbcode
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert Markdown file to BBCode with HTML processing.')
+    parser.add_argument('input', help='Input Markdown file path')
+    parser.add_argument('--domain', help='Domain to prepend to relative URLs')
+    parser.add_argument('--debug', action='store_true', help='Output intermediate results to files for debugging')
+    args = parser.parse_args()
+
+    if args.input == '-':
+        # Read Markdown content from stdin
+        markdown_text = sys.stdin.read()
+    else:
+        with open(args.input, 'r', encoding='utf-8') as md_file:
+            markdown_text = md_file.read()
+
+    # Process the readme and get the final BBCode
+    final_bbcode = process_readme(markdown_text, args.domain, args.debug)
+
+    # Optionally, print final BBCode to console
+    if not args.debug:
+        print(final_bbcode)
+
+if __name__ == '__main__':
+    main()

sbapp/md2bbcode/main.py

@@ -0,0 +1,47 @@
+# this is for debugging the custom mistune renderer bbcode.py
+import argparse
+import mistune
+import json  # Import the json module for serialization
+from mistune.plugins.formatting import strikethrough, mark, superscript, subscript, insert
+from mistune.plugins.table import table, table_in_list
+from mistune.plugins.footnotes import footnotes
+from mistune.plugins.task_lists import task_lists
+from mistune.plugins.def_list import def_list
+from mistune.plugins.abbr import abbr
+from mistune.plugins.spoiler import spoiler
+
+#local
+from md2bbcode.plugins.merge_lists import merge_ordered_lists
+
+def convert_markdown_to_ast(input_filepath, output_filepath):
+    # Initialize Markdown parser with no renderer to produce an AST
+    markdown_parser = mistune.create_markdown(renderer=None, plugins=[strikethrough, mark, superscript, subscript, insert, table, footnotes, task_lists, def_list, abbr, spoiler, table_in_list, merge_ordered_lists])
+    
+    # Read the input Markdown file
+    with open(input_filepath, 'r', encoding='utf-8') as md_file:
+        markdown_text = md_file.read()
+    
+    # Convert Markdown text to AST
+    ast_text = markdown_parser(markdown_text)
+    
+    # Serialize the AST to a JSON string
+    ast_json = json.dumps(ast_text, indent=4)
+    
+    # Write the output AST to a new file in JSON format
+    with open(output_filepath, 'w', encoding='utf-8') as ast_file:
+        ast_file.write(ast_json)
+
+def main():
+    # Create argument parser
+    parser = argparse.ArgumentParser(description='Convert Markdown file to AST file (JSON format).')
+    # Add arguments
+    parser.add_argument('input', help='Input Markdown file path')
+    parser.add_argument('output', help='Output AST file path (JSON format)')
+    # Parse arguments
+    args = parser.parse_args()
+    
+    # Convert the Markdown to AST using the provided paths
+    convert_markdown_to_ast(args.input, args.output)
+
+if __name__ == '__main__':
+    main()

sbapp/md2bbcode/md2ast.py

@@ -0,0 +1,83 @@
+from typing import Dict, Any, List
+
+def merge_ordered_lists(md):
+    """
+    A plugin to merge consecutive "top-level" ordered lists into one,
+    and also attach any intervening code blocks or blank lines to the
+    last list item so that the final BBCode appears as a single list
+    with multiple steps.
+
+    This relies on a few assumptions:
+      1) The only tokens between two ordered lists that should be merged
+         are code blocks or blank lines (not normal paragraphs).
+      2) We want any code block(s) right after a list item to appear in
+         that same bullet item.
+    """
+
+    def rewrite_tokens(md, state):
+        tokens = state.tokens
+        merged = []
+        i = 0
+
+        while i < len(tokens):
+            token = tokens[i]
+
+            # Check if this token is a top-level ordered list
+            if (
+                token["type"] == "list"
+                and token.get("attrs", {}).get("ordered", False)
+                and token.get("attrs", {}).get("depth", 0) == 0
+            ):
+                # Start new merged list
+                current_depth = token["attrs"]["depth"]
+                list_items = list(token["children"])  # bullet items in the first list
+                i += 1
+
+                # Continue until we run into something that's not:
+                #   another top-level ordered list,
+                #   or code blocks / blank lines (which we'll attach to the last bullet).
+                while i < len(tokens):
+                    nxt = tokens[i]
+
+                    # If there's another ordered list at the same depth, merge its bullet items
+                    if (
+                        nxt["type"] == "list"
+                        and nxt.get("attrs", {}).get("ordered", False)
+                        and nxt.get("attrs", {}).get("depth", 0) == current_depth
+                    ):
+                        list_items.extend(nxt["children"])
+                        i += 1
+
+                    # If there's a code block or blank line, attach it to the *last* bullet item.
+                    elif nxt["type"] in ["block_code", "blank_line"]:
+                        if list_items:  # attach to last bullet item, if any
+                            list_items[-1]["children"].append(nxt)
+                        i += 1
+
+                    else:
+                        # Not a same-depth list or code block—stop merging
+                        break
+
+                # Create single merged list token
+                merged.append(
+                    {
+                        "type": "list",
+                        "children": list_items,
+                        "attrs": {
+                            "ordered": True,
+                            "depth": current_depth,
+                        },
+                    }
+                )
+
+            else:
+                # If not a top-level ordered list, just keep it as-is
+                merged.append(token)
+                i += 1
+
+        # Replace the old tokens with the merged version
+        state.tokens = merged
+
+    # Attach to before_render_hooks so we can manipulate tokens before rendering
+    md.before_render_hooks.append(rewrite_tokens)
+    return md