bbj/src/formatting.py

265 lines
8.4 KiB
Python
Raw Normal View History

2017-04-03 04:51:44 +00:00
"""
A B A N D O N ,:
A L L H O P E ,' |
/ :
--' /
F O R Y E W H O \/ /:/
E N T E R H E R E / ://_\
__/ /
)'-. /
Crude hacks lie beneath us. ./ :\
/.' '
This module includes a couple '/'
of custom (GROAN) formatting +
specifications and parsers '
for them. Why did i do this? `.
I have no idea! .-"-
( |
. .-' '.
( (. )8:
.' / (_ )
_. :(. )8P `
. ( `-' ( `. .
. : ( .a8a)
/_`( "a `a. )"'
( (/ . ' )=='
( ( ) .8" +
(`'8a.( _( (
..-. `8P ) ` ) +
-' ( -ab: )
' _ ` (8P"Ya
_( ( )b -`. ) +
( 8) ( _.aP" _a \( \ *
+ )/ (8P (88 ) )
(a:f " `"`
The internal representation of formatted text is much like an s-expression.
They are specified as follows:
[directive: this is the body of text to apply it to]
The colon and the space following are important! The first space is not part
of the body, but any trailing spaces after it or at the end of the body are
included in the output.
Escaping via backslash is supported. Nesting is supported as well, but escaping
the delimiters is a bit tricky when nesting (both ends need to be escaped).
See the following examples:
2017-04-03 04:51:44 +00:00
[bold: this here \] is totally valid, and so is [<-TOTALLY OK this]
[bold: \[red: but both]<-CHOKE delimiters within a nest must be escaped.]
2017-04-11 20:31:01 +00:00
Directives are only parsed whenever the directive name is defined, and the
colon/space follow it. Thus, including [brackets like this] in a post body
will NOT require you to escape it! Even [brackets: like this] is safe, because
brackets is not a defined formatting parameter. So, any amount of unescaped brackets
may exist within the body unless they mimic a directive. To escape a valid directive,
escaping only the opening is suffiecient: \[bold: like this]. The literal body of
text outputted by that will be [bold: like this], with the backslash removed.
Just like the brackets themselves, backslashes may occur freely within bodies,
they are only removed when they occur before a valid expression.
2017-04-11 20:31:01 +00:00
"""
from string import punctuation
2017-03-01 21:54:34 +00:00
import re
2017-04-02 07:35:58 +00:00
colors = [
#0, 1 2 3 4 5 6 dim is not used in color api
"red", "yellow", "green", "blue", "cyan", "magenta", "dim"
2017-04-02 07:35:58 +00:00
]
2017-03-04 01:56:08 +00:00
2017-04-02 07:35:58 +00:00
markup = [
"bold", "underline", "linequote", "quote", "rainbow"
2017-04-02 07:35:58 +00:00
]
2017-03-01 21:54:34 +00:00
2017-04-11 20:31:01 +00:00
# quotes being references to other post_ids, like >>34 or >>0 for OP
2017-04-10 14:02:08 +00:00
quotes = re.compile(">>([0-9]+)")
bold = re.compile(r"(?<!\\)\*{2}(.+?)(?<!\\)\*{2}")
underline = re.compile(r"(?<!\\)_{2}(.+?)(?<!\\)_{2}")
escapes = re.compile(r"\\([*_]{2})")
def apply_directives(text):
# is there a better way to do this? smh....
text = quotes.sub(lambda m: "[quote: %s]" % m.group(1), text)
text = bold.sub(lambda m: "[bold: %s]" % m.group(1), text)
text = underline.sub(lambda m: "[underline: %s]" % m.group(1), text)
return escapes.sub(lambda m: m.group(1), text)
2017-04-11 20:31:01 +00:00
def linequote_p(line):
if not line.startswith(">"):
return False
_fp = line.find(" ")
return not quotes.search(line[:_fp] if _fp != -1 else line)
2017-04-11 20:31:01 +00:00
def parse_segments(text, sanitize_linequotes=True):
"""
Parse linequotes, quotes, and paragraphs into their appropriate
representations. Paragraphs are represented as separate strings
in the returned list, and quote-types are compiled to their
[bracketed] representations.
"""
result = list()
for paragraph in re.split("\n{2,}", text):
2017-04-11 20:31:01 +00:00
pg = str()
for line in paragraph.split("\n"):
if linequote_p(line):
2017-04-11 20:31:01 +00:00
if sanitize_linequotes:
inner = line.replace("]", "\\]")
2017-04-11 20:31:01 +00:00
else:
inner = apply_directives(line)
pg += "[linequote: %s]" % inner
2017-04-11 20:31:01 +00:00
else:
pg += apply_directives(line)
pg += "\n"
result.append(pg.rstrip())
2017-04-11 20:31:01 +00:00
return result
def sequential_expressions(string):
"""
Takes a string, sexpifies it, and returns a list of lists
who contain tuples. Each list of tuples represents a paragraph.
Within each paragraph, [0] is either None or a markup directive,
and [1] is the body of text to which it applies. This representation
is very easy to handle for a client. It semi-supports nesting:
eg, the expression [red: this [blue: is [green: mixed]]] will
return [("red", "this "), ("blue", "is "), ("green", "mixed")],
but this cannot effectively express an input like
[bold: [red: bolded colors.]], in which case the innermost
expression will take precedence. For the input:
"[bold: [red: this] is some shit [green: it cant handle]]"
you get:
[('red', 'this'), ('bold', ' is some shit '), ('green', 'it cant handle')]
"""
# abandon all hope ye who enter here
directives = colors + markup
result = list()
for paragraph in parse_segments(string):
stack = [[None, str()]]
skip_iters = 0
2017-04-11 20:31:01 +00:00
nest = [None]
escaped = False
for index, char in enumerate(paragraph):
if skip_iters:
skip_iters -= 1
2017-04-11 20:31:01 +00:00
continue
if not escaped and char == "[":
directive = paragraph[index+1:paragraph.find(": ", index+1)]
open_p = directive in directives
else:
open_p = False
2017-04-11 20:31:01 +00:00
clsd_p = not escaped and nest[-1] != None and char == "]"
# dont splice other directives into linequotes: that is far
# too confusing for the client to determine where to put line
# breaks
if open_p and nest[-1] != "linequote":
stack.append([directive, str()])
nest.append(directive)
skip_iters += len(directive) + 2
2017-04-11 20:31:01 +00:00
elif clsd_p:
nest.pop()
stack.append([nest[-1], str()])
else:
escaped = char == "\\"
try:
n = paragraph[index + 1]
except IndexError:
n = " "
if not (escaped and n in "[]"):
2017-04-11 20:31:01 +00:00
stack[-1][1] += char
# filter out unused bodies, eg ["red", ""]
2017-04-11 20:31:01 +00:00
result.append([(directive, body) for directive, body in stack if body])
return result
2017-04-02 07:35:58 +00:00
def apply_formatting(msg_obj, formatter):
"""
Receives a messages object from a thread and returns it with
2017-04-11 20:31:01 +00:00
all the message bodies passed through FORMATTER. Not all
formatting functions have to return a string. Refer to the
documentation for each formatter.
2017-04-02 07:35:58 +00:00
"""
2017-04-11 20:31:01 +00:00
for x, obj in enumerate(msg_obj):
2017-04-21 08:17:18 +00:00
if not msg_obj[x].get("send_raw"):
msg_obj[x]["body"] = formatter(obj["body"])
2017-04-02 07:35:58 +00:00
return msg_obj
def raw(text):
"""
Just return the message in the same state that it was submitted.
"""
return text
2017-04-10 14:02:08 +00:00
def strip(text):
"""
Returns the text with all formatting directives removed.
Not to be confused with `raw`.
"""
2017-04-17 19:38:14 +00:00
pass # me the bong im boutta smash tha bish
2017-04-10 14:02:08 +00:00
def entities(text):
"""
2017-04-17 19:38:14 +00:00
Returns a tuple where [0] is raw text and [1] is documentation
2017-04-10 14:02:08 +00:00
"""
2017-04-17 19:38:14 +00:00
# once someone asked me if i wanted a life
# and i said
pass
2017-04-10 14:02:08 +00:00
2017-04-02 07:35:58 +00:00
def html(text):
"""
Returns messages in html format, after being sent through markdown.
Color directives are given as:
<span color="{COLOR}" style="color: {COLOR};">content</span>
Directives may be nested. If you don't have access to a fully featured
and compliant html renderer in your client, you should use one of the
simpler directives like strip, indice, or raw.
"""
2017-04-17 19:38:14 +00:00
return "where is your god now"
2017-04-02 07:35:58 +00:00
2017-04-17 19:38:14 +00:00
# and this is drunk too
2017-03-03 01:10:16 +00:00
def map_html(match):
2017-04-17 19:38:14 +00:00
return """
If there is a place you got to go
I am the one you need to know
I'm the Map!
I'm the Map!
I'm the Map!
If there is a place you got to get
I can get you there I bet
I'm the Map!
I'm the Map!
I'm the Map!
I'm the Map!
I'm the Map!
I'm the Map!
I'm the Map!
I'm the Map!
I'm the Map!
I'm the Map!
I'm the Map!
I'm the Map!
"""