golded 1.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- golded/__init__.py +0 -0
- golded/__main__.py +3 -0
- golded/cli.py +65 -0
- golded/data/__init__.py +0 -0
- golded/data/area.py +8 -0
- golded/data/sqlite_store.py +99 -0
- golded/data/store.py +47 -0
- golded/logic/__init__.py +0 -0
- golded/logic/display_text.py +15 -0
- golded/logic/quote.py +124 -0
- golded/logic/session.py +304 -0
- golded/logic/subject.py +22 -0
- golded/logic/tear_origin.py +38 -0
- golded/logic/thread_tree.py +101 -0
- golded/logic/user_config.py +80 -0
- golded/logic/version.py +9 -0
- golded/py.typed +0 -0
- golded/ui/__init__.py +0 -0
- golded/ui/app.py +149 -0
- golded/ui/area_list.py +265 -0
- golded/ui/list_screen.py +73 -0
- golded/ui/logo.py +14 -0
- golded/ui/message_list.py +334 -0
- golded/ui/message_view.py +330 -0
- golded/ui/pagebar.py +90 -0
- golded/ui/splash.py +143 -0
- golded/ui/status.py +71 -0
- golded/ui/theme.py +89 -0
- golded/ui/title.py +29 -0
- golded/ui/write_message.py +467 -0
- golded-1.0.0.dist-info/METADATA +95 -0
- golded-1.0.0.dist-info/RECORD +35 -0
- golded-1.0.0.dist-info/WHEEL +4 -0
- golded-1.0.0.dist-info/entry_points.txt +2 -0
- golded-1.0.0.dist-info/licenses/LICENSE +21 -0
golded/__init__.py
ADDED
|
File without changes
|
golded/__main__.py
ADDED
golded/cli.py
ADDED
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
import argparse
|
|
2
|
+
import sqlite3
|
|
3
|
+
import sys
|
|
4
|
+
|
|
5
|
+
from golded.data.store import open_message_store
|
|
6
|
+
from golded.logic.user_config import THEME_NAMES, load_user_config
|
|
7
|
+
from golded.ui.app import run
|
|
8
|
+
|
|
9
|
+
DEFAULT_DATABASE = "messages.sqlite3"
|
|
10
|
+
DEFAULT_CONFIG = "golded.toml"
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
def main() -> None:
|
|
14
|
+
parser = argparse.ArgumentParser(
|
|
15
|
+
prog="golded", description="GoldED.py message reader"
|
|
16
|
+
)
|
|
17
|
+
parser.add_argument(
|
|
18
|
+
"--config",
|
|
19
|
+
default=DEFAULT_CONFIG,
|
|
20
|
+
help="path to golded.toml (default: golded.toml)",
|
|
21
|
+
)
|
|
22
|
+
parser.add_argument(
|
|
23
|
+
"--database",
|
|
24
|
+
default=None,
|
|
25
|
+
help="path to SQLite message database (overrides config)",
|
|
26
|
+
)
|
|
27
|
+
parser.add_argument(
|
|
28
|
+
"--theme",
|
|
29
|
+
choices=THEME_NAMES,
|
|
30
|
+
default=None,
|
|
31
|
+
help="colour theme (overrides config; toggle with F9)",
|
|
32
|
+
)
|
|
33
|
+
args = parser.parse_args()
|
|
34
|
+
|
|
35
|
+
try:
|
|
36
|
+
user_config = load_user_config(args.config)
|
|
37
|
+
except (OSError, ValueError) as error:
|
|
38
|
+
print(f"Cannot read config {args.config}: {error}", file=sys.stderr)
|
|
39
|
+
raise SystemExit(1) from None
|
|
40
|
+
|
|
41
|
+
if args.database is None:
|
|
42
|
+
database = (
|
|
43
|
+
DEFAULT_DATABASE if user_config.database == "" else user_config.database
|
|
44
|
+
)
|
|
45
|
+
else:
|
|
46
|
+
database = args.database
|
|
47
|
+
|
|
48
|
+
theme = user_config.theme if args.theme is None else args.theme
|
|
49
|
+
|
|
50
|
+
try:
|
|
51
|
+
store = open_message_store(database)
|
|
52
|
+
except FileNotFoundError:
|
|
53
|
+
print(f"Database not found: {database}", file=sys.stderr)
|
|
54
|
+
print("Pass --database PATH or set database in golded.toml.", file=sys.stderr)
|
|
55
|
+
raise SystemExit(1) from None
|
|
56
|
+
except (sqlite3.Error, ValueError) as error:
|
|
57
|
+
# golded-ftn-sqlite raises ValueError for a foreign or unsupported schema.
|
|
58
|
+
print(f"Cannot open database {database}: {error}", file=sys.stderr)
|
|
59
|
+
raise SystemExit(1) from None
|
|
60
|
+
|
|
61
|
+
run(store, theme, user_config)
|
|
62
|
+
|
|
63
|
+
|
|
64
|
+
if __name__ == "__main__":
|
|
65
|
+
main()
|
golded/data/__init__.py
ADDED
|
File without changes
|
golded/data/area.py
ADDED
|
@@ -0,0 +1,99 @@
|
|
|
1
|
+
"""SQLite message store."""
|
|
2
|
+
|
|
3
|
+
from collections.abc import Sequence
|
|
4
|
+
from pathlib import Path
|
|
5
|
+
|
|
6
|
+
from golded_ftn import FtnAddress, OutgoingMessage, ParsedMessage
|
|
7
|
+
from golded_ftn_sqlite import (
|
|
8
|
+
AreaDefinition,
|
|
9
|
+
AreaKind,
|
|
10
|
+
SqliteDatabase,
|
|
11
|
+
SqliteReader,
|
|
12
|
+
SqliteWriter,
|
|
13
|
+
)
|
|
14
|
+
|
|
15
|
+
from golded.data.area import Area
|
|
16
|
+
from golded.data.store import MessageStore
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
def _to_definition(
|
|
20
|
+
area: Area, default_origin: FtnAddress | None = None
|
|
21
|
+
) -> AreaDefinition:
|
|
22
|
+
return AreaDefinition(
|
|
23
|
+
code=area.code,
|
|
24
|
+
name=area.name,
|
|
25
|
+
kind=AreaKind(area.kind),
|
|
26
|
+
default_origin=default_origin,
|
|
27
|
+
)
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
def _from_definition(area: AreaDefinition) -> Area:
|
|
31
|
+
if area.kind is AreaKind.NETMAIL:
|
|
32
|
+
kind = "netmail"
|
|
33
|
+
else:
|
|
34
|
+
kind = "echomail"
|
|
35
|
+
|
|
36
|
+
return Area(area.code, area.name, kind)
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
class SqliteMessageStore(MessageStore):
|
|
40
|
+
def __init__(self, path: Path) -> None:
|
|
41
|
+
self.__path = path
|
|
42
|
+
self.__db = SqliteDatabase.open(path)
|
|
43
|
+
|
|
44
|
+
def areas(self) -> tuple[Area, ...]:
|
|
45
|
+
result = []
|
|
46
|
+
for area in self.__db.areas():
|
|
47
|
+
result.append(_from_definition(area))
|
|
48
|
+
|
|
49
|
+
return tuple(result)
|
|
50
|
+
|
|
51
|
+
def messages(self, area: str) -> tuple[ParsedMessage, ...]:
|
|
52
|
+
result = []
|
|
53
|
+
for message in SqliteReader(area).read(self.__path):
|
|
54
|
+
result.append(message)
|
|
55
|
+
|
|
56
|
+
return tuple(result)
|
|
57
|
+
|
|
58
|
+
def message(self, area: str, msgno: int) -> ParsedMessage:
|
|
59
|
+
with SqliteWriter(area).open(self.__path) as session:
|
|
60
|
+
return session.read(msgno).message
|
|
61
|
+
|
|
62
|
+
def append(self, area: str, message: OutgoingMessage) -> int:
|
|
63
|
+
with SqliteWriter(area).open(self.__path) as session:
|
|
64
|
+
result = session.append(message)
|
|
65
|
+
|
|
66
|
+
return result.identity.msgno
|
|
67
|
+
|
|
68
|
+
def delete(self, area: str, msgno: int) -> None:
|
|
69
|
+
with SqliteWriter(area).open(self.__path) as session:
|
|
70
|
+
stored = session.read(msgno)
|
|
71
|
+
session.delete(stored.identity, stored.revision)
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
def open_message_store(path: str | Path) -> SqliteMessageStore:
|
|
75
|
+
return SqliteMessageStore(Path(path).resolve())
|
|
76
|
+
|
|
77
|
+
|
|
78
|
+
def create_message_store(
|
|
79
|
+
path: str | Path,
|
|
80
|
+
areas: Sequence[Area],
|
|
81
|
+
default_origin: FtnAddress | None = None,
|
|
82
|
+
) -> SqliteMessageStore:
|
|
83
|
+
if len(areas) == 0:
|
|
84
|
+
raise ValueError("at least one area is required")
|
|
85
|
+
|
|
86
|
+
database_path = Path(path).resolve()
|
|
87
|
+
|
|
88
|
+
first = areas[0]
|
|
89
|
+
|
|
90
|
+
SqliteDatabase.create(
|
|
91
|
+
database_path,
|
|
92
|
+
area=_to_definition(first, default_origin),
|
|
93
|
+
)
|
|
94
|
+
|
|
95
|
+
db = SqliteDatabase.open(database_path)
|
|
96
|
+
for area in areas[1:]:
|
|
97
|
+
db.add_area(_to_definition(area))
|
|
98
|
+
|
|
99
|
+
return SqliteMessageStore(database_path)
|
golded/data/store.py
ADDED
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
"""Message store ABC and open/create entry points; implementation in sqlite_store."""
|
|
2
|
+
|
|
3
|
+
from abc import ABC, abstractmethod
|
|
4
|
+
from collections.abc import Sequence
|
|
5
|
+
from pathlib import Path
|
|
6
|
+
|
|
7
|
+
from golded_ftn import FtnAddress, OutgoingMessage, ParsedMessage
|
|
8
|
+
|
|
9
|
+
from golded.data.area import Area
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
class MessageStore(ABC):
|
|
13
|
+
@abstractmethod
|
|
14
|
+
def areas(self) -> tuple[Area, ...]:
|
|
15
|
+
pass
|
|
16
|
+
|
|
17
|
+
@abstractmethod
|
|
18
|
+
def messages(self, area: str) -> tuple[ParsedMessage, ...]:
|
|
19
|
+
pass
|
|
20
|
+
|
|
21
|
+
@abstractmethod
|
|
22
|
+
def message(self, area: str, msgno: int) -> ParsedMessage:
|
|
23
|
+
pass
|
|
24
|
+
|
|
25
|
+
@abstractmethod
|
|
26
|
+
def append(self, area: str, message: OutgoingMessage) -> int:
|
|
27
|
+
pass
|
|
28
|
+
|
|
29
|
+
@abstractmethod
|
|
30
|
+
def delete(self, area: str, msgno: int) -> None:
|
|
31
|
+
pass
|
|
32
|
+
|
|
33
|
+
|
|
34
|
+
def open_message_store(path: str | Path) -> MessageStore:
|
|
35
|
+
from golded.data.sqlite_store import open_message_store as open_store
|
|
36
|
+
|
|
37
|
+
return open_store(path)
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
def create_message_store(
|
|
41
|
+
path: str | Path,
|
|
42
|
+
areas: Sequence[Area],
|
|
43
|
+
default_origin: FtnAddress | None = None,
|
|
44
|
+
) -> MessageStore:
|
|
45
|
+
from golded.data.sqlite_store import create_message_store as create_store
|
|
46
|
+
|
|
47
|
+
return create_store(path, areas, default_origin)
|
golded/logic/__init__.py
ADDED
|
File without changes
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
"""Optional display repair for damaged charset text."""
|
|
2
|
+
|
|
3
|
+
from golded_ftn import repair_mojibake
|
|
4
|
+
from rich.text import Text
|
|
5
|
+
|
|
6
|
+
|
|
7
|
+
def for_display(text: str, repair: bool) -> str:
|
|
8
|
+
if not repair:
|
|
9
|
+
return text
|
|
10
|
+
|
|
11
|
+
return repair_mojibake(text).text
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
def literal_text(text: str) -> Text:
|
|
15
|
+
return Text(text)
|
golded/logic/quote.py
ADDED
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
"""Classic GoldED FL quote initials."""
|
|
2
|
+
|
|
3
|
+
|
|
4
|
+
def quote_initials(from_name: str) -> str:
|
|
5
|
+
words = from_name.split()
|
|
6
|
+
letters = []
|
|
7
|
+
|
|
8
|
+
for word in words:
|
|
9
|
+
for character in word:
|
|
10
|
+
if character.isalpha():
|
|
11
|
+
letters.append(character.upper())
|
|
12
|
+
break
|
|
13
|
+
|
|
14
|
+
if len(letters) == 0:
|
|
15
|
+
return ""
|
|
16
|
+
|
|
17
|
+
if len(letters) == 1:
|
|
18
|
+
return letters[0]
|
|
19
|
+
|
|
20
|
+
return letters[0] + letters[-1]
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
def _is_origin_line(line: str) -> bool:
|
|
24
|
+
return line.startswith(" * Origin: ")
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
def _is_tearline_line(line: str) -> bool:
|
|
28
|
+
return line.startswith("--- ")
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
def _trailing_tagline_start(lines: list[str]) -> int | None:
|
|
32
|
+
index = len(lines) - 1
|
|
33
|
+
|
|
34
|
+
while index >= 0 and lines[index].strip() == "":
|
|
35
|
+
index -= 1
|
|
36
|
+
|
|
37
|
+
if index < 0 or not _is_origin_line(lines[index]):
|
|
38
|
+
return None
|
|
39
|
+
|
|
40
|
+
tear_index = index - 1
|
|
41
|
+
while tear_index >= 0 and lines[tear_index].strip() == "":
|
|
42
|
+
tear_index -= 1
|
|
43
|
+
|
|
44
|
+
if tear_index < 0 or not _is_tearline_line(lines[tear_index]):
|
|
45
|
+
return None
|
|
46
|
+
|
|
47
|
+
return tear_index
|
|
48
|
+
|
|
49
|
+
|
|
50
|
+
def body_without_tearline(body_text: str) -> str:
|
|
51
|
+
lines = body_text.splitlines()
|
|
52
|
+
start = _trailing_tagline_start(lines)
|
|
53
|
+
|
|
54
|
+
if start is None:
|
|
55
|
+
return body_text
|
|
56
|
+
|
|
57
|
+
return "\n".join(lines[:start])
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def split_body_at_tagline(body_text: str) -> tuple[str, str]:
|
|
61
|
+
lines = body_text.splitlines()
|
|
62
|
+
start = _trailing_tagline_start(lines)
|
|
63
|
+
|
|
64
|
+
if start is None:
|
|
65
|
+
return body_text, ""
|
|
66
|
+
|
|
67
|
+
return "\n".join(lines[:start]), "\n".join(lines[start:])
|
|
68
|
+
|
|
69
|
+
|
|
70
|
+
def has_golded_tagline(body_text: str) -> bool:
|
|
71
|
+
lines = body_text.splitlines()
|
|
72
|
+
start = _trailing_tagline_start(lines)
|
|
73
|
+
|
|
74
|
+
if start is not None:
|
|
75
|
+
return lines[start].startswith("--- GoldED")
|
|
76
|
+
|
|
77
|
+
index = len(lines) - 1
|
|
78
|
+
while index >= 0 and lines[index].strip() == "":
|
|
79
|
+
index -= 1
|
|
80
|
+
|
|
81
|
+
if index < 0:
|
|
82
|
+
return False
|
|
83
|
+
|
|
84
|
+
return lines[index].startswith("--- GoldED")
|
|
85
|
+
|
|
86
|
+
|
|
87
|
+
def quote_body(from_name: str, body_text: str) -> str:
|
|
88
|
+
initials = quote_initials(from_name)
|
|
89
|
+
main = body_without_tearline(body_text)
|
|
90
|
+
lines = []
|
|
91
|
+
|
|
92
|
+
for line in main.splitlines():
|
|
93
|
+
if initials == "":
|
|
94
|
+
if line == "":
|
|
95
|
+
lines.append(">")
|
|
96
|
+
else:
|
|
97
|
+
lines.append("> " + line)
|
|
98
|
+
else:
|
|
99
|
+
if line == "":
|
|
100
|
+
lines.append(initials + ">")
|
|
101
|
+
else:
|
|
102
|
+
lines.append(initials + "> " + line)
|
|
103
|
+
|
|
104
|
+
return "\n".join(lines) + "\n"
|
|
105
|
+
|
|
106
|
+
|
|
107
|
+
def first_name(full_name: str) -> str:
|
|
108
|
+
words = full_name.split()
|
|
109
|
+
if len(words) == 0:
|
|
110
|
+
return ""
|
|
111
|
+
|
|
112
|
+
return words[0]
|
|
113
|
+
|
|
114
|
+
|
|
115
|
+
def reply_intro(from_name: str, body_for_quote: str) -> str:
|
|
116
|
+
name = first_name(from_name)
|
|
117
|
+
if name == "":
|
|
118
|
+
greeting = "Hello"
|
|
119
|
+
else:
|
|
120
|
+
greeting = "Hello " + name
|
|
121
|
+
|
|
122
|
+
quoted = quote_body(from_name, body_for_quote)
|
|
123
|
+
|
|
124
|
+
return greeting + "\n\n" + quoted
|
golded/logic/session.py
ADDED
|
@@ -0,0 +1,304 @@
|
|
|
1
|
+
"""Selected area, current message and draft."""
|
|
2
|
+
|
|
3
|
+
from golded_ftn import FtnAddress, OutgoingMessage, ParsedMessage
|
|
4
|
+
|
|
5
|
+
from golded.data.area import Area
|
|
6
|
+
from golded.data.store import MessageStore
|
|
7
|
+
from golded.logic.quote import reply_intro
|
|
8
|
+
from golded.logic.subject import reply_subject, thread_subject
|
|
9
|
+
from golded.logic.tear_origin import with_tear_origin
|
|
10
|
+
from golded.logic.thread_tree import ThreadRow, build_thread_rows
|
|
11
|
+
from golded.logic.user_config import UserConfig
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class Session:
|
|
15
|
+
def __init__(
|
|
16
|
+
self,
|
|
17
|
+
store: MessageStore,
|
|
18
|
+
user_config: UserConfig | None = None,
|
|
19
|
+
) -> None:
|
|
20
|
+
self.__store = store
|
|
21
|
+
self.__user = UserConfig() if user_config is None else user_config
|
|
22
|
+
self.__selected_area: str | None = None
|
|
23
|
+
self.__current_message_index: int | None = None
|
|
24
|
+
self.__draft_message: OutgoingMessage | None = None
|
|
25
|
+
self.__draft_area: str | None = None
|
|
26
|
+
self.__threaded_list = self.__user.threaded_list
|
|
27
|
+
self.__message_rows_cache: list[ThreadRow] | None = None
|
|
28
|
+
self.__cache_area: str | None = None
|
|
29
|
+
self.__cache_threaded: bool | None = None
|
|
30
|
+
|
|
31
|
+
def __clear_message_cache(self) -> None:
|
|
32
|
+
self.__message_rows_cache = None
|
|
33
|
+
|
|
34
|
+
def areas(self) -> tuple[Area, ...]:
|
|
35
|
+
return self.__store.areas()
|
|
36
|
+
|
|
37
|
+
def selected_area(self) -> str | None:
|
|
38
|
+
return self.__selected_area
|
|
39
|
+
|
|
40
|
+
def current_message_index(self) -> int | None:
|
|
41
|
+
return self.__current_message_index
|
|
42
|
+
|
|
43
|
+
def message_count(self, area: str) -> int:
|
|
44
|
+
return len(self.__store.messages(area))
|
|
45
|
+
|
|
46
|
+
def draft_message(self) -> OutgoingMessage | None:
|
|
47
|
+
return self.__draft_message
|
|
48
|
+
|
|
49
|
+
def draft_area(self) -> str | None:
|
|
50
|
+
return self.__draft_area
|
|
51
|
+
|
|
52
|
+
def splash_seconds(self) -> int:
|
|
53
|
+
return self.__user.splash_seconds
|
|
54
|
+
|
|
55
|
+
def threaded_list(self) -> bool:
|
|
56
|
+
return self.__threaded_list
|
|
57
|
+
|
|
58
|
+
def toggle_threaded_list(self) -> bool:
|
|
59
|
+
current = self.current_message()
|
|
60
|
+
msgno = None
|
|
61
|
+
if current is not None:
|
|
62
|
+
msgno = current.msgno
|
|
63
|
+
|
|
64
|
+
self.__threaded_list = not self.__threaded_list
|
|
65
|
+
|
|
66
|
+
if msgno is not None:
|
|
67
|
+
self.select_message(msgno)
|
|
68
|
+
|
|
69
|
+
return self.__threaded_list
|
|
70
|
+
|
|
71
|
+
def select_area(self, area: str) -> None:
|
|
72
|
+
self.__selected_area = area
|
|
73
|
+
self.__current_message_index = None
|
|
74
|
+
self.__clear_message_cache()
|
|
75
|
+
|
|
76
|
+
def message_rows(self) -> list[ThreadRow]:
|
|
77
|
+
if self.__selected_area is None:
|
|
78
|
+
return []
|
|
79
|
+
|
|
80
|
+
if (
|
|
81
|
+
self.__message_rows_cache is not None
|
|
82
|
+
and self.__cache_area == self.__selected_area
|
|
83
|
+
and self.__cache_threaded == self.__threaded_list
|
|
84
|
+
):
|
|
85
|
+
return self.__message_rows_cache
|
|
86
|
+
|
|
87
|
+
messages = self.__store.messages(self.__selected_area)
|
|
88
|
+
|
|
89
|
+
if self.__threaded_list:
|
|
90
|
+
rows = build_thread_rows(messages)
|
|
91
|
+
else:
|
|
92
|
+
rows = []
|
|
93
|
+
for message in messages:
|
|
94
|
+
rows.append(ThreadRow(message, []))
|
|
95
|
+
|
|
96
|
+
self.__cache_area = self.__selected_area
|
|
97
|
+
self.__cache_threaded = self.__threaded_list
|
|
98
|
+
self.__message_rows_cache = rows
|
|
99
|
+
|
|
100
|
+
return rows
|
|
101
|
+
|
|
102
|
+
def messages(self) -> tuple[ParsedMessage, ...]:
|
|
103
|
+
rows = self.message_rows()
|
|
104
|
+
result = []
|
|
105
|
+
for row in rows:
|
|
106
|
+
result.append(row.message)
|
|
107
|
+
|
|
108
|
+
return tuple(result)
|
|
109
|
+
|
|
110
|
+
def select_message(self, msgno: int) -> None:
|
|
111
|
+
messages = self.messages()
|
|
112
|
+
|
|
113
|
+
for index, message in enumerate(messages):
|
|
114
|
+
if message.msgno == msgno:
|
|
115
|
+
self.__current_message_index = index
|
|
116
|
+
return
|
|
117
|
+
|
|
118
|
+
self.__current_message_index = None
|
|
119
|
+
|
|
120
|
+
def current_message(self) -> ParsedMessage | None:
|
|
121
|
+
if self.__current_message_index is None:
|
|
122
|
+
return None
|
|
123
|
+
|
|
124
|
+
messages = self.messages()
|
|
125
|
+
if self.__current_message_index >= len(messages):
|
|
126
|
+
return None
|
|
127
|
+
|
|
128
|
+
return messages[self.__current_message_index]
|
|
129
|
+
|
|
130
|
+
def next_message(self) -> None:
|
|
131
|
+
if self.__current_message_index is None:
|
|
132
|
+
return
|
|
133
|
+
|
|
134
|
+
messages = self.messages()
|
|
135
|
+
|
|
136
|
+
if self.__current_message_index + 1 < len(messages):
|
|
137
|
+
self.__current_message_index = self.__current_message_index + 1
|
|
138
|
+
|
|
139
|
+
def previous_message(self) -> None:
|
|
140
|
+
if self.__current_message_index is None:
|
|
141
|
+
return
|
|
142
|
+
|
|
143
|
+
if self.__current_message_index > 0:
|
|
144
|
+
self.__current_message_index = self.__current_message_index - 1
|
|
145
|
+
|
|
146
|
+
def next_subject_message(self) -> None:
|
|
147
|
+
if self.__current_message_index is None:
|
|
148
|
+
return
|
|
149
|
+
|
|
150
|
+
messages = self.messages()
|
|
151
|
+
|
|
152
|
+
current = messages[self.__current_message_index]
|
|
153
|
+
subject = thread_subject(current.subject)
|
|
154
|
+
|
|
155
|
+
for index, message in enumerate(messages):
|
|
156
|
+
if index <= self.__current_message_index:
|
|
157
|
+
continue
|
|
158
|
+
if thread_subject(message.subject) == subject:
|
|
159
|
+
self.__current_message_index = index
|
|
160
|
+
return
|
|
161
|
+
|
|
162
|
+
def previous_subject_message(self) -> None:
|
|
163
|
+
if self.__current_message_index is None:
|
|
164
|
+
return
|
|
165
|
+
|
|
166
|
+
messages = self.messages()
|
|
167
|
+
|
|
168
|
+
current = messages[self.__current_message_index]
|
|
169
|
+
subject = thread_subject(current.subject)
|
|
170
|
+
|
|
171
|
+
for index, message in reversed(list(enumerate(messages))):
|
|
172
|
+
if index >= self.__current_message_index:
|
|
173
|
+
continue
|
|
174
|
+
if thread_subject(message.subject) == subject:
|
|
175
|
+
self.__current_message_index = index
|
|
176
|
+
return
|
|
177
|
+
|
|
178
|
+
def area_name(self, area: str) -> str:
|
|
179
|
+
for item in self.__store.areas():
|
|
180
|
+
if item.code == area:
|
|
181
|
+
return item.name
|
|
182
|
+
|
|
183
|
+
return area
|
|
184
|
+
|
|
185
|
+
def area_kind(self, area: str) -> str:
|
|
186
|
+
for item in self.__store.areas():
|
|
187
|
+
if item.code == area:
|
|
188
|
+
return item.kind
|
|
189
|
+
|
|
190
|
+
return "echomail"
|
|
191
|
+
|
|
192
|
+
def start_draft_message(self) -> None:
|
|
193
|
+
if self.__selected_area is None:
|
|
194
|
+
return
|
|
195
|
+
|
|
196
|
+
to_name = ""
|
|
197
|
+
if self.area_kind(self.__selected_area) == "echomail":
|
|
198
|
+
to_name = "All"
|
|
199
|
+
|
|
200
|
+
self.__draft_area = self.__selected_area
|
|
201
|
+
|
|
202
|
+
self.__draft_message = OutgoingMessage(
|
|
203
|
+
from_name=self.__user.from_name,
|
|
204
|
+
to_name=to_name,
|
|
205
|
+
subject="",
|
|
206
|
+
body_text=with_tear_origin(
|
|
207
|
+
"",
|
|
208
|
+
self.__user.origin,
|
|
209
|
+
self.__user.from_address,
|
|
210
|
+
),
|
|
211
|
+
from_address=self.__user.from_address,
|
|
212
|
+
)
|
|
213
|
+
|
|
214
|
+
def start_reply_draft(
|
|
215
|
+
self,
|
|
216
|
+
body_for_quote: str,
|
|
217
|
+
subject_for_reply: str | None = None,
|
|
218
|
+
) -> None:
|
|
219
|
+
if self.__selected_area is None:
|
|
220
|
+
return
|
|
221
|
+
|
|
222
|
+
message = self.current_message()
|
|
223
|
+
if message is None:
|
|
224
|
+
return
|
|
225
|
+
|
|
226
|
+
if subject_for_reply is None:
|
|
227
|
+
subject_for_reply = message.subject
|
|
228
|
+
|
|
229
|
+
body = reply_intro(message.from_name, body_for_quote)
|
|
230
|
+
|
|
231
|
+
self.__draft_area = self.__selected_area
|
|
232
|
+
|
|
233
|
+
# The reader returns addresses as text; the writer stores str(FtnAddress),
|
|
234
|
+
# so parsing it back gives the same address.
|
|
235
|
+
to_address = None
|
|
236
|
+
if message.from_address is not None:
|
|
237
|
+
to_address = FtnAddress.from_string(message.from_address)
|
|
238
|
+
|
|
239
|
+
self.__draft_message = OutgoingMessage(
|
|
240
|
+
from_name=self.__user.from_name,
|
|
241
|
+
to_name=message.from_name,
|
|
242
|
+
subject=reply_subject(subject_for_reply),
|
|
243
|
+
body_text=with_tear_origin(
|
|
244
|
+
body,
|
|
245
|
+
self.__user.origin,
|
|
246
|
+
self.__user.from_address,
|
|
247
|
+
),
|
|
248
|
+
reply_to_msgno=message.msgno,
|
|
249
|
+
from_address=self.__user.from_address,
|
|
250
|
+
to_address=to_address,
|
|
251
|
+
)
|
|
252
|
+
|
|
253
|
+
def set_draft_message(self, message: OutgoingMessage) -> None:
|
|
254
|
+
if self.__draft_area is None:
|
|
255
|
+
return
|
|
256
|
+
|
|
257
|
+
self.__draft_message = message
|
|
258
|
+
|
|
259
|
+
def discard_draft_message(self) -> None:
|
|
260
|
+
self.__draft_message = None
|
|
261
|
+
self.__draft_area = None
|
|
262
|
+
|
|
263
|
+
def save_draft_message(self) -> int | None:
|
|
264
|
+
if self.__draft_message is None or self.__draft_area is None:
|
|
265
|
+
return None
|
|
266
|
+
|
|
267
|
+
if self.__draft_message.from_name.strip() == "":
|
|
268
|
+
raise ValueError("from name is required")
|
|
269
|
+
|
|
270
|
+
if self.__draft_message.to_name.strip() == "":
|
|
271
|
+
raise ValueError("to name is required")
|
|
272
|
+
|
|
273
|
+
if self.__draft_message.subject.strip() == "":
|
|
274
|
+
raise ValueError("subject is required")
|
|
275
|
+
|
|
276
|
+
if (
|
|
277
|
+
self.area_kind(self.__draft_area) == "netmail"
|
|
278
|
+
and self.__draft_message.to_address is None
|
|
279
|
+
):
|
|
280
|
+
raise ValueError("netmail requires a destination address")
|
|
281
|
+
|
|
282
|
+
draft = self.__draft_message
|
|
283
|
+
|
|
284
|
+
message = OutgoingMessage(
|
|
285
|
+
from_name=draft.from_name,
|
|
286
|
+
to_name=draft.to_name,
|
|
287
|
+
subject=draft.subject,
|
|
288
|
+
body_text=with_tear_origin(
|
|
289
|
+
draft.body_text,
|
|
290
|
+
self.__user.origin,
|
|
291
|
+
draft.from_address,
|
|
292
|
+
),
|
|
293
|
+
reply_to_msgno=draft.reply_to_msgno,
|
|
294
|
+
from_address=draft.from_address,
|
|
295
|
+
to_address=draft.to_address,
|
|
296
|
+
)
|
|
297
|
+
|
|
298
|
+
msgno = self.__store.append(self.__draft_area, message)
|
|
299
|
+
|
|
300
|
+
self.__draft_message = None
|
|
301
|
+
self.__draft_area = None
|
|
302
|
+
self.__clear_message_cache()
|
|
303
|
+
|
|
304
|
+
return msgno
|
golded/logic/subject.py
ADDED
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
"""Subject line helpers for threads and replies."""
|
|
2
|
+
|
|
3
|
+
|
|
4
|
+
def subject_without_re(subject: str) -> str:
|
|
5
|
+
text = subject.strip()
|
|
6
|
+
|
|
7
|
+
while True:
|
|
8
|
+
lower = text.lower()
|
|
9
|
+
if lower.startswith("re:"):
|
|
10
|
+
text = text[3:].lstrip()
|
|
11
|
+
else:
|
|
12
|
+
break
|
|
13
|
+
|
|
14
|
+
return text
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
def thread_subject(subject: str) -> str:
|
|
18
|
+
return subject_without_re(subject).lower()
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
def reply_subject(subject: str) -> str:
|
|
22
|
+
return "Re: " + subject_without_re(subject)
|