id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
17,600
|
thematicbreak.py
|
rafalp_Misago/misago/parser/postprocessors/thematicbreak.py
|
from .removerepeats import RemoveRepeatsPostProcessor
class RemoveThematicBreaksRepeatsPostProcessor(RemoveRepeatsPostProcessor):
checked_types = ["thematic-break-bbcode", "thematic-break"]
| 196
|
Python
|
.py
| 3
| 62.333333
| 75
| 0.858639
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,601
|
quote.py
|
rafalp_Misago/misago/parser/postprocessors/quote.py
|
from ..parser import Parser
from .block import BlockPostProcessor
class QuoteBBCodePostProcessor(BlockPostProcessor):
opening_type = "quote-bbcode-open"
closing_type = "quote-bbcode-close"
def wrap_block(
self,
parser: Parser,
opening_block: dict,
closing_block: dict,
children: list[dict],
) -> dict | None:
if not children:
return None
return {
"type": "quote-bbcode",
"author": opening_block["author"],
"post": opening_block["post"],
"children": self(parser, children),
}
| 619
|
Python
|
.py
| 20
| 22.75
| 51
| 0.593277
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,602
|
block.py
|
rafalp_Misago/misago/parser/postprocessors/block.py
|
from ..parser import Parser
class BlockPostProcessor:
opening_type: str
closing_type: str
def __call__(self, parser: Parser, ast: list[dict]) -> list[dict]:
new_ast: list[dict] = []
stack: list[tuple[dict, list[dict]]] = []
for block_ast in ast:
if block_ast["type"] == self.opening_type:
stack.append((block_ast, []))
elif stack:
if block_ast["type"] == self.closing_type:
opening_block, children = stack.pop(-1)
wrapped_block = self.wrap_block(
parser, opening_block, block_ast, children
)
if wrapped_block:
if stack:
stack[-1][1].append(wrapped_block)
else:
new_ast.append(wrapped_block)
else:
stack[-1][1].append(self.process_other_block(parser, block_ast))
else:
new_ast.append(self.process_other_block(parser, block_ast))
for opening_block, children in stack:
new_ast.append(opening_block)
new_ast += self(parser, children)
return new_ast
def wrap_block(
self,
parser: Parser,
opening_block: dict,
closing_block: dict,
children: list[dict],
) -> dict | None:
if not children:
return None
new_children: list[dict]
for block_ast in children:
new_children.append(self.process_other_block(parser, block_ast))
return new_children
def process_other_block(self, parser: Parser, block_ast: dict) -> dict:
if block_ast["type"] != "paragraph" and block_ast.get("children"):
block_ast["children"] = self(parser, block_ast["children"])
return block_ast
| 1,896
|
Python
|
.py
| 46
| 28.282609
| 84
| 0.532863
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,603
|
removerepeats.py
|
rafalp_Misago/misago/parser/postprocessors/removerepeats.py
|
from ..parser import Parser
class RemoveRepeatsPostProcessor:
checked_types: list[str]
def __call__(self, parser: Parser, ast: list[dict]) -> list[dict]:
new_ast: list[dict] = []
for node in ast:
if (
node["type"] in self.checked_types
and new_ast
and new_ast[-1]["type"] in self.checked_types
):
continue
if "children" in node:
node["children"] = self(parser, node["children"])
new_ast.append(node)
return new_ast
| 581
|
Python
|
.py
| 16
| 24.9375
| 70
| 0.527728
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,604
|
__init__.py
|
rafalp_Misago/misago/parser/postprocessors/__init__.py
|
from .block import BlockPostProcessor
from .quote import QuoteBBCodePostProcessor
from .removerepeats import RemoveRepeatsPostProcessor
from .spoiler import SpoilerBBCodePostProcessor
from .thematicbreak import RemoveThematicBreaksRepeatsPostProcessor
__all__ = [
"BlockPostProcessor",
"QuoteBBCodePostProcessor",
"RemoveRepeatsPostProcessor",
"SpoilerBBCodePostProcessor",
"post_processors",
]
post_processors = [
QuoteBBCodePostProcessor(),
SpoilerBBCodePostProcessor(),
RemoveThematicBreaksRepeatsPostProcessor(),
]
| 553
|
Python
|
.py
| 17
| 29.529412
| 67
| 0.827715
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,605
|
spoiler.py
|
rafalp_Misago/misago/parser/postprocessors/spoiler.py
|
from ..parser import Parser
from .block import BlockPostProcessor
class SpoilerBBCodePostProcessor(BlockPostProcessor):
opening_type = "spoiler-bbcode-open"
closing_type = "spoiler-bbcode-close"
def wrap_block(
self,
parser: Parser,
opening_block: dict,
closing_block: dict,
children: list[dict],
) -> dict | None:
if not children:
return None
return {
"type": "spoiler-bbcode",
"summary": opening_block["summary"],
"children": self(parser, children),
}
| 586
|
Python
|
.py
| 19
| 22.894737
| 53
| 0.609236
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,606
|
thematicbreak.py
|
rafalp_Misago/misago/parser/patterns/thematicbreak.py
|
from ..parser import Parser, Pattern
class ThematicBreakMarkdown(Pattern):
pattern_type: str = "thematic-break"
pattern: str = (
r"(\n|^) {0,3}((-\s*-\s*-(\s*-)*)|(_\s*_\s*_(\s*_)*)|(\*\s*\*\s*\*(\s*\*)*))\s*(\n|$)"
)
def parse(
self, parser: Parser, match: str, parents: list[str]
) -> dict | list[dict]:
return {"type": self.pattern_type}
class ThematicBreakBBCode(Pattern):
pattern_type: str = "thematic-break-bbcode"
pattern: str = r"\[hr\/?\]"
def parse(
self, parser: Parser, match: str, parents: list[str]
) -> dict | list[dict]:
return {"type": self.pattern_type}
| 654
|
Python
|
.py
| 17
| 32.647059
| 94
| 0.565769
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,607
|
escape.py
|
rafalp_Misago/misago/parser/patterns/escape.py
|
import re
from ..parser import Parser, Pattern
ESCAPE = r"\\(_|[^\w\s])"
class Escape(Pattern):
pattern_type: str = "escape"
pattern: str = ESCAPE
def parse(
self, parser: Parser, match: str, parents: list[str]
) -> dict | list[dict]:
return {"type": self.pattern_type, "character": match[1:]}
ESCAPE_RE = re.compile(ESCAPE)
def unescape_markup(value: str) -> str:
return ESCAPE_RE.sub("\\1", value)
| 445
|
Python
|
.py
| 13
| 29.769231
| 66
| 0.643026
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,608
|
quote.py
|
rafalp_Misago/misago/parser/patterns/quote.py
|
from ..parser import Parser, Pattern
class QuoteMarkdown(Pattern):
pattern_type: str = "quote"
pattern: str = r"(\n|^) ? ? ?>.*(\n ? ? ?>.*)*"
def parse(
self, parser: Parser, match: str, parents: list[str]
) -> dict | list[dict]:
content = clean_quote_markdown_content(match)
if not content.strip():
return []
return {
"type": self.pattern_type,
"children": parser.parse_blocks(content, parents + [self.pattern_type]),
}
def clean_quote_markdown_content(match: str) -> str:
return "\n".join(line.lstrip()[1:] for line in match.splitlines())
class QuoteBBCodeOpen(Pattern):
pattern_type: str = "quote-bbcode-open"
pattern: str = r"\[quote(=.*?)?\]"
def parse(self, parser: Parser, match: str, parents: list[str]) -> dict:
args = parse_args(
parser.reverse_reservations(match[6:-1].strip("\"' =")),
)
return {
"type": self.pattern_type,
"author": args["author"],
"post": args["post"],
}
def parse_args(args: str) -> dict:
if "post:" not in args:
return {"author": args or None, "post": None}
data = {"author": None, "post": None}
post_pos = args.rfind("post:")
data["author"] = args[:post_pos].rstrip("; ") or None
try:
post_id = int(args[post_pos + 5 :].strip())
if post_id > 0:
data["post"] = post_id
except (TypeError, ValueError):
pass
return data
class QuoteBBCodeClose(Pattern):
pattern_type: str = "quote-bbcode-close"
pattern: str = r"\[\/quote\]"
def parse(self, parser: Parser, match: str, parents: list[str]) -> dict:
return {"type": self.pattern_type}
| 1,761
|
Python
|
.py
| 46
| 30.804348
| 84
| 0.575133
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,609
|
urls.py
|
rafalp_Misago/misago/parser/patterns/urls.py
|
import re
from functools import cached_property
from django.utils.crypto import get_random_string
from ..parents import has_invalid_parent
from ..parser import Parser, Pattern
MAIL_RE = re.compile(r"^\w+[.-_+\w]*@[-\w]+(.\w+)+$")
URL_RE = re.compile(
r"^(((https?)|(ftps?))://)?\w+(([-_\w])?\w+)*(\.\w+(([-_\w])?\w+))+[^\s]*$"
)
def clean_url(value: str) -> str | None:
value = value.strip()
if not value:
return None
if MAIL_RE.match(value):
return f"mailto:{value}"
if URL_RE.match(value):
return value
return None
BBCODE_CONTENTS = re.compile(
r"\[[a-z]+(=(?P<arg>(.+)))?\](?P<content>((.|\n)*?))\[\/[a-z]+\]", re.IGNORECASE
)
class UrlBBCode(Pattern):
pattern_type: str = "url-bbcode"
pattern: str = r"((\[url=.+?\](.|\n)*?)|(\[url\].*?))\[\/url\]"
invalid_parents: set[str] = {pattern_type, "url"}
def parse(self, parser: Parser, match: str, parents: list[dict]) -> dict:
contents = BBCODE_CONTENTS.match(match).groupdict()
arg = contents["arg"].strip(" \"'") if contents["arg"] else None
content = contents["content"]
if arg:
url = clean_url(arg)
elif content:
url = clean_url(content.strip())
content = None
else:
url = None
if (
not url
or not contents["content"].strip()
or has_invalid_parent(self.invalid_parents, parents)
):
return {"type": "text", "text": match}
return self.make_ast(parser, match, url, content, parents)
def make_ast(
self,
parser: Parser,
match: str,
url: str | None,
content: str,
parents: list[dict],
) -> dict:
if content:
children = parser.parse_inline(content, parents + [self.pattern_type])
else:
children = []
return {
"type": self.pattern_type,
"href": url,
"children": children,
}
class ImgBBCode(UrlBBCode):
pattern_type: str = "image-bbcode"
pattern: str = r"((\[img=.+?\](.|\n)*?)|(\[img\].*?))\[\/img\]"
invalid_parents: set[str] = {pattern_type, "image"}
def make_ast(
self,
parser: Parser,
match: str,
url: str | None,
alt_text: str | None,
parents: list[dict],
) -> dict:
if url.startswith("mailto:"):
return {"type": "text", "text": match}
if alt_text:
alt_text = alt_text.strip()
return {
"type": self.pattern_type,
"alt": alt_text or None,
"src": url,
}
INLINE_CODE_PATTERN = r"(?<!\\)`(.|\n)*?(?<!\\)`"
IMAGE_PATTERN = r"!(\[(.|\n)*?\])?\(.*?\)"
IMAGE_RE = re.compile(IMAGE_PATTERN)
URL_START_RE = re.compile(r"\[(.|\n)*?\]\(")
class UrlMarkdown(Pattern):
pattern_type: str = "url"
pattern: str = r"(?<!\!)\[.*\]\(.*\)"
exclude_patterns: list[str] = [INLINE_CODE_PATTERN, IMAGE_PATTERN]
def parse(self, parser: Parser, match: str, parents: list[dict]) -> list[dict]:
clean_match, reserved_patterns = self.prepare_match_str(match)
return self.parse_clean_match(parser, clean_match, reserved_patterns, parents)
def parse_clean_match(
self,
parser: Parser,
clean_match: str,
reserved_patterns: dict[str, str],
parents: list[dict],
) -> list[dict]:
ast: list[dict] = []
cursor = 0
urls_starts = list(URL_START_RE.finditer(clean_match))
urls_starts_last = len(urls_starts) - 1
for i, m in enumerate(urls_starts):
if m.start() > cursor:
markup = clean_match[cursor : m.start()]
if reserved_patterns:
markup = self.reverse_text_patterns(markup, reserved_patterns)
ast += parser.parse_inline(markup, parents)
text = m.group(0)[1:-2]
if reserved_patterns:
text = self.reverse_text_patterns(text, reserved_patterns)
url_source_start = m.end() - 1
if i < urls_starts_last:
next_url_start = urls_starts[i + 1].start()
url_source = clean_match[url_source_start:next_url_start]
else:
url_source = clean_match[url_source_start:]
url, end = self.extract_url_from_source(url_source)
if text and url:
ast.append(self.make_link_ast(parser, text, url, parents))
cursor = m.end() - 1 + end
else:
markup = self.reverse_text_patterns(m.group(0), reserved_patterns)
for ast_node in parser.parse_inline(markup, parents):
if ast_node["type"] == "text" and ast and ast[-1]["type"] == "text":
ast[-1]["text"] += ast_node["text"]
else:
ast.append(ast_node)
cursor = m.end()
if cursor < len(clean_match):
markup = clean_match[cursor:]
if reserved_patterns:
markup = self.reverse_text_patterns(markup, reserved_patterns)
ast += parser.parse_inline(markup, parents)
return ast
def prepare_match_str(self, match: str) -> tuple[str, dict[str, str]]:
clean_match: str = ""
reserved_patterns = {}
cursor = 0
for m in self._exclude_patterns_re.finditer(match):
if m.start() > cursor:
clean_match += match[cursor : m.start()]
pattern_id = f"%%{get_random_string(8)}%%"
clean_match += pattern_id
reserved_patterns[pattern_id] = m.group(0)
cursor = m.end()
if cursor < len(match):
clean_match += match[cursor:]
return clean_match, reserved_patterns
def reverse_text_patterns(self, text: str, reserved_patterns: dict) -> str:
for token, value in reserved_patterns.items():
text = text.replace(token, value)
return text
def extract_url_from_source(self, source: str) -> tuple[str, int]:
opening = source.count("(")
closing = source.count(")")
# Simplest case, one opening parenthesis matched by one closing
if opening == closing and opening == 1:
url = source[1 : source.find(")")].strip()
return url, source.find(")") + 1
if not closing:
return "", 0
# Walk the string to find pairs of parentheses
nesting = 0
length = 0
for i, c in enumerate(source):
if c == "(":
nesting += 1
elif c == ")":
nesting -= 1
if nesting >= 0:
length = i
url = source[1:length].strip()
return url, length + 1
def make_link_ast(
self, parser: Parser, text: str, url: str, parents: list[dict]
) -> dict:
return {
"type": self.pattern_type,
"href": url,
"children": parser.parse_inline(text, parents + [self.pattern_type]),
}
@cached_property
def _exclude_patterns_re(self) -> re.Pattern:
return re.compile("|".join(f"({p})" for p in self.exclude_patterns))
IMAGE_CONTENTS = re.compile(r"!(\[(?P<alt>(.|\n)*?)\])?\((?P<src>.*?)\)")
class ImgMarkdown(Pattern):
pattern_type: str = "image"
pattern: str = IMAGE_PATTERN
def parse(self, parser: Parser, match: str, parents: list[dict]) -> list[dict]:
contents = IMAGE_CONTENTS.match(match).groupdict()
if contents["alt"]:
alt = contents["alt"].strip() or None
else:
alt = None
src = contents["src"].strip()
if URL_RE.match(src):
return {
"type": "image",
"alt": alt,
"src": src,
}
return {"type": "text", "text": match}
class AutolinkMarkdown(Pattern):
pattern_type: str = "auto-link"
pattern: str = r"\<!?[^\s]*?\>"
invalid_parents: set[str] = {UrlMarkdown.pattern_type, UrlBBCode.pattern_type}
def parse(self, parser: Parser, match: str, parents: list[dict]) -> dict:
url = match[1:-1]
if url and url[0] == "!":
url = url[1:]
is_image = True
else:
is_image = False
url = clean_url(url)
if (
not url
or (is_image and url.startswith("mailto:"))
or has_invalid_parent(self.invalid_parents, parents)
):
return {"type": "text", "text": match}
return {"type": self.pattern_type, "image": is_image, "href": url}
class AutoUrl(AutolinkMarkdown):
pattern_type: str = "auto-url"
pattern: str = (
r"(?<!\w)((https?://(www\.)?)|(www\.))\w+(-|\w)*(\.\w+(-|\w)*)+[^\s)]*"
)
def parse(self, parser: Parser, match: str, parents: list[dict]) -> dict:
url = clean_url(match)
if not url or has_invalid_parent(self.invalid_parents, parents):
return {"type": "text", "text": match}
return {"type": self.pattern_type, "href": url}
| 9,200
|
Python
|
.py
| 233
| 29.656652
| 88
| 0.535514
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,610
|
code.py
|
rafalp_Misago/misago/parser/patterns/code.py
|
import re
from textwrap import dedent
from ..parser import Parser, Pattern
BLOCK_START = r"(\n|^)"
BLOCK_END = r"(\s+)?($|\n)"
CODE_FENCE = r"(```(.+)?\n(.|\n)+?\n```)"
CODE_FENCE_ALT = r"(~~~(.+)?\n(.|\n)+?\n~~~)"
CODE_FENCE_CONTENTS = re.compile(r"(?P<syntax>(.+))?\n(?P<code>(.|\n)+)\n")
class FencedCodeMarkdown(Pattern):
pattern_type: str = "code"
pattern: str = BLOCK_START + f"{CODE_FENCE}|{CODE_FENCE_ALT}" + BLOCK_END
def parse(self, parser: Parser, match: str, parents: list[str]) -> dict:
contents = CODE_FENCE_CONTENTS.match(match.strip()[3:-3])
syntax = str(contents.group("syntax") or "").strip()
if syntax:
syntax = parser.reverse_reservations(syntax)
return {
"type": self.pattern_type,
"syntax": syntax or None,
"code": parser.reverse_reservations(
contents.group("code").lstrip("\n").rstrip(),
),
}
class IndentedCodeMarkdown(Pattern):
pattern_type = "code-indented"
pattern: str = r"(\n|^) {4}.+(\n {4}.+)*"
def parse(self, parser: Parser, match: str, parents: list[str]) -> dict:
return {
"type": self.pattern_type,
"syntax": None,
"code": parser.reverse_reservations(
dedent(match.strip("\n")).strip(),
),
}
CODE_BBCODE_PATTERN = r"\[code(=.+)?\]((.|\n)*?)\[\/code\]"
CODE_BBCODE_CONTENTS = re.compile(
r"\[code(=(?P<syntax>(.+)))?\](?P<code>((.|\n)*?))\[\/code\]", re.IGNORECASE
)
class CodeBBCode(Pattern):
pattern_type: str = "code-bbcode"
pattern: str = CODE_BBCODE_PATTERN
def parse(self, parser: Parser, match: str, parents: list[str]) -> dict:
contents = CODE_BBCODE_CONTENTS.match(match.strip())
syntax = str(contents.group("syntax") or "").strip("\"' ")
if syntax:
syntax = parser.reverse_reservations(syntax)
return {
"type": self.pattern_type,
"syntax": syntax or None,
"code": parser.reverse_reservations(
dedent(contents.group("code").rstrip()).strip(),
),
}
class InlineCodeMarkdown(Pattern):
pattern_type: str = "code-inline"
pattern: str = r"(?<!\\)`(.|\n)*?(?<!\\)`"
linebreaks_pattern = re.compile(r"\n+")
def parse(self, parser: Parser, match: str, parents: list[str]) -> dict:
code = match.strip("`")
if "\n" in code:
code = self.linebreaks_pattern.sub(" ", code)
return {
"type": self.pattern_type,
"code": code,
}
| 2,613
|
Python
|
.py
| 65
| 32.184615
| 80
| 0.554984
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,611
|
__init__.py
|
rafalp_Misago/misago/parser/patterns/__init__.py
|
from ..parser import Pattern
from .bbcode import (
BoldBBCode,
InlineBBCodePattern,
ItalicsBBCode,
StrikethroughBBCode,
SubscriptBBCode,
SuperscriptBBCode,
UnderlineBBCode,
)
from .code import (
CodeBBCode,
FencedCodeMarkdown,
IndentedCodeMarkdown,
InlineCodeMarkdown,
)
from .escape import Escape, unescape_markup
from .headings import AtxHeading, SetexHeading
from .lists import ListMarkdown
from .markdown import (
EmphasisMarkdown,
EmphasisUnderscoreMarkdown,
StrikethroughMarkdown,
StrongMarkdown,
StrongUnderscoreMarkdown,
)
from .mention import Mention
from .quote import QuoteBBCodeOpen, QuoteBBCodeClose, QuoteMarkdown
from .spoiler import SpoilerBBCodeOpen, SpoilerBBCodeClose
from .thematicbreak import ThematicBreakBBCode, ThematicBreakMarkdown
from .urls import (
AutolinkMarkdown,
AutoUrl,
ImgBBCode,
ImgMarkdown,
UrlBBCode,
UrlMarkdown,
)
block_patterns: list[Pattern] = [
FencedCodeMarkdown(),
CodeBBCode(),
AtxHeading(),
SetexHeading(),
ThematicBreakBBCode(),
ThematicBreakMarkdown(),
ListMarkdown(),
IndentedCodeMarkdown(),
QuoteMarkdown(),
QuoteBBCodeOpen(),
QuoteBBCodeClose(),
SpoilerBBCodeOpen(),
SpoilerBBCodeClose(),
]
bold_bbcode = BoldBBCode()
italics_bbcode = ItalicsBBCode()
underline_bbcode = UnderlineBBCode()
strikethrough_bbcode = StrikethroughBBCode()
superscript_bbcode = SuperscriptBBCode()
subscript_bbcode = SubscriptBBCode()
emphasis_markdown = EmphasisMarkdown()
emphasis_underscore_markdown = EmphasisUnderscoreMarkdown()
strong_markdown = StrongMarkdown()
strong_underscore_markdown = StrongUnderscoreMarkdown()
strikethrough_markdown = StrikethroughMarkdown()
autolink_markdown = AutolinkMarkdown()
auto_url = AutoUrl()
img_bbcode = ImgBBCode()
img_markdown = ImgMarkdown()
url_bbcode = UrlBBCode()
url_markdown = UrlMarkdown()
mention = Mention()
inline_patterns: list[Pattern] = [
InlineCodeMarkdown(),
bold_bbcode,
italics_bbcode,
underline_bbcode,
strikethrough_bbcode,
superscript_bbcode,
subscript_bbcode,
strong_markdown,
emphasis_markdown,
strong_underscore_markdown,
emphasis_underscore_markdown,
strikethrough_markdown,
autolink_markdown,
img_markdown,
url_markdown,
img_bbcode,
url_bbcode,
auto_url,
mention,
Escape(),
]
| 2,405
|
Python
|
.py
| 93
| 22.376344
| 69
| 0.772708
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,612
|
markdown.py
|
rafalp_Misago/misago/parser/patterns/markdown.py
|
from ..parents import has_invalid_parent
from ..parser import Parser, Pattern
class InlineMarkdownPattern(Pattern):
pattern_type: str
pattern: str
pattern_length: int
invalid_parents: set[str] | None = None
def parse(
self, parser: Parser, match: str, parents: list[str]
) -> dict | list[dict]:
content = match[self.pattern_length : self.pattern_length * -1]
if not content:
return {"type": "text", "text": match}
if not content.strip():
pattern = {"type": "text", "text": match[: self.pattern_length]}
return [pattern] + parser.parse_inline(content, parents) + [pattern]
if has_invalid_parent(self.invalid_parents, parents):
return parser.parse_inline(content, parents)
return {
"type": self.pattern_type,
"children": parser.parse_inline(content, parents + [self.pattern_type]),
}
class EmphasisUnderscoreMarkdown(InlineMarkdownPattern):
pattern_type: str = "emphasis-underscore"
pattern: str = r"(?<!\w)_.+?(\n.+)*?_(?!\w)"
pattern_length: int = 1
invalid_parents: set[str] = {pattern_type, "emphasis"}
class StrongUnderscoreMarkdown(InlineMarkdownPattern):
pattern_type: str = "strong-underscore"
pattern: str = r"(?<!\w)__.*?(\n.+)*?__(?!\w)"
pattern_length: int = 2
invalid_parents: set[str] = {pattern_type, "strong"}
class EmphasisMarkdown(InlineMarkdownPattern):
pattern_type: str = "emphasis"
pattern: str = r"\*.+?(\n.+)*?\*"
pattern_length: int = 1
invalid_parents: set[str] = {pattern_type, "emphasis-underscore"}
class StrongMarkdown(InlineMarkdownPattern):
pattern_type: str = "strong"
pattern: str = r"\*\*.*?(\n.+)*?\*\*"
pattern_length: int = 2
invalid_parents: set[str] = {pattern_type, "strong-underscore"}
class StrikethroughMarkdown(InlineMarkdownPattern):
pattern_type: str = "strikethrough"
pattern: str = r"~~.+?(\n.+)*?~~"
pattern_length: int = 2
| 2,016
|
Python
|
.py
| 46
| 37.521739
| 84
| 0.64176
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,613
|
lists.py
|
rafalp_Misago/misago/parser/patterns/lists.py
|
import re
from textwrap import dedent
from ..parser import Parser, Pattern
LIST_PATTERN = (
r"(\n|^)" # List is preceded by a new line or the start of the text
r" *(([-*+]|(1[.)]))( +.+)?(\n+|$))" # First list item
r"( *([-*+]|([0-9]+[.)]))( +.+)?(\n+|$))*" # Next list items
)
LIST_CONTENTS = re.compile(
r"(?P<prefix> *)(?P<marker>[-*+i]|([0-9]+[.)]))(?P<text> *.*)"
)
ListItem = tuple[int, str, list[dict]]
class ListMarkdown(Pattern):
pattern_type: str = "list"
pattern: str = LIST_PATTERN
def parse(self, parser: Parser, match: str, parents: list[str]) -> list[dict]:
items = self.parse_list_items(
parser, match, parents + [self.pattern_type, "list-item"]
)
return self.get_lists_from_items(items)
def parse_list_items(
self, parser: Parser, match: str, parents: list[str]
) -> list[ListItem]:
items: list[ListItem] = []
prev_level: int | None = None
for item in LIST_CONTENTS.finditer(dedent(match).strip()):
raw_level = len(item.group("prefix") or "")
if not items:
clean_level = 0
prev_level = raw_level
else:
level_diff = raw_level - prev_level
if level_diff >= 2:
clean_level = items[-1][1] + 1
elif level_diff >= 0:
clean_level = items[-1][1]
else:
clean_level = 0
for prev_item in items:
if raw_level - prev_item[0] >= 2:
clean_level += 1
prev_level = raw_level
marker = item.group("marker")
if marker not in "-*+":
marker = "n"
text = item.group("text").strip()
items.append(
(
raw_level,
clean_level,
marker,
parser.parse_inline(text, parents, reverse_reservations=True),
)
)
return items
def get_lists_from_items(self, items: list[ListItem]) -> list[dict]:
lists_asts: list[dict] = []
lists_stack: list[dict] = []
level: int = -1
marker: str | None = None
for _, item_level, item_sign, children in items:
if item_level > level or item_sign != marker:
list_ast = {
"type": ListMarkdown.pattern_type,
"ordered": item_sign == "n",
"sign": item_sign if item_sign != "n" else None,
"items": [],
}
if item_level == level:
lists_stack.pop(-1)
if not lists_stack:
lists_asts.append(list_ast)
if lists_stack:
lists_stack[-1]["items"][-1]["lists"].append(list_ast)
lists_stack.append(list_ast)
if item_level < level:
for _ in range(level - item_level):
lists_stack.pop(-1)
if item_level != level or item_sign != marker:
level = item_level
marker = item_sign
lists_stack[-1]["items"].append(
{
"type": "list-item",
"children": children,
"lists": [],
}
)
return lists_asts
| 3,491
|
Python
|
.py
| 89
| 25.741573
| 82
| 0.463155
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,614
|
headings.py
|
rafalp_Misago/misago/parser/patterns/headings.py
|
from ..parser import Parser, Pattern
class AtxHeading(Pattern):
pattern_type: str = "heading"
pattern: str = r"(\n|^)#{1,6}.*"
def parse(
self, parser: Parser, match: str, parents: list[str]
) -> dict | list[dict]:
content = match.strip()
level = 0
while content.startswith("#"):
content = content[1:]
level += 1
return {
"type": self.pattern_type,
"level": level,
"children": parser.parse_inline(
content.strip(),
parents + [self.pattern_type],
reverse_reservations=True,
),
}
class SetexHeading(Pattern):
pattern_type: str = "heading-setex"
pattern: str = r"(\n|^).+\n((=+)|(-+)) *(\n|$)"
def parse(
self, parser: Parser, match: str, parents: list[str]
) -> dict | list[dict]:
content, underline = match.strip().splitlines()
return {
"type": self.pattern_type,
"level": 1 if underline[0] == "=" else 2,
"children": parser.parse_inline(
content.strip(),
parents + [self.pattern_type],
reverse_reservations=True,
),
}
| 1,255
|
Python
|
.py
| 37
| 23.810811
| 60
| 0.508685
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,615
|
bbcode.py
|
rafalp_Misago/misago/parser/patterns/bbcode.py
|
from ..parents import has_invalid_parent
from ..parser import Parser, Pattern
class InlineBBCodePattern(Pattern):
pattern_type: str
pattern: str
invalid_parents: set[str] | None = None
@staticmethod
def create_pattern(bbcode: str) -> str:
return r"\[" + bbcode + r"\](.|\n)*?\[\/" + bbcode + r"\]"
def parse(
self, parser: Parser, match: str, parents: list[str]
) -> dict | list[dict]:
content_start = match.find("]") + 1
content_end = match.rfind("[")
content = match[content_start:content_end]
if not content.strip():
return []
if has_invalid_parent(self.invalid_parents, parents):
return parser.parse_inline(content, parents)
return {
"type": self.pattern_type,
"children": parser.parse_inline(content, parents + [self.pattern_type]),
}
class BoldBBCode(InlineBBCodePattern):
pattern_type: str = "bold-bbcode"
pattern: str = InlineBBCodePattern.create_pattern("b")
invalid_parents: set[str] = {pattern_type, "strong", "strong-underline"}
class ItalicsBBCode(InlineBBCodePattern):
pattern_type: str = "italics-bbcode"
pattern: str = InlineBBCodePattern.create_pattern("i")
invalid_parents: set[str] = {pattern_type, "emphasis", "emphasis-underline"}
class UnderlineBBCode(InlineBBCodePattern):
pattern_type: str = "underline-bbcode"
pattern: str = InlineBBCodePattern.create_pattern("u")
invalid_parents: set[str] = {pattern_type}
class StrikethroughBBCode(InlineBBCodePattern):
pattern_type: str = "strikethrough-bbcode"
pattern: str = InlineBBCodePattern.create_pattern("s")
invalid_parents: set[str] = {pattern_type, "strikethrough"}
class SuperscriptBBCode(InlineBBCodePattern):
pattern_type: str = "superscript-bbcode"
pattern: str = InlineBBCodePattern.create_pattern("sup")
invalid_parents: set[str] = {pattern_type, "subscript-bbcode"}
class SubscriptBBCode(InlineBBCodePattern):
pattern_type: str = "subscript-bbcode"
pattern: str = InlineBBCodePattern.create_pattern("sub")
invalid_parents: set[str] = {pattern_type, "superscript-bbcode"}
| 2,190
|
Python
|
.py
| 47
| 40.510638
| 84
| 0.691149
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,616
|
mention.py
|
rafalp_Misago/misago/parser/patterns/mention.py
|
from ..parents import has_invalid_parent
from ..parser import Parser, Pattern
from .urls import UrlBBCode, UrlMarkdown
class Mention(Pattern):
pattern_type: str = "mention"
pattern: str = r"(?<!\w)@[a-zA-Z0-9-_]+"
invalid_parents: set[str] = {UrlBBCode.pattern_type, UrlMarkdown.pattern_type}
def parse(self, parser: Parser, match: str, parents: list[dict]) -> dict:
if has_invalid_parent(self.invalid_parents, parents):
return {"type": "text", "text": match}
return {"type": self.pattern_type, "username": match[1:]}
| 566
|
Python
|
.py
| 11
| 46.090909
| 82
| 0.675136
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,617
|
spoiler.py
|
rafalp_Misago/misago/parser/patterns/spoiler.py
|
from ..parser import Parser, Pattern
class SpoilerBBCodeOpen(Pattern):
pattern_type: str = "spoiler-bbcode-open"
pattern: str = r"\[spoiler(=.*?)?\]"
def parse(self, parser: Parser, match: str, parents: list[str]) -> dict:
summary = parser.reverse_reservations(match[8:-1].strip("\"' ="))
return {
"type": self.pattern_type,
"summary": summary or None,
}
class SpoilerBBCodeClose(Pattern):
pattern_type: str = "spoiler-bbcode-close"
pattern: str = r"\[\/spoiler\]"
def parse(self, parser: Parser, match: str, parents: list[str]) -> dict:
return {"type": self.pattern_type}
| 660
|
Python
|
.py
| 15
| 37.2
| 76
| 0.628527
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,618
|
conftest.py
|
rafalp_Misago/misago/parser/tests/conftest.py
|
from textwrap import dedent
import pytest
from ...permissions.proxy import UserPermissionsProxy
from ..context import create_parser_context
from ..factory import create_parser
@pytest.fixture
def parser(parser_context):
return create_parser(parser_context)
@pytest.fixture
def parser_context(dynamic_settings, cache_versions, user):
dynamic_settings.forum_address = "http://example.org"
return create_parser_context(
user_permissions=UserPermissionsProxy(user, cache_versions),
settings=dynamic_settings,
cache_versions=cache_versions,
)
@pytest.fixture
def parse_markup(parser):
def parse_markup_func(markup: str) -> list[dict]:
return parser(dedent(markup).strip())
return parse_markup_func
| 759
|
Python
|
.py
| 21
| 32
| 68
| 0.767857
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,619
|
test_headings.py
|
rafalp_Misago/misago/parser/tests/test_headings.py
|
def test_empty_atx_heading(parse_markup):
result = parse_markup("#")
assert result == [
{
"type": "heading",
"level": 1,
"children": [],
}
]
def test_atx_heading_with_text(parse_markup):
result = parse_markup("# Hello World!")
assert result == [
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": "Hello World!"},
],
}
]
def test_atx_heading_second_level(parse_markup):
result = parse_markup("## Hello World!")
assert result == [
{
"type": "heading",
"level": 2,
"children": [
{"type": "text", "text": "Hello World!"},
],
}
]
def test_atx_heading_third_level(parse_markup):
result = parse_markup("### Hello World!")
assert result == [
{
"type": "heading",
"level": 3,
"children": [
{"type": "text", "text": "Hello World!"},
],
}
]
def test_atx_heading_fourth_level(parse_markup):
result = parse_markup("#### Hello World!")
assert result == [
{
"type": "heading",
"level": 4,
"children": [
{"type": "text", "text": "Hello World!"},
],
}
]
def test_atx_heading_fifth_level(parse_markup):
result = parse_markup("##### Hello World!")
assert result == [
{
"type": "heading",
"level": 5,
"children": [
{"type": "text", "text": "Hello World!"},
],
}
]
def test_atx_heading_sixth_level(parse_markup):
result = parse_markup("###### Hello World!")
assert result == [
{
"type": "heading",
"level": 6,
"children": [
{"type": "text", "text": "Hello World!"},
],
}
]
def test_atx_heading_text_whitespace_is_stripped(parse_markup):
result = parse_markup("# Hello World! ")
assert result == [
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": "Hello World!"},
],
}
]
def test_atx_heading_breaks_paragraphs(parse_markup):
result = parse_markup("Lorem ipsum\n# Dolor met\nSit amet")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum"},
],
},
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": "Dolor met"},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Sit amet"},
],
},
]
def test_setex_heading(parse_markup):
result = parse_markup("Hello World!\n=")
assert result == [
{
"type": "heading-setex",
"level": 1,
"children": [
{"type": "text", "text": "Hello World!"},
],
}
]
def test_setex_heading_second_level(parse_markup):
result = parse_markup("Hello World!\n-")
assert result == [
{
"type": "heading-setex",
"level": 2,
"children": [
{"type": "text", "text": "Hello World!"},
],
}
]
def test_setex_heading_text_whitespace_is_stripped(parse_markup):
result = parse_markup(" Hello World! \n-")
assert result == [
{
"type": "heading-setex",
"level": 2,
"children": [
{"type": "text", "text": "Hello World!"},
],
}
]
def test_setex_heading_breaks_paragraphs(parse_markup):
result = parse_markup("Lorem ipsum\nDolor met\n===\nSit amet")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum"},
],
},
{
"type": "heading-setex",
"level": 1,
"children": [
{"type": "text", "text": "Dolor met"},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Sit amet"},
],
},
]
| 4,506
|
Python
|
.py
| 165
| 17.436364
| 66
| 0.424832
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,620
|
test_lists.py
|
rafalp_Misago/misago/parser/tests/test_lists.py
|
def test_unordered_list(parse_markup):
result = parse_markup("- Lorem")
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
],
}
]
def test_unordered_list_with_multiple_items(parse_markup):
result = parse_markup("- Lorem\n- Ipsum\n- Dolor")
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Dolor",
},
],
"lists": [],
},
],
}
]
def test_unordered_list_with_asterisk(parse_markup):
result = parse_markup("* Lorem\n* Ipsum")
assert result == [
{
"type": "list",
"ordered": False,
"sign": "*",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
],
}
]
def test_unordered_list_with_plus(parse_markup):
result = parse_markup("+ Lorem\n+ Ipsum")
assert result == [
{
"type": "list",
"ordered": False,
"sign": "+",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
],
}
]
def test_unordered_list_with_indent(parse_markup):
result = parse_markup(" - Lorem\n - Ipsum")
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
],
}
]
def test_ordered_list(parse_markup):
result = parse_markup("1. Lorem\n2) Ipsum\n4. Dolor")
assert result == [
{
"type": "list",
"ordered": True,
"sign": None,
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Dolor",
},
],
"lists": [],
},
],
}
]
def test_list_with_separating_blank_lines(parse_markup):
result = parse_markup(" - Lorem\n\n\n - Ipsum")
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
],
}
]
def test_multiple_lists_separated_by_marker(parse_markup):
result = parse_markup("- Lorem\n- Ipsum\n* Dolor\n* Met\n+ Sit\n1. Amet")
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
],
},
{
"type": "list",
"ordered": False,
"sign": "*",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Dolor",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Met",
},
],
"lists": [],
},
],
},
{
"type": "list",
"ordered": False,
"sign": "+",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Sit",
},
],
"lists": [],
},
],
},
{
"type": "list",
"ordered": True,
"sign": None,
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Amet",
},
],
"lists": [],
},
],
},
]
def test_list_with_first_item_subitems(parse_markup):
result = parse_markup(
"""
- Lorem
- Ipsum
- Dolor
- Met
"""
)
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Dolor",
},
],
"lists": [],
},
],
}
],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Met",
},
],
"lists": [],
},
],
}
]
def test_list_with_second_item_subitems(parse_markup):
result = parse_markup(
"""
- Lorem
- Met
- Ipsum
- Dolor
"""
)
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Met",
},
],
"lists": [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Dolor",
},
],
"lists": [],
},
],
},
],
},
],
}
]
def test_list_with_first_item_subitems_two_levels_deep(parse_markup):
result = parse_markup(
"""
- Met
- Ipsum
- Dolor
- Elit
- Lorem
"""
)
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Met",
},
],
"lists": [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Dolor",
},
],
"lists": [],
},
],
},
],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Elit",
},
],
"lists": [],
},
],
},
],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
],
}
]
def test_list_with_first_item_children_three_levels_deep(parse_markup):
result = parse_markup(
"""
- Met
- Ipsum
- Dolor
- Pacem
- Elit
- Lorem
"""
)
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Met",
},
],
"lists": [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Dolor",
},
],
"lists": [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Pacem",
},
],
"lists": [],
},
],
},
],
},
],
},
],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Elit",
},
],
"lists": [],
},
],
},
],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
],
}
]
def test_list_with_empty_first_item(parse_markup):
result = parse_markup(
"""
-
- Met
- Ipsum
- Lorem
"""
)
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Met",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
],
}
]
def test_list_with_empty_middle_item(parse_markup):
result = parse_markup(
"""
- Met
- Ipsum
-
- Lorem
"""
)
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Met",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
],
}
]
def test_list_with_empty_nested_item(parse_markup):
result = parse_markup(
"""
- Met
- Ipsum
-
- Lorem
"""
)
assert result == [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Met",
},
],
"lists": [
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
{
"type": "list-item",
"children": [],
"lists": [],
},
],
},
],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem",
},
],
"lists": [],
},
],
}
]
def test_list_items_with_too_deep_levels_are_fixed(parse_markup):
result = parse_markup(
"""
- Met
- Ipsum
- Dolor
- Sit
- Lorem
"""
)
expected_result = parse_markup(
"""
- Met
- Ipsum
- Dolor
- Sit
- Lorem
"""
)
assert result == expected_result
def test_list_with_too_deep_item_followed_by_deep_item_is_fixed(parse_markup):
result = parse_markup(
"""
- Met
- Ipsum
- Dolor
- Sit
- Lorem
"""
)
expected_result = parse_markup(
"""
- Met
- Ipsum
- Dolor
- Sit
- Lorem
"""
)
assert result == expected_result
def test_list_with_too_deep_item_followed_by_two_too_deep_items_is_fixed(parse_markup):
result = parse_markup(
"""
- Met
- Ipsum
- Dolor
- Sit
- Lorem
"""
)
expected_result = parse_markup(
"""
- Met
- Ipsum
- Dolor
- Sit
- Lorem
"""
)
assert result == expected_result
def test_list_with_first_item_indented_is_fixed(parse_markup):
result = parse_markup(
"""
Lorem ipsum
- Met
- Ipsum
- Dolor
- Sit
- Lorem
"""
)
expected_result = parse_markup(
"""
Lorem ipsum
- Met
- Ipsum
- Dolor
- Sit
- Lorem
"""
)
assert result == expected_result
def test_list_items_with_not_deep_levels_are_fixed(parse_markup):
result = parse_markup(
"""
- Met
- Ipsum
- Dolor
- Sit
- Lorem
"""
)
expected_result = parse_markup(
"""
- Met
- Ipsum
- Dolor
- Sit
- Lorem
"""
)
assert result == expected_result
| 28,159
|
Python
|
.py
| 909
| 9.678768
| 92
| 0.185704
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,621
|
test_block_postprocessor.py
|
rafalp_Misago/misago/parser/tests/test_block_postprocessor.py
|
from unittest.mock import Mock
import pytest
from ..parser import Parser
from ..postprocessors import BlockPostProcessor
class PostProcessor(BlockPostProcessor):
opening_type = "mock-open"
closing_type = "mock-close"
def wrap_block(
self,
parser: Parser,
opening_block: dict,
closing_block: dict,
children: list[dict],
) -> dict | None:
if not children:
return None
return {"type": "mock", "children": self(parser, children)}
@pytest.fixture
def post_processor():
return PostProcessor()
def test_block_post_processor_wraps_block(parser, post_processor):
result = post_processor(
parser,
[
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
{"type": "mock-close"},
],
)
assert result == [
{
"type": "mock",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
}
]
def test_block_post_processor_wraps_block_in_other_block(parser, post_processor):
result = post_processor(
parser,
[
{
"type": "other-block",
"children": [
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
{"type": "mock-close"},
],
},
],
)
assert result == [
{
"type": "other-block",
"children": [
{
"type": "mock",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
}
],
},
]
def test_block_post_processor_removes_empty_block_in_other_block(
parser, post_processor
):
result = post_processor(
parser,
[
{
"type": "other-block",
"children": [
{"type": "mock-open"},
{"type": "mock-close"},
],
},
],
)
assert result == [
{
"type": "other-block",
"children": [],
},
]
def test_block_post_processor_wraps_block_in_block(parser, post_processor):
result = post_processor(
parser,
[
{"type": "mock-open"},
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
{"type": "mock-close"},
{"type": "mock-close"},
],
)
assert result == [
{
"type": "mock",
"children": [
{
"type": "mock",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
}
],
},
]
def test_block_post_processor_handles_siblings_blocks(parser, post_processor):
result = post_processor(
parser,
[
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
{"type": "mock-close"},
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Lorem Ipsum!"}],
},
{"type": "mock-close"},
],
)
assert result == [
{
"type": "mock",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
{
"type": "mock",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Lorem Ipsum!"}],
},
],
},
]
def test_block_post_processor_handles_blocks_separated_with_paragraph(
parser, post_processor
):
result = post_processor(
parser,
[
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
{"type": "mock-close"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Separator!"}],
},
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Lorem Ipsum!"}],
},
{"type": "mock-close"},
],
)
assert result == [
{
"type": "mock",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Separator!"}],
},
{
"type": "mock",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Lorem Ipsum!"}],
},
],
},
]
def test_block_post_processor_handles_unclosed_block(parser, post_processor):
result = post_processor(
parser,
[
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
)
assert result == [
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
]
def test_block_post_processor_handles_unopened_block(parser, post_processor):
result = post_processor(
parser,
[
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
{"type": "mock-close"},
],
)
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
{"type": "mock-close"},
]
def test_block_post_processor_handles_extra_closing_block(parser, post_processor):
result = post_processor(
parser,
[
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
{"type": "mock-close"},
{"type": "mock-close"},
],
)
assert result == [
{
"type": "mock",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
{"type": "mock-close"},
]
def test_block_post_processor_handles_extra_opening_block(parser, post_processor):
result = post_processor(
parser,
[
{"type": "mock-open"},
{"type": "mock-open"},
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
{"type": "mock-close"},
],
)
assert result == [
{"type": "mock-open"},
{
"type": "mock",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
| 8,409
|
Python
|
.py
| 299
| 16.180602
| 83
| 0.378248
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,622
|
test_indented_code.py
|
rafalp_Misago/misago/parser/tests/test_indented_code.py
|
def test_indented_code(parse_markup):
result = parse_markup(
"""
Code:
lorem ipsum
"""
)
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Code:"}],
},
{
"type": "code-indented",
"syntax": None,
"code": "lorem ipsum",
},
]
def test_indented_code_multiline(parse_markup):
result = parse_markup(
"""
Code:
lorem ipsum
dolor met
sit amet
"""
)
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Code:"}],
},
{
"type": "code-indented",
"syntax": None,
"code": "lorem ipsum\n dolor met\nsit amet",
},
]
def test_indented_code_is_broken_by_empty_line(parse_markup):
result = parse_markup(
"""
Code:
lorem ipsum
sit amet
"""
)
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Code:"}],
},
{
"type": "code-indented",
"syntax": None,
"code": "lorem ipsum",
},
{
"type": "code-indented",
"syntax": None,
"code": "sit amet",
},
]
| 1,451
|
Python
|
.py
| 62
| 13.725806
| 61
| 0.403496
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,623
|
test_thematic_break.py
|
rafalp_Misago/misago/parser/tests/test_thematic_break.py
|
def test_thematic_break(parse_markup):
result = parse_markup("---")
assert result == [
{"type": "thematic-break"},
]
def test_thematic_break_with_asterisks(parse_markup):
result = parse_markup("***")
assert result == [
{"type": "thematic-break"},
]
def test_thematic_break_with_underscores(parse_markup):
result = parse_markup("___")
assert result == [
{"type": "thematic-break"},
]
def test_thematic_break_with_extra_signs(parse_markup):
result = parse_markup(" - - - --- ")
assert result == [
{"type": "thematic-break"},
]
def test_thematic_break_breaks_paragraphs(parse_markup):
result = parse_markup("Lorem ipsum\n- - -\nDolor met")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum"},
],
},
{"type": "thematic-break"},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Dolor met"},
],
},
]
def test_thematic_break_bbcode(parse_markup):
result = parse_markup("[hr]")
assert result == [
{"type": "thematic-break-bbcode"},
]
def test_thematic_break_bbcode_alt(parse_markup):
result = parse_markup("[hr/]")
assert result == [
{"type": "thematic-break-bbcode"},
]
def test_thematic_break_bbcode_breaks_paragraphs(parse_markup):
result = parse_markup("Lorem ipsum[hr]Dolor met")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum"},
],
},
{"type": "thematic-break-bbcode"},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Dolor met"},
],
},
]
def test_repeated_thematic_break_is_removed(parse_markup):
result = parse_markup("Lorem ipsum\n- - -\n[hr]Dolor met")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum"},
],
},
{"type": "thematic-break"},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Dolor met"},
],
},
]
| 2,404
|
Python
|
.py
| 81
| 21.222222
| 63
| 0.494582
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,624
|
test_inline_bbcode.py
|
rafalp_Misago/misago/parser/tests/test_inline_bbcode.py
|
def test_inline_bbcode_with_text(parse_markup):
result = parse_markup("Hello [b]guest[/b]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "bold-bbcode",
"children": [
{"type": "text", "text": "guest"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_inline_bbcode_with_new_line(parse_markup):
result = parse_markup("Hello [b]guest\nname[/b]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "bold-bbcode",
"children": [
{"type": "text", "text": "guest"},
{"type": "line-break"},
{"type": "text", "text": "name"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_inline_bbcode_without_content_is_removed(parse_markup):
result = parse_markup("Hello [b][/b]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello !"},
],
}
]
def test_inline_bbcode_with_only_whitespaces_is_removed(parse_markup):
result = parse_markup("Hello [b] \n [/b]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello !"},
],
}
]
def test_inline_bbcode_with_invalid_parent_is_unwrapped(parse_markup):
result = parse_markup("Hello [sub]Bob [sup]Doe[/sup][/sub]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "subscript-bbcode",
"children": [
{"type": "text", "text": "Bob Doe"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_bold_bbcode(parse_markup):
result = parse_markup("Hello [b]guest[/b]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "bold-bbcode",
"children": [
{"type": "text", "text": "guest"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_italics_bbcode(parse_markup):
result = parse_markup("Hello [i]guest[/i]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "italics-bbcode",
"children": [
{"type": "text", "text": "guest"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_underline_bbcode(parse_markup):
result = parse_markup("Hello [u]guest[/u]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "underline-bbcode",
"children": [
{"type": "text", "text": "guest"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_strikethrough_bbcode(parse_markup):
result = parse_markup("Hello [s]guest[/s]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strikethrough-bbcode",
"children": [
{"type": "text", "text": "guest"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_superscript_bbcode(parse_markup):
result = parse_markup("Hello [sup]guest[/sup]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "superscript-bbcode",
"children": [
{"type": "text", "text": "guest"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_subscript_bbcode(parse_markup):
result = parse_markup("Hello [sub]guest[/sub]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "subscript-bbcode",
"children": [
{"type": "text", "text": "guest"},
],
},
{"type": "text", "text": "!"},
],
}
]
| 5,393
|
Python
|
.py
| 175
| 17.611429
| 70
| 0.356291
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,625
|
test_quote_bbcode.py
|
rafalp_Misago/misago/parser/tests/test_quote_bbcode.py
|
def test_quote_bbcode(parse_markup):
result = parse_markup("[quote]Hello world![/quote]")
assert result == [
{
"type": "quote-bbcode",
"author": None,
"post": None,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_quote_bbcode_with_empty_author(parse_markup):
result = parse_markup("[quote=]Hello world![/quote]")
assert result == [
{
"type": "quote-bbcode",
"author": None,
"post": None,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_quote_bbcode_with_author(parse_markup):
result = parse_markup("[quote=Dune, part 2]Hello world![/quote]")
assert result == [
{
"type": "quote-bbcode",
"author": "Dune, part 2",
"post": None,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_quote_bbcode_with_author_and_post(parse_markup):
result = parse_markup("[quote=John; post:2137]Hello world![/quote]")
assert result == [
{
"type": "quote-bbcode",
"author": "John",
"post": 2137,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_quote_bbcode_with_author_and_empty_post(parse_markup):
result = parse_markup("[quote=John; post:]Hello world![/quote]")
assert result == [
{
"type": "quote-bbcode",
"author": "John",
"post": None,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_quote_bbcode_with_author_and_invalid_post(parse_markup):
result = parse_markup("[quote=John; post:dsadsa]Hello world![/quote]")
assert result == [
{
"type": "quote-bbcode",
"author": "John",
"post": None,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_quote_bbcode_without_author_and_with_post(parse_markup):
result = parse_markup("[quote=post:2137]Hello world![/quote]")
assert result == [
{
"type": "quote-bbcode",
"author": None,
"post": 2137,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_quote_bbcode_with_extra_post(parse_markup):
result = parse_markup("[quote=John; post:1; post:3]Hello world![/quote]")
assert result == [
{
"type": "quote-bbcode",
"author": "John; post:1",
"post": 3,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_quote_bbcode_with_space_around_post(parse_markup):
result = parse_markup("[quote=John; post: 3]Hello world![/quote]")
assert result == [
{
"type": "quote-bbcode",
"author": "John",
"post": 3,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_quote_bbcode_strips_quotations_and_spaces_from_author(parse_markup):
result = parse_markup('[quote=" Dune, part 2 "]Hello world![/quote]')
assert result == [
{
"type": "quote-bbcode",
"author": "Dune, part 2",
"post": None,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_empty_quote_bbcode_is_removed_from_result(parse_markup):
result = parse_markup("Lorem ipsum.[quote][/quote]")
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Lorem ipsum."}],
},
]
def test_quote_bbcode_next_to_paragraph_is_parsed(parse_markup):
result = parse_markup("Lorem ipsum.[quote]Dolor met![/quote]")
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Lorem ipsum."}],
},
{
"type": "quote-bbcode",
"author": None,
"post": None,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Dolor met!"}],
},
],
},
]
| 5,545
|
Python
|
.py
| 177
| 19.740113
| 77
| 0.424617
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,626
|
test_escaping.py
|
rafalp_Misago/misago/parser/tests/test_escaping.py
|
from ..patterns import unescape_markup
def test_escaped_atx_heading(parse_markup):
result = parse_markup("\\# Lorem ipsum")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "escape", "character": "#"},
{"type": "text", "text": " Lorem ipsum"},
],
}
]
def test_escaped_inline_code(parse_markup):
result = parse_markup("Lorem ipsum \\`dolor\\` met.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum "},
{"type": "escape", "character": "`"},
{"type": "text", "text": "dolor"},
{"type": "escape", "character": "`"},
{"type": "text", "text": " met."},
],
}
]
def test_escape_is_not_working_for_characters(parse_markup):
result = parse_markup("Lorem ipsum \\met.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum \\met."},
],
}
]
def test_unescape_markup_removes_slashes():
assert unescape_markup("Lorem \\*Ipsum\\*") == "Lorem *Ipsum*"
| 1,271
|
Python
|
.py
| 38
| 23.710526
| 66
| 0.469388
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,627
|
test_autolink.py
|
rafalp_Misago/misago/parser/tests/test_autolink.py
|
def test_autolink(parse_markup):
result = parse_markup("Hello <https://image.com/>!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "auto-link",
"image": False,
"href": "https://image.com/",
},
{"type": "text", "text": "!"},
],
}
]
def test_autolink_image(parse_markup):
result = parse_markup("Hello <!https://image.com/>!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "auto-link",
"image": True,
"href": "https://image.com/",
},
{"type": "text", "text": "!"},
],
}
]
def test_autolink_invalid_url(parse_markup):
result = parse_markup("Hello <!invalid-url>!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello <!invalid-url>!"},
],
}
]
def test_autolink_image_email_url(parse_markup):
result = parse_markup("Hello <!lorem@ipsum.com>!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello <!lorem@ipsum.com>!"},
],
}
]
def test_autolink_in_url_is_not_parsed(parse_markup):
result = parse_markup("Hello [<!https://image.com/>](https://image.com/)!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://image.com/",
"children": [
{"type": "text", "text": "<!https://image.com/>"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_autolink_in_url_bbcode_is_not_parsed(parse_markup):
result = parse_markup("Hello [url=https://image.com/]<!https://image.com/>[/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url-bbcode",
"href": "https://image.com/",
"children": [
{"type": "text", "text": "<!https://image.com/>"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_auto_url(parse_markup):
result = parse_markup("Hello https://image.com/ !")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "auto-url",
"href": "https://image.com/",
},
{"type": "text", "text": " !"},
],
}
]
| 3,235
|
Python
|
.py
| 103
| 18.951456
| 87
| 0.377885
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,628
|
test_code_bbcode.py
|
rafalp_Misago/misago/parser/tests/test_code_bbcode.py
|
def test_code_bbcode_can_be_one_liner(parse_markup):
result = parse_markup(
"""
[code]alert("hello!")[/code]
"""
)
assert result == [
{
"type": "code-bbcode",
"syntax": None,
"code": 'alert("hello!")',
}
]
def test_code_bbcode_can_be_multiline(parse_markup):
result = parse_markup(
"""
[code]
alert("hello!")
alert("world!")
[/code]
"""
)
assert result == [
{
"type": "code-bbcode",
"syntax": None,
"code": 'alert("hello!")\nalert("world!")',
}
]
def test_code_bbcode_dedents_content(parse_markup):
result = parse_markup(
"""
[code]
alert("hello!")
alert("world!")
[/code]
"""
)
assert result == [
{
"type": "code-bbcode",
"syntax": None,
"code": 'alert("hello!")\nalert("world!")',
}
]
def test_code_bbcode_trims_content(parse_markup):
result = parse_markup(
"""
[code]
alert("hello!")
alert("world!")
[/code]
"""
)
assert result == [
{
"type": "code-bbcode",
"syntax": None,
"code": 'alert("hello!")\nalert("world!")',
}
]
def test_code_bbcode_supports_syntax(parse_markup):
result = parse_markup(
"""
[code=python]
alert("hello!")
alert("world!")
[/code]
"""
)
assert result == [
{
"type": "code-bbcode",
"syntax": "python",
"code": 'alert("hello!")\nalert("world!")',
}
]
def test_code_bbcode_trims_syntax(parse_markup):
result = parse_markup(
"""
[code= python ]
alert("hello!")
alert("world!")
[/code]
"""
)
assert result == [
{
"type": "code-bbcode",
"syntax": "python",
"code": 'alert("hello!")\nalert("world!")',
}
]
def test_code_bbcode_trims_syntax_quotes(parse_markup):
result = parse_markup(
"""
[code=" python "]
alert("hello!")
alert("world!")
[/code]
"""
)
assert result == [
{
"type": "code-bbcode",
"syntax": "python",
"code": 'alert("hello!")\nalert("world!")',
}
]
def test_code_bbcode_trims_syntax_single_quotes(parse_markup):
result = parse_markup(
"""
[code=' python ']
alert("hello!")
alert("world!")
[/code]
"""
)
assert result == [
{
"type": "code-bbcode",
"syntax": "python",
"code": 'alert("hello!")\nalert("world!")',
}
]
def test_code_bbcode_can_be_mixed_with_other_blocks(parse_markup):
result = parse_markup(
"""
Here is the code:
[code]
1 + 3
[/code]
It's cool!
"""
)
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Here is the code:"}],
},
{
"type": "code-bbcode",
"syntax": None,
"code": "1 + 3",
},
{
"type": "paragraph",
"children": [{"type": "text", "text": "It's cool!"}],
},
]
def test_code_bbcode_can_be_used_next_to_each_other(parse_markup):
result = parse_markup(
"""
Here is the code:
[code]
1 + 3
[/code][code]
5 x 3
[/code]
It's cool!
"""
)
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Here is the code:"}],
},
{
"type": "code-bbcode",
"syntax": None,
"code": "1 + 3",
},
{
"type": "code-bbcode",
"syntax": None,
"code": "5 x 3",
},
{
"type": "paragraph",
"children": [{"type": "text", "text": "It's cool!"}],
},
]
| 4,247
|
Python
|
.py
| 182
| 14.587912
| 72
| 0.419985
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,629
|
test_spoiler_bbcode.py
|
rafalp_Misago/misago/parser/tests/test_spoiler_bbcode.py
|
def test_spoiler_bbcode(parse_markup):
result = parse_markup("[spoiler]Hello world![/spoiler]")
assert result == [
{
"type": "spoiler-bbcode",
"summary": None,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_spoiler_bbcode_with_empty_summary(parse_markup):
result = parse_markup("[spoiler=]Hello world![/spoiler]")
assert result == [
{
"type": "spoiler-bbcode",
"summary": None,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_spoiler_bbcode_with_summary(parse_markup):
result = parse_markup("[spoiler=Dune, part 2]Hello world![/spoiler]")
assert result == [
{
"type": "spoiler-bbcode",
"summary": "Dune, part 2",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_spoiler_bbcode_strips_quotations_and_spaces_from_summary(parse_markup):
result = parse_markup('[spoiler=" Dune, part 2 "]Hello world![/spoiler]')
assert result == [
{
"type": "spoiler-bbcode",
"summary": "Dune, part 2",
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Hello world!"}],
},
],
},
]
def test_empty_spoiler_bbcode_is_removed_from_result(parse_markup):
result = parse_markup("Lorem ipsum.[spoiler][/spoiler]")
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Lorem ipsum."}],
},
]
def test_spoiler_bbcode_next_to_paragraph_is_parsed(parse_markup):
result = parse_markup("Lorem ipsum.[spoiler]Dolor met![/spoiler]")
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Lorem ipsum."}],
},
{
"type": "spoiler-bbcode",
"summary": None,
"children": [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Dolor met!"}],
},
],
},
]
| 2,634
|
Python
|
.py
| 82
| 20.853659
| 80
| 0.444138
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,630
|
test_html.py
|
rafalp_Misago/misago/parser/tests/test_html.py
|
import pytest
from ..html import complete_markup_html, render_ast_to_html
from ..metadata import create_ast_metadata
@pytest.mark.parametrize(
"markup",
(
"# Hello world!",
"## Hello world!",
"### Hello world!",
"#### Hello world!",
"##### Hello world!",
"###### Hello world!",
),
)
def test_render_ast_to_html_heading(markup, parser_context, parse_markup, snapshot):
ast = parse_markup(markup)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
@pytest.mark.parametrize(
"markup",
(
"Hello world!\n=====",
"Hello world!\n-----",
),
)
def test_render_ast_to_html_setex_heading(
markup, parser_context, parse_markup, snapshot
):
ast = parse_markup(markup)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_quote(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
> Hello world!
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_quote_bbcode(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
[quote]Hello world![/quote]
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_quote_bbcode_with_author(
parser_context, parse_markup, snapshot
):
ast = parse_markup(
"""
[quote=Author]Hello world![/quote]
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_unordered_list(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
- Lorem
- _Ipsum_
- Dolor
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_ordered_list(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
1. Lorem
2. _Ipsum_
3. Dolor
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_unordered_list_with_nested_list(
parser_context, parse_markup, snapshot
):
ast = parse_markup(
"""
- Lorem
- _Ipsum_
- Met
- Elit
- Dolor
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_spoiler(parser_context, parse_markup, snapshot):
ast = parse_markup("[spoiler]Hello world![/spoiler]")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_spoiler_with_summary(
parser_context, parse_markup, snapshot
):
ast = parse_markup("[spoiler=Secret message]Hello world![/spoiler]")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_paragraph(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello world!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_two_paragraphs(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello world!\n\nHow's going?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_thematic_break(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello world!\n- - -\nHow's going?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_thematic_break_bbcode(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello world!\n[hr]\nHow's going?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_code(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
```
if random.randint(0, 10) > 4:
print("Gotcha!")
return True
return False
```
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_code_with_syntax(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
```python
if random.randint(0, 10) > 4:
print("Gotcha!")
return True
return False
```
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_code_bbcode(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
[code]
if random.randint(0, 10) > 4:
print("Gotcha!")
return True
return False
[/code]
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_code_bbcode_with_syntax(
parser_context, parse_markup, snapshot
):
ast = parse_markup(
"""
[code=python]
if random.randint(0, 10) > 4:
print("Gotcha!")
return True
return False
[/code]
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_code_indented(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
Hello:
if random.randint(0, 10) > 4:
print("Gotcha!")
return True
return False
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_inline_code(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello `world`!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_emphasis_text(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello *world*!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_emphasis_underscore_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello _world_!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_strong_text(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello **world**!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_strikethrough_text(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello ~~world~~!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_bold_bbcode_text(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello [b]world[/b]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_italics_bbcode_text(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello [i]world[/i]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_underline_bbcode_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello [u]world[/u]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_strikethrough_bbcode_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello [s]world[/s]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_superscript_bbcode_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello [sup]world[/sup]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_subscript_bbcode_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello [sub]world[/sub]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_escaped_characters(parser_context, parse_markup, snapshot):
ast = parse_markup(r"Hello\[hr\]World!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_soft_linebreak(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello world!\nHow's going?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_image_auto_link(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See the logo: <!https://misago-project.org/img.png>")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_image(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See the logo: !(https://misago-project.org/img.png)")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_image_with_alt_text(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See the logo: ")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_image_bbcode(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See the logo: [img]https://misago-project.org/img.png[/img]")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_image_bbcode_with_alt_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup(
f"See the logo: [img=https://misago-project.org/img.png]Alt text[/img]"
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_url(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See [*the site*](https://misago-project.org)!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_url_bbcode(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See [url]https://misago-project.org[/url]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_url_bbcode_with_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See [url=https://misago-project.org]*the site*[/url]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_auto_link(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See the site: <https://misago-project.org>")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_auto_url(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See the site: https://misago-project.org")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_mention(parser_context, parse_markup, snapshot, user):
user.id = 1000
user.set_username("MentionedUser")
user.set_email("mentioned@example.com")
user.save()
ast = parse_markup(f"How's going, @{user.username}?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_mention_non_existing_user(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"How's going, @JohnDoe?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_html(parser_context, ast, metadata)
def test_render_ast_to_html_for_unsupported_ast_raises_error(parser_context):
with pytest.raises(ValueError):
metadata = create_ast_metadata(parser_context, [])
render_ast_to_html(parser_context, [{"type": "unsupported"}], metadata)
def test_complete_markup_html_replaces_default_spoiler_summary(
parser_context, parse_markup, snapshot
):
ast = parse_markup("[spoiler]Hello world![/spoiler]")
metadata = create_ast_metadata(parser_context, ast)
html = render_ast_to_html(parser_context, ast, metadata)
assert snapshot == complete_markup_html(html)
| 14,325
|
Python
|
.py
| 318
| 39.358491
| 88
| 0.690267
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,631
|
test_parser.py
|
rafalp_Misago/misago/parser/tests/test_parser.py
|
from textwrap import dedent
from ..parser import Parser
def parse(value: str) -> list[dict]:
return Parser()(dedent(value).strip())
def test_parser_parses_single_paragraph():
result = parse("Hello world!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello world!"},
],
}
]
def test_parser_parses_two_paragraphs():
result = parse("First paragraph.\n\nSecond paragraph.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "First paragraph."},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Second paragraph."},
],
},
]
def test_parser_parses_skips_extra_linebreaks_between_blocks():
result = parse("First paragraph.\n\n\n\nSecond paragraph.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "First paragraph."},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Second paragraph."},
],
},
]
def test_parser_parses_skips_whitespace_between_paragraphs():
result = parse("First paragraph.\n \nSecond paragraph.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "First paragraph."},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Second paragraph."},
],
},
]
def test_parser_parses_skips_tabs_between_paragraphs():
result = parse("First paragraph.\n\t\nSecond paragraph.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "First paragraph."},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Second paragraph."},
],
},
]
def test_parser_parses_line_breaks():
result = parse("Paragraph with\na line break.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Paragraph with"},
{"type": "line-break"},
{"type": "text", "text": "a line break."},
],
},
]
def test_parser_parses_line_breaks_surrounded_by_spaces():
result = parse("Paragraph with \n a line break.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Paragraph with"},
{"type": "line-break"},
{"type": "text", "text": "a line break."},
],
},
]
| 3,032
|
Python
|
.py
| 102
| 19.735294
| 63
| 0.452798
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,632
|
test_template_tags.py
|
rafalp_Misago/misago/parser/tests/test_template_tags.py
|
from django.template import Context, Template
from ..html import complete_markup_html, render_ast_to_html
from ..metadata import create_ast_metadata
def render(template_str, context: dict | None = None):
base_template = "{%% load misago_markup %%} %s"
context = Context(context or {})
template = Template(base_template % template_str)
return template.render(context).strip()
def test_complete_markup_template_tag_replaces_default_spoiler_summary(
parser_context, parse_markup, snapshot
):
ast = parse_markup("[spoiler]Hello world![/spoiler]")
metadata = create_ast_metadata(parser_context, ast)
html = render_ast_to_html(parser_context, ast, metadata)
assert snapshot == render("{% completemarkup html %}", {"html": html})
| 764
|
Python
|
.py
| 15
| 47.2
| 74
| 0.731183
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,633
|
test_context.py
|
rafalp_Misago/misago/parser/tests/test_context.py
|
from unittest.mock import Mock
import pytest
from ...permissions.proxy import UserPermissionsProxy
from ..context import create_parser_context
def test_create_parser_context_creates_context_from_request(
dynamic_settings, cache_versions, user
):
request = Mock(
settings=dynamic_settings,
cache_versions=cache_versions,
user=user,
user_permissions=UserPermissionsProxy(user, cache_versions),
)
context = create_parser_context(request)
assert context.request is request
assert context.forum_address
assert context.user is request.user
assert context.user_permissions is request.user_permissions
assert context.settings is dynamic_settings
assert context.cache_versions is cache_versions
def test_create_parser_context_creates_context_with_empty_content_type(
dynamic_settings, cache_versions, user
):
request = Mock(
settings=dynamic_settings,
cache_versions=cache_versions,
user=user,
user_permissions=UserPermissionsProxy(user, cache_versions),
)
context = create_parser_context(request)
assert context.content_type is None
def test_create_parser_context_creates_context_with_given_content_type(
dynamic_settings, cache_versions, user
):
request = Mock(
settings=dynamic_settings,
cache_versions=cache_versions,
user=user,
user_permissions=UserPermissionsProxy(user, cache_versions),
)
context = create_parser_context(request, content_type="TEST")
assert context.content_type == "TEST"
def test_create_parser_context_creates_context_with_empty_plugin_data(
dynamic_settings, cache_versions, user
):
request = Mock(
settings=dynamic_settings,
cache_versions=cache_versions,
user=user,
user_permissions=UserPermissionsProxy(user, cache_versions),
)
context = create_parser_context(request)
assert context.plugin_data == {}
def test_create_parser_context_creates_context_without_request(
dynamic_settings, cache_versions, user
):
user_permissions = UserPermissionsProxy(user, cache_versions)
context = create_parser_context(
user_permissions=user_permissions,
settings=dynamic_settings,
cache_versions=cache_versions,
)
assert context.request is None
assert context.forum_address
assert context.user is user
assert context.user_permissions is user_permissions
assert context.settings is dynamic_settings
assert context.cache_versions is cache_versions
def test_create_parser_context_creates_context_with_explicit_user_permissions(
dynamic_settings, cache_versions, user, other_user
):
request = Mock(
settings=dynamic_settings,
cache_versions=cache_versions,
user=user,
user_permissions=UserPermissionsProxy(user, cache_versions),
)
other_user_permissions = UserPermissionsProxy(other_user, cache_versions)
context = create_parser_context(request, user_permissions=other_user_permissions)
assert context.user is other_user
assert context.user_permissions is other_user_permissions
def test_create_parser_context_raises_error_if_user_permissions_is_missing(
dynamic_settings, cache_versions
):
with pytest.raises(TypeError):
create_parser_context(
settings=dynamic_settings,
cache_versions=cache_versions,
)
def test_create_parser_context_raises_error_if_settings_is_missing(
dynamic_settings, cache_versions, user
):
user_permissions = UserPermissionsProxy(user, cache_versions)
with pytest.raises(TypeError):
create_parser_context(
user_permissions=user_permissions,
cache_versions=cache_versions,
)
def test_create_parser_context_raises_error_if_cache_versions_is_missing(
dynamic_settings, cache_versions, user
):
user_permissions = UserPermissionsProxy(user, cache_versions)
with pytest.raises(TypeError):
create_parser_context(
user_permissions=user_permissions,
dynamic_settings=dynamic_settings,
)
| 4,136
|
Python
|
.py
| 107
| 32.672897
| 85
| 0.73775
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,634
|
test_urls.py
|
rafalp_Misago/misago/parser/tests/test_urls.py
|
def test_url(parse_markup):
result = parse_markup("Hello [link label](https://image.com/)!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://image.com/",
"children": [
{"type": "text", "text": "link label"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_with_image_with_alt_markdown(parse_markup):
result = parse_markup(
"Hello [](https://image.com/)!"
)
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://image.com/",
"children": [
{
"type": "image",
"alt": "Image Alt",
"src": "https://image.com/image.jpg",
},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_two_urls_with_image_with_alt_markdown(parse_markup):
result = parse_markup(
"Hello [](https://image.com/) "
"[Image: ](https://other.com/)!"
)
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://image.com/",
"children": [
{
"type": "image",
"alt": "Image Alt",
"src": "https://image.com/image.jpg",
},
],
},
{"type": "text", "text": " "},
{
"type": "url",
"href": "https://other.com/",
"children": [
{"type": "text", "text": "Image: "},
{
"type": "image",
"alt": "Image Other",
"src": "https://image.com/other.jpg",
},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_with_parenthesis(parse_markup):
result = parse_markup("Hello [link label](https://example.com/Link_(Film))!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://example.com/Link_(Film)",
"children": [
{"type": "text", "text": "link label"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_with_multiple_parenthesis(parse_markup):
result = parse_markup(
"Hello [link label](https://example.com/Link_(Film)_(Comedy))!"
)
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://example.com/Link_(Film)_(Comedy)",
"children": [
{"type": "text", "text": "link label"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_with_nested_parenthesis(parse_markup):
result = parse_markup(
"Hello [link label](https://example.com/Link_(Film_(Comedy)))!"
)
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://example.com/Link_(Film_(Comedy))",
"children": [
{"type": "text", "text": "link label"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_with_missing_closing_parenthesis_is_trimmed_to_last_one(parse_markup):
result = parse_markup("Hello [link label](https://example.com/Link_(Film_(Comedy)!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://example.com/Link_(Film_(Comedy",
"children": [
{"type": "text", "text": "link label"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_with_missing_closing_parenthesis_next_to_other_url(parse_markup):
result = parse_markup(
"Hello [link label](https://example.com/link "
"[other link](https://example.com/other)!"
)
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello [link label]("},
{
"type": "auto-url",
"href": "https://example.com/link",
},
{"type": "text", "text": " "},
{
"type": "url",
"href": "https://example.com/other",
"children": [
{"type": "text", "text": "other link"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_with_extra_closing_parenthesis_excludes_them(parse_markup):
result = parse_markup("Hello [link label](https://example.com/Link_(Film)))!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://example.com/Link_(Film)",
"children": [
{"type": "text", "text": "link label"},
],
},
{"type": "text", "text": ")!"},
],
}
]
def test_image_between_two_urls(parse_markup):
result = parse_markup(
"Hello [Lorem](https://image.com/) "
" "
"[Ipsum](https://other.com/)!"
)
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://image.com/",
"children": [{"type": "text", "text": "Lorem"}],
},
{"type": "text", "text": " "},
{
"type": "image",
"alt": "Image Alt",
"src": "https://image.com/image.jpg",
},
{"type": "text", "text": " "},
{
"type": "url",
"href": "https://other.com/",
"children": [{"type": "text", "text": "Ipsum"}],
},
{"type": "text", "text": "!"},
],
}
]
def test_image_before_url(parse_markup):
result = parse_markup(
"Hello  "
"[Lorem](https://image.com/)!"
)
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image",
"alt": "Image Alt",
"src": "https://image.com/image.jpg",
},
{"type": "text", "text": " "},
{
"type": "url",
"href": "https://image.com/",
"children": [{"type": "text", "text": "Lorem"}],
},
{"type": "text", "text": "!"},
],
}
]
def test_image_after_url(parse_markup):
result = parse_markup(
"Hello [Lorem](https://image.com/) "
"!"
)
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url",
"href": "https://image.com/",
"children": [{"type": "text", "text": "Lorem"}],
},
{"type": "text", "text": " "},
{
"type": "image",
"alt": "Image Alt",
"src": "https://image.com/image.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_url_bbcode(parse_markup):
result = parse_markup("Hello [url]https://image.com/img.jpg[/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url-bbcode",
"href": "https://image.com/img.jpg",
"children": [],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_bbcode_url_whitespace_is_stripped(parse_markup):
result = parse_markup("Hello [url] https://image.com/img.jpg [/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url-bbcode",
"href": "https://image.com/img.jpg",
"children": [],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_bbcode_with_invalid_url(parse_markup):
result = parse_markup("Hello [url] invalid url [/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello [url] invalid url [/url]!"},
],
}
]
def test_url_bbcode_with_email_url(parse_markup):
result = parse_markup("Hello [url]lorem@ipsum.com[/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url-bbcode",
"href": "mailto:lorem@ipsum.com",
"children": [],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_bbcode_with_empty_url(parse_markup):
result = parse_markup("Hello [url] [/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello [url] [/url]!"},
],
}
]
def test_url_bbcode_with_children(parse_markup):
result = parse_markup("Hello [url=example.com]Alt text[/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url-bbcode",
"href": "example.com",
"children": [
{"type": "text", "text": "Alt text"},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_bbcode_with_children_empty_url(parse_markup):
result = parse_markup("Hello [url=]Alt text[/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello [url=]Alt text[/url]!"},
],
}
]
def test_url_bbcode_with_children_invalid_url(parse_markup):
result = parse_markup("Hello [url=invalid url]Alt text[/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello [url=invalid url]Alt text[/url]!"},
],
}
]
def test_url_bbcode_children_are_parsed(parse_markup):
result = parse_markup("Hello [url=example.com]Alt **text**[/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "url-bbcode",
"href": "example.com",
"children": [
{"type": "text", "text": "Alt "},
{
"type": "strong",
"children": [
{"type": "text", "text": "text"},
],
},
],
},
{"type": "text", "text": "!"},
],
}
]
def test_url_bbcode_with_empty_children(parse_markup):
result = parse_markup("Hello [url=example.com][/url]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello [url=example.com][/url]!"},
],
}
]
| 14,033
|
Python
|
.py
| 422
| 19.338863
| 88
| 0.365097
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,635
|
test_quote.py
|
rafalp_Misago/misago/parser/tests/test_quote.py
|
def test_empty_quote_is_removed(parse_markup):
result = parse_markup("> ")
assert result == []
def test_single_line_quote(parse_markup):
result = parse_markup("> Lorem ipsum")
assert result == [
{
"type": "quote",
"children": [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum"},
],
},
],
}
]
def test_multi_line_quote(parse_markup):
result = parse_markup("> Lorem ipsum\n> Dolor met")
assert result == [
{
"type": "quote",
"children": [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum"},
{"type": "line-break"},
{"type": "text", "text": "Dolor met"},
],
},
],
}
]
def test_multi_paragraph_quote(parse_markup):
result = parse_markup("> Lorem ipsum\n>\n> Dolor met")
assert result == [
{
"type": "quote",
"children": [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum"},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Dolor met"},
],
},
],
}
]
def test_nested_quote(parse_markup):
result = parse_markup("> Lorem ipsum\n> > Sit amet\n> Dolor met")
assert result == [
{
"type": "quote",
"children": [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Lorem ipsum"},
],
},
{
"type": "quote",
"children": [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Sit amet"},
],
},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Dolor met"},
],
},
],
}
]
| 2,664
|
Python
|
.py
| 88
| 14.818182
| 69
| 0.311916
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,636
|
test_inline_code.py
|
rafalp_Misago/misago/parser/tests/test_inline_code.py
|
def test_inline_code(parse_markup):
result = parse_markup("Hello `world`.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{"type": "code-inline", "code": "world"},
{"type": "text", "text": "."},
],
}
]
def test_multiple_inline_code(parse_markup):
result = parse_markup("Hello `world`, how's `going`?")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{"type": "code-inline", "code": "world"},
{"type": "text", "text": ", how's "},
{"type": "code-inline", "code": "going"},
{"type": "text", "text": "?"},
],
}
]
def test_inline_code_linebreak_is_replaced_with_space(parse_markup):
result = parse_markup("Hello `lorem\nipsum`.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{"type": "code-inline", "code": "lorem ipsum"},
{"type": "text", "text": "."},
],
}
]
def test_inline_code_linebreaks_are_replaced_with_single_space(parse_markup):
result = parse_markup("Hello `lorem\n\n\n\nipsum`.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{"type": "code-inline", "code": "lorem ipsum"},
{"type": "text", "text": "."},
],
}
]
def test_inline_code_content_is_skipped_by_block_parser(parse_markup):
result = parse_markup("Hello `[quote]Text[/quote]`.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{"type": "code-inline", "code": "[quote]Text[/quote]"},
{"type": "text", "text": "."},
],
}
]
def test_inline_code_content_is_skipped_by_inline_parser(parse_markup):
result = parse_markup("Hello `<http://misago-project.org>`.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{"type": "code-inline", "code": "<http://misago-project.org>"},
{"type": "text", "text": "."},
],
}
]
| 2,556
|
Python
|
.py
| 74
| 23.891892
| 79
| 0.441748
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,637
|
test_metadata.py
|
rafalp_Misago/misago/parser/tests/test_metadata.py
|
from ..metadata import create_ast_metadata
def test_create_ast_metadata_creates_metadata_for_empty_ast(parser_context):
metadata = create_ast_metadata(parser_context, [])
assert metadata["outbound-links"] == set()
assert metadata["usernames"] == set()
assert metadata["users"] == {}
def test_create_ast_metadata_creates_metadata_for_ast_with_mentions(
parser_context, user, other_user
):
metadata = create_ast_metadata(
parser_context,
[
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": f"Hello "},
{"type": "mention", "username": user.username},
{"type": "text", "text": f"!"},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": f"See "},
{"type": "mention", "username": other_user.username},
{"type": "text", "text": f"."},
],
},
{"type": "thematic-break"},
],
)
assert metadata["usernames"] == set([user.slug, other_user.slug])
assert metadata["users"] == {
user.slug: user,
other_user.slug: other_user,
}
def test_create_ast_metadata_handles_nonexisting_users_mentions(parser_context, user):
metadata = create_ast_metadata(
parser_context,
[
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": f"Hello "},
{"type": "mention", "username": user.username},
{"type": "text", "text": f"!"},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": f"See "},
{"type": "mention", "username": "Doesnt_Exist"},
{"type": "text", "text": f"."},
],
},
{"type": "thematic-break"},
],
)
assert metadata["usernames"] == set([user.slug, "doesnt-exist"])
assert metadata["users"] == {user.slug: user}
def test_create_ast_metadata_handles_repeated_users_mentions(parser_context, user):
metadata = create_ast_metadata(
parser_context,
[
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": f"Hello "},
{"type": "mention", "username": user.username},
{"type": "text", "text": f"!"},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": f"See "},
{"type": "mention", "username": user.username},
{"type": "text", "text": f"."},
],
},
{"type": "thematic-break"},
],
)
assert metadata["usernames"] == set([user.slug])
assert metadata["users"] == {user.slug: user}
def test_create_ast_metadata_normalizes_mentioned_users_names(parser_context, user):
metadata = create_ast_metadata(
parser_context,
[
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": f"Hello "},
{"type": "mention", "username": user.username.upper()},
{"type": "text", "text": f"!"},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": f"See "},
{"type": "mention", "username": user.username.lower()},
{"type": "text", "text": f"."},
],
},
{"type": "thematic-break"},
],
)
assert metadata["usernames"] == set([user.slug])
assert metadata["users"] == {user.slug: user}
def test_create_ast_metadata_includes_an_outbound_link(parser_context):
metadata = create_ast_metadata(
parser_context,
[
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": "Hello!"},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "See "},
{
"type": "url",
"href": "my-website.com",
"children": [{"type": "text", "text": "my homepage"}],
},
{"type": "text", "text": "!"},
],
},
{"type": "thematic-break"},
],
)
assert metadata["outbound-links"] == set(["my-website.com"])
def test_create_ast_metadata_outbound_links_excludes_inbound_link(parser_context):
metadata = create_ast_metadata(
parser_context,
[
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": "Hello!"},
],
},
{
"type": "paragraph",
"children": [
{"type": "text", "text": "See "},
{
"type": "url",
"href": "example.org/t/123/",
"children": [{"type": "text", "text": "this thread"}],
},
{"type": "text", "text": "!"},
],
},
{"type": "thematic-break"},
],
)
assert metadata["outbound-links"] == set()
def test_create_ast_metadata_visits_lists_items(parser_context, user):
metadata = create_ast_metadata(
parser_context,
[
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": "Hello!"},
],
},
{
"type": "list",
"ordered": False,
"sign": "+",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem ",
},
{"type": "mention", "username": user.username},
],
"lists": [],
},
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
],
"lists": [],
},
],
},
],
)
assert metadata["usernames"] == set([user.slug])
assert metadata["users"] == {user.slug: user}
def test_create_ast_metadata_visits_nested_lists_items(parser_context, user):
metadata = create_ast_metadata(
parser_context,
[
{
"type": "heading",
"level": 1,
"children": [
{"type": "text", "text": "Hello!"},
],
},
{
"type": "list",
"ordered": False,
"sign": "-",
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Lorem ",
},
],
"lists": [
{
"type": "list",
"ordered": True,
"sign": None,
"items": [
{
"type": "list-item",
"children": [
{
"type": "text",
"text": "Ipsum",
},
{
"type": "mention",
"username": user.username,
},
],
"lists": [],
},
],
}
],
},
],
},
],
)
assert metadata["usernames"] == set([user.slug])
assert metadata["users"] == {user.slug: user}
| 9,369
|
Python
|
.py
| 266
| 18.109023
| 86
| 0.335168
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,638
|
test_plaintext.py
|
rafalp_Misago/misago/parser/tests/test_plaintext.py
|
import pytest
from ..metadata import create_ast_metadata
from ..plaintext import PlainTextFormat, render_ast_to_plaintext
@pytest.mark.parametrize(
"markup",
(
"# Hello world!",
"## Hello world!",
"### Hello world!",
"#### Hello world!",
"##### Hello world!",
"###### Hello world!",
),
)
def test_render_ast_to_plaintext_heading(
markup, parser_context, parse_markup, snapshot
):
ast = parse_markup(markup)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
@pytest.mark.parametrize(
"markup",
(
"Hello world!\n=====",
"Hello world!\n-----",
),
)
def test_render_ast_to_plaintext_setex_heading(
markup, parser_context, parse_markup, snapshot
):
ast = parse_markup(markup)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_quote(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
> Hello world!
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_quote_bbcode(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
[quote]Hello world![/quote]
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_quote_bbcode_with_author(
parser_context, parse_markup, snapshot
):
ast = parse_markup(
"""
[quote=Author]Hello world![/quote]
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_unordered_list(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
- Lorem
- _Ipsum_
- Dolor
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_ordered_list(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
1. Lorem
2. _Ipsum_
3. Dolor
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_unordered_list_with_nested_list(
parser_context, parse_markup, snapshot
):
ast = parse_markup(
"""
- Lorem
- _Ipsum_
- Met
- Elit
- Dolor
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_spoiler(parser_context, parse_markup, snapshot):
ast = parse_markup("[spoiler]Hello world![/spoiler]")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_spoiler_with_summary(
parser_context, parse_markup, snapshot
):
ast = parse_markup("[spoiler=Secret message]Hello world![/spoiler]")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_paragraph(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello world!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_two_paragraphs(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello world!\n\nHow's going?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_thematic_break(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello world!\n- - -\nHow's going?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_thematic_break_bbcode(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello world!\n[hr]\nHow's going?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_code(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
```
if random.randint(0, 10) > 4:
print("Gotcha!")
return True
return False
```
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_code_with_syntax(
parser_context, parse_markup, snapshot
):
ast = parse_markup(
"""
```python
if random.randint(0, 10) > 4:
print("Gotcha!")
return True
return False
```
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_code_bbcode(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
[code]
if random.randint(0, 10) > 4:
print("Gotcha!")
return True
return False
[/code]
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_code_bbcode_with_syntax(
parser_context, parse_markup, snapshot
):
ast = parse_markup(
"""
[code=python]
if random.randint(0, 10) > 4:
print("Gotcha!")
return True
return False
[/code]
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_code_indented(parser_context, parse_markup, snapshot):
ast = parse_markup(
"""
Hello:
if random.randint(0, 10) > 4:
print("Gotcha!")
return True
return False
"""
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_inline_code(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello `world`!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_emphasis_text(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello *world*!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_emphasis_underscore_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello _world_!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_strong_text(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello **world**!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_strikethrough_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello ~~world~~!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_bold_bbcode_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello [b]world[/b]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_italics_bbcode_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello [i]world[/i]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_underline_bbcode_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello [u]world[/u]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_strikethrough_bbcode_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello [s]world[/s]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_superscript_bbcode_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello [sup]world[/sup]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_subscript_bbcode_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup("Hello [sub]world[/sub]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_escaped_characters(
parser_context, parse_markup, snapshot
):
ast = parse_markup(r"Hello\[hr\]World!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_soft_linebreak(parser_context, parse_markup, snapshot):
ast = parse_markup("Hello world!\nHow's going?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_image_auto_link(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See the logo: <!https://misago-project.org/img.png>")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_image(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See the logo: !(https://misago-project.org/img.png)")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_image_with_alt_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See the logo: ")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_image_bbcode(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See the logo: [img]https://misago-project.org/img.png[/img]")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_image_bbcode_with_alt_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup(
f"See the logo: [img=https://misago-project.org/img.png]Alt text[/img]"
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_image_auto_link_meta_description(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See the logo: <!https://misago-project.org/img.png>")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
def test_render_ast_to_plaintext_image_meta_description(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See the logo: !(https://misago-project.org/img.png)")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
def test_render_ast_to_plaintext_image_with_alt_text_meta_description(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See the logo: ")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
def test_render_ast_to_plaintext_image_bbcode_meta_description(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See the logo: [img]https://misago-project.org/img.png[/img]")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
def test_render_ast_to_plaintext_image_bbcode_with_alt_text_meta_description(
parser_context, parse_markup, snapshot
):
ast = parse_markup(
f"See the logo: [img=https://misago-project.org/img.png]Alt text[/img]"
)
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
def test_render_ast_to_plaintext_url(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See [*the site*](https://misago-project.org)!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_url_bbcode(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See [url]https://misago-project.org[/url]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_url_bbcode_with_text(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See [url=https://misago-project.org]*the site*[/url]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_auto_link(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See the site: <https://misago-project.org>")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_auto_url(parser_context, parse_markup, snapshot):
ast = parse_markup(f"See the site: https://misago-project.org")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_url_meta_description(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See [*the site*](https://misago-project.org)!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
def test_render_ast_to_plaintext_url_bbcode_meta_description(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See [url]https://misago-project.org[/url]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
def test_render_ast_to_plaintext_url_bbcode_with_text_meta_description(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See [url=https://misago-project.org]*the site*[/url]!")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
def test_render_ast_to_plaintext_auto_link_meta_description(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See the site: <https://misago-project.org>")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
def test_render_ast_to_plaintext_auto_url_meta_description(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"See the site: https://misago-project.org")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
def test_render_ast_to_plaintext_mention(parser_context, parse_markup, snapshot, user):
user.id = 1000
user.set_username("MentionedUser")
user.set_email("mentioned@example.com")
user.save()
ast = parse_markup(f"How's going, @{user.username}?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_mention_non_existing_user(
parser_context, parse_markup, snapshot
):
ast = parse_markup(f"How's going, @JohnDoe?")
metadata = create_ast_metadata(parser_context, ast)
assert snapshot == render_ast_to_plaintext(parser_context, ast, metadata)
def test_render_ast_to_plaintext_for_unsupported_ast_raises_error(parser_context):
with pytest.raises(ValueError):
metadata = create_ast_metadata(parser_context, [])
render_ast_to_plaintext(parser_context, [{"type": "unsupported"}], metadata)
def test_render_ast_to_plaintext_meta_description_removes_new_lines(
parser_context, parse_markup
):
ast = parse_markup(f"Lorem ipsum\nDolor met")
metadata = create_ast_metadata(parser_context, ast)
assert (
render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.META_DESCRIPTION,
)
== "Lorem ipsum Dolor met"
)
def test_render_ast_to_plaintext_search_document_removes_new_lines(
parser_context, parse_markup
):
ast = parse_markup(f"Lorem ipsum\nDolor met")
metadata = create_ast_metadata(parser_context, ast)
assert (
render_ast_to_plaintext(
parser_context,
ast,
metadata,
PlainTextFormat.SEARCH_DOCUMENT,
)
== "Lorem ipsum Dolor met"
)
| 19,338
|
Python
|
.py
| 467
| 35.610278
| 88
| 0.692332
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,639
|
test_inline_markdown.py
|
rafalp_Misago/misago/parser/tests/test_inline_markdown.py
|
import pytest
def test_emphasis_whole_word(parse_markup):
result = parse_markup(f"Hello *word*.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "emphasis",
"children": [{"type": "text", "text": "word"}],
},
{"type": "text", "text": "."},
],
}
]
def test_emphasis_two_words(parse_markup):
result = parse_markup(f"Hello *two words*.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "emphasis",
"children": [{"type": "text", "text": "two words"}],
},
{"type": "text", "text": "."},
],
}
]
def test_emphasis_word_start(parse_markup):
result = parse_markup(f"Hello *lorem*ipsum.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "emphasis",
"children": [{"type": "text", "text": "lorem"}],
},
{"type": "text", "text": "ipsum."},
],
}
]
def test_emphasis_word_part(parse_markup):
result = parse_markup(f"Hello lo*rem*ipsum.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello lo"},
{
"type": "emphasis",
"children": [{"type": "text", "text": "rem"}],
},
{"type": "text", "text": "ipsum."},
],
}
]
def test_emphasis_word_end(parse_markup):
result = parse_markup(f"Hello lorem*ipsum*.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello lorem"},
{
"type": "emphasis",
"children": [{"type": "text", "text": "ipsum"}],
},
{"type": "text", "text": "."},
],
}
]
def test_emphasis_two_word_parts(parse_markup):
result = parse_markup(f"Hello lo*rem*i*ps*um.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello lo"},
{
"type": "emphasis",
"children": [{"type": "text", "text": "rem"}],
},
{"type": "text", "text": "i"},
{
"type": "emphasis",
"children": [{"type": "text", "text": "ps"}],
},
{"type": "text", "text": "um."},
],
}
]
def test_emphasis_first_word_is_parsed_correctly(parse_markup):
result = parse_markup(f"*Hello* world.")
assert result == [
{
"type": "paragraph",
"children": [
{
"type": "emphasis",
"children": [{"type": "text", "text": "Hello"}],
},
{"type": "text", "text": " world."},
],
}
]
def test_emphasis_without_content_is_skipped(parse_markup):
result = parse_markup(f"Hello **.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello **."},
],
}
]
def test_emphasis_with_only_whitespaces_is_skipped(parse_markup):
result = parse_markup(f"Hello * *.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello * *."},
],
}
]
def test_emphasis_containing_strong_underscore(parse_markup):
result = parse_markup(f"Hello *__world__*.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "emphasis",
"children": [
{
"type": "strong-underscore",
"children": [{"type": "text", "text": "world"}],
},
],
},
{"type": "text", "text": "."},
],
}
]
def test_emphasis_containing_emphasis_underscore_is_unwrapped(parse_markup):
result = parse_markup(f"Hello *_world_*.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "emphasis",
"children": [{"type": "text", "text": "world"}],
},
{"type": "text", "text": "."},
],
}
]
def test_strong_whole_word(parse_markup):
result = parse_markup(f"Hello **word**.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strong",
"children": [{"type": "text", "text": "word"}],
},
{"type": "text", "text": "."},
],
}
]
def test_strong_two_words(parse_markup):
result = parse_markup(f"Hello **two words**.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strong",
"children": [{"type": "text", "text": "two words"}],
},
{"type": "text", "text": "."},
],
}
]
def test_strong_word_start(parse_markup):
result = parse_markup(f"Hello **lorem**ipsum.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strong",
"children": [{"type": "text", "text": "lorem"}],
},
{"type": "text", "text": "ipsum."},
],
}
]
def test_strong_word_part(parse_markup):
result = parse_markup(f"Hello lo**rem**ipsum.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello lo"},
{
"type": "strong",
"children": [{"type": "text", "text": "rem"}],
},
{"type": "text", "text": "ipsum."},
],
}
]
def test_strong_word_end(parse_markup):
result = parse_markup(f"Hello lorem**ipsum**.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello lorem"},
{
"type": "strong",
"children": [{"type": "text", "text": "ipsum"}],
},
{"type": "text", "text": "."},
],
}
]
def test_strong_two_word_parts(parse_markup):
result = parse_markup(f"Hello lo**rem**i**ps**um.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello lo"},
{
"type": "strong",
"children": [{"type": "text", "text": "rem"}],
},
{"type": "text", "text": "i"},
{
"type": "strong",
"children": [{"type": "text", "text": "ps"}],
},
{"type": "text", "text": "um."},
],
}
]
def test_strong_first_word_is_parsed_correctly(parse_markup):
result = parse_markup(f"**Hello** world.")
assert result == [
{
"type": "paragraph",
"children": [
{
"type": "strong",
"children": [{"type": "text", "text": "Hello"}],
},
{"type": "text", "text": " world."},
],
}
]
def test_strong_without_content_is_skipped(parse_markup):
result = parse_markup(f"Hello ****.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello ****."},
],
}
]
def test_strong_with_only_whitespaces_is_skipped(parse_markup):
result = parse_markup(f"Hello ** **.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello ** **."},
],
}
]
def test_strong_containing_emphasis_underscore(parse_markup):
result = parse_markup(f"Hello **_world_**.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strong",
"children": [
{
"type": "emphasis-underscore",
"children": [{"type": "text", "text": "world"}],
},
],
},
{"type": "text", "text": "."},
],
}
]
def test_strong_containing_strong_underscore_is_unwrapped(parse_markup):
result = parse_markup(f"Hello **__world__**.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strong",
"children": [{"type": "text", "text": "world"}],
},
{"type": "text", "text": "."},
],
}
]
VALID_UNDERSCORE = (
"world",
"two worlds",
"two_worlds",
"two__worlds",
"#words (with) symbols!",
)
@pytest.mark.parametrize("text", VALID_UNDERSCORE)
def test_emphasis_underscore(parse_markup, text):
result = parse_markup(f"Hello _{text}_.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "emphasis-underscore",
"children": [{"type": "text", "text": text}],
},
{"type": "text", "text": "."},
],
}
]
def test_emphasis_underscore_with_line_break(parse_markup):
result = parse_markup(f"Hello _lorem\nipsum_.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "emphasis-underscore",
"children": [
{"type": "text", "text": "lorem"},
{"type": "line-break"},
{"type": "text", "text": "ipsum"},
],
},
{"type": "text", "text": "."},
],
}
]
def test_emphasis_underscores_next_to_each_other(parse_markup):
result = parse_markup(f"Hello _lorem_ _ipsum_.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "emphasis-underscore",
"children": [{"type": "text", "text": "lorem"}],
},
{"type": "text", "text": " "},
{
"type": "emphasis-underscore",
"children": [{"type": "text", "text": "ipsum"}],
},
{"type": "text", "text": "."},
],
}
]
def test_emphasis_underscore_without_content_is_skipped(parse_markup):
result = parse_markup(f"Hello __.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello __."},
],
}
]
def test_emphasis_underscore_with_only_whitespaces_is_skipped(parse_markup):
result = parse_markup(f"Hello _ \n _.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello _"},
{"type": "line-break"},
{"type": "text", "text": "_."},
],
}
]
def test_emphasis_underscore_containing_strong(parse_markup):
result = parse_markup(f"Hello _**world**_.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "emphasis-underscore",
"children": [
{
"type": "strong",
"children": [{"type": "text", "text": "world"}],
},
],
},
{"type": "text", "text": "."},
],
}
]
def test_emphasis_underscore_containing_emphasis_is_unwrapped(parse_markup):
result = parse_markup(f"Hello _*world*_.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "emphasis-underscore",
"children": [{"type": "text", "text": "world"}],
},
{"type": "text", "text": "."},
],
}
]
INVALID_EMPHASIS_UNDERSCORE = (
"_lorem_ipsum",
"lorem_ips_um",
"lorem_ipsum_",
)
@pytest.mark.parametrize("text", INVALID_EMPHASIS_UNDERSCORE)
def test_emphasis_underscore_invalid_patterns(parse_markup, text):
result = parse_markup(f"Hello {text}.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": f"Hello {text}."},
],
}
]
@pytest.mark.parametrize("text", VALID_UNDERSCORE)
def test_strong_underscore(parse_markup, text):
result = parse_markup(f"Hello __{text}__.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strong-underscore",
"children": [{"type": "text", "text": text}],
},
{"type": "text", "text": "."},
],
}
]
def test_strong_underscore_with_line_break(parse_markup):
result = parse_markup(f"Hello __lorem\nipsum__.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strong-underscore",
"children": [
{"type": "text", "text": "lorem"},
{"type": "line-break"},
{"type": "text", "text": "ipsum"},
],
},
{"type": "text", "text": "."},
],
}
]
def test_strong_underscores_next_to_each_other(parse_markup):
result = parse_markup(f"Hello __lorem__ __ipsum__.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strong-underscore",
"children": [{"type": "text", "text": "lorem"}],
},
{"type": "text", "text": " "},
{
"type": "strong-underscore",
"children": [{"type": "text", "text": "ipsum"}],
},
{"type": "text", "text": "."},
],
}
]
def test_strong_underscores_without_content_is_skipped(parse_markup):
result = parse_markup(f"Hello ____.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello ____."},
],
}
]
def test_strong_underscores_with_whitespaces_only_is_skipped(parse_markup):
result = parse_markup(f"Hello __ \n __.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello __"},
{"type": "line-break"},
{"type": "text", "text": "__."},
],
}
]
def test_strong_underscore_containing_emphasis(parse_markup):
result = parse_markup(f"Hello __*world*__.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strong-underscore",
"children": [
{
"type": "emphasis",
"children": [{"type": "text", "text": "world"}],
},
],
},
{"type": "text", "text": "."},
],
}
]
def test_strong_underscore_containing_strong_is_unwrapped(parse_markup):
result = parse_markup(f"Hello __**world**__.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strong-underscore",
"children": [{"type": "text", "text": "world"}],
},
{"type": "text", "text": "."},
],
}
]
def test_emphasis_preceded_by_extra_ampersand(parse_markup):
result = parse_markup(f"**L*orem ipsum.")
assert result == [
{
"type": "paragraph",
"children": [
{
"type": "emphasis",
"children": [{"type": "text", "text": "*L"}],
},
{"type": "text", "text": "orem ipsum."},
],
}
]
INVALID_STRONG_UNDERSCORE = (
"__lorem__ipsum",
"lorem__ips__um",
"lorem__ipsum__",
)
@pytest.mark.parametrize("text", INVALID_STRONG_UNDERSCORE)
def test_strong_underscore_invalid_patterns(parse_markup, text):
result = parse_markup(f"Hello {text}.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": f"Hello {text}."},
],
}
]
def test_strikethrough(parse_markup):
result = parse_markup(f"Hello ~~lorem~~.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strikethrough",
"children": [
{"type": "text", "text": "lorem"},
],
},
{"type": "text", "text": "."},
],
}
]
def test_strikethrough_beginning_of_word(parse_markup):
result = parse_markup(f"Hello ~~lo~~rem.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strikethrough",
"children": [
{"type": "text", "text": "lo"},
],
},
{"type": "text", "text": "rem."},
],
}
]
def test_strikethrough_inside_a_word(parse_markup):
result = parse_markup(f"Hello lo~~r~~em.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello lo"},
{
"type": "strikethrough",
"children": [
{"type": "text", "text": "r"},
],
},
{"type": "text", "text": "em."},
],
}
]
def test_strikethrough_end_of_word(parse_markup):
result = parse_markup(f"Hello lo~~rem~~.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello lo"},
{
"type": "strikethrough",
"children": [
{"type": "text", "text": "rem"},
],
},
{"type": "text", "text": "."},
],
}
]
def test_strikethrough_two_words(parse_markup):
result = parse_markup(f"Hello ~~lorem ipsum~~.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strikethrough",
"children": [
{"type": "text", "text": "lorem ipsum"},
],
},
{"type": "text", "text": "."},
],
}
]
def test_strikethrough_with_line_break(parse_markup):
result = parse_markup(f"Hello ~~lorem\nipsum~~.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strikethrough",
"children": [
{"type": "text", "text": "lorem"},
{"type": "line-break"},
{"type": "text", "text": "ipsum"},
],
},
{"type": "text", "text": "."},
],
}
]
def test_strikethrough_with_symbols(parse_markup):
result = parse_markup(f"Hello ~~(lorem ipsum)~~.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strikethrough",
"children": [
{"type": "text", "text": "(lorem ipsum)"},
],
},
{"type": "text", "text": "."},
],
}
]
def test_strikethrough_next_to_another(parse_markup):
result = parse_markup(f"Hello ~~lorem~~ ~~ipsum~~.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "strikethrough",
"children": [
{"type": "text", "text": "lorem"},
],
},
{"type": "text", "text": " "},
{
"type": "strikethrough",
"children": [
{"type": "text", "text": "ipsum"},
],
},
{"type": "text", "text": "."},
],
}
]
def test_strikethrough_without_content_is_skupped(parse_markup):
result = parse_markup(f"Hello ~~~~.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello ~~~~."},
],
}
]
def test_strikethrough_with_whitespaces_only_is_skipped(parse_markup):
result = parse_markup(f"Hello ~~ \n ~~.")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello ~~"},
{"type": "line-break"},
{"type": "text", "text": "~~."},
],
}
]
| 24,413
|
Python
|
.py
| 773
| 19.021992
| 76
| 0.381373
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,640
|
test_forum_address.py
|
rafalp_Misago/misago/parser/tests/test_forum_address.py
|
from unittest.mock import Mock
import pytest
from django.test import override_settings
from ..forumaddress import ForumAddress
@pytest.mark.parametrize(
"link",
(
"https://misago-project.org/",
"http://misago-project.org/",
"http://misago-project.org",
"misago-project.org",
"misago-project.org/some-path/",
),
)
def test_forum_address_is_inbound_link_returns_true_for_inbound_link(link):
forum_address = ForumAddress(Mock(forum_address="https://misago-project.org"))
assert forum_address.is_inbound_link(link)
@pytest.mark.parametrize(
"link",
(
"https://example.org/",
"http://example.org/",
"http://example.org",
"example.org",
"example.org/some-path/",
),
)
@override_settings(MISAGO_FORUM_ADDRESS_HISTORY=["http://example.org"])
def test_forum_address_is_inbound_link_returns_true_for_historic_inbound_link(link):
forum_address = ForumAddress(Mock(forum_address="https://misago-project.org"))
assert forum_address.is_inbound_link(link)
@pytest.mark.parametrize(
"link",
(
"https://google.com",
"http://google.org/",
"http://google.org",
"google.org",
"google.org/some-path/",
),
)
@override_settings(MISAGO_FORUM_ADDRESS_HISTORY=["http://example.org"])
def test_forum_address_is_inbound_link_returns_false_for_outbound_link(link):
forum_address = ForumAddress(Mock(forum_address="https://misago-project.org"))
assert not forum_address.is_inbound_link(link)
@pytest.mark.parametrize(
"link",
(
"https://google.com",
"http://google.org/",
"http://google.org",
"google.org",
"google.org/some-path/",
),
)
def test_forum_address_is_inbound_link_returns_false_if_address_is_not_configured(link):
forum_address = ForumAddress(Mock(forum_address=None))
assert not forum_address.is_inbound_link(link)
| 1,948
|
Python
|
.py
| 58
| 28.275862
| 88
| 0.670213
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,641
|
test_mention.py
|
rafalp_Misago/misago/parser/tests/test_mention.py
|
def test_mention(parse_markup):
result = parse_markup("Hello @Bob_Boberston!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "mention",
"username": "Bob_Boberston",
},
{"type": "text", "text": "!"},
],
}
]
| 430
|
Python
|
.py
| 15
| 16.466667
| 51
| 0.366265
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,642
|
test_images.py
|
rafalp_Misago/misago/parser/tests/test_images.py
|
def test_image(parse_markup):
result = parse_markup("Hello !(https://image.com/img.jpg)!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image",
"alt": None,
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_with_alt_text(parse_markup):
result = parse_markup("Hello !")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image",
"alt": "Image Alt",
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_alt_text_whitespace_is_stripped(parse_markup):
result = parse_markup("Hello !")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image",
"alt": "Image Alt",
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_alt_text_is_empty(parse_markup):
result = parse_markup("Hello !")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image",
"alt": None,
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_alt_text_is_not_parsed(parse_markup):
result = parse_markup("Hello !")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image",
"alt": "*Image Alt*",
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_alt_text_reserved_tokens_are_reversed(parse_markup):
result = parse_markup("Hello !")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image",
"alt": "`Image`",
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_with_invalid_url(parse_markup):
result = parse_markup("Hello !(invalid url)!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello !(invalid url)!"},
],
}
]
def test_image_with_email_url(parse_markup):
result = parse_markup("Hello !(lorem@ipsum.com).")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello !(lorem@ipsum.com)."},
],
}
]
def test_image_with_empty_url(parse_markup):
result = parse_markup("Hello !().")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello !()."},
],
}
]
def test_image_with_alt_text_next_to_another_image_with_alt_text(parse_markup):
result = parse_markup(
"Hello "
" !"
)
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image",
"alt": "Image Alt",
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": " "},
{
"type": "image",
"alt": "Other Alt",
"src": "https://image.com/other.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_bbcode(parse_markup):
result = parse_markup("Hello [img]https://image.com/img.jpg[/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image-bbcode",
"alt": None,
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_bbcode_url_whitespace_is_stripped(parse_markup):
result = parse_markup("Hello [img] https://image.com/img.jpg [/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image-bbcode",
"alt": None,
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_bbcode_with_invalid_url(parse_markup):
result = parse_markup("Hello [img] invalid url [/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello [img] invalid url [/img]!"},
],
}
]
def test_image_bbcode_with_email_url(parse_markup):
result = parse_markup("Hello [img]lorem@ipsum.com[/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello [img]lorem@ipsum.com[/img]!"},
],
}
]
def test_image_bbcode_with_alt_text(parse_markup):
result = parse_markup("Hello [img=https://image.com/img.jpg]alt text[/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image-bbcode",
"alt": "alt text",
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_bbcode_alt_text_whitespace_is_striped(parse_markup):
result = parse_markup("Hello [img=https://image.com/img.jpg] alt text [/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image-bbcode",
"alt": "alt text",
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_bbcode_alt_text_is_not_parsed(parse_markup):
result = parse_markup("Hello [img=https://image.com/img.jpg]**alt text**[/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image-bbcode",
"alt": "**alt text**",
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_bbcode_alt_text_reserved_patterns_are_reversed(parse_markup):
result = parse_markup("Hello [img=https://image.com/img.jpg]`alt text`[/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image-bbcode",
"alt": "`alt text`",
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_bbcode_with_alt_text_url_is_trimmed(parse_markup):
result = parse_markup("Hello [img=' https://image.com/img.jpg' ]alt text[/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello "},
{
"type": "image-bbcode",
"alt": "alt text",
"src": "https://image.com/img.jpg",
},
{"type": "text", "text": "!"},
],
}
]
def test_image_bbcode_with_alt_text_empty_url(parse_markup):
result = parse_markup("Hello [img=]alt text[/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello [img=]alt text[/img]!"},
],
}
]
def test_image_bbcode_with_alt_text_invalid_url(parse_markup):
result = parse_markup("Hello [img=invalid url]alt text[/img]!")
assert result == [
{
"type": "paragraph",
"children": [
{"type": "text", "text": "Hello [img=invalid url]alt text[/img]!"},
],
}
]
| 9,869
|
Python
|
.py
| 303
| 20.481848
| 87
| 0.406152
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,643
|
test_fenced_code.py
|
rafalp_Misago/misago/parser/tests/test_fenced_code.py
|
def test_fenced_code_supports_backticks(parse_markup):
result = parse_markup(
"""
```
alert("hello!")
```
"""
)
assert result == [
{
"type": "code",
"syntax": None,
"code": 'alert("hello!")',
}
]
def test_fenced_code_supports_tildes(parse_markup):
result = parse_markup(
"""
~~~
alert("hello!")
~~~
"""
)
assert result == [
{
"type": "code",
"syntax": None,
"code": 'alert("hello!")',
}
]
def test_fenced_code_supports_syntax(parse_markup):
result = parse_markup(
"""
~~~python
alert("hello!")
~~~
"""
)
assert result == [
{
"type": "code",
"syntax": "python",
"code": 'alert("hello!")',
}
]
def test_fenced_code_trims_syntax(parse_markup):
result = parse_markup(
"""
~~~ python
alert("hello!")
~~~
"""
)
assert result == [
{
"type": "code",
"syntax": "python",
"code": 'alert("hello!")',
}
]
def test_fenced_code_doesnt_dedent_code(parse_markup):
result = parse_markup(
"""
~~~
def hello():
return 1
~~~
"""
)
assert result == [
{
"type": "code",
"syntax": None,
"code": " def hello():\n return 1",
}
]
def test_fenced_code_trims_code(parse_markup):
result = parse_markup(
"""
~~~
1 + 3
~~~
"""
)
assert result == [
{
"type": "code",
"syntax": None,
"code": " 1 + 3",
}
]
def test_fenced_code_can_be_mixed_with_other_blocks(parse_markup):
result = parse_markup(
"""
Here is the code:
```
1 + 3
```
It's cool!
"""
)
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Here is the code:"}],
},
{
"type": "code",
"syntax": None,
"code": "1 + 3",
},
{
"type": "paragraph",
"children": [{"type": "text", "text": "It's cool!"}],
},
]
def test_fenced_code_can_be_used_next_to_each_other(parse_markup):
result = parse_markup(
"""
Here is the code:
```
1 + 3
```
```math
4 x 2
```
It's cool!
"""
)
assert result == [
{
"type": "paragraph",
"children": [{"type": "text", "text": "Here is the code:"}],
},
{
"type": "code",
"syntax": None,
"code": "1 + 3",
},
{
"type": "code",
"syntax": "math",
"code": "4 x 2",
},
{
"type": "paragraph",
"children": [{"type": "text", "text": "It's cool!"}],
},
]
| 3,209
|
Python
|
.py
| 149
| 12.637584
| 72
| 0.376397
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,644
|
render_ast_node_to_html.py
|
rafalp_Misago/misago/parser/hooks/render_ast_node_to_html.py
|
from typing import TYPE_CHECKING, Protocol
from ...plugins.hooks import FilterHook
if TYPE_CHECKING:
from ..context import ParserContext
class RenderAstNodeToHtmlHookAction(Protocol):
"""
A standard Misago function used to create an HTML representation of the abstract
syntax tree's node or the next filter function from another plugin.
# Arguments
## `context: ParserContext`
A `ParserContext` data class instance.
## `ast_node: dict`
A `dict` with the AST node to create an HTML representation for.
## `metadata: dict`
A `dict` with metadata.
# Return value
A `str` with an HTML representation of the AST node.
"""
def __call__(
self,
context: "ParserContext",
ast_node: dict,
metadata: dict,
) -> str: ...
class RenderAstNodeToHtmlHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: RenderAstNodeToHtmlHookAction`
A standard Misago function used to create an HTML representation of the abstract
syntax tree's node or the next filter function from another plugin.
See the [action](#action) section for details.
## `context: ParserContext`
A `ParserContext` data class instance.
## `ast_node: dict`
A `dict` with the AST node to create an HTML representation for.
## `metadata: dict`
A `dict` with metadata.
# Return value
A `str` with an HTML representation of the AST node.
"""
def __call__(
self,
action: RenderAstNodeToHtmlHookAction,
context: "ParserContext",
ast_node: dict,
metadata: dict,
) -> str: ...
class RenderAstNodeToHtmlHook(
FilterHook[RenderAstNodeToHtmlHookAction, RenderAstNodeToHtmlHookFilter]
):
"""
This hook wraps the standard function that Misago uses to create an HTML
representation of the abstract syntax tree's node.
# Example
The code below implements a custom filter function that replaces Twitter media
links with images:
```python
from misago.parser.context import ParserContext
@render_ast_node_to_html_hook.append_filter
def render_twitter_media_link_as_image(
action: RenderAstNodeToHtmlHookAction,
context: ParserContext,
ast_node: dict,
metadata: dict,
) -> str:
if (
ast_node["type"] in ("auto-link", "auto-url") and
is_twitter_media(ast_node["href"])
):
new_ast_node = {
"type": "auto-link",
"image": True,
"href": ast_node["href"],
}
return action(context, new_ast_node, metadata)
# Call the next function in chain
return action(context, ast_node, metadata)
def is_twitter_media(href: str) -> bool:
return bool(
href.startswith("https://pbs.twimg.com/media/") and
"?format=jpg&" in href
)
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: RenderAstNodeToHtmlHookAction,
context: "ParserContext",
ast_node: dict,
metadata: dict,
) -> str:
return super().__call__(action, context, ast_node, metadata)
render_ast_node_to_html_hook = RenderAstNodeToHtmlHook()
| 3,369
|
Python
|
.py
| 95
| 28.336842
| 84
| 0.648824
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,645
|
get_ast_metadata_users_queryset.py
|
rafalp_Misago/misago/parser/hooks/get_ast_metadata_users_queryset.py
|
from typing import TYPE_CHECKING, Iterable, Protocol
from django.contrib.auth import get_user_model
from ...plugins.hooks import FilterHook
if TYPE_CHECKING:
from ..context import ParserContext
User = get_user_model()
class GetAstMetadataUsersQuerysetHookAction(Protocol):
"""
A standard Misago function used to create a `User` queryset or the next filter
function from another plugin.
# Arguments
## `context: ParserContext`
An instance of the `ParserContext` data class that contains dependencies
used during parsing.
## `usernames: list[str]`
A list of normalized usernames of `User` instance to retrieve from the database.
Names are normalized using the `slugify` function from `misago.core.utils`.
# Return value
A queryset with `User` instances to use in updating the metadata.
"""
def __call__(
self,
*,
context: "ParserContext",
usernames: list[str],
) -> Iterable[User]: ...
class GetAstMetadataUsersQuerysetHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetAstMetadataUsersQuerysetHookAction`
A standard Misago function used to create a `User` queryset or the next filter
function from another plugin.
See the [action](#action) section for details.
## `context: ParserContext`
An instance of the `ParserContext` data class that contains dependencies
used during parsing.
## `usernames: list[str]`
A list of normalized usernames of `User` instance to retrieve from the database.
Names are normalized using the `slugify` function from `misago.core.utils`.
# Return value
A queryset with `User` instances to use in updating the metadata.
"""
def __call__(
self,
action: GetAstMetadataUsersQuerysetHookAction,
context: "ParserContext",
usernames: list[str],
) -> Iterable[User]: ...
class GetAstMetadataUsersQuerysetHook(
FilterHook[
GetAstMetadataUsersQuerysetHookAction, GetAstMetadataUsersQuerysetHookFilter
]
):
"""
This hook wraps the standard function that Misago uses to retrieve the metadata
with data from the Abstract Syntax Tree representation of parsed markup.
It can be employed to initialize new keys in the `metadata` dictionary before
the next action call and to retrieve missing data from the database or another
source after the action.
# Example
The code below implements a custom filter function that updates the queryset
to exclude users belonging to a specified group.
```python
from misago.parser.context import ParserContext
@get_ast_metadata_users_queryset_hook.append_filter
def get_ast_metadata_users_queryset_exclude_promotors(
action: GetAstMetadataUsersQuerysetHookAction,
context: ParserContext,
usernames: list[str],
):
return action(context, usernames).exclude(group_id=10)
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetAstMetadataUsersQuerysetHookAction,
context: "ParserContext",
usernames: list[str],
):
return super().__call__(action, context, usernames)
get_ast_metadata_users_queryset_hook = GetAstMetadataUsersQuerysetHook()
| 3,376
|
Python
|
.py
| 83
| 34.807229
| 84
| 0.721488
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,646
|
create_parser.py
|
rafalp_Misago/misago/parser/hooks/create_parser.py
|
from typing import TYPE_CHECKING, Callable, Protocol
from ...plugins.hooks import FilterHook
from ..parser import Parser, Pattern
if TYPE_CHECKING:
from ..context import ParserContext
class CreateParserHookAction(Protocol):
"""
A standard Misago function used to create a markup parser instance or the
next filter function from another plugin.
# Arguments
## `context: ParserContext`
An instance of the `ParserContext` data class that contains dependencies
used during parsing.
## `block_patterns: list[Pattern]`
A list of `Pattern` instances of block patterns to be used by the parser.
## `inline_patterns: list[Pattern]`
A list of `Pattern` instances of inline patterns to be used by the parser.
## `post_processors: list[Callable[[Parser, list[dict]], list[dict]]]`
A list of post-processor functions called by the parser to finalize the AST.
A post-processor function should have the following signature:
```python
def custom_postprocessor(parser: Parser, ast: list[dict]) -> list[dict]:
# Do something with the 'ast'...
return ast
```
# Return value
An instance of the `Parser` class.
"""
def __call__(
self,
context: "ParserContext",
*,
block_patterns: list[Pattern],
inline_patterns: list[Pattern],
post_processors: list[Callable[[Parser, list[dict]], list[dict]]],
) -> Parser: ...
class CreateParserHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: CreateParserHookAction`
A standard Misago function used to create a markup parser instance or the
next filter function from another plugin.
See the [action](#action) section for details.
## `context: ParserContext`
An instance of the `ParserContext` data class that contains dependencies
used during parsing.
## `block_patterns: list[Pattern]`
A list of `Pattern` instances of block patterns to be used by the parser.
## `inline_patterns: list[Pattern]`
A list of `Pattern` instances of inline patterns to be used by the parser.
## `post_processors: list[Callable[[Parser, list[dict]], list[dict]]]`
A list of post-processor functions called by the parser to finalize the AST.
A post-processor function should have the following signature:
```python
def custom_postprocessor(parser: Parser, ast: list[dict]) -> list[dict]:
# Do something with the 'ast'...
return ast
```
# Return value
An instance of the `Parser` class.
"""
def __call__(
self,
action: CreateParserHookAction,
context: "ParserContext",
*,
block_patterns: list[Pattern],
inline_patterns: list[Pattern],
post_processors: list[Callable[[Parser, list[dict]], list[dict]]],
) -> Parser: ...
class CreateParserHook(FilterHook[CreateParserHookAction, CreateParserHookFilter]):
"""
This hook wraps the standard function that Misago uses to create a markup
parser instance.
# Example
The code below implements a custom filter function that adds new block pattern
to the parser:
```python
from misago.parser.context import ParserContext
from misago.parser.parser import Parser
from .patterns import PluginPattern
@create_parser_hook.append_filter
def create_parser_with_custom_pattern(
action: CreateParserHookAction,
context: ParserContext,
*,
block_patterns,
**kwargs,
) -> Parser:
block_patterns.append(PluginPattern)
# Call the next function in chain
return action(context, block_patterns=block_patterns, **kwargs)
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: CreateParserHookAction,
context: "ParserContext",
*,
block_patterns: list[Pattern],
inline_patterns: list[Pattern],
post_processors: list[Callable[[Parser, list[dict]], list[dict]]],
) -> Parser:
return super().__call__(
action,
context,
block_patterns=block_patterns,
inline_patterns=inline_patterns,
post_processors=post_processors,
)
create_parser_hook = CreateParserHook()
| 4,398
|
Python
|
.py
| 113
| 32.20354
| 83
| 0.675561
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,647
|
update_ast_metadata_users.py
|
rafalp_Misago/misago/parser/hooks/update_ast_metadata_users.py
|
from typing import TYPE_CHECKING, Protocol
from ...plugins.hooks import FilterHook
if TYPE_CHECKING:
from ..context import ParserContext
class UpdateAstMetadataUsersHookAction(Protocol):
"""
A standard Misago function used to update the metadata with users from the database,
or the next filter function from another plugin.
# Arguments
## `context: ParserContext`
An instance of the `ParserContext` data class that contains dependencies
used during parsing.
## `metadata: dict`
A `dict` with metadata to update.
"""
def __call__(
self,
*,
context: "ParserContext",
metadata: dict,
) -> None: ...
class UpdateAstMetadataUsersHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: UpdateAstMetadataUsersHookAction`
A standard Misago function used to update the metadata with users from the database,
or the next filter function from another plugin.
See the [action](#action) section for details.
## `context: ParserContext`
An instance of the `ParserContext` data class that contains dependencies
used during parsing.
## `metadata: dict`
A `dict` with metadata to update.
"""
def __call__(
self,
action: UpdateAstMetadataUsersHookAction,
context: "ParserContext",
metadata: dict,
) -> None: ...
class UpdateAstMetadataUsersHook(
FilterHook[UpdateAstMetadataUsersHookAction, UpdateAstMetadataUsersHookFilter]
):
"""
This hook wraps the standard function that Misago uses to update the metadata
with users from the database.
# Example
The code below implements a custom filter function that removes users with extra
flag in their `plugin_data`:
```python
from misago.parser.context import ParserContext
@update_ast_metadata_users_hook.append_filter
def update_ast_metadata_users_remove(
action: UpdateAstMetadataUsersHookAction,
context: ParserContext,
metadata: dict,
) -> None:
for key, user in list(metadata["users"].items()):
if user.plugin_data.get("disable_mentions"):
del metadata["users"][key]
action(context, metadata)
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: UpdateAstMetadataUsersHookAction,
context: "ParserContext",
metadata: dict,
) -> None:
return super().__call__(action, context, metadata)
update_ast_metadata_users_hook = UpdateAstMetadataUsersHook()
| 2,638
|
Python
|
.py
| 72
| 30.347222
| 88
| 0.692854
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,648
|
complete_markup_html.py
|
rafalp_Misago/misago/parser/hooks/complete_markup_html.py
|
from typing import TYPE_CHECKING, Protocol
from ...plugins.hooks import FilterHook
if TYPE_CHECKING:
from ..context import ParserContext
class CompleteMarkupHtmlHookAction(Protocol):
"""
A standard Misago function used to complete an HTML representation of parsed markup
or the next filter function from another plugin.
# Arguments
## `html: str`
An HTML representation of parsed markup to complete.
## `**kwargs`
Additional data that can be used to complete the HTML.
# Return value
A `str` with completed HTML representation of parsed markup.
"""
def __call__(self, html: str, **kwargs) -> str: ...
class CompleteMarkupHtmlHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: CompleteMarkupHtmlHookAction`
A standard Misago function used to complete an HTML representation of parsed markup
or the next filter function from another plugin.
See the [action](#action) section for details.
## `html: str`
An HTML representation of parsed markup to complete.
## `**kwargs`
Additional data that can be used to complete the HTML.
# Return value
A `str` with completed HTML representation of parsed markup.
"""
def __call__(
self,
action: CompleteMarkupHtmlHookAction,
html: str,
**kwargs,
) -> str: ...
class CompleteMarkupHtmlHook(
FilterHook[CompleteMarkupHtmlHookAction, CompleteMarkupHtmlHookFilter]
):
"""
This hook wraps the standard function that Misago uses to complete an HTML
representation of parsed markup.
Completion process includes:
- Replacing of placeholder spoiler blocks summaries with messages in active language.
- Replacing quotation blocks headers with final HTML.
# Example
The code below implements a custom filter function that replaces default spoiler
block summary with a custom message:
```python
from misago.parser.context import ParserContext
from misago.parser.html import SPOILER_SUMMARY
@complete_markup_html_hook.append_filter
def complete_markup_html_with_custom_spoiler-summary(
action: CompleteMarkupHtmlHookAction,
html: str,
**kwargs,
) -> str:
if SPOILER_SUMMARY in html:
html = html.replace(
SPOILER_SUMMARY, "SPOILER! Click at your own discretion!"
)
# Call the next function in chain
return action(context, html, **kwargs)
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: CompleteMarkupHtmlHookAction,
html: str,
**kwargs,
) -> str:
return super().__call__(action, html, **kwargs)
complete_markup_html_hook = CompleteMarkupHtmlHook()
| 2,861
|
Python
|
.py
| 76
| 31.394737
| 89
| 0.695921
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,649
|
__init__.py
|
rafalp_Misago/misago/parser/hooks/__init__.py
|
from .complete_markup_html import complete_markup_html_hook
from .create_parser import create_parser_hook
from .get_ast_metadata_users_queryset import get_ast_metadata_users_queryset_hook
from .render_ast_node_to_html import render_ast_node_to_html_hook
from .render_ast_node_to_plaintext import render_ast_node_to_plaintext_hook
from .setup_parser_context import setup_parser_context_hook
from .update_ast_metadata import update_ast_metadata_hook
from .update_ast_metadata_from_node import update_ast_metadata_from_node_hook
from .update_ast_metadata_users import update_ast_metadata_users_hook
__all__ = [
"complete_markup_html_hook",
"create_parser_hook",
"get_ast_metadata_users_queryset_hook",
"render_ast_node_to_html_hook",
"render_ast_node_to_plaintext_hook",
"setup_parser_context_hook",
"update_ast_metadata_hook",
"update_ast_metadata_from_node_hook",
"update_ast_metadata_users_hook",
]
| 936
|
Python
|
.py
| 20
| 43.95
| 81
| 0.777049
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,650
|
render_ast_node_to_plaintext.py
|
rafalp_Misago/misago/parser/hooks/render_ast_node_to_plaintext.py
|
from typing import TYPE_CHECKING, Protocol
from ...plugins.hooks import FilterHook
if TYPE_CHECKING:
from ..context import ParserContext
class RenderAstNodeToPlainTextHookAction(Protocol):
"""
A standard Misago function used to create a plain text representation of the
abstract syntax tree's node or the next filter function from another plugin.
# Arguments
## `context: ParserContext`
A `ParserContext` data class instance.
## `ast_node: dict`
A `dict` with the AST node to create a plain text representation for.
## `metadata: dict`
A `dict` with metadata.
## `text_format: str | None = None`
A `str` with target plain text format, or `None` if not provided.
# Return value
A `str` with a plain text representation of the AST node.
"""
def __call__(
self,
context: "ParserContext",
ast_node: dict,
metadata: dict,
text_format: str | None = None,
) -> str: ...
class RenderAstNodeToPlainTextHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: RenderAstNodeToPlainTextHookAction`
A standard Misago function used to create a plain text representation of the
abstract syntax tree's node or the next filter function from another plugin.
See the [action](#action) section for details
## `context: ParserContext`
A `ParserContext` data class instance.
## `ast_node: dict`
A `dict` with the AST node to create a plain text representation for.
## `metadata: dict`
A `dict` with metadata.
## `text_format: str | None = None`
A `str` with target plain text format, or `None` if not provided.
# Return value
A `str` with a plain text representation of the AST node.
"""
def __call__(
self,
action: RenderAstNodeToPlainTextHookAction,
context: "ParserContext",
ast_node: dict,
metadata: dict,
text_format: str | None = None,
) -> str: ...
class RenderAstNodeToPlainTextHook(
FilterHook[RenderAstNodeToPlainTextHookAction, RenderAstNodeToPlainTextHookFilter]
):
"""
This hook wraps the standard function that Misago uses to create a plain text
representation of the abstract syntax tree's node.
# Example
The code below implements a custom filter function that only inserts images
alt text in the text document:
```python
from misago.parser.context import ParserContext
@render_ast_node_to_plaintext_hook.append_filter
def render_images_alt_text_only(
action: RenderAstNodeToPlainTextHookAction,
context: ParserContext,
ast_node: dict,
metadata: dict,
text_format: str | None = None,
) -> str:
if ast_node["type"] in ("image", "image-bbcode"):
return ast_node["alt"] or ""
# Call the next function in chain
return action(context, ast_node, metadata, text_format)
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: RenderAstNodeToPlainTextHookAction,
context: "ParserContext",
ast_node: dict,
metadata: dict,
text_format: str | None = None,
) -> str:
return super().__call__(action, context, ast_node, metadata, text_format)
render_ast_node_to_plaintext_hook = RenderAstNodeToPlainTextHook()
| 3,453
|
Python
|
.py
| 90
| 31.977778
| 86
| 0.676311
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,651
|
update_ast_metadata.py
|
rafalp_Misago/misago/parser/hooks/update_ast_metadata.py
|
from typing import TYPE_CHECKING, Protocol
from ...plugins.hooks import FilterHook
if TYPE_CHECKING:
from ..context import ParserContext
class UpdateAstMetadataHookAction(Protocol):
"""
A standard Misago function used to update the metadata with data from the Abstract
Syntax Tree representation of parsed markup or the next filter function
from another plugin.
# Arguments
## `context: ParserContext`
An instance of the `ParserContext` data class that contains dependencies
used during parsing.
## `ast: list[dict]`
A list of `dict`s representing parsed markup.
## `metadata: dict`
A `dict` with metadata with some keys already pre-set by Misago and
previous plugins.
# Return value
A `dict` with completed metadata.
"""
def __call__(
self,
*,
context: "ParserContext",
ast: list[dict],
metadata: dict,
) -> dict: ...
class UpdateAstMetadataHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: UpdateAstMetadataHookAction`
A standard Misago function used to update the metadata with data from the Abstract
Syntax Tree representation of parsed markup or the next filter function
from another plugin.
See the [action](#action) section for details.
## `context: ParserContext`
An instance of the `ParserContext` data class that contains dependencies
used during parsing.
## `ast: list[dict]`
A list of `dict`s representing parsed markup.
## `metadata: dict`
A `dict` with metadata with some keys already pre-set by Misago and
previous plugins.
# Return value
A `dict` with completed metadata.
"""
def __call__(
self,
action: UpdateAstMetadataHookAction,
context: "ParserContext",
ast: list[dict],
metadata: dict,
) -> dict: ...
class UpdateAstMetadataHook(
FilterHook[UpdateAstMetadataHookAction, UpdateAstMetadataHookFilter]
):
"""
This hook wraps the standard function that Misago uses to update the metadata
with data from the Abstract Syntax Tree representation of parsed markup.
It can be employed to initialize new keys in the `metadata` dictionary before
the next action call and to retrieve missing data from the database or another
source after the action.
# Example
The code below implements a custom filter function that sets `threads` entry in the
metadata and populates it with threads:
```python
from misago.parser.context import ParserContext
from misago.threads.models import Thread
@update_ast_metadata_hook.append_filter
def update_ast_metadata_threads(
action: UpdateAstMetadataHookAction,
context: ParserContext,
ast: list[dict],
metadata: dict,
) -> dict:
metadata["threads"] = {
"ids": set(),
"threads": {},
},
# Call the next function in chain
metadata = action(context, ast, metadata)
threads_ids = metadata["threads"]["ids"]
if threads_ids and len(threads_ids) < 30: # Safety limit
for thread in Thread.objects.filter(id__in=threads_ids):
metadata["threads"]["threads"][thread.id] = thread
return metadata
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: UpdateAstMetadataHookAction,
context: "ParserContext",
ast: list[dict],
metadata: dict,
) -> dict:
return super().__call__(action, context, ast, metadata)
update_ast_metadata_hook = UpdateAstMetadataHook()
| 3,730
|
Python
|
.py
| 100
| 30.74
| 87
| 0.680145
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,652
|
setup_parser_context.py
|
rafalp_Misago/misago/parser/hooks/setup_parser_context.py
|
from typing import TYPE_CHECKING, Protocol
from ...plugins.hooks import FilterHook
if TYPE_CHECKING:
from ..context import ParserContext
class SetupParserContextHookAction(Protocol):
"""
A standard Misago function used to setup the Parser Context data class
instance or the next filter function from another plugin.
# Arguments
## `context: ParserContext`
A `ParserContext` data class instance to setup.
# Return value
A `ParserContext` instance to use during parsing.
"""
def __call__(self, context: "ParserContext") -> "ParserContext": ...
class SetupParserContextHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: SetupParserContextHookAction`
A standard Misago function used to setup the Parser Context data class
instance or the next filter function from another plugin.
See the [action](#action) section for details.
## `context: ParserContext`
A `ParserContext` data class instance to setup.
# Return value
A `ParserContext` instance to use during parsing.
"""
def __call__(
self,
action: SetupParserContextHookAction,
context: "ParserContext",
) -> "ParserContext": ...
class SetupParserContextHook(
FilterHook[SetupParserContextHookAction, SetupParserContextHookFilter]
):
"""
This hook wraps the standard function that Misago uses to setup a `ParserContext`
instance.
# Example
The code below implements a custom filter function that adds extra data to
`plugin_data` dictionary on `ParserContext`:
```python
from misago.parser.context import ParserContext
@setup_parser_context_hook.append_filter
def register_plugin_data_in_parser_context(
action: SetupParserContextHookAction, context: ParserContext
) -> ParserContext:
if context.request:
context.plugin_data["my_plugin"] = request.my_plugin.get_parser_context()
# Call the next function in chain
return action(context)
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: SetupParserContextHookAction,
context: "ParserContext",
) -> "ParserContext":
return super().__call__(action, context)
setup_parser_context_hook = SetupParserContextHook()
| 2,396
|
Python
|
.py
| 62
| 32.790323
| 85
| 0.71143
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,653
|
update_ast_metadata_from_node.py
|
rafalp_Misago/misago/parser/hooks/update_ast_metadata_from_node.py
|
from typing import TYPE_CHECKING, Protocol
from ...plugins.hooks import FilterHook
if TYPE_CHECKING:
from ..context import ParserContext
class UpdateAstMetadataFromNodeHookAction(Protocol):
"""
A standard Misago function used to update the metadata from an individual node
from the Abstract Syntax Tree representation of parsed markup or the next
filter function from another plugin.
# Arguments
## `context: ParserContext`
An instance of the `ParserContext` data class that contains dependencies
used during parsing.
## `ast_node: dict`
A `dict` with the individual node.
## `metadata: dict`
A `dict` with metadata to update.
"""
def __call__(
self,
*,
context: "ParserContext",
ast_node: dict,
metadata: dict,
) -> None: ...
class UpdateAstMetadataFromNodeHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: UpdateAstMetadataFromNodeHookAction`
A standard Misago function used to update the metadata from an individual node
from the Abstract Syntax Tree representation of parsed markup or the next
filter function from another plugin.
See the [action](#action) section for details.
## `context: ParserContext`
An instance of the `ParserContext` data class that contains dependencies
used during parsing.
## `ast_node: dict`
A `dict` with the individual node.
## `metadata: dict`
A `dict` with metadata to update.
"""
def __call__(
self,
action: UpdateAstMetadataFromNodeHookAction,
context: "ParserContext",
ast_node: dict,
metadata: dict,
) -> None: ...
class UpdateAstMetadataFromNodeHook(
FilterHook[UpdateAstMetadataFromNodeHookAction, UpdateAstMetadataFromNodeHookFilter]
):
"""
This hook wraps the standard function that Misago uses to update the metadata
from an individual node from the Abstract Syntax Tree representation
of parsed markup.
# Example
The code below implements a custom filter function that populates `threads` entry in
the metadata with threads ids extracted them the `url` nodes:
```python
from django.urls import Resolver404, resolve
from misago.parser.context import ParserContext
@update_ast_metadata_from_node_hook.append_filter
def update_ast_metadata_threads(
action: UpdateAstMetadataFromNodeHookAction,
context: ParserContext,
ast_node: dict,
metadata: dict,
) -> None:
if ast_node["type"] in ("url", "url-bbcode", "auto-link", "auto-url"):
if thread_id := get_thread_id_from_url(context, ast_node["href"])
metadata["threads"]["ids"].add(thread_id)
action(ast_node, metadata, request)
def get_thread_id_from_url(context: ParserContext, url: str) -> int | None:
try:
resolver_match = resolve(url)
except Resolver404:
return None
if not context.forum_address.is_inbound_link(url):
return None
if (
resolver_match.namespace == "misago" and
resolver_match.url_name == "thread" and
resolver_match.captured_kwargs.get("pk")
)
return resolver_match.captured_kwargs.get("pk")
return None
```
For an explanation on `metadata["threads"]`, please see the
`create_ast_metadata_hook` reference.
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: UpdateAstMetadataFromNodeHookAction,
context: "ParserContext",
ast_node: dict,
metadata: dict,
) -> None:
return super().__call__(action, context, ast_node, metadata)
update_ast_metadata_from_node_hook = UpdateAstMetadataFromNodeHook()
| 3,892
|
Python
|
.py
| 101
| 31.564356
| 88
| 0.677161
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,654
|
signals.py
|
rafalp_Misago/misago/categories/signals.py
|
from django.dispatch import Signal, receiver
from ..users.signals import anonymize_user_data, username_changed
from .models import Category
delete_category_content = Signal()
move_category_content = Signal()
@receiver([anonymize_user_data, username_changed])
def update_usernames(sender, **kwargs):
Category.objects.filter(last_poster=sender).update(
last_poster_name=sender.username, last_poster_slug=sender.slug
)
| 436
|
Python
|
.py
| 10
| 40.6
| 70
| 0.7891
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,655
|
models.py
|
rafalp_Misago/misago/categories/models.py
|
from django.db import models
from mptt.managers import TreeManager
from mptt.models import MPTTModel, TreeForeignKey
from ..acl.cache import clear_acl_cache
from ..acl.models import BaseRole
from ..conf import settings
from ..core.utils import slugify
from ..plugins.models import PluginDataModel
from ..threads.threadtypes import trees_map
from .enums import CategoryTree, CategoryChildrenComponent
class CategoryManager(TreeManager):
def private_threads(self):
return self.get(level=0, tree_id=CategoryTree.PRIVATE_THREADS)
def root_category(self):
return self.get(level=0, tree_id=CategoryTree.THREADS)
def all_categories(self, include_root=False):
queryset = self.filter(tree_id=CategoryTree.THREADS)
if not include_root:
queryset = queryset.filter(level__gt=0)
return queryset.order_by("lft")
class Category(MPTTModel, PluginDataModel):
parent = TreeForeignKey(
"self", null=True, blank=True, related_name="children", on_delete=models.CASCADE
)
special_role = models.CharField(max_length=255, null=True, blank=True)
name = models.CharField(max_length=255)
slug = models.CharField(max_length=255)
short_name = models.CharField(max_length=255, null=True, blank=True)
color = models.CharField(max_length=7, null=True, blank=True)
description = models.TextField(null=True, blank=True)
css_class = models.CharField(max_length=255, null=True, blank=True)
allow_polls = models.BooleanField(default=True)
delay_browse_check = models.BooleanField(default=False)
show_started_only = models.BooleanField(default=False)
is_closed = models.BooleanField(default=False)
is_vanilla = models.BooleanField(default=False)
list_children_threads = models.BooleanField(default=True)
children_categories_component = models.CharField(
max_length=12,
null=False,
blank=False,
default=CategoryChildrenComponent.FULL,
)
threads = models.PositiveIntegerField(default=0)
posts = models.PositiveIntegerField(default=0)
unapproved_threads = models.PositiveIntegerField(default=0)
unapproved_posts = models.PositiveIntegerField(default=0)
last_post_on = models.DateTimeField(null=True, blank=True)
last_thread = models.ForeignKey(
"misago_threads.Thread",
related_name="+",
null=True,
blank=True,
on_delete=models.SET_NULL,
)
last_thread_title = models.CharField(max_length=255, null=True, blank=True)
last_thread_slug = models.CharField(max_length=255, null=True, blank=True)
last_poster = models.ForeignKey(
settings.AUTH_USER_MODEL,
related_name="+",
null=True,
blank=True,
on_delete=models.SET_NULL,
)
last_poster_name = models.CharField(max_length=255, null=True, blank=True)
last_poster_slug = models.CharField(max_length=255, null=True, blank=True)
require_threads_approval = models.BooleanField(default=False)
require_replies_approval = models.BooleanField(default=False)
require_edits_approval = models.BooleanField(default=False)
prune_started_after = models.PositiveIntegerField(default=0)
prune_replied_after = models.PositiveIntegerField(default=0)
archive_pruned_in = models.ForeignKey(
"self",
related_name="pruned_archive",
null=True,
blank=True,
on_delete=models.SET_NULL,
)
objects = CategoryManager()
class Meta:
indexes = PluginDataModel.Meta.indexes
def __str__(self):
return str(self.thread_type.get_category_name(self))
@property
def thread_type(self):
return trees_map.get_type_for_tree_id(self.tree_id)
def delete(self, *args, **kwargs):
clear_acl_cache()
return super().delete(*args, **kwargs)
def synchronize(self):
threads_queryset = self.thread_set.filter(is_hidden=False, is_unapproved=False)
self.threads = threads_queryset.count()
if self.threads:
replies_sum = threads_queryset.aggregate(models.Sum("replies"))
self.posts = self.threads + replies_sum["replies__sum"]
else:
self.posts = 0
if self.threads:
last_thread_qs = threads_queryset.filter(
is_hidden=False, is_unapproved=False
)
last_thread = last_thread_qs.order_by("-last_post_on")[:1][0]
self.set_last_thread(last_thread)
else:
self.empty_last_thread()
def delete_content(self):
from .signals import delete_category_content
delete_category_content.send(sender=self)
def move_content(self, new_category):
from .signals import move_category_content
move_category_content.send(sender=self, new_category=new_category)
def get_absolute_url(self):
return self.thread_type.get_category_absolute_url(self)
def get_last_thread_url(self):
return self.thread_type.get_category_last_thread_url(self)
def get_last_thread_new_url(self):
return self.thread_type.get_category_last_thread_new_url(self)
def get_last_post_url(self):
return self.thread_type.get_category_last_post_url(self)
def set_name(self, name):
self.name = name
self.slug = slugify(name)
def set_last_thread(self, thread):
self.last_post_on = thread.last_post_on
self.last_thread = thread
self.last_thread_title = thread.title
self.last_thread_slug = thread.slug
self.last_poster = thread.last_poster
self.last_poster_name = thread.last_poster_name
self.last_poster_slug = thread.last_poster_slug
def empty_last_thread(self):
self.last_post_on = None
self.last_thread = None
self.last_thread_title = None
self.last_thread_slug = None
self.last_poster = None
self.last_poster_name = None
self.last_poster_slug = None
def has_child(self, child):
return child.lft > self.lft and child.rght < self.rght
class CategoryRole(BaseRole):
pass
class RoleCategoryACL(models.Model):
role = models.ForeignKey(
"misago_acl.Role", related_name="categories_acls", on_delete=models.CASCADE
)
category = models.ForeignKey(
"Category", related_name="category_role_set", on_delete=models.CASCADE
)
category_role = models.ForeignKey(CategoryRole, on_delete=models.CASCADE)
| 6,482
|
Python
|
.py
| 150
| 36.14
| 88
| 0.693858
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,656
|
enums.py
|
rafalp_Misago/misago/categories/enums.py
|
from enum import IntEnum, StrEnum
from django.utils.translation import pgettext_lazy
class CategoryTree(IntEnum):
THREADS = 0
PRIVATE_THREADS = 1
class CategoryTreeDeprecated(IntEnum):
PRIVATE_THREADS = 0
THREADS = 1
class CategoryChildrenComponent(StrEnum):
FULL = "full"
DROPDOWN = "dropdown"
DISABLED = "disabled"
@classmethod
def get_category_choices(cls):
return (
(
cls.FULL,
pgettext_lazy("category children component choice", "Full panel"),
),
(
cls.DROPDOWN,
pgettext_lazy("category children component choice", "Dropdown"),
),
)
@classmethod
def get_threads_choices(cls):
return (
(
cls.DISABLED,
pgettext_lazy("category children component choice", "Disabled"),
),
) + cls.get_category_choices()
| 958
|
Python
|
.py
| 32
| 21.03125
| 82
| 0.586696
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,657
|
proxy.py
|
rafalp_Misago/misago/categories/proxy.py
|
from collections import defaultdict
from functools import cached_property
from ..permissions.proxy import UserPermissionsProxy
from .categories import get_categories
class CategoriesProxy:
user_permissions: UserPermissionsProxy
cache_versions: dict
_threads_paths: dict[list[dict]]
def __init__(self, user_permissions: UserPermissionsProxy, cache_versions: dict):
self.user_permissions = user_permissions
self.cache_versions = cache_versions
self._threads_paths: dict[int, list[dict]] = {}
@cached_property
def categories(self) -> dict[int, dict]:
return get_categories(self.user_permissions, self.cache_versions)
@cached_property
def categories_list(self) -> list[dict]:
return list(self.categories.values())
def get_categories_menu(self) -> list[dict]:
top_categories: list[dict] = []
children: dict[int, list[dict]] = defaultdict(list)
for item in self.categories_list:
category = item.copy()
if category["parent_id"] is None:
children[item["id"]] = []
top_categories.append(category)
elif category["parent_id"] in children:
children[category["parent_id"]].append(category)
# Flatten menu for React.js
menu_items: list[dict] = []
for category in top_categories:
category_children = children.get(category["id"])
if not category["is_vanilla"] or category_children:
menu_items.append(category)
if category_children:
menu_items += category_children
menu_items[-1]["last"] = True
if menu_items:
menu_items[-1].pop("last", None)
return menu_items
def get_category_parents(
self, category_id: int, include_self: bool = True
) -> list[dict]:
parents: list[dict] = []
category = self.categories[category_id]
while True:
if category["id"] != category_id or include_self:
parents.append(category)
if not category["parent_id"]:
break
category = self.categories[category["parent_id"]]
return parents
def get_category_path(
self, category_id: int, include_self: bool = True
) -> list[dict]:
parents = self.get_category_parents(category_id, include_self)
return list(reversed(parents))
def get_category_descendants(
self, category_id: int, include_self: bool = True
) -> list[dict]:
parent = self.categories[category_id]
items: list[dict] = []
if include_self:
items.append(parent)
for item in self.categories_list:
if item["lft"] > parent["lft"] and item["rght"] < parent["rght"]:
items.append(item)
return items
def get_thread_categories(
self, thread_category_id: int, current_category_id: int | None = None
) -> list[dict]:
if thread_category_id in self._threads_paths:
return self._threads_paths[thread_category_id]
path: list[dict] = self.get_category_path(thread_category_id)
if current_category_id:
cutoff = next(
(
i + 1
for i, category in enumerate(path)
if category["id"] == current_category_id
),
None,
)
if cutoff:
path = path[cutoff:]
self._threads_paths[thread_category_id] = path
return path
| 3,624
|
Python
|
.py
| 87
| 31.137931
| 85
| 0.595787
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,658
|
serializers.py
|
rafalp_Misago/misago/categories/serializers.py
|
from django.urls import reverse
from rest_framework import serializers
from ..core.serializers import MutableFields
from ..core.utils import format_plaintext_for_html
from .models import Category
__all__ = ["CategorySerializer"]
def last_activity_detail(f):
"""util for serializing last activity details"""
def decorator(self, obj):
if not obj.last_thread_id:
return None
acl = self.get_acl(obj)
tested_acls = (
acl.get("can_see"),
acl.get("can_browse"),
acl.get("can_see_all_threads"),
)
if not all(tested_acls):
return None
return f(self, obj)
return decorator
class CategorySerializer(serializers.ModelSerializer, MutableFields):
parent = serializers.PrimaryKeyRelatedField(read_only=True)
description = serializers.SerializerMethodField()
is_read = serializers.SerializerMethodField()
subcategories = serializers.SerializerMethodField()
acl = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = Category
fields = [
"id",
"parent",
"name",
"short_name",
"color",
"description",
"is_closed",
"threads",
"posts",
"last_post_on",
"last_thread_title",
"last_poster",
"last_poster_name",
"css_class",
"is_read",
"subcategories",
"acl",
"level",
"lft",
"rght",
"url",
]
def to_representation(self, instance):
data = super().to_representation(instance)
if instance.special_role:
data["special_role"] = instance.special_role
return data
def get_description(self, obj):
if obj.description:
return {
"plain": obj.description,
"html": format_plaintext_for_html(obj.description),
}
# Serve root category's description
if obj.special_role == "root_category" and self.context:
settings = self.context["settings"]
if settings.index_message:
return {
"plain": settings.index_message,
"html": format_plaintext_for_html(settings.index_message),
}
def get_css_class(self, obj):
return obj.css_class or None
def get_is_read(self, obj):
try:
return obj.is_read
except AttributeError:
return None
def get_subcategories(self, obj):
try:
return CategorySerializer(
obj.subcategories, context=self.context, many=True
).data
except AttributeError:
return []
def get_acl(self, obj):
try:
return obj.acl
except AttributeError:
return {}
@last_activity_detail
def get_last_poster(self, obj):
if obj.last_poster_id:
return {
"id": obj.last_poster_id,
"avatars": obj.last_poster.avatars,
"url": reverse(
"misago:user",
kwargs={"slug": obj.last_poster_slug, "pk": obj.last_poster_id},
),
}
def get_url(self, obj):
return {
"index": obj.get_absolute_url(),
"last_thread": self.get_last_thread_url(obj),
"last_thread_new": self.get_last_thread_new_url(obj),
"last_post": self.get_last_post_url(obj),
}
@last_activity_detail
def get_last_thread_url(self, obj):
return obj.get_last_thread_url()
@last_activity_detail
def get_last_thread_new_url(self, obj):
return obj.get_last_thread_new_url()
@last_activity_detail
def get_last_post_url(self, obj):
return obj.get_last_post_url()
class CategoryWithPosterSerializer(CategorySerializer):
last_poster = serializers.SerializerMethodField()
def get_subcategories(self, obj):
try:
return CategoryWithPosterSerializer(obj.subcategories, many=True).data
except AttributeError:
return []
CategoryWithPosterSerializer = CategoryWithPosterSerializer.extend_fields("last_poster")
| 4,387
|
Python
|
.py
| 126
| 24.650794
| 88
| 0.579433
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,659
|
components.py
|
rafalp_Misago/misago/categories/components.py
|
from typing import TYPE_CHECKING, Union
from django.contrib.auth import get_user_model
from django.contrib.auth.models import AnonymousUser
from django.http import HttpRequest
from ..permissions.enums import CategoryPermission
from ..permissions.proxy import UserPermissionsProxy
from ..readtracker.tracker import (
annotate_categories_read_time,
get_unread_categories,
)
from .enums import CategoryTree
from .models import Category
if TYPE_CHECKING:
from ..users.models import User
__all__ = [
"get_categories_data",
"get_categories_page_component",
"get_subcategories_data",
]
def get_categories_data(request: HttpRequest) -> list[dict]:
permissions = request.user_permissions
queryset = Category.objects.filter(
id__in=permissions.categories[CategoryPermission.SEE],
tree_id=CategoryTree.THREADS,
level__gt=0,
)
queryset = annotate_categories_read_time(request.user, queryset)
unread_categories = get_unread_categories(request, queryset)
categories_data: dict[int, dict] = {
category.id: get_category_data(
category, category.id in unread_categories, permissions
)
for category in queryset
}
aggregate_categories_data(request, categories_data)
return [
category for category in categories_data.values() if show_top_category(category)
]
def show_top_category(category: dict) -> bool:
if category["category"].level != 1:
return False
if category["category"].is_vanilla and not category["children"]:
return False
return True
def get_subcategories_data(request: HttpRequest, category: Category) -> list[dict]:
if category.is_leaf_node():
return []
permissions = request.user_permissions
queryset = Category.objects.filter(
id__in=permissions.categories[CategoryPermission.SEE],
tree_id=CategoryTree.THREADS,
lft__gt=category.lft,
rght__lt=category.rght,
)
queryset = annotate_categories_read_time(request.user, queryset)
unread_categories = get_unread_categories(request, queryset)
categories_data: dict[int, dict] = {
category.id: get_category_data(
category, category.id in unread_categories, permissions
)
for category in queryset
}
aggregate_categories_data(request, categories_data)
return [
subcategory
for subcategory in categories_data.values()
if subcategory["category"].parent_id == category.id
]
def get_category_data(
category: Category, unread: bool, permissions: UserPermissionsProxy
) -> dict:
if can_see_last_thread(category, permissions.user, permissions):
category_last_thread = {
"id": category.last_thread_id,
"title": category.last_thread_title,
"slug": category.last_thread_slug,
"last_post_on": category.last_post_on,
"last_poster": None,
"last_poster_name": category.last_poster_name,
"is_visible": (
category.id in permissions.categories[CategoryPermission.BROWSE]
or category.delay_browse_check
),
}
else:
category_last_thread = None
return {
"category": category,
"threads": category.threads,
"posts": category.posts,
"last_thread": category_last_thread,
"unread": unread,
"can_browse": (
category.id in permissions.categories[CategoryPermission.BROWSE]
or category.delay_browse_check
),
"show_started_only": category.show_started_only,
"children": [],
"children_threads": category.threads,
"children_posts": category.posts,
"children_last_thread": category_last_thread,
"children_unread": unread,
}
def can_see_last_thread(
category: Category,
user: Union["User", AnonymousUser],
permissions: UserPermissionsProxy,
) -> bool:
if not category.last_thread_id:
return False
if (
category.show_started_only
and category.id not in permissions.categories_moderator
and (user.is_anonymous or category.last_poster_id != user.id)
):
return False
return True
def aggregate_categories_data(
request: HttpRequest,
categories_data: dict[int, dict],
) -> None:
last_posters = prefetch_last_posters(request, categories_data.values())
# Populate categories last posters and read states
# Aggregate categories to their parents
for category_data in reversed(categories_data.values()):
category = category_data["category"]
# Populate last poster objects
if category_data["last_thread"] and category.last_poster_id:
last_poster = last_posters[category.last_poster_id]
category_data["last_thread"].update(
{
"last_poster": last_poster,
"last_poster_name": last_poster.username,
}
)
# Aggregate data from category to its parent
if category.parent_id in categories_data:
parent = categories_data[category.parent_id]
aggregate_category_to_its_parent(category_data, parent)
def aggregate_category_to_its_parent(category: dict, parent: dict):
parent["children_threads"] += category["children_threads"]
parent["children_posts"] += category["children_posts"]
item_last_thread = category["children_last_thread"]
parent_last_thread = parent["children_last_thread"]
if (
item_last_thread
and item_last_thread["is_visible"]
and (
not parent_last_thread
or item_last_thread["last_post_on"] > parent_last_thread["last_post_on"]
)
):
parent["children_last_thread"] = item_last_thread
# Propagate to parent the new posts status
if category["children_unread"]:
parent["children_unread"] = True
parent["children"].insert(0, category)
def prefetch_last_posters(
request: HttpRequest, categories_list: list[dict]
) -> dict[int, "User"]:
if not categories_list:
return []
last_posters: dict[int, User] = {}
last_posters_ids: set[int] = set()
for item in categories_list:
last_poster_id = item["category"].last_poster_id
if last_poster_id:
if last_poster_id == request.user.id:
last_posters[request.user.id] = request.user
else:
last_posters_ids.add(last_poster_id)
if last_posters_ids:
users_qs = (
get_user_model()
.objects.filter(id__in=last_posters_ids)
.select_related("rank")
)
for user in users_qs:
last_posters[user.id] = user
return last_posters
| 6,842
|
Python
|
.py
| 180
| 30.333333
| 88
| 0.65659
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,660
|
urls.py
|
rafalp_Misago/misago/categories/urls.py
|
from django.urls import path
from . import views
urlpatterns = [
path("categories/", views.index, name="categories", kwargs={"is_index": False}),
]
| 154
|
Python
|
.py
| 5
| 28.6
| 84
| 0.721088
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,661
|
apps.py
|
rafalp_Misago/misago/categories/apps.py
|
from django.apps import AppConfig
class MisagoCategoriesConfig(AppConfig):
name = "misago.categories"
label = "misago_categories"
verbose_name = "Misago Categories"
def ready(self):
from . import signals as _
| 236
|
Python
|
.py
| 7
| 28.857143
| 40
| 0.725664
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,662
|
mptt.py
|
rafalp_Misago/misago/categories/mptt.py
|
from .models import Category
MPTTData = tuple[int, int, int]
def heal_category_trees() -> int:
trees: set[int] = set()
categories: dict[int, dict] = {}
queryset = Category.objects.values(
"id",
"parent_id",
"tree_id",
"level",
"lft",
"rght",
).order_by("tree_id", "lft")
for category in queryset:
trees.add(category["tree_id"])
categories[category["id"]] = category
healthy_categories: list[dict] = []
for tree_id in trees:
healthy_categories += heal_tree(tree_id, categories)
updates = 0
for healed_category in healthy_categories:
org_category = categories[healed_category["id"]]
if org_category != healed_category:
Category.objects.filter(id=healed_category["id"]).update(
level=healed_category["level"],
lft=healed_category["lft"],
rght=healed_category["rght"],
)
updates += 1
return updates
def heal_tree(tree_id: int, categories: dict[int, dict]) -> list[dict]:
tree_categories = {
c["id"]: c.copy() for c in categories.values() if c["tree_id"] == tree_id
}
tree_categories_list = list(tree_categories.values())
cursor = 0
for category in tree_categories_list:
if category["parent_id"]:
continue
category["level"] = 0
cursor += 1
category["lft"] = cursor
category["rght"] = cursor = heal_category(category, tree_categories_list) + 1
return sorted(tree_categories_list, key=lambda i: i["lft"])
def heal_category(category: dict, tree_categories_list: list[dict]) -> int:
cursor = category["lft"]
for child in tree_categories_list:
if child["parent_id"] != category["id"]:
continue
child["level"] = category["level"] + 1
cursor += 1
child["lft"] = cursor
child["rght"] = cursor = heal_category(child, tree_categories_list) + 1
return cursor
| 2,021
|
Python
|
.py
| 54
| 29.425926
| 85
| 0.597742
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,663
|
permissions.py
|
rafalp_Misago/misago/categories/permissions.py
|
from django import forms
from django.core.exceptions import PermissionDenied
from django.http import Http404
from django.utils.translation import pgettext_lazy
from ..acl import algebra
from ..acl.decorators import return_boolean
from ..admin.forms import YesNoSwitch
from .models import Category, CategoryRole, RoleCategoryACL
class PermissionsForm(forms.Form):
legend = pgettext_lazy("categories permission", "Category access")
can_see = YesNoSwitch(
label=pgettext_lazy("categories permission", "Can see category")
)
can_browse = YesNoSwitch(
label=pgettext_lazy("categories permission", "Can see category contents")
)
def change_permissions_form(role):
if isinstance(role, CategoryRole):
return PermissionsForm
def build_acl(acl, roles, key_name):
new_acl = {"visible_categories": [], "browseable_categories": [], "categories": {}}
new_acl.update(acl)
roles = get_categories_roles(roles)
for category in Category.objects.all_categories():
build_category_acl(new_acl, category, roles, key_name)
return new_acl
def get_categories_roles(roles):
queryset = RoleCategoryACL.objects.filter(role__in=roles)
queryset = queryset.select_related("category_role")
roles = {}
for acl_relation in queryset.iterator():
role = acl_relation.category_role
roles.setdefault(acl_relation.category_id, []).append(role)
return roles
def build_category_acl(acl, category, categories_roles, key_name):
if category.level > 1:
if category.parent_id not in acl["visible_categories"]:
# dont bother with child categories of invisible parents
return
if not acl["categories"][category.parent_id]["can_browse"]:
# parent's visible, but its contents aint
return
category_roles = categories_roles.get(category.pk, [])
final_acl = {"can_see": 0, "can_browse": 0}
algebra.sum_acls(
final_acl,
roles=category_roles,
key=key_name,
can_see=algebra.greater,
can_browse=algebra.greater,
)
if final_acl["can_see"]:
acl["visible_categories"].append(category.pk)
acl["categories"][category.pk] = final_acl
if final_acl["can_browse"]:
acl["browseable_categories"].append(category.pk)
def add_acl_to_category(user_acl, target):
target.acl["can_see"] = can_see_category(user_acl, target)
target.acl["can_browse"] = can_browse_category(user_acl, target)
def serialize_categories_acls(user_acl):
categories_acl = []
for category, acl in user_acl.pop("categories").items():
if acl["can_browse"]:
categories_acl.append(
{
"id": category,
"can_start_threads": acl.get("can_start_threads", False),
"can_reply_threads": acl.get("can_reply_threads", False),
"can_pin_threads": acl.get("can_pin_threads", 0),
"can_hide_threads": acl.get("can_hide_threads", 0),
"can_close_threads": acl.get("can_close_threads", False),
}
)
user_acl["categories"] = categories_acl
def register_with(registry):
registry.acl_annotator(Category, add_acl_to_category)
registry.user_acl_serializer(serialize_categories_acls)
def allow_see_category(user_acl, target):
try:
category_id = target.pk
except AttributeError:
category_id = int(target)
if not category_id in user_acl["visible_categories"]:
raise Http404()
can_see_category = return_boolean(allow_see_category)
def allow_browse_category(user_acl, target):
target_acl = user_acl["categories"].get(target.id, {"can_browse": False})
if not target_acl["can_browse"]:
message = pgettext_lazy(
"categories permission",
'You don\'t have permission to browse "%(category)s" contents.',
)
raise PermissionDenied(message % {"category": target.name})
can_browse_category = return_boolean(allow_browse_category)
| 4,100
|
Python
|
.py
| 94
| 36.06383
| 87
| 0.665743
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,664
|
categories.py
|
rafalp_Misago/misago/categories/categories.py
|
from typing import Any
from django.core.cache import cache
from django.urls import reverse
from ..cache.enums import CacheName
from ..permissions.enums import CategoryPermission
from ..permissions.proxy import UserPermissionsProxy
from .hooks import (
get_categories_query_values_hook,
get_category_data_hook,
)
from .models import Category
CACHE_PREFIX = "categories"
def get_categories(
user_permissions: UserPermissionsProxy,
cache_versions: dict[str, str],
) -> dict[int, dict]:
cache_key = get_cache_key(user_permissions, cache_versions)
categories_map = cache.get(cache_key, None)
if categories_map is None:
categories_map = get_categories_from_db(user_permissions)
cache.set(cache_key, categories_map)
return {c["id"]: c for c in categories_map}
def get_cache_key(
user_permissions: UserPermissionsProxy,
cache_versions: dict[str, str],
) -> str:
categories_version = cache_versions[CacheName.CATEGORIES]
perms_version = cache_versions[CacheName.PERMISSIONS]
if user_permissions.user.is_authenticated:
permissions_id = user_permissions.user.permissions_id
else:
permissions_id = "anonymous"
return f"{CACHE_PREFIX}:{categories_version}:{perms_version}:{permissions_id}"
def get_categories_from_db(user_permissions: UserPermissionsProxy) -> list[dict]:
categories_list = []
queryset = Category.objects.filter(
id__in=user_permissions.categories[CategoryPermission.SEE],
special_role__isnull=True,
).order_by("lft")
fields = get_category_fields()
for category in queryset.values(*fields):
categories_list.append(get_category_data(category))
return categories_list
CATEGORY_FIELDS = (
"id",
"parent_id",
"name",
"slug",
"short_name",
"color",
"css_class",
"delay_browse_check",
"show_started_only",
"is_closed",
"is_vanilla",
"level",
"lft",
"rght",
)
def get_category_fields() -> set[str]:
return get_categories_query_values_hook(_get_category_fields_action)
def _get_category_fields_action() -> set[str]:
return set(CATEGORY_FIELDS)
def get_category_data(result: dict[str, Any]) -> dict[str, Any]:
return get_category_data_hook(_get_category_data_action, result)
def _get_category_data_action(result: dict[str, Any]) -> dict[str, Any]:
category_url = reverse(
"misago:category",
kwargs={"id": result["id"], "slug": result["slug"]},
)
return {
"id": result["id"],
"parent_id": result["parent_id"] if result["level"] > 1 else None,
"name": result["name"],
"short_name": result["short_name"],
"color": result["color"],
"css_class": result["css_class"],
"delay_browse_check": result["delay_browse_check"],
"show_started_only": result["show_started_only"],
"is_closed": result["is_closed"],
"is_vanilla": result["is_vanilla"],
"level": result["level"] - 1,
"lft": result["lft"],
"rght": result["rght"],
"url": category_url,
}
| 3,103
|
Python
|
.py
| 86
| 30.709302
| 82
| 0.671567
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,665
|
views.py
|
rafalp_Misago/misago/categories/views.py
|
from typing import TYPE_CHECKING
from django.contrib import messages
from django.db import transaction
from django.http import HttpRequest, HttpResponse
from django.shortcuts import redirect, render
from django.urls import reverse
from django.utils import timezone
from django.utils.translation import pgettext
from ..metatags.metatags import get_forum_index_metatags
from ..readtracker.models import ReadCategory, ReadThread
from .hooks import (
get_categories_page_component_hook,
get_categories_page_metatags_hook,
)
from .components import get_categories_data
if TYPE_CHECKING:
from ..users.models import User
def index(request, *args, is_index: bool | None = None, **kwargs):
if not is_index and request.settings.index_view == "categories":
return redirect(reverse("misago:index"))
if (
request.method == "POST"
and "mark_as_read" in request.POST
and request.user.is_authenticated
):
if response := mark_as_read(request):
return response
context = {
"is_index": is_index,
"categories_list": get_categories_page_component(request),
}
context["metatags"] = get_categories_page_metatags(request, context)
if request.is_htmx:
template_name = "misago/categories/partial.html"
else:
template_name = "misago/categories/index.html"
return render(request, template_name, context)
def mark_as_read(request: HttpRequest) -> HttpResponse | None:
if not request.POST.get("confirm"):
return render(request, "misago/categories/mark_as_read_page.html")
if categories_ids := list(request.categories.categories):
read_all_categories(request.user, categories_ids)
messages.success(
request, pgettext("mark categories as read", "Categories marked as read")
)
if request.is_htmx:
return None
if request.settings.index_view == "categories":
return redirect(reverse("misago:index"))
return redirect(reverse("misago:categories"))
@transaction.atomic
def read_all_categories(user: "User", categories_ids: list[int]):
read_time = timezone.now()
# Clear read tracker for categories
ReadThread.objects.filter(user=user, category_id__in=categories_ids).delete()
ReadCategory.objects.filter(user=user, category_id__in=categories_ids).delete()
ReadCategory.objects.bulk_create(
ReadCategory(user=user, read_time=read_time, category_id=category_id)
for category_id in categories_ids
)
def get_categories_page_component(request: HttpRequest) -> dict:
return get_categories_page_component_hook(
_get_categories_page_component_action, request
)
def _get_categories_page_component_action(request: HttpRequest) -> dict:
return {
"categories": get_categories_data(request),
"template_name": "misago/categories/component.html",
}
def get_categories_page_metatags(request: HttpRequest, context: dict) -> dict:
return get_categories_page_metatags_hook(
_get_categories_page_metatags_action, request, context
)
def _get_categories_page_metatags_action(request: HttpRequest, context: dict) -> dict:
if context["is_index"]:
return get_forum_index_metatags(request)
return {}
| 3,289
|
Python
|
.py
| 77
| 37.12987
| 86
| 0.723217
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,666
|
0012_categories_trees_ids.py
|
rafalp_Misago/misago/categories/migrations/0012_categories_trees_ids.py
|
# Generated by Django 4.2.7 on 2023-12-19 18:07
from django.db import migrations
from ..enums import CategoryTree, CategoryTreeDeprecated
def change_default_categories_trees_ids(apps, schema_editor):
# Swaps tree ids for threads and private threads around
Category = apps.get_model("misago_categories", "Category")
Category.objects.filter(tree_id=CategoryTreeDeprecated.THREADS).update(
tree_id=CategoryTree.THREADS
)
Category.objects.filter(special_role="private_threads").update(
tree_id=CategoryTree.PRIVATE_THREADS
)
class Migration(migrations.Migration):
dependencies = [
("misago_categories", "0011_plugin_data"),
]
operations = [migrations.RunPython(change_default_categories_trees_ids)]
| 762
|
Python
|
.py
| 17
| 39.882353
| 76
| 0.753388
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,667
|
0002_default_categories.py
|
rafalp_Misago/misago/categories/migrations/0002_default_categories.py
|
from django.db import migrations
from ...core.utils import slugify
from ..enums import CategoryTreeDeprecated
_ = lambda s: s
def create_default_categories_tree(apps, schema_editor):
Category = apps.get_model("misago_categories", "Category")
Category.objects.create(
special_role="private_threads",
name="Private",
slug="private",
lft=1,
rght=2,
tree_id=CategoryTreeDeprecated.PRIVATE_THREADS,
level=0,
)
root = Category.objects.create(
special_role="root_category",
name="Root",
slug="root",
lft=1,
rght=4,
tree_id=CategoryTreeDeprecated.THREADS,
level=0,
)
category_name = _("First category")
Category.objects.create(
parent=root,
lft=2,
rght=3,
tree_id=CategoryTreeDeprecated.THREADS,
level=1,
name=category_name,
slug=slugify(category_name),
)
class Migration(migrations.Migration):
dependencies = [("misago_categories", "0001_initial")]
operations = [migrations.RunPython(create_default_categories_tree)]
| 1,129
|
Python
|
.py
| 37
| 23.594595
| 71
| 0.648474
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,668
|
0006_moderation_queue_roles.py
|
rafalp_Misago/misago/categories/migrations/0006_moderation_queue_roles.py
|
from django.db import migrations
_ = lambda s: s
def create_default_categories_roles(apps, schema_editor):
CategoryRole = apps.get_model("misago_categories", "CategoryRole")
CategoryRole.objects.create(
name=_("In moderation queue"),
permissions={
# threads perms
"misago.threads.permissions.threads": {
"require_threads_approval": 1,
"require_replies_approval": 1,
}
},
)
class Migration(migrations.Migration):
dependencies = [("misago_categories", "0005_auto_20170303_2027")]
operations = [migrations.RunPython(create_default_categories_roles)]
| 666
|
Python
|
.py
| 17
| 31.176471
| 72
| 0.652648
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,669
|
0009_auto_20221101_2111.py
|
rafalp_Misago/misago/categories/migrations/0009_auto_20221101_2111.py
|
# Generated by Django 3.2.15 on 2022-11-01 21:11
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("misago_categories", "0008_auto_20190518_1659"),
]
operations = [
migrations.AddField(
model_name="category",
name="color",
field=models.CharField(blank=True, max_length=7, null=True),
),
migrations.AddField(
model_name="category",
name="short_name",
field=models.CharField(blank=True, max_length=255, null=True),
),
]
| 598
|
Python
|
.py
| 18
| 24.888889
| 74
| 0.604167
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,670
|
0001_initial.py
|
rafalp_Misago/misago/categories/migrations/0001_initial.py
|
import django.db.models.deletion
import mptt.fields
from django.conf import settings
from django.db import migrations, models
from ...acl.models import permissions_default
class Migration(migrations.Migration):
initial = True
dependencies = [
("misago_acl", "0001_initial"),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name="Category",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"special_role",
models.CharField(max_length=255, null=True, blank=True),
),
("name", models.CharField(max_length=255)),
("slug", models.CharField(max_length=255)),
("description", models.TextField(null=True, blank=True)),
("is_closed", models.BooleanField(default=False)),
("threads", models.PositiveIntegerField(default=0)),
("posts", models.PositiveIntegerField(default=0)),
(
"last_thread_title",
models.CharField(max_length=255, null=True, blank=True),
),
(
"last_thread_slug",
models.CharField(max_length=255, null=True, blank=True),
),
(
"last_poster_name",
models.CharField(max_length=255, null=True, blank=True),
),
(
"last_poster_slug",
models.CharField(max_length=255, null=True, blank=True),
),
("last_post_on", models.DateTimeField(null=True, blank=True)),
("prune_started_after", models.PositiveIntegerField(default=0)),
("prune_replied_after", models.PositiveIntegerField(default=0)),
("css_class", models.CharField(max_length=255, null=True, blank=True)),
("lft", models.PositiveIntegerField(editable=False, db_index=True)),
("rght", models.PositiveIntegerField(editable=False, db_index=True)),
("tree_id", models.PositiveIntegerField(editable=False, db_index=True)),
("level", models.PositiveIntegerField(editable=False, db_index=True)),
(
"archive_pruned_in",
models.ForeignKey(
related_name="pruned_archive",
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to="misago_categories.Category",
null=True,
),
),
(
"last_poster",
models.ForeignKey(
related_name="+",
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to=settings.AUTH_USER_MODEL,
null=True,
),
),
(
"parent",
mptt.fields.TreeForeignKey(
related_name="children",
on_delete=django.db.models.deletion.CASCADE,
blank=True,
to="misago_categories.Category",
null=True,
),
),
],
options={"abstract": False},
bases=(models.Model,),
),
migrations.CreateModel(
name="CategoryRole",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("name", models.CharField(max_length=255)),
(
"special_role",
models.CharField(max_length=255, null=True, blank=True),
),
("permissions", models.JSONField(default=permissions_default)),
],
options={"abstract": False},
bases=(models.Model,),
),
migrations.CreateModel(
name="RoleCategoryACL",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"category",
models.ForeignKey(
related_name="category_role_set",
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
),
(
"category_role",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.CategoryRole",
to_field="id",
),
),
(
"role",
models.ForeignKey(
related_name="categories_acls",
on_delete=django.db.models.deletion.CASCADE,
to="misago_acl.Role",
),
),
],
options={},
bases=(models.Model,),
),
]
| 6,014
|
Python
|
.py
| 155
| 20.709677
| 88
| 0.423471
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,671
|
0010_alter_rolecategoryacl_category_role.py
|
rafalp_Misago/misago/categories/migrations/0010_alter_rolecategoryacl_category_role.py
|
# Generated by Django 4.2.7 on 2023-11-13 19:08
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
("misago_categories", "0009_auto_20221101_2111"),
]
operations = [
migrations.AlterField(
model_name="rolecategoryacl",
name="category_role",
field=models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.categoryrole",
),
),
]
| 559
|
Python
|
.py
| 17
| 24.588235
| 60
| 0.622677
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,672
|
0013_new_behaviors.py
|
rafalp_Misago/misago/categories/migrations/0013_new_behaviors.py
|
# Generated by Django 4.2.10 on 2024-06-13 16:16
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("misago_categories", "0012_categories_trees_ids"),
]
operations = [
migrations.AddField(
model_name="category",
name="delay_browse_check",
field=models.BooleanField(default=False),
),
migrations.AddField(
model_name="category",
name="allow_polls",
field=models.BooleanField(default=True),
),
migrations.AddField(
model_name="category",
name="show_started_only",
field=models.BooleanField(default=False),
),
migrations.AddField(
model_name="category",
name="children_categories_component",
field=models.CharField(
default="full",
max_length=12,
),
),
migrations.AddField(
model_name="category",
name="is_vanilla",
field=models.BooleanField(default=False),
),
migrations.AddField(
model_name="category",
name="list_children_threads",
field=models.BooleanField(default=True),
),
migrations.AddField(
model_name="category",
name="unapproved_posts",
field=models.PositiveIntegerField(default=0),
),
migrations.AddField(
model_name="category",
name="unapproved_threads",
field=models.PositiveIntegerField(default=0),
),
]
| 1,652
|
Python
|
.py
| 51
| 21.803922
| 59
| 0.560777
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,673
|
0005_auto_20170303_2027.py
|
rafalp_Misago/misago/categories/migrations/0005_auto_20170303_2027.py
|
# Generated by Django 1.10.5 on 2017-03-03 20:27
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_categories", "0004_category_last_thread")]
operations = [
migrations.AddField(
model_name="category",
name="require_edits_approval",
field=models.BooleanField(default=False),
),
migrations.AddField(
model_name="category",
name="require_replies_approval",
field=models.BooleanField(default=False),
),
migrations.AddField(
model_name="category",
name="require_threads_approval",
field=models.BooleanField(default=False),
),
]
| 749
|
Python
|
.py
| 21
| 26.52381
| 71
| 0.617931
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,674
|
0008_auto_20190518_1659.py
|
rafalp_Misago/misago/categories/migrations/0008_auto_20190518_1659.py
|
# Generated by Django 2.2.1 on 2019-05-18 16:59
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_categories", "0007_best_answers_roles")]
operations = [
migrations.AlterField(
model_name="category",
name="level",
field=models.PositiveIntegerField(editable=False),
),
migrations.AlterField(
model_name="category",
name="lft",
field=models.PositiveIntegerField(editable=False),
),
migrations.AlterField(
model_name="category",
name="rght",
field=models.PositiveIntegerField(editable=False),
),
]
| 722
|
Python
|
.py
| 21
| 25.190476
| 69
| 0.611191
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,675
|
0007_best_answers_roles.py
|
rafalp_Misago/misago/categories/migrations/0007_best_answers_roles.py
|
# Generated by Django 1.11.9 on 2018-03-18 20:40
from django.db import migrations
_ = lambda s: s
def create_default_categories_roles(apps, schema_editor):
CategoryRole = apps.get_model("misago_categories", "CategoryRole")
CategoryRole.objects.create(
name=_("Q&A user"),
permissions={
# best answers perms
"misago.threads.permissions.bestanswers": {
"can_mark_best_answers": 1,
"can_change_marked_answers": 1,
"best_answer_change_time": 60 * 36, # 1.5 day
}
},
)
CategoryRole.objects.create(
name=_("Q&A moderator"),
permissions={
# best answers perms
"misago.threads.permissions.bestanswers": {
"can_mark_best_answers": 2,
"can_change_marked_answers": 2,
"best_answer_change_time": 0,
}
},
)
class Migration(migrations.Migration):
dependencies = [("misago_categories", "0006_moderation_queue_roles")]
operations = [migrations.RunPython(create_default_categories_roles)]
| 1,125
|
Python
|
.py
| 30
| 28.1
| 73
| 0.593376
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,676
|
0011_plugin_data.py
|
rafalp_Misago/misago/categories/migrations/0011_plugin_data.py
|
# Generated by Django 4.2.7 on 2023-12-05 19:22
import django.contrib.postgres.indexes
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("misago_categories", "0010_alter_rolecategoryacl_category_role"),
]
operations = [
migrations.AddField(
model_name="category",
name="plugin_data",
field=models.JSONField(default=dict),
),
migrations.AddIndex(
model_name="category",
index=django.contrib.postgres.indexes.GinIndex(
fields=["plugin_data"], name="misago_cate_plugin__15709c_gin"
),
),
]
| 683
|
Python
|
.py
| 20
| 25.75
| 77
| 0.622155
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,677
|
0003_categories_roles.py
|
rafalp_Misago/misago/categories/migrations/0003_categories_roles.py
|
from django.db import migrations
_ = lambda s: s
def create_default_categories_roles(apps, schema_editor):
CategoryRole = apps.get_model("misago_categories", "CategoryRole")
CategoryRole.objects.create(
name=_("See only"),
permissions={
# categories perms
"misago.categories.permissions": {"can_see": 1, "can_browse": 0}
},
)
read_only = CategoryRole.objects.create(
name=_("Read only"),
permissions={
# categories perms
"misago.categories.permissions": {"can_see": 1, "can_browse": 1},
# threads perms
"misago.threads.permissions.threads": {
"can_see_all_threads": 1,
"can_see_posts_likes": 1,
"can_download_other_users_attachments": 1,
"can_like_posts": 1,
},
},
)
CategoryRole.objects.create(
name=_("Reply to threads"),
permissions={
# categories perms
"misago.categories.permissions": {"can_see": 1, "can_browse": 1},
# threads perms
"misago.threads.permissions.threads": {
"can_see_all_threads": 1,
"can_reply_threads": 1,
"can_edit_posts": 1,
"can_download_other_users_attachments": 1,
"max_attachment_size": 500,
"can_see_posts_likes": 2,
"can_like_posts": 1,
},
},
)
standard = CategoryRole.objects.create(
name=_("Start and reply threads"),
permissions={
# categories perms
"misago.categories.permissions": {"can_see": 1, "can_browse": 1},
# threads perms
"misago.threads.permissions.threads": {
"can_see_all_threads": 1,
"can_start_threads": 1,
"can_reply_threads": 1,
"can_edit_threads": 1,
"can_edit_posts": 1,
"can_download_other_users_attachments": 1,
"max_attachment_size": 500,
"can_see_posts_likes": 2,
"can_like_posts": 1,
},
},
)
moderator = CategoryRole.objects.create(
name=_("Moderator"),
permissions={
# categories perms
"misago.categories.permissions": {"can_see": 1, "can_browse": 1},
# threads perms
"misago.threads.permissions.threads": {
"can_see_all_threads": 1,
"can_start_threads": 1,
"can_reply_threads": 1,
"can_edit_threads": 2,
"can_edit_posts": 2,
"can_hide_own_threads": 2,
"can_hide_own_posts": 2,
"thread_edit_time": 0,
"post_edit_time": 0,
"can_hide_threads": 2,
"can_hide_posts": 2,
"can_protect_posts": 1,
"can_move_posts": 1,
"can_merge_posts": 1,
"can_announce_threads": 1,
"can_pin_threads": 2,
"can_close_threads": 1,
"can_move_threads": 1,
"can_merge_threads": 1,
"can_approve_content": 1,
"can_download_other_users_attachments": 1,
"max_attachment_size": 2500,
"can_delete_other_users_attachments": 1,
"can_see_posts_likes": 2,
"can_like_posts": 1,
"can_report_content": 1,
"can_see_reports": 1,
"can_hide_events": 2,
},
},
)
# assign category roles to roles
Category = apps.get_model("misago_categories", "Category")
Role = apps.get_model("misago_acl", "Role")
RoleCategoryACL = apps.get_model("misago_categories", "RoleCategoryACL")
category = Category.objects.get(tree_id=1, level=1)
RoleCategoryACL.objects.create(
role=Role.objects.get(name=_("Moderator")),
category=category,
category_role=moderator,
)
RoleCategoryACL.objects.create(
role=Role.objects.get(special_role="authenticated"),
category=category,
category_role=standard,
)
RoleCategoryACL.objects.create(
role=Role.objects.get(special_role="anonymous"),
category=category,
category_role=read_only,
)
class Migration(migrations.Migration):
dependencies = [
("misago_categories", "0002_default_categories"),
("misago_acl", "0003_default_roles"),
]
operations = [migrations.RunPython(create_default_categories_roles)]
| 4,686
|
Python
|
.py
| 125
| 25.64
| 77
| 0.524972
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,678
|
0004_category_last_thread.py
|
rafalp_Misago/misago/categories/migrations/0004_category_last_thread.py
|
import django.db.models.deletion
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("misago_threads", "0001_initial"),
("misago_categories", "0003_categories_roles"),
]
operations = [
migrations.AddField(
model_name="category",
name="last_thread",
field=models.ForeignKey(
related_name="+",
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to="misago_threads.Thread",
null=True,
),
preserve_default=True,
)
]
| 656
|
Python
|
.py
| 21
| 21.142857
| 61
| 0.55538
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,679
|
test_component.py
|
rafalp_Misago/misago/categories/tests/test_component.py
|
from unittest.mock import Mock
import pytest
from django.utils import timezone
from ...permissions.enums import CategoryPermission
from ...permissions.proxy import UserPermissionsProxy
from ...testutils import (
grant_category_group_permissions,
remove_category_group_permissions,
)
from ..components import get_categories_data, get_subcategories_data
from ..models import Category
@pytest.fixture
def mock_request(dynamic_settings, user, cache_versions):
user_permissions = UserPermissionsProxy(user, cache_versions)
return Mock(
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
def test_categories_component_data_returns_empty_categories_list(
default_category, mock_request
):
remove_category_group_permissions(default_category, mock_request.user.group)
data = get_categories_data(mock_request)
assert len(data) == 0
def test_categories_component_data_includes_category(default_category, mock_request):
data = get_categories_data(mock_request)
assert len(data) == 1
category_data = data[0]
assert category_data["category"] == default_category
assert category_data["threads"] == default_category.threads
assert category_data["posts"] == default_category.posts
assert category_data["children_threads"] == default_category.threads
assert category_data["children_posts"] == default_category.posts
assert category_data["children"] == []
assert not category_data["children_unread"]
def test_categories_component_data_excludes_invisible_category(
root_category, default_category, mock_request
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
data = get_categories_data(mock_request)
assert len(data) == 1
category_data = data[0]
assert category_data["category"] == default_category
assert category_data["children"] == []
def test_categories_component_data_includes_visible_category(
root_category, default_category, mock_request
):
sibling_category = Category(
name="Sibling Category", slug="sibling-category", threads=42, posts=100
)
sibling_category.insert_at(root_category, position="last-child", save=True)
grant_category_group_permissions(
sibling_category,
mock_request.user.group,
CategoryPermission.SEE,
)
data = get_categories_data(mock_request)
assert len(data) == 2
assert data[0]["category"] == default_category
assert data[0]["threads"] == default_category.threads
assert data[0]["posts"] == default_category.posts
assert data[0]["children_threads"] == default_category.threads
assert data[0]["children_posts"] == default_category.posts
assert data[0]["children"] == []
assert not data[0]["children_unread"]
assert data[1]["category"] == sibling_category
assert data[1]["threads"] == sibling_category.threads
assert data[1]["posts"] == sibling_category.posts
assert data[1]["children_threads"] == sibling_category.threads
assert data[1]["children_posts"] == sibling_category.posts
assert data[1]["children"] == []
assert not data[1]["children_unread"]
def test_categories_component_data_excludes_invisible_child_category(
root_category, default_category, mock_request
):
child_category = Category(
name="Child Category", slug="child-category", threads=42, posts=100
)
child_category.insert_at(root_category, position="last-child", save=True)
data = get_categories_data(mock_request)
assert len(data) == 1
category_data = data[0]
assert category_data["category"] == default_category
assert category_data["category"] == default_category
assert category_data["threads"] == default_category.threads
assert category_data["posts"] == default_category.posts
assert category_data["children_threads"] == default_category.threads
assert category_data["children_posts"] == default_category.posts
assert category_data["children"] == []
assert not category_data["children_unread"]
def test_categories_component_data_includes_visible_child_category(
default_category, mock_request
):
default_category.threads = 12
default_category.posts = 15
default_category.save()
child_category = Category(
name="Child Category", slug="child-category", threads=42, posts=100
)
child_category.insert_at(default_category, position="last-child", save=True)
grant_category_group_permissions(
child_category,
mock_request.user.group,
CategoryPermission.SEE,
)
data = get_categories_data(mock_request)
assert len(data) == 1
category_data = data[0]
assert category_data["category"] == default_category
assert category_data["category"] == default_category
assert category_data["threads"] == default_category.threads
assert category_data["posts"] == default_category.posts
assert (
category_data["children_threads"]
== default_category.threads + child_category.threads
)
assert (
category_data["children_posts"] == default_category.posts + child_category.posts
)
assert not category_data["children_unread"]
assert len(category_data["children"]) == 1
child_data = category_data["children"][0]
assert child_data["category"] == child_category
assert child_data["threads"] == child_category.threads
assert child_data["posts"] == child_category.posts
assert child_data["children_threads"] == child_category.threads
assert child_data["children_posts"] == child_category.posts
assert child_data["children"] == []
assert not child_data["children_unread"]
def test_categories_component_data_includes_unread_category(
default_category, mock_request, user
):
user.joined_on = user.joined_on.replace(year=2012)
user.save()
default_category.last_post_on = timezone.now()
default_category.save()
data = get_categories_data(mock_request)
assert len(data) == 1
category_data = data[0]
assert category_data["category"] == default_category
assert category_data["threads"] == default_category.threads
assert category_data["posts"] == default_category.posts
assert category_data["children_threads"] == default_category.threads
assert category_data["children_posts"] == default_category.posts
assert category_data["children"] == []
assert category_data["children_unread"]
def test_get_subcategories_data_returns_empty_categories_list(
default_category, mock_request
):
data = get_subcategories_data(mock_request, default_category)
assert len(data) == 0
def test_get_subcategories_data_excludes_sibling_categories(
root_category, default_category, mock_request
):
sibling_category = Category(
name="Sibling Category", slug="sibling-category", threads=42, posts=100
)
sibling_category.insert_at(root_category, position="last-child", save=True)
grant_category_group_permissions(
sibling_category,
mock_request.user.group,
CategoryPermission.SEE,
)
data = get_subcategories_data(mock_request, default_category)
assert len(data) == 0
def test_get_subcategories_data_excludes_invisible_child_category(
default_category, mock_request
):
child_category = Category(
name="Child Category", slug="child-category", threads=42, posts=100
)
child_category.insert_at(default_category, position="last-child", save=True)
data = get_subcategories_data(mock_request, default_category)
assert len(data) == 0
def test_get_subcategories_data_includes_visible_child_category(
default_category, mock_request
):
default_category.threads = 12
default_category.posts = 15
default_category.save()
child_category = Category(
name="Child Category", slug="child-category", threads=42, posts=100
)
child_category.insert_at(default_category, position="last-child", save=True)
grant_category_group_permissions(
child_category,
mock_request.user.group,
CategoryPermission.SEE,
)
data = get_subcategories_data(mock_request, default_category)
assert len(data) == 1
child_data = data[0]
assert child_data["category"] == child_category
assert child_data["threads"] == child_category.threads
assert child_data["posts"] == child_category.posts
assert child_data["children_threads"] == child_category.threads
assert child_data["children_posts"] == child_category.posts
assert child_data["children"] == []
assert not child_data["children_unread"]
def test_get_subcategories_data_includes_unread_child_category(
user, default_category, mock_request
):
user.joined_on = user.joined_on.replace(year=2012)
user.save()
default_category.threads = 12
default_category.posts = 15
default_category.save()
child_category = Category(
name="Child Category",
slug="child-category",
threads=42,
posts=100,
last_post_on=timezone.now(),
)
child_category.insert_at(default_category, position="last-child", save=True)
grant_category_group_permissions(
child_category,
mock_request.user.group,
CategoryPermission.SEE,
)
data = get_subcategories_data(mock_request, default_category)
assert len(data) == 1
child_data = data[0]
assert child_data["category"] == child_category
assert child_data["threads"] == child_category.threads
assert child_data["posts"] == child_category.posts
assert child_data["children_threads"] == child_category.threads
assert child_data["children_posts"] == child_category.posts
assert child_data["children"] == []
assert child_data["children_unread"]
| 9,877
|
Python
|
.py
| 232
| 37.357759
| 88
| 0.718264
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,680
|
test_category_model_manager.py
|
rafalp_Misago/misago/categories/tests/test_category_model_manager.py
|
from ..models import Category
def test_category_manager_returns_private_threads(private_threads_category):
category = Category.objects.private_threads()
assert category == private_threads_category
assert category.special_role == "private_threads"
def test_category_manager_returns_root_category(root_category):
category = Category.objects.root_category()
assert category == root_category
assert category.special_role == "root_category"
def test_category_manager_returns_all_categories(root_category):
test_category_a = Category(name="Test")
test_category_a.insert_at(root_category, position="last-child", save=True)
test_category_b = Category(name="Test 2")
test_category_b.insert_at(root_category, position="last-child", save=True)
all_categories_from_db = list(Category.objects.all_categories(True))
assert root_category in all_categories_from_db
assert test_category_a in all_categories_from_db
assert test_category_b in all_categories_from_db
| 1,014
|
Python
|
.py
| 18
| 51.611111
| 78
| 0.766497
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,681
|
test_categories_proxy.py
|
rafalp_Misago/misago/categories/tests/test_categories_proxy.py
|
from ...categories.models import Category
from ...permissions.enums import CategoryPermission
from ...permissions.proxy import UserPermissionsProxy
from ...testutils import (
grant_category_group_permissions,
remove_category_group_permissions,
)
from ..categories import get_category_data
from ..proxy import CategoriesProxy
def get_category_data_dict(category: Category):
return get_category_data(category.__dict__)
def test_categories_proxy_loads_categories_visible_to_anonymous_user(
default_category, anonymous_user, cache_versions
):
user_permissions = UserPermissionsProxy(anonymous_user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.categories[default_category.id] == get_category_data_dict(
default_category
)
def test_categories_proxy_loads_categories_visible_to_user(
default_category, user, cache_versions
):
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.categories[default_category.id] == get_category_data_dict(
default_category
)
def test_categories_proxy_excludes_categories_inaccessible_by_user(
root_category, user, cache_versions
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert sibling_category.id not in categories.categories
def test_categories_proxy_list_has_categories_visible_to_user(
root_category, default_category, user, cache_versions
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.categories_list == [
get_category_data_dict(default_category),
]
def test_categories_proxy_returns_category_parents_with_self(
root_category, default_category, user, cache_versions
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_category_parents(child_category.id) == [
get_category_data_dict(child_category),
get_category_data_dict(default_category),
]
def test_categories_proxy_returns_category_parents_without_self(
root_category, default_category, user, cache_versions
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_category_parents(child_category.id, include_self=False) == [
get_category_data_dict(default_category),
]
def test_categories_proxy_returns_category_path_with_self(
root_category, default_category, user, cache_versions
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_category_path(child_category.id) == [
get_category_data_dict(default_category),
get_category_data_dict(child_category),
]
def test_categories_proxy_returns_category_path_without_self(
root_category, default_category, user, cache_versions
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_category_path(child_category.id, include_self=False) == [
get_category_data_dict(default_category),
]
def test_categories_proxy_returns_category_descendants(
root_category, default_category, user, cache_versions
):
sibling_category = Category(
name="Sibling Category", slug="sibling-category", is_vanilla=True
)
sibling_category.insert_at(root_category, position="first-child", save=True)
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
deep_category = Category(name="Deep Category", slug="deep-category")
deep_category.insert_at(child_category, position="last-child", save=True)
default_category.refresh_from_db()
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
deep_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_category_descendants(default_category.id) == [
get_category_data_dict(default_category),
get_category_data_dict(child_category),
get_category_data_dict(deep_category),
]
def test_categories_proxy_returns_category_descendants_without_self(
root_category, default_category, user, cache_versions
):
sibling_category = Category(
name="Sibling Category", slug="sibling-category", is_vanilla=True
)
sibling_category.insert_at(root_category, position="first-child", save=True)
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
deep_category = Category(name="Deep Category", slug="deep-category")
deep_category.insert_at(child_category, position="last-child", save=True)
default_category.refresh_from_db()
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
deep_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_category_descendants(
default_category.id, include_self=False
) == [
get_category_data_dict(child_category),
get_category_data_dict(deep_category),
]
def test_categories_proxy_returns_empty_categories_menu(
default_category, user, cache_versions
):
remove_category_group_permissions(default_category, user.group)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_categories_menu() == []
def test_categories_proxy_returns_categories_menu_with_one_category(
default_category, user, cache_versions
):
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_categories_menu() == [
get_category_data_dict(default_category),
]
def test_categories_proxy_returns_categories_menu_with_two_categories(
root_category, default_category, user, cache_versions
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_categories_menu() == [
get_category_data_dict(default_category),
get_category_data_dict(sibling_category),
]
def test_categories_proxy_returns_categories_menu_with_vanilla_category(
root_category, default_category, user, cache_versions
):
sibling_category = Category(
name="Sibling Category", slug="sibling-category", is_vanilla=True
)
sibling_category.insert_at(root_category, position="last-child", save=True)
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(sibling_category, position="last-child", save=True)
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_categories_menu() == [
get_category_data_dict(default_category),
get_category_data_dict(sibling_category),
get_category_data_dict(child_category),
]
def test_categories_proxy_returns_categories_menu_without_empty_vanilla_category(
root_category, default_category, user, cache_versions
):
sibling_category = Category(
name="Sibling Category", slug="sibling-category", is_vanilla=True
)
sibling_category.insert_at(root_category, position="last-child", save=True)
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(sibling_category, position="last-child", save=True)
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_categories_menu() == [
get_category_data_dict(default_category),
]
def test_categories_proxy_sets_last_flag_on_categories_menu_vanilla_category_last_item(
root_category, default_category, user, cache_versions
):
sibling_category = Category(
name="Sibling Category", slug="sibling-category", is_vanilla=True
)
sibling_category.insert_at(root_category, position="first-child", save=True)
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(sibling_category, position="last-child", save=True)
default_category.refresh_from_db()
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_categories_menu() == [
get_category_data_dict(sibling_category),
dict(**get_category_data_dict(child_category), last=True),
get_category_data_dict(default_category),
]
def test_categories_proxy_returns_default_category_thread_path(
default_category, user, cache_versions
):
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_thread_categories(default_category.id) == [
get_category_data_dict(default_category),
]
def test_categories_proxy_returns_default_category_thread_path_from_default_category(
default_category, user, cache_versions
):
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert (
categories.get_thread_categories(default_category.id, default_category.id) == []
)
def test_categories_proxy_returns_child_category_thread_path(
default_category, user, cache_versions
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
default_category.refresh_from_db()
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_thread_categories(child_category.id) == [
get_category_data_dict(default_category),
get_category_data_dict(child_category),
]
def test_categories_proxy_returns_child_category_thread_path_from_default_category(
default_category, user, cache_versions
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
default_category.refresh_from_db()
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_thread_categories(child_category.id, default_category.id) == [
get_category_data_dict(child_category),
]
def test_categories_proxy_returns_child_category_thread_path_from_child_category(
default_category, user, cache_versions
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
default_category.refresh_from_db()
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_thread_categories(child_category.id, child_category.id) == []
def test_categories_proxy_returns_sibling_category_thread_path_from_child_category(
root_category, default_category, user, cache_versions
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
default_category.refresh_from_db()
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
grant_category_group_permissions(
sibling_category,
user.group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = CategoriesProxy(user_permissions, cache_versions)
assert categories.get_thread_categories(sibling_category.id, child_category.id) == [
get_category_data_dict(sibling_category),
]
| 18,130
|
Python
|
.py
| 418
| 37.263158
| 88
| 0.733678
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,682
|
test_prunecategories.py
|
rafalp_Misago/misago/categories/tests/test_prunecategories.py
|
from datetime import timedelta
from io import StringIO
from django.core.management import call_command
from django.test import TestCase
from django.utils import timezone
from ...threads import test
from ..management.commands import prunecategories
from ..models import Category
class PruneCategoriesTests(TestCase):
def test_category_prune_by_start_date(self):
"""command prunes category content based on start date"""
category = Category.objects.all_categories()[:1][0]
category.prune_started_after = 20
category.save()
# post old threads with recent replies
started_on = timezone.now() - timedelta(days=30)
posted_on = timezone.now()
for _ in range(10):
thread = test.post_thread(category, started_on=started_on)
test.reply_thread(thread, posted_on=posted_on)
# post recent threads that will be preserved
threads = [test.post_thread(category) for _ in range(10)]
category.synchronize()
self.assertEqual(category.threads, 20)
self.assertEqual(category.posts, 30)
# run command
command = prunecategories.Command()
out = StringIO()
call_command(command, stdout=out)
category.synchronize()
self.assertEqual(category.threads, 10)
self.assertEqual(category.posts, 10)
for thread in threads:
category.thread_set.get(id=thread.id)
command_output = out.getvalue().strip()
self.assertEqual(command_output, "Categories were pruned")
def test_category_prune_by_last_reply(self):
"""command prunes category content based on last reply date"""
category = Category.objects.all_categories()[:1][0]
category.prune_replied_after = 20
category.save()
# post old threads with recent replies
started_on = timezone.now() - timedelta(days=30)
for _ in range(10):
thread = test.post_thread(category, started_on=started_on)
test.reply_thread(thread)
# post recent threads that will be preserved
threads = [test.post_thread(category) for _ in range(10)]
category.synchronize()
self.assertEqual(category.threads, 20)
self.assertEqual(category.posts, 30)
# run command
command = prunecategories.Command()
out = StringIO()
call_command(command, stdout=out)
category.synchronize()
self.assertEqual(category.threads, 10)
self.assertEqual(category.posts, 10)
for thread in threads:
category.thread_set.get(id=thread.id)
command_output = out.getvalue().strip()
self.assertEqual(command_output, "Categories were pruned")
def test_category_archive_by_start_date(self):
"""command archives category content based on start date"""
category = Category.objects.all_categories()[:1][0]
archive = Category.objects.create(
lft=7, rght=8, tree_id=2, level=0, name="Archive", slug="archive"
)
category.prune_started_after = 20
category.archive_pruned_in = archive
category.save()
# post old threads with recent replies
started_on = timezone.now() - timedelta(days=30)
posted_on = timezone.now()
for _ in range(10):
thread = test.post_thread(category, started_on=started_on)
test.reply_thread(thread, posted_on=posted_on)
# post recent threads that will be preserved
threads = [test.post_thread(category) for _ in range(10)]
category.synchronize()
self.assertEqual(category.threads, 20)
self.assertEqual(category.posts, 30)
# run command
command = prunecategories.Command()
out = StringIO()
call_command(command, stdout=out)
category.synchronize()
self.assertEqual(category.threads, 10)
self.assertEqual(category.posts, 10)
archive.synchronize()
self.assertEqual(archive.threads, 10)
self.assertEqual(archive.posts, 20)
for thread in threads:
category.thread_set.get(id=thread.id)
command_output = out.getvalue().strip()
self.assertEqual(command_output, "Categories were pruned")
def test_category_archive_by_last_reply(self):
"""command archives category content based on last reply date"""
category = Category.objects.all_categories()[:1][0]
archive = Category.objects.create(
lft=7, rght=8, tree_id=2, level=0, name="Archive", slug="archive"
)
category.prune_replied_after = 20
category.archive_pruned_in = archive
category.save()
# post old threads with recent replies
started_on = timezone.now() - timedelta(days=30)
for _ in range(10):
thread = test.post_thread(category, started_on=started_on)
test.reply_thread(thread)
# post recent threads that will be preserved
threads = [test.post_thread(category) for _ in range(10)]
category.synchronize()
self.assertEqual(category.threads, 20)
self.assertEqual(category.posts, 30)
# run command
command = prunecategories.Command()
out = StringIO()
call_command(command, stdout=out)
category.synchronize()
self.assertEqual(category.threads, 10)
self.assertEqual(category.posts, 10)
archive.synchronize()
self.assertEqual(archive.threads, 10)
self.assertEqual(archive.posts, 20)
for thread in threads:
category.thread_set.get(id=thread.id)
command_output = out.getvalue().strip()
self.assertEqual(command_output, "Categories were pruned")
| 5,787
|
Python
|
.py
| 129
| 35.75969
| 77
| 0.655621
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,683
|
test_mark_as_read.py
|
rafalp_Misago/misago/categories/tests/test_mark_as_read.py
|
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...readtracker.models import ReadCategory, ReadThread
from ...test import assert_contains
@override_dynamic_settings(index_view="threads")
def test_categories_view_mark_as_read_displays_categories_for_guests(
default_category, client
):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
response = client.post(reverse("misago:categories"), {"mark_as_read": "true"})
assert_contains(response, default_category.description)
@override_dynamic_settings(index_view="threads")
def test_categories_view_mark_as_read_displays_confirmation_page_to_users(user_client):
response = user_client.post(reverse("misago:categories"), {"mark_as_read": "true"})
assert_contains(response, "Mark as read | Categories")
assert_contains(response, "Are you sure you want to mark all categories as read?")
@override_dynamic_settings(index_view="threads")
def test_categories_view_mark_as_read_marks_categories_read(
user_client, default_category, user, thread
):
ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=thread.last_post_on,
)
response = user_client.post(
reverse("misago:categories"), {"mark_as_read": "true", "confirm": "true"}
)
assert response.status_code == 302
assert response["location"] == reverse("misago:categories")
ReadCategory.objects.get(
user=user,
category=default_category,
)
assert not ReadThread.objects.exists()
@override_dynamic_settings(index_view="threads")
def test_categories_view_mark_as_read_marks_categories_read_in_htmx(
user_client, default_category, user, thread
):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=thread.last_post_on,
)
response = user_client.post(
reverse("misago:categories"),
{"mark_as_read": "true", "confirm": "true"},
headers={"hx-request": "true"},
)
assert_contains(response, default_category.description)
ReadCategory.objects.get(
user=user,
category=default_category,
)
assert not ReadThread.objects.exists()
| 2,400
|
Python
|
.py
| 60
| 34.65
| 87
| 0.716315
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,684
|
test_synchronizecategories.py
|
rafalp_Misago/misago/categories/tests/test_synchronizecategories.py
|
from io import StringIO
from django.core.management import call_command
from django.test import TestCase
from ...threads import test
from ..management.commands import synchronizecategories
from ..models import Category
class SynchronizeCategoriesTests(TestCase):
def test_categories_sync(self):
"""command synchronizes categories"""
category = Category.objects.all_categories()[:1][0]
threads = [test.post_thread(category) for _ in range(10)]
for thread in threads:
[test.reply_thread(thread) for _ in range(5)]
category.threads = 0
category.posts = 0
command = synchronizecategories.Command()
out = StringIO()
call_command(command, stdout=out)
category = Category.objects.get(id=category.id)
self.assertEqual(category.threads, 10)
self.assertEqual(category.posts, 60)
command_output = out.getvalue().splitlines()[-1].strip()
self.assertTrue(command_output.startswith("Synchronized 3 categories in"))
| 1,039
|
Python
|
.py
| 23
| 38.173913
| 82
| 0.705765
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,685
|
test_healcategorytrees.py
|
rafalp_Misago/misago/categories/tests/test_healcategorytrees.py
|
from io import StringIO
from django.core.management import call_command
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ..management.commands import healcategorytrees
from ..models import Category
def run_command():
"""Run the management command"""
command = healcategorytrees.Command()
out = StringIO()
call_command(command, stdout=out)
def test_heal_category_trees_command_rebuilds_trees(default_category):
category = Category.objects.create(
name="Test", slug="test", parent=default_category
)
Category.objects.filter(id=default_category.id).update(lft=2, rght=2)
Category.objects.filter(id=category.id).update(lft=10, rght=3)
run_command()
default_category.refresh_from_db()
assert default_category.lft == 2
assert default_category.rght == 5
category.refresh_from_db()
assert category.lft == 3
assert category.rght == 4
def test_heal_category_trees_command_invalidates_caches(db):
with assert_invalidates_cache(CacheName.CATEGORIES):
run_command()
| 1,089
|
Python
|
.py
| 27
| 35.925926
| 73
| 0.748571
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,686
|
test_heal_category_trees.py
|
rafalp_Misago/misago/categories/tests/test_heal_category_trees.py
|
import pytest
from ..delete import delete_category
from ..models import Category
from ..mptt import heal_category_trees
@pytest.fixture
def clear_categories(db):
for category in Category.objects.order_by("-lft"):
delete_category(category)
def create_category(
tree_id: int,
level: int,
lft: int,
rght: int,
parent_id: int | None = None,
) -> Category:
category = Category.objects.create(
name="Test",
slug="test",
tree_id=0,
level=0,
lft=1,
rght=2,
)
Category.objects.filter(id=category.id).update(
parent_id=parent_id,
tree_id=tree_id,
level=level,
lft=lft,
rght=rght,
)
category.parent_id = parent_id
category.tree_id = tree_id
category.level = level
category.lft = lft
category.rght = rght
return category
def repr_mptt(category: Category):
return (category.tree_id, category.level, category.lft, category.rght)
def test_heal_category_trees_fixes_top_leaf_category(clear_categories):
category = create_category(0, 10, 12, 0)
heal_category_trees()
category.refresh_from_db()
assert repr_mptt(category) == (0, 0, 1, 2)
def test_heal_category_trees_fixes_separate_trees(clear_categories):
category = create_category(0, 10, 12, 0)
other_category = create_category(1, 15, 4, 10)
heal_category_trees()
category.refresh_from_db()
assert repr_mptt(category) == (0, 0, 1, 2)
other_category.refresh_from_db()
assert repr_mptt(other_category) == (1, 0, 1, 2)
def test_heal_category_trees_fixes_overlapping_categories(clear_categories):
category = create_category(0, 10, 5, 10)
other_category = create_category(0, 15, 10, 15)
heal_category_trees()
category.refresh_from_db()
assert repr_mptt(category) == (0, 0, 1, 2)
other_category.refresh_from_db()
assert repr_mptt(other_category) == (0, 0, 3, 4)
def test_heal_category_trees_fixes_parents_children(clear_categories):
category = create_category(0, 10, 5, 10)
child_category = create_category(0, 15, 10, 15, category.id)
heal_category_trees()
category.refresh_from_db()
assert repr_mptt(category) == (0, 0, 1, 4)
child_category.refresh_from_db()
assert repr_mptt(child_category) == (0, 1, 2, 3)
def test_heal_category_trees_fixes_parents_children_siblings(clear_categories):
category = create_category(0, 10, 5, 10)
sibling_category = create_category(0, 15, 10, 15)
child_category = create_category(0, 15, 10, 15, category.id)
heal_category_trees()
category.refresh_from_db()
assert repr_mptt(category) == (0, 0, 1, 4)
child_category.refresh_from_db()
assert repr_mptt(child_category) == (0, 1, 2, 3)
sibling_category.refresh_from_db()
assert repr_mptt(sibling_category) == (0, 0, 5, 6)
def test_heal_category_trees_fixes_complex_tree(clear_categories):
category = create_category(0, 10, 5, 10)
sibling_category = create_category(0, 15, 10, 15)
child_category = create_category(0, 15, 10, 15, category.id)
deep_child_category = create_category(0, 15, 10, 15, child_category.id)
other_child_category = create_category(0, 15, 11, 18, category.id)
sibling_child_category = create_category(0, 15, 10, 15, sibling_category.id)
heal_category_trees()
category.refresh_from_db()
assert repr_mptt(category) == (0, 0, 1, 8)
child_category.refresh_from_db()
assert repr_mptt(child_category) == (0, 1, 2, 5)
deep_child_category.refresh_from_db()
assert repr_mptt(deep_child_category) == (0, 2, 3, 4)
other_child_category.refresh_from_db()
assert repr_mptt(other_child_category) == (0, 1, 6, 7)
sibling_category.refresh_from_db()
assert repr_mptt(sibling_category) == (0, 0, 9, 12)
sibling_child_category.refresh_from_db()
assert repr_mptt(sibling_child_category) == (0, 1, 10, 11)
| 3,936
|
Python
|
.py
| 98
| 34.836735
| 80
| 0.677122
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,687
|
test_categories_view.py
|
rafalp_Misago/misago/categories/tests/test_categories_view.py
|
from datetime import timedelta
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...permissions.enums import CategoryPermission
from ...test import assert_contains, assert_not_contains
from ...testutils import (
grant_category_group_permissions,
remove_category_group_permissions,
)
from ..models import Category
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_default_category_for_guest(default_category, client):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
response = client.get(reverse("misago:categories"))
assert_contains(response, default_category.description)
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_default_category_for_user(
default_category, user_client
):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
response = user_client.get(reverse("misago:categories"))
assert_contains(response, default_category.description)
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_for_guest_in_htmx(default_category, client):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
response = client.get(
reverse("misago:categories"),
headers={"hx-request": "true"},
)
assert_contains(response, default_category.description)
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_for_user_in_htmx(default_category, user_client):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
response = user_client.get(
reverse("misago:categories"),
headers={"hx-request": "true"},
)
assert_contains(response, default_category.description)
@override_dynamic_settings(index_view="threads")
def test_categories_view_excludes_default_category_for_guest_without_permission(
default_category, guests_group, client
):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
remove_category_group_permissions(default_category, guests_group)
response = client.get(reverse("misago:categories"))
assert_not_contains(response, default_category.description)
@override_dynamic_settings(index_view="threads")
def test_categories_view_excludes_default_category_for_user_without_permission(
default_category, user, user_client
):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
remove_category_group_permissions(default_category, user.group)
response = user_client.get(reverse("misago:categories"))
assert_not_contains(response, default_category.description)
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_child_category_for_user_with_permission(
default_category, user, user_client
):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
child_category = Category(
name="Child Category",
slug="child-category",
description="CHILD-CATEGORY-DESCRIPTION",
)
child_category.insert_at(default_category, position="last-child", save=True)
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
)
response = user_client.get(reverse("misago:categories"))
assert_contains(response, default_category.description)
assert_contains(response, child_category.description)
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_child_category_for_category_with_delay_browse_check(
default_category, user, user_client
):
default_category.delay_browse_check = True
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
child_category = Category(
name="Child Category",
slug="child-category",
description="CHILD-CATEGORY-DESCRIPTION",
)
child_category.insert_at(default_category, position="last-child", save=True)
remove_category_group_permissions(default_category, user.group)
grant_category_group_permissions(
default_category,
user.group,
CategoryPermission.SEE,
)
grant_category_group_permissions(
child_category,
user.group,
CategoryPermission.SEE,
)
response = user_client.get(reverse("misago:categories"))
assert_contains(response, default_category.description)
assert_contains(response, child_category.description)
@override_dynamic_settings(index_view="threads")
def test_categories_view_excludes_child_category_for_user_without_permission(
default_category, user_client
):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.save()
child_category = Category(
name="Child Category",
slug="child-category",
description="CHILD-CATEGORY-DESCRIPTION",
)
child_category.insert_at(default_category, position="last-child", save=True)
response = user_client.get(reverse("misago:categories"))
assert_contains(response, default_category.description)
assert_not_contains(response, child_category.description)
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_category_user_thread(
default_category, user_client, user_thread
):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.synchronize()
default_category.save()
response = user_client.get(reverse("misago:categories"))
assert_contains(response, default_category.description)
assert_contains(response, user_thread.title)
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_category_thread(
default_category, user_client, thread
):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.synchronize()
default_category.save()
response = user_client.get(reverse("misago:categories"))
assert_contains(response, default_category.description)
assert_contains(response, thread.title)
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_unread_category(
default_category, user_client, user, user_thread
):
user.joined_on -= timedelta(days=2)
user.save()
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.synchronize()
default_category.save()
response = user_client.get(reverse("misago:categories"))
assert_contains(response, default_category.description)
assert_contains(response, user_thread.title)
assert_contains(response, "Category has unread posts")
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_category_thread_if_category_allows_list_access(
default_category, user, user_client, thread
):
default_category.delay_browse_check = True
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.synchronize()
default_category.save()
remove_category_group_permissions(default_category, user.group)
grant_category_group_permissions(
default_category,
user.group,
CategoryPermission.SEE,
)
response = user_client.get(reverse("misago:categories"))
assert_contains(response, default_category.description)
assert_contains(response, thread.title)
@override_dynamic_settings(index_view="threads")
def test_categories_view_excludes_category_thread_if_user_has_no_browse_permission(
default_category, user, user_client, thread
):
default_category.description = "FIRST-CATEGORY-DESCRIPTION"
default_category.synchronize()
default_category.save()
remove_category_group_permissions(default_category, user.group)
grant_category_group_permissions(
default_category,
user.group,
CategoryPermission.SEE,
)
response = user_client.get(reverse("misago:categories"))
assert_contains(response, default_category.description)
assert_not_contains(response, thread.title)
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_empty_list_for_guest(
default_category, guests_group, client
):
remove_category_group_permissions(default_category, guests_group)
default_category.delete()
response = client.get(reverse("misago:categories"))
assert_contains(response, "No categories exist")
@override_dynamic_settings(index_view="threads")
def test_categories_view_displays_empty_list_for_user(
default_category, user, user_client
):
remove_category_group_permissions(default_category, user.group)
default_category.delete()
response = user_client.get(reverse("misago:categories"))
assert_contains(response, "No categories exist")
| 8,887
|
Python
|
.py
| 204
| 38.730392
| 87
| 0.761286
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,688
|
test_category_model.py
|
rafalp_Misago/misago/categories/tests/test_category_model.py
|
from ...threads.test import post_thread
from ..models import Category
def assert_category_is_empty(category: Category):
assert category.last_post_on is None
assert category.last_thread is None
assert category.last_thread_title is None
assert category.last_thread_slug is None
assert category.last_poster is None
assert category.last_poster_name is None
assert category.last_poster_slug is None
def test_category_synchronize_updates_category_data(default_category):
default_category.synchronize()
assert default_category.threads == 0
assert default_category.posts == 0
thread = post_thread(default_category)
hidden = post_thread(default_category)
unapproved = post_thread(default_category)
default_category.synchronize()
assert default_category.threads == 3
assert default_category.posts == 3
assert default_category.last_thread == unapproved
unapproved.is_unapproved = True
unapproved.post_set.update(is_unapproved=True)
unapproved.save()
default_category.synchronize()
assert default_category.threads == 2
assert default_category.posts == 2
assert default_category.last_thread == hidden
hidden.is_hidden = True
hidden.post_set.update(is_hidden=True)
hidden.save()
default_category.synchronize()
assert default_category.threads == 1
assert default_category.posts == 1
assert default_category.last_thread == thread
unapproved.is_unapproved = False
unapproved.post_set.update(is_unapproved=False)
unapproved.save()
default_category.synchronize()
assert default_category.threads == 2
assert default_category.posts == 2
assert default_category.last_thread == unapproved
def test_category_delete_content_deletes_category_threads(default_category):
for _ in range(10):
post_thread(default_category)
default_category.synchronize()
assert default_category.threads == 10
assert default_category.posts == 10
default_category.delete_content()
default_category.synchronize()
assert default_category.threads == 0
assert default_category.posts == 0
assert_category_is_empty(default_category)
def test_category_move_content_moves_category_contents(default_category):
"""move_content moves category threads and posts to other category"""
for _ in range(10):
post_thread(default_category)
default_category.synchronize()
# we are using category so we don't have to fake another category
new_category = Category.objects.create(
lft=7, rght=8, tree_id=2, level=0, name="Archive", slug="archive"
)
default_category.move_content(new_category)
default_category.synchronize()
new_category.synchronize()
assert default_category.threads == 0
assert default_category.posts == 0
assert_category_is_empty(default_category)
assert new_category.threads == 10
assert new_category.posts == 10
def test_category_set_last_thread_updates_last_thread_data(default_category):
default_category.synchronize()
new_thread = post_thread(default_category)
default_category.set_last_thread(new_thread)
assert default_category.last_post_on == new_thread.last_post_on
assert default_category.last_thread == new_thread
assert default_category.last_thread_title == new_thread.title
assert default_category.last_thread_slug == new_thread.slug
assert default_category.last_poster == new_thread.last_poster
assert default_category.last_poster_name == new_thread.last_poster_name
assert default_category.last_poster_slug == new_thread.last_poster_slug
def test_category_empty_last_thread_empties_last_thread_data(default_category):
post_thread(default_category)
default_category.synchronize()
default_category.empty_last_thread()
assert_category_is_empty(default_category)
| 3,877
|
Python
|
.py
| 86
| 39.930233
| 79
| 0.752262
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,689
|
test_get_categories.py
|
rafalp_Misago/misago/categories/tests/test_get_categories.py
|
from unittest.mock import ANY
from ...permissions.enums import CategoryPermission
from ...permissions.proxy import UserPermissionsProxy
from ...testutils import grant_category_group_permissions
from ..categories import get_categories, get_category_data
def grant_categories_permissions(user, categories):
for category in categories:
grant_category_group_permissions(
category, user.group, CategoryPermission.SEE, CategoryPermission.BROWSE
)
def test_get_categories_returns_all_categories_visible_by_user(
cache_versions,
user,
default_category,
sibling_category,
child_category,
other_category,
):
grant_categories_permissions(
user,
[
default_category,
sibling_category,
child_category,
other_category,
],
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = get_categories(user_permissions, cache_versions)
assert categories == {
default_category.id: get_category_data(default_category.__dict__),
sibling_category.id: get_category_data(sibling_category.__dict__),
child_category.id: get_category_data(child_category.__dict__),
other_category.id: get_category_data(other_category.__dict__),
}
def test_get_categories_uses_delay_browse_check_for_child_category(
cache_versions,
user,
default_category,
sibling_category,
child_category,
other_category,
):
sibling_category.delay_browse_check = True
sibling_category.save()
grant_categories_permissions(
user,
[
default_category,
sibling_category,
other_category,
],
)
grant_category_group_permissions(child_category, user.group, CategoryPermission.SEE)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = get_categories(user_permissions, cache_versions)
assert categories == {
default_category.id: get_category_data(default_category.__dict__),
sibling_category.id: get_category_data(sibling_category.__dict__),
child_category.id: get_category_data(child_category.__dict__),
other_category.id: get_category_data(other_category.__dict__),
}
def test_get_categories_excludes_categories_invisible_to_user(
cache_versions,
user,
default_category,
other_category,
):
grant_categories_permissions(
user,
[
default_category,
other_category,
],
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = get_categories(user_permissions, cache_versions)
assert categories == {
default_category.id: get_category_data(default_category.__dict__),
other_category.id: get_category_data(other_category.__dict__),
}
def test_get_categories_excludes_special_categories(
cache_versions,
user,
private_threads_category,
default_category,
other_category,
):
grant_categories_permissions(
user,
[
private_threads_category,
default_category,
other_category,
],
)
user_permissions = UserPermissionsProxy(user, cache_versions)
categories = get_categories(user_permissions, cache_versions)
assert categories == {
default_category.id: get_category_data(default_category.__dict__),
other_category.id: get_category_data(other_category.__dict__),
}
def test_get_categories_skips_database_read_if_there_is_cache(
mocker,
django_assert_num_queries,
cache_versions,
user,
default_category,
):
user_permissions = UserPermissionsProxy(user, cache_versions)
user_permissions.permissions
cache_get = mocker.patch(
"django.core.cache.cache.get",
return_value=[
get_category_data(default_category.__dict__),
],
)
with django_assert_num_queries(0):
categories = get_categories(user_permissions, cache_versions)
assert categories == {
default_category.id: get_category_data(default_category.__dict__),
}
cache_get.assert_called_once()
def test_get_categories_is_cached_when_database_is_used(
mocker,
django_assert_num_queries,
cache_versions,
user,
default_category,
other_category,
):
cache_set = mocker.patch("django.core.cache.cache.set")
grant_categories_permissions(
user,
[
default_category,
other_category,
],
)
user_permissions = UserPermissionsProxy(user, cache_versions)
user_permissions.permissions
with django_assert_num_queries(1):
categories = get_categories(user_permissions, cache_versions)
assert categories == {
default_category.id: get_category_data(default_category.__dict__),
other_category.id: get_category_data(other_category.__dict__),
}
cache_set.assert_called_with(
ANY,
[
get_category_data(default_category.__dict__),
get_category_data(other_category.__dict__),
],
)
def test_get_category_data_returns_dict_with_category_data(default_category):
assert get_category_data(default_category.__dict__) == {
"id": default_category.id,
"parent_id": None,
"level": default_category.level - 1,
"name": default_category.name,
"short_name": default_category.short_name,
"color": default_category.color,
"css_class": default_category.css_class,
"delay_browse_check": default_category.delay_browse_check,
"show_started_only": default_category.show_started_only,
"is_closed": default_category.is_closed,
"is_vanilla": default_category.is_vanilla,
"url": default_category.get_absolute_url(),
"lft": default_category.lft,
"rght": default_category.rght,
}
| 5,943
|
Python
|
.py
| 171
| 27.883041
| 88
| 0.671548
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,690
|
synchronizecategories.py
|
rafalp_Misago/misago/categories/management/commands/synchronizecategories.py
|
import time
from django.core.management.base import BaseCommand
from ....core.management.progressbar import show_progress
from ...models import Category
class Command(BaseCommand):
help = "Synchronizes categories"
def handle(self, *args, **options):
categories_to_sync = Category.objects.count()
message = "Synchronizing %s categories...\n"
self.stdout.write(message % categories_to_sync)
message = "\n\nSynchronized %s categories in %s"
start_time = time.time()
synchronized_count = 0
show_progress(self, synchronized_count, categories_to_sync)
for category in Category.objects.iterator():
category.synchronize()
category.save()
synchronized_count += 1
show_progress(self, synchronized_count, categories_to_sync)
end_time = time.time() - start_time
total_time = time.strftime("%H:%M:%S", time.gmtime(end_time))
self.stdout.write(message % (synchronized_count, total_time))
| 1,030
|
Python
|
.py
| 22
| 38.727273
| 71
| 0.673695
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,691
|
healcategorytrees.py
|
rafalp_Misago/misago/categories/management/commands/healcategorytrees.py
|
from django.core.management.base import BaseCommand
from ....acl.cache import clear_acl_cache
from ....cache.enums import CacheName
from ....cache.versions import invalidate_cache
from ...mptt import heal_category_trees
class Command(BaseCommand):
"""
This command rebuilds the category trees in the database.
It's useful when the MPTT data of one or more categories becomes invalid,
either due to a bug or manual database manipulation.
"""
help = "Heals the category trees in the database"
def handle(self, *args, **options):
heal_category_trees()
self.stdout.write("Rebuild category trees in the database.")
invalidate_cache(
CacheName.CATEGORIES,
CacheName.MODERATORS,
CacheName.PERMISSIONS,
)
clear_acl_cache()
self.stdout.write("Cleared caches associated with category trees.")
| 903
|
Python
|
.py
| 22
| 34.590909
| 77
| 0.704467
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,692
|
prunecategories.py
|
rafalp_Misago/misago/categories/management/commands/prunecategories.py
|
from datetime import timedelta
from django.core.management.base import BaseCommand
from django.utils import timezone
from ...models import Category
class Command(BaseCommand):
"""
This command is intended to work as CRON job fired
every few days (or more often) to execute categories pruning policies
"""
help = "Prunes categories"
def handle(self, *args, **options): # pylint: disable=too-many-branches
now = timezone.now()
synchronize_categories = []
for category in Category.objects.iterator():
archive = category.archive_pruned_in
pruned_threads = 0
threads_qs = category.thread_set.filter(weight=0)
if category.prune_started_after:
cutoff = now - timedelta(days=category.prune_started_after)
prune_qs = threads_qs.filter(started_on__lte=cutoff)
for thread in prune_qs.iterator(chunk_size=50):
if archive:
thread.move(archive)
thread.save()
else:
thread.delete()
pruned_threads += 1
if category.prune_replied_after:
cutoff = now - timedelta(days=category.prune_replied_after)
prune_qs = threads_qs.filter(last_post_on__lte=cutoff)
for thread in prune_qs.iterator(chunk_size=50):
if archive:
thread.move(archive)
thread.save()
else:
thread.delete()
pruned_threads += 1
if pruned_threads:
if category not in synchronize_categories:
synchronize_categories.append(category)
if archive and archive not in synchronize_categories:
synchronize_categories.append(archive)
for category in synchronize_categories:
category.synchronize()
category.save()
self.stdout.write("\n\nCategories were pruned")
| 2,100
|
Python
|
.py
| 46
| 31.5
| 76
| 0.575208
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,693
|
__init__.py
|
rafalp_Misago/misago/categories/admin/__init__.py
|
from django.urls import path
from django.utils.translation import pgettext_lazy
from .views.perms import (
CategoryPermissions,
CategoryRolesList,
DeleteCategoryRole,
EditCategoryRole,
NewCategoryRole,
RoleCategoriesACL,
)
class MisagoAdminExtension:
def register_urlpatterns(self, urlpatterns):
# Nodes
urlpatterns.patterns(
"categories",
path(
"permissions-deprecated/<int:pk>/",
CategoryPermissions.as_view(),
name="permissions-deprecated",
),
)
# Category Roles
urlpatterns.namespace("categories/", "categories", "permissions")
urlpatterns.patterns(
"permissions:categories",
path("", CategoryRolesList.as_view(), name="index"),
path("new/", NewCategoryRole.as_view(), name="new"),
path("edit/<int:pk>/", EditCategoryRole.as_view(), name="edit"),
path("delete/<int:pk>/", DeleteCategoryRole.as_view(), name="delete"),
)
# Change Role Category Permissions
urlpatterns.patterns(
"permissions",
path(
"categories/<int:pk>/",
RoleCategoriesACL.as_view(),
name="categories",
),
)
def register_navigation_nodes(self, site):
site.add_node(
name=pgettext_lazy("admin node", "Category permissions"),
parent="permissions",
namespace="categories",
)
| 1,541
|
Python
|
.py
| 45
| 24.4
| 82
| 0.585906
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,694
|
forms.py
|
rafalp_Misago/misago/categories/admin/forms.py
|
from django import forms
from django.utils.translation import pgettext_lazy
from ..models import CategoryRole
class CategoryRoleForm(forms.ModelForm):
name = forms.CharField(label=pgettext_lazy("admin category role form", "Role name"))
class Meta:
model = CategoryRole
fields = ["name"]
def RoleCategoryACLFormFactory(category, category_roles, selected_role):
attrs = {
"category": category,
"role": forms.ModelChoiceField(
label=pgettext_lazy("admin permissions form", "Role"),
required=False,
queryset=category_roles,
initial=selected_role,
empty_label=pgettext_lazy("admin permissions form", "No access"),
),
}
return type("RoleCategoryACLForm", (forms.Form,), attrs)
def CategoryRolesACLFormFactory(role, category_roles, selected_role):
attrs = {
"role": role,
"category_role": forms.ModelChoiceField(
label=pgettext_lazy("admin permissions form", "Role"),
required=False,
queryset=category_roles,
initial=selected_role,
empty_label=pgettext_lazy("admin permissions form", "No access"),
),
}
return type("CategoryRolesACLForm", (forms.Form,), attrs)
| 1,280
|
Python
|
.py
| 32
| 31.9375
| 88
| 0.659128
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,695
|
perms.py
|
rafalp_Misago/misago/categories/admin/views/perms.py
|
from django.contrib import messages
from django.shortcuts import redirect
from django.utils.translation import pgettext_lazy
from ....acl.admin.forms import get_permissions_forms
from ....acl.admin.views import RoleAdmin, RolesList
from ....acl.cache import clear_acl_cache
from ....acl.models import Role
from ....admin.views import generic
from ....admin.categories.views import CategoriesList, CategoryAdmin
from ...models import Category, CategoryRole, RoleCategoryACL
from ..forms import (
CategoryRoleForm,
CategoryRolesACLFormFactory,
RoleCategoryACLFormFactory,
)
class CategoryRoleAdmin(generic.AdminBaseMixin):
root_link = "misago:admin:permissions:categories:index"
model = CategoryRole
templates_dir = "misago/admin/categoryroles"
message_404 = pgettext_lazy(
"admin categories roles", "Requested role does not exist."
)
class CategoryRolesList(CategoryRoleAdmin, generic.ListView):
ordering = (("name", None),)
class RoleFormMixin:
def real_dispatch(self, request, target):
form = CategoryRoleForm(instance=target)
perms_forms = get_permissions_forms(target)
if request.method == "POST":
perms_forms = get_permissions_forms(target, request.POST)
valid_forms = 0
for permissions_form in perms_forms:
if permissions_form.is_valid():
valid_forms += 1
form = CategoryRoleForm(request.POST, instance=target)
if form.is_valid():
if len(perms_forms) == valid_forms:
new_permissions = {}
for permissions_form in perms_forms:
cleaned_data = permissions_form.cleaned_data
new_permissions[permissions_form.prefix] = cleaned_data
form.instance.permissions = new_permissions
form.instance.save()
messages.success(
request, self.message_submit % {"name": target.name}
)
if "stay" in request.POST:
return redirect(request.path)
return redirect(self.root_link)
form.add_error(
None, pgettext_lazy("admin form", "Form contains errors.")
)
template_name = self.get_template_name(request, target)
return self.render(
request,
{"form": form, "target": target, "perms_forms": perms_forms},
template_name,
)
class NewCategoryRole(RoleFormMixin, CategoryRoleAdmin, generic.ModelFormView):
message_submit = pgettext_lazy(
"admin categories roles", 'New role "%(name)s" has been saved.'
)
class EditCategoryRole(RoleFormMixin, CategoryRoleAdmin, generic.ModelFormView):
message_submit = pgettext_lazy(
"admin categories roles", 'Role "%(name)s" has been changed.'
)
class DeleteCategoryRole(CategoryRoleAdmin, generic.ButtonView):
def check_permissions(self, request, target):
if target.special_role:
message = pgettext_lazy(
"admin categories roles",
'Role "%(name)s" is special role and can\'t be deleted.',
)
return message % {"name": target.name}
def button_action(self, request, target):
target.delete()
message = pgettext_lazy(
"admin categories roles", 'Role "%(name)s" has been deleted.'
)
messages.success(request, message % {"name": target.name})
class CategoryPermissions(CategoryAdmin, generic.ModelFormView):
templates_dir = "misago/admin/categoryroles"
template_name = "categoryroles.html"
def real_dispatch(self, request, target):
category_roles = CategoryRole.objects.order_by("name")
assigned_roles = {}
for acl in target.category_role_set.select_related("category_role"):
assigned_roles[acl.role_id] = acl.category_role
forms = []
forms_are_valid = True
for role in Role.objects.order_by("name"):
FormType = CategoryRolesACLFormFactory(
role, category_roles, assigned_roles.get(role.pk)
)
if request.method == "POST":
forms.append(FormType(request.POST, prefix=role.pk))
if not forms[-1].is_valid():
forms_are_valid = False
else:
forms.append(FormType(prefix=role.pk))
if request.method == "POST" and forms_are_valid:
target.category_role_set.all().delete()
new_permissions = []
for form in forms:
if form.cleaned_data["category_role"]:
new_permissions.append(
RoleCategoryACL(
role=form.role,
category=target,
category_role=form.cleaned_data["category_role"],
)
)
if new_permissions:
RoleCategoryACL.objects.bulk_create(new_permissions)
clear_acl_cache()
message = pgettext_lazy(
"admin categories roles",
"Category %(name)s permissions have been changed.",
)
messages.success(request, message % {"name": target.name})
if "stay" in request.POST:
return redirect(request.path)
return redirect(self.root_link)
template_name = self.get_template_name(request, target)
return self.render(request, {"forms": forms, "target": target}, template_name)
CategoriesList.add_item_action(
name=pgettext_lazy("admin categories", "Change permissions (deprecated)"),
link="misago:admin:categories:permissions-deprecated",
)
class RoleCategoriesACL(RoleAdmin, generic.ModelFormView):
templates_dir = "misago/admin/categoryroles"
template_name = "rolecategories.html"
def real_dispatch(self, request, target):
categories = Category.objects.all_categories()
roles = CategoryRole.objects.order_by("name")
if not categories:
messages.info(
request, pgettext_lazy("admin categories", "No categories exist.")
)
return redirect(self.root_link)
choices = {}
for choice in target.categories_acls.select_related("category_role"):
choices[choice.category_id] = choice.category_role
forms = []
forms_are_valid = True
for category in categories:
category.level_range = range(category.level - 1)
FormType = RoleCategoryACLFormFactory(
category, roles, choices.get(category.pk)
)
if request.method == "POST":
forms.append(FormType(request.POST, prefix=category.pk))
if not forms[-1].is_valid():
forms_are_valid = False
else:
forms.append(FormType(prefix=category.pk))
if request.method == "POST" and forms_are_valid:
target.categories_acls.all().delete()
new_permissions = []
for form in forms:
if form.cleaned_data["role"]:
new_permissions.append(
RoleCategoryACL(
role=target,
category=form.category,
category_role=form.cleaned_data["role"],
)
)
if new_permissions:
RoleCategoryACL.objects.bulk_create(new_permissions)
clear_acl_cache()
message = pgettext_lazy(
"admin categories roles",
"Category permissions for role %(name)s have been changed.",
)
messages.success(request, message % {"name": target.name})
if "stay" in request.POST:
return redirect(request.path)
return redirect(self.root_link)
template_name = self.get_template_name(request, target)
return self.render(request, {"forms": forms, "target": target}, template_name)
RolesList.add_item_action(
name=pgettext_lazy("admin roles", "Categories permissions"),
link="misago:admin:permissions:categories",
)
| 8,399
|
Python
|
.py
| 185
| 33.291892
| 86
| 0.598996
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,696
|
test_permissions_admin_views.py
|
rafalp_Misago/misago/categories/admin/tests/test_permissions_admin_views.py
|
from django.urls import reverse
from ....acl import ACL_CACHE
from ....acl.models import Role
from ....acl.admin.test import mock_role_form_data
from ....admin.test import AdminTestCase
from ....cache.test import assert_invalidates_cache
from ...models import Category, CategoryRole
def create_data(data_dict):
return mock_role_form_data(CategoryRole(), data_dict)
class CategoryRoleAdminViewsTests(AdminTestCase):
def test_link_registered(self):
"""admin nav contains category roles link"""
response = self.client.get(reverse("misago:admin:permissions:categories:index"))
self.assertContains(
response, reverse("misago:admin:permissions:categories:index")
)
def test_list_view(self):
"""roles list view returns 200"""
response = self.client.get(reverse("misago:admin:permissions:categories:index"))
self.assertEqual(response.status_code, 200)
def test_new_view(self):
"""new role view has no showstoppers"""
response = self.client.get(reverse("misago:admin:permissions:categories:new"))
self.assertEqual(response.status_code, 200)
response = self.client.post(
reverse("misago:admin:permissions:categories:new"),
data=create_data({"name": "Test CategoryRole"}),
)
self.assertEqual(response.status_code, 302)
test_role = CategoryRole.objects.get(name="Test CategoryRole")
response = self.client.get(reverse("misago:admin:permissions:categories:index"))
self.assertContains(response, test_role.name)
def test_edit_view(self):
"""edit role view has no showstoppers"""
self.client.post(
reverse("misago:admin:permissions:categories:new"),
data=create_data({"name": "Test CategoryRole"}),
)
test_role = CategoryRole.objects.get(name="Test CategoryRole")
response = self.client.get(
reverse(
"misago:admin:permissions:categories:edit", kwargs={"pk": test_role.pk}
)
)
self.assertContains(response, "Test CategoryRole")
response = self.client.post(
reverse(
"misago:admin:permissions:categories:edit", kwargs={"pk": test_role.pk}
),
data=create_data({"name": "Top Lel"}),
)
self.assertEqual(response.status_code, 302)
test_role = CategoryRole.objects.get(name="Top Lel")
response = self.client.get(reverse("misago:admin:permissions:categories:index"))
self.assertContains(response, test_role.name)
def test_editing_role_invalidates_acl_cache(self):
self.client.post(
reverse("misago:admin:permissions:categories:new"),
data=create_data({"name": "Test CategoryRole"}),
)
test_role = CategoryRole.objects.get(name="Test CategoryRole")
with assert_invalidates_cache(ACL_CACHE):
self.client.post(
reverse(
"misago:admin:permissions:categories:edit",
kwargs={"pk": test_role.pk},
),
data=create_data({"name": "Top Lel"}),
)
def test_delete_view(self):
"""delete role view has no showstoppers"""
self.client.post(
reverse("misago:admin:permissions:categories:new"),
data=create_data({"name": "Test CategoryRole"}),
)
test_role = CategoryRole.objects.get(name="Test CategoryRole")
response = self.client.post(
reverse(
"misago:admin:permissions:categories:delete",
kwargs={"pk": test_role.pk},
)
)
self.assertEqual(response.status_code, 302)
self.client.get(reverse("misago:admin:permissions:categories:index"))
response = self.client.get(reverse("misago:admin:permissions:categories:index"))
self.assertNotContains(response, test_role.name)
def test_deleting_role_invalidates_acl_cache(self):
self.client.post(
reverse("misago:admin:permissions:categories:new"),
data=create_data({"name": "Test CategoryRole"}),
)
test_role = CategoryRole.objects.get(name="Test CategoryRole")
with assert_invalidates_cache(ACL_CACHE):
self.client.post(
reverse(
"misago:admin:permissions:categories:delete",
kwargs={"pk": test_role.pk},
)
)
def test_change_category_roles_view(self):
"""change category roles perms view works"""
root = Category.objects.root_category()
for descendant in root.get_descendants():
descendant.delete()
# Create categories tree for test cases:
#
# Category A
# + Category B
# Category C
# + Category D
root = Category.objects.root_category()
self.client.post(
reverse("misago:admin:categories:new"),
data={
"name": "Category A",
"new_parent": root.pk,
"children_categories_component": "full",
"prune_started_after": 0,
"prune_replied_after": 0,
},
)
test_category = Category.objects.get(slug="category-a")
self.assertEqual(Category.objects.count(), 3)
# Create test roles
self.client.post(
reverse("misago:admin:permissions:new"),
data=mock_role_form_data(Role(), {"name": "Test Role A"}),
)
self.client.post(
reverse("misago:admin:permissions:new"),
data=mock_role_form_data(Role(), {"name": "Test Role B"}),
)
test_role_a = Role.objects.get(name="Test Role A")
test_role_b = Role.objects.get(name="Test Role B")
self.client.post(
reverse("misago:admin:permissions:categories:new"),
data=create_data({"name": "Test Comments"}),
)
self.client.post(
reverse("misago:admin:permissions:categories:new"),
data=create_data({"name": "Test Full"}),
)
role_comments = CategoryRole.objects.get(name="Test Comments")
role_full = CategoryRole.objects.get(name="Test Full")
# Test view itself
# See if form page is rendered
response = self.client.get(
reverse(
"misago:admin:categories:permissions-deprecated",
kwargs={"pk": test_category.pk},
)
)
self.assertContains(response, test_category.name)
self.assertContains(response, test_role_a.name)
self.assertContains(response, test_role_b.name)
self.assertContains(response, role_comments.name)
self.assertContains(response, role_full.name)
# Assign roles to categories
response = self.client.post(
reverse(
"misago:admin:categories:permissions-deprecated",
kwargs={"pk": test_category.pk},
),
data={
("%s-category_role" % test_role_a.pk): role_full.pk,
("%s-category_role" % test_role_b.pk): role_comments.pk,
},
)
self.assertEqual(response.status_code, 302)
# Check that roles were assigned
category_role_set = test_category.category_role_set
self.assertEqual(
category_role_set.get(role=test_role_a).category_role_id, role_full.pk
)
self.assertEqual(
category_role_set.get(role=test_role_b).category_role_id, role_comments.pk
)
# Check that ACL was invalidated
with assert_invalidates_cache(ACL_CACHE):
self.client.post(
reverse(
"misago:admin:categories:permissions-deprecated",
kwargs={"pk": test_category.pk},
),
data={
("%s-category_role" % test_role_a.pk): role_full.pk,
("%s-category_role" % test_role_b.pk): role_comments.pk,
},
)
def test_change_role_categories_permissions_view(self):
"""change role categories perms view works"""
self.client.post(
reverse("misago:admin:permissions:new"),
data=mock_role_form_data(Role(), {"name": "Test CategoryRole"}),
)
test_role = Role.objects.get(name="Test CategoryRole")
root = Category.objects.root_category()
for descendant in root.get_descendants():
descendant.delete()
self.assertEqual(Category.objects.count(), 2)
response = self.client.get(
reverse("misago:admin:permissions:categories", kwargs={"pk": test_role.pk})
)
self.assertEqual(response.status_code, 302)
# Create categories tree for test cases:
#
# Category A
# + Category B
# Category C
# + Category D
root = Category.objects.root_category()
a = self.client.post(
reverse("misago:admin:categories:new"),
data={
"name": "Category A",
"new_parent": root.pk,
"children_categories_component": "full",
"prune_started_after": 0,
"prune_replied_after": 0,
},
)
self.client.post(
reverse("misago:admin:categories:new"),
data={
"name": "Category C",
"new_parent": root.pk,
"children_categories_component": "full",
"prune_started_after": 0,
"prune_replied_after": 0,
},
)
category_a = Category.objects.get(slug="category-a")
category_c = Category.objects.get(slug="category-c")
self.client.post(
reverse("misago:admin:categories:new"),
data={
"name": "Category B",
"new_parent": category_a.pk,
"children_categories_component": "full",
"prune_started_after": 0,
"prune_replied_after": 0,
},
)
category_b = Category.objects.get(slug="category-b")
self.client.post(
reverse("misago:admin:categories:new"),
data={
"name": "Category D",
"new_parent": category_c.pk,
"children_categories_component": "full",
"prune_started_after": 0,
"prune_replied_after": 0,
},
)
category_d = Category.objects.get(slug="category-d")
self.assertEqual(Category.objects.count(), 6)
# See if form page is rendered
response = self.client.get(
reverse("misago:admin:permissions:categories", kwargs={"pk": test_role.pk})
)
self.assertContains(response, category_a.name)
self.assertContains(response, category_b.name)
self.assertContains(response, category_c.name)
self.assertContains(response, category_d.name)
# Set test roles
self.client.post(
reverse("misago:admin:permissions:categories:new"),
data=create_data({"name": "Test Comments"}),
)
role_comments = CategoryRole.objects.get(name="Test Comments")
self.client.post(
reverse("misago:admin:permissions:categories:new"),
data=create_data({"name": "Test Full"}),
)
role_full = CategoryRole.objects.get(name="Test Full")
# See if form contains those roles
response = self.client.get(
reverse("misago:admin:permissions:categories", kwargs={"pk": test_role.pk})
)
self.assertContains(response, role_comments.name)
self.assertContains(response, role_full.name)
# Assign roles to categories
response = self.client.post(
reverse("misago:admin:permissions:categories", kwargs={"pk": test_role.pk}),
data={
("%s-role" % category_a.pk): role_comments.pk,
("%s-role" % category_b.pk): role_comments.pk,
("%s-role" % category_c.pk): role_full.pk,
("%s-role" % category_d.pk): role_full.pk,
},
)
self.assertEqual(response.status_code, 302)
# Check that roles were assigned
categories_acls = test_role.categories_acls
self.assertEqual(
categories_acls.get(category=category_a).category_role_id, role_comments.pk
)
self.assertEqual(
categories_acls.get(category=category_b).category_role_id, role_comments.pk
)
self.assertEqual(
categories_acls.get(category=category_c).category_role_id, role_full.pk
)
self.assertEqual(
categories_acls.get(category=category_d).category_role_id, role_full.pk
)
# Check that ACL was invalidated
with assert_invalidates_cache(ACL_CACHE):
self.client.post(
reverse(
"misago:admin:permissions:categories", kwargs={"pk": test_role.pk}
),
data={
("%s-role" % category_a.pk): role_comments.pk,
("%s-role" % category_b.pk): role_comments.pk,
("%s-role" % category_c.pk): role_full.pk,
("%s-role" % category_d.pk): role_full.pk,
},
)
| 13,591
|
Python
|
.py
| 319
| 31.056426
| 88
| 0.578561
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,697
|
get_categories_page_component.py
|
rafalp_Misago/misago/categories/hooks/get_categories_page_component.py
|
from typing import Protocol
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
class GetCategoriesPageComponentHookAction(Protocol):
"""
A standard Misago function used to build a `dict` with data for
the categories list component, used to display the list of categories on
the categories page.
# Arguments
## `request: HttpRequest`
The request object.
# Return value
A Python `dict` with data for the categories list component.
Must have at least two keys: `categories` and `template_name`:
```python
{
"categories": ...,
"template_name": "misago/categories/list.html"
}
```
"""
def __call__(self, request: HttpRequest) -> dict: ...
class GetCategoriesPageComponentHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetCategoriesPageComponentHookAction`
A standard Misago function used to build a `dict` with data for
the categories list component, used to display the list of categories on
the categories page.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
# Return value
A Python `dict` with data for the categories list component.
"""
def __call__(
self, action: GetCategoriesPageComponentHookAction, request: HttpRequest
) -> dict: ...
class GetCategoriesPageComponentHook(
FilterHook[
GetCategoriesPageComponentHookAction, GetCategoriesPageComponentHookFilter
]
):
"""
This hook wraps the standard function that Misago uses to build a `dict`
with data for the categories list component, used to display the list of
categories on the categories page.
# Example
The code below implements a custom filter function that replaces default
categories component with a custom one.
```python
from django.http import HttpRequest
from misago.categories.hooks import get_categories_component_hook
@get_categories_component_hook.append_filter
def custom_categories_list(action, request: HttpRequest) -> dict:
return {
"categories": [],
"template_name": "plugin/categories_list.html",
}
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self, action: GetCategoriesPageComponentHookAction, request: HttpRequest
) -> dict:
return super().__call__(action, request)
get_categories_page_component_hook = GetCategoriesPageComponentHook()
| 2,594
|
Python
|
.py
| 68
| 32.411765
| 82
| 0.70947
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,698
|
__init__.py
|
rafalp_Misago/misago/categories/hooks/__init__.py
|
from .get_categories_page_component import get_categories_page_component_hook
from .get_categories_page_metatags import get_categories_page_metatags_hook
from .get_categories_query_values import get_categories_query_values_hook
from .get_category_data import get_category_data_hook
| 282
|
Python
|
.py
| 4
| 69.5
| 77
| 0.848921
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,699
|
get_categories_page_metatags.py
|
rafalp_Misago/misago/categories/hooks/get_categories_page_metatags.py
|
from typing import Protocol
from django.http import HttpRequest
from ...metatags.metatag import MetaTag
from ...plugins.hooks import FilterHook
class GetCategoriesPageMetatagsHookAction(Protocol):
"""
A standard Misago function used to get metatags for the categories page.
# Arguments
## `request: HttpRequest`
The request object.
## `context: dict`
The context to render the page with.
# Return value
A Python `dict` with metatags to include in the response HTML.
"""
def __call__(self, request: HttpRequest, context: dict) -> dict[str, MetaTag]: ...
class GetCategoriesPageMetatagsHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetCategoriesPageMetatagsHookAction`
A standard Misago function used to get metatags for the categories page.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
## `context: dict`
The context to render the page with.
# Return value
A Python `dict` with metatags to include in the response HTML.
"""
def __call__(
self,
action: GetCategoriesPageMetatagsHookAction,
request: HttpRequest,
context: dict,
) -> dict[str, MetaTag]: ...
class GetCategoriesPageMetatagsHook(
FilterHook[GetCategoriesPageMetatagsHookAction, GetCategoriesPageMetatagsHookFilter]
):
"""
This hook wraps the standard function that Misago uses to get
metatags for the categories page.
# Example
The code below implements a custom filter function that sets a custom
metatag on the categories page, if its not used as the forum index page:
```python
from django.http import HttpRequest
from misago.categories.hooks import get_categories_page_metatags_hook
from misago.metatags.metatag import MetaTag
@get_categories_page_metatags_hook.append_filter
def include_custom_metatag(action, request: HttpRequest, context) -> dict[str, MetaTag]:
metatags = action(request)
if not context["is_index"]:
categories = len(context["categories_list"])
metatags["description"] = MetaTag(
name="og:description",
property="twitter:description",
content=f"There are currently {categories} categories on our forums.",
)
return metatags
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetCategoriesPageMetatagsHookAction,
request: HttpRequest,
context: dict,
) -> dict[str, MetaTag]:
return super().__call__(action, request, context)
get_categories_page_metatags_hook = GetCategoriesPageMetatagsHook()
| 2,813
|
Python
|
.py
| 71
| 33.070423
| 92
| 0.696746
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|