# -*- coding: utf-8 -*-
#
# Copyright © 2017 markdown-link-style contributors.
#
# This file is part of markdown-link-style.
#
# markdown-link-style is free software: you can redistribute it
# and/or modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation, either version 3 of
# the License, or (at your option) any later version.
#
# markdown-link-style is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with markdown-link-style (see COPYING). If not, see
# <http://www.gnu.org/licenses/>.
import argparse
import re
from mistune import BlockGrammar, BlockLexer, InlineLexer, Renderer, Markdown
from markdown_link_style.logging import MDLSLogger
from markdown_link_style._version import __version__
# Initialize logger for this module.
logger = MDLSLogger(__name__)
# from mistune
_inline_tags = [
"a",
"em",
"strong",
"small",
"s",
"cite",
"q",
"dfn",
"abbr",
"data",
"time",
"code",
"var",
"samp",
"kbd",
"sub",
"sup",
"i",
"b",
"u",
"mark",
"ruby",
"rt",
"rp",
"bdi",
"bdo",
"span",
"br",
"wbr",
"ins",
"del",
"img",
"font",
]
_valid_end = r"(?!:/|[^\w\s@]*@)\b"
_block_tag = r"(?!(?:%s)\b)\w+%s" % ("|".join(_inline_tags), _valid_end)
def _pure_pattern(regex):
"""Function from mistune."""
pattern = regex.pattern
if pattern.startswith("^"):
pattern = pattern[1:]
return pattern
class LSBlockGrammar(BlockGrammar):
def __init__(self):
# remove list_block and block_quote from paragraph
self.paragraph = re.compile(
r"^((?:[^\n]+\n?(?!"
r"%s|%s|%s|%s|%s|%s|%s"
r"))+)\n*"
% (
_pure_pattern(self.fences).replace(r"\1", r"\2"),
_pure_pattern(self.hrule),
_pure_pattern(self.heading),
_pure_pattern(self.lheading),
_pure_pattern(self.def_links),
_pure_pattern(self.def_footnotes),
"<" + _block_tag,
)
)
class LSBlockLexer(BlockLexer):
"""Link Style Block Lexer.
"""
grammar_class = LSBlockGrammar
def __init__(self, rules=None, **kwargs):
super(LSBlockLexer, self).__init__(rules, **kwargs)
# Only parse these block rules.
self.default_rules = ["def_links", "paragraph", "text"]
class LSInlineLexer(InlineLexer):
"""Link Style Inline Lexer.
"""
def __init__(self, renderer, rules=None, **kwargs):
super(LSInlineLexer, self).__init__(renderer, rules, **kwargs)
# Only parse these inline rules
self.default_rules = ["autolink", "link", "reflink", "text"]
class LSRenderer(Renderer):
"""Link Style Renderer.
"""
def __init__(self, **kwargs):
super(LSRenderer, self).__init__(**kwargs)
# Link style is either 'inline' or 'footnote'.
self.link_style = self.options.get("link_style")
self.fn_lnk_num = 0 # footnote style link number
self.fn_lnk_refs = [] # footnote style link refs
def text(self, text):
return text
def autolink(self, link, is_email=False):
return "<{}>".format(link)
def paragraph(self, text):
p = text
fn_refs = self._pop_fn_refs()
if fn_refs:
# Insert footnote refs, if any, after paragraph.
return "\n{}\n\n{}".format(p, fn_refs)
return "\n{}\n".format(p)
def link(self, link, title, text):
link_text = self._stylize_link(link, title, text)
return link_text
def image(self, src, title, text):
# Markup for images are same as links, except it is prefixed
# with a bang (!).
return "{}{}".format("!", self.link(src, title, text))
def _stylize_link(self, link, title, text):
if self.link_style == "inline":
return self._gen_inline_link(link, title, text)
else:
return self._gen_footnote_link(link, title, text)
def _gen_inline_link(self, link, title, text):
if title:
return '[{}]({} "{}")'.format(text, link, title)
else:
return "[{}]({})".format(text, link)
def _gen_footnote_link(self, link, title, text):
fn_num = self._st_fn_ref(link, title)
return "[{}][{}]".format(text, fn_num)
def _st_fn_ref(self, link, title):
"""Store footnote link reference.
"""
fn_num = self._get_fn_lnk_num()
if title:
fn_ref = "[{}]: {} ({})".format(fn_num, link, title)
else:
fn_ref = "[{}]: {}".format(fn_num, link)
self.fn_lnk_refs.append(fn_ref)
return fn_num
def _get_fn_lnk_num(self):
"""Get footnote link number.
"""
fn_num = self.fn_lnk_num
self.fn_lnk_num = self.fn_lnk_num + 1
return fn_num
def _pop_fn_refs(self):
"""Pop all footnote refs and return them as a string.
"""
refs = ""
for ref in self.fn_lnk_refs:
refs += "{}\n".format(ref)
# Empty fn_lnk_refs
self.fn_lnk_refs = []
return refs
class LSMarkdown(Markdown):
"""Link Style Markdown parser.
"""
def __init__(self, renderer=None, inline=None, block=None, **kwargs):
link_style = kwargs.get("link_style") or "inline"
if not renderer:
renderer = LSRenderer(link_style=link_style)
if not inline:
inline = LSInlineLexer(renderer)
if not block:
block = LSBlockLexer()
super(LSMarkdown, self).__init__(renderer, inline, block, **kwargs)
def parse(self, text):
# Reset footnote link variables.
self.renderer.fn_lnk_num = 0
self.renderer.fn_lnk_refs = []
# Parse text.
out = super(LSMarkdown, self).parse(text)
# Spit out.
return out.lstrip("\n")
class LinkStyler(object):
"""Markdown Link Styler.
"""
def __init__(self, link_style="inline"):
self.style = link_style
def __call__(self, file_):
return self._link_stylize(file_)
def _link_stylize(self, file_):
text = file_.read()
md = LSMarkdown(link_style=self.style)
return md(text)
def _write_to(file_, content):
"""Write `content` to `file_`.
`file_` is expected to be a sub-class of `io.TextIOBase`.
"""
file_.truncate(0)
file_.seek(0)
file_.write(content)
file_.flush()
file_.close()
def _mdl_stylize(args):
ls = LinkStyler(args.link_style)
stylized_content = ls(args.in_file)
if args.out_file:
args.in_file.close()
_write_to(open(args.out_file, "wt"), stylized_content)
else:
_write_to(args.in_file, stylized_content)
def _get_args(args=None):
parser = argparse.ArgumentParser()
parser.add_argument("--version", action="version", version=__version__)
parser.add_argument(
"link_style", choices=["inline", "footnote"], help="markdown link style."
)
parser.add_argument(
"in_file", type=argparse.FileType("rt+"), help="path to markdown file."
)
parser.add_argument(
"out_file",
nargs="?",
type=str,
default=None,
help=" ".join(
[
"path to output file.",
"if it is not given, the output is",
"directly written to the original",
"in_file.",
]
),
)
return parser.parse_args(args)
def main():
args = _get_args()
_mdl_stylize(args)
