meta: add known limitation about ordered lists #97

Sublime Text renders ordered lists as unordered lists. I've only added it to the README.md for now, because I'm not sure about how the GitHub website and README should sync...

.gitattributes

@@ -1,3 +1,3 @@
 docs/ export-ignore
-resources/*.png export-ignore
-resources/*.py export-ignore
+resources/
+!resources/*.base64

MarkdownLivePreview.py

@@ -1,48 +1,39 @@
+"""
+Terminology
+original_view: the view in the regular editor, without it's own window
+markdown_view: the markdown view, in the special window
+preview_view: the preview view, in the special window
+original_window: the regular window
+preview_window: the window with the markdown file and the preview
+"""
+
+import time
 import os.path
+import struct
 import sublime
 import sublime_plugin
 
 from functools import partial
 
 from .markdown2html import markdown2html
-from .utils import *
 
 MARKDOWN_VIEW_INFOS = "markdown_view_infos"
 PREVIEW_VIEW_INFOS = "preview_view_infos"
-# FIXME: put this as a setting for the user to choose?
-DELAY = 100  # ms
-
-
-def get_resource(resource):
-    path = "Packages/MarkdownLivePreview/resources/" + resource
-    abs_path = os.path.join(sublime.packages_path(), "..", path)
-    if os.path.isfile(abs_path):
-        with open(abs_path, "r") as fp:
-            return fp.read()
-    return sublime.load_resource(path)
-
+SETTING_DELAY_BETWEEN_UPDATES = "delay_between_updates"
 
 resources = {}
 
 
 def plugin_loaded():
-    resources["base64_404_image"] = get_resource("404.base64")
-    resources["base64_loading_image"] = get_resource("loading.base64")
+    global DELAY
+    resources["base64_404_image"] = parse_image_resource(get_resource("404.base64"))
+    resources["base64_loading_image"] = parse_image_resource(
+        get_resource("loading.base64")
+    )
     resources["stylesheet"] = get_resource("stylesheet.css")
-
-
-# try to reload the resources if we save this file
-try:
-    plugin_loaded()
-except OSError:
-    pass
-
-# Terminology
-# original_view: the view in the regular editor, without it's own window
-# markdown_view: the markdown view, in the special window
-# preview_view: the preview view, in the special window
-# original_window: the regular window
-# preview_window: the window with the markdown file and the preview
+    # FIXME: how could we make this setting update without restarting sublime text
+    #        and not loading it every update as well
+    DELAY = get_settings().get(SETTING_DELAY_BETWEEN_UPDATES)
 
 
 class MdlpInsertCommand(sublime_plugin.TextCommand):
@@ -91,6 +82,7 @@ class OpenMarkdownPreviewCommand(sublime_plugin.TextCommand):
         preview_view.set_scratch(True)
         preview_view.settings().set(PREVIEW_VIEW_INFOS, {})
         preview_view.set_name("Preview")
+        # FIXME: hide number lines on preview
 
         preview_window.focus_group(0)
         if file_name:
@@ -102,7 +94,7 @@ class OpenMarkdownPreviewCommand(sublime_plugin.TextCommand):
 
         markdown_view.set_syntax_file(syntax_file)
         markdown_view.settings().set(
-            MARKDOWN_VIEW_INFOS, {"original_window_id": original_window_id}
+            MARKDOWN_VIEW_INFOS, {"original_window_id": original_window_id,},
         )
 
     def is_enabled(self):
@@ -220,9 +212,16 @@ class MarkdownLivePreviewListener(sublime_plugin.EventListener):
         total_region = sublime.Region(0, markdown_view.size())
         markdown = markdown_view.substr(total_region)
 
+        preview_view = markdown_view.window().active_view_in_group(1)
+        viewport_width = preview_view.viewport_extent()[0]
+
         basepath = os.path.dirname(markdown_view.file_name())
         html = markdown2html(
-            markdown, basepath, partial(self._update_preview, markdown_view), resources,
+            markdown,
+            basepath,
+            partial(self._update_preview, markdown_view),
+            resources,
+            viewport_width,
         )
 
         self.phantom_sets[markdown_view.id()].update(
@@ -235,3 +234,28 @@ class MarkdownLivePreviewListener(sublime_plugin.EventListener):
                 )
             ]
         )
+
+
+def get_settings():
+    return sublime.load_settings("MarkdownLivePreview.sublime-settings")
+
+
+def get_resource(resource):
+    path = "Packages/MarkdownLivePreview/resources/" + resource
+    abs_path = os.path.join(sublime.packages_path(), "..", path)
+    if os.path.isfile(abs_path):
+        with open(abs_path, "r") as fp:
+            return fp.read()
+    return sublime.load_resource(path)
+
+
+def parse_image_resource(text):
+    width, height, base64_image = text.splitlines()
+    return base64_image, (int(width), int(height))
+
+
+# try to reload the resources if we save this file
+try:
+    plugin_loaded()
+except OSError:
+    pass

MarkdownLivePreview.sublime-commands

@@ -3,5 +3,13 @@
 	{
 		"caption": "MarkdownLivePreview: Open Preview",
 		"command": "open_markdown_preview"
+	},
+	{
+		"caption": "MarkdownLivePreview: Open Settings",
+		"command": "edit_settings", "args":
+		{
+			"base_file": "${packages}/MarkdownLivePreview/MarkdownLivePreview.sublime-settings",
+			"default": "{\n\t$0\n}\n"
+		},
 	}
 ]

MarkdownLivePreview.sublime-settings

@@ -0,0 +1,4 @@
+{
+	// minimum number of milliseconds to wait before updating the preview again
+	"delay_between_updates": 100
+}

README.md

@@ -7,13 +7,34 @@ No dependencies!
 
 It's available on package control!
 
+## Setting a keybinding
+
+The open the preview, you can search up in the command palette
+(<kbd>ctrl+shift+p</kbd>) `MarkdownLivePreview: Open Preview`. But if you
+prefer to have a shortcut, add this to your keybindings file:
+
+```json
+{
+    "keys": ["alt+m"],
+    "command": "open_markdown_preview"
+}
+```
+
 ## How to contribute
 
 If you know what feature you want to implement, or what bug you wanna fix, then
-go ahead and hack! But if you wanna contribute just to say thanks, and don't
-really know what you could be working on, then there are a bunch of `FIXME`s
-in `MarkdownLivePreview.py` and `markdown2html.py` (GitHub only shows the top
-2 results if you try to search using their interface :slightly_frowning_face:).
+go ahead and hack! Maybe raise an issue before hand so that we can talk about
+it if it's a big feature.
+
+But if you wanna contribute just to say thanks, and don't really know what you
+could be working on, then there are a bunch of `FIXME`s all over this package.
+Just pick one and fix it :-)
+
+```
+$ git clone https://github.com/math2001/MarkdownLivePreview
+$ cd MarkdownLivePreview
+$ grep -R FIXME
+```
 
 ### Hack it!
 
@@ -23,4 +44,22 @@ in `MarkdownLivePreview.py` and `markdown2html.py` (GitHub only shows the top
 3. All your code should be formated by black.
 4. Send a PR!
 
-FIXME: add a git hook to format using black (can the git hook be added on github?)
+### Known limitations
+
+#### Numbered lists are rendered as unordered lists
+
+```md
+1. first
+2. second
+3. third
+```
+
+will be previewed the exact same way as
+
+```md
+- first
+- second
+- third
+```
+
+The issue comes from [Sublime Text's minihtml](https://www.sublimetext.com/docs/3/minihtml.html) which [doesn't support ordered lists](https://github.com/sublimehq/sublime_text/issues/1767). If you think feel like implementing a workaround, feel free to contribute, but it's not something I'm planning on doing. It isn't a critical feature, and support should come with time...

live-testing/test.md

@@ -1,18 +1,52 @@
-# hello world
+# Why?
+Why do you want to use fancy symbols in your standard monospace font? Obviously to have a fancy prompt like mine :-)
 
-This is a *test*. Some inline `[2]code()`.
+<!-- ![prompt](https://github.com/gabrielelana/awesome-terminal-fonts/raw/master/why.png) -->
 
-what the hell...
+And because when you live in a terminal a symbol can convey more informations in less space creating a dense and beautiful (for those who have a certain aesthetic taste) informative workspace
 
-```python
-import this
+Heavily inspired by <https://github.com/Lokaltog/vim-powerline> and the relative patch script from **Kim Silkebækken** (kim.silkebaekken+vim@gmail.com)
 
-if input("answer yes") != 'yes':
-	print("Really?")
-```
+## Patching vs Fallback
+There are two strategies that could be used to have symbols in a terminal
+* you can take a bunch of symbol fonts, your favourite monospace font and merge them together (patching strategy)
+* you can use a feature of `freetype2` font engine, basically you can say that whenever the current font doesn't have a glyph for a certain codepoint then fallback and go look into other fonts (fallback strategy)
 
-this flickering is really annoying...
+Initially I used the first strategy, later I switched to the second. The patching strategy it's more reliable and portable, the problem is that you need to patch every monospace font you want to use and patching a single font it's a lot of manual fine tuning. If you want you can find all previous patched fonts in [patching-strategy branch](https://github.com/gabrielelana/awesome-terminal-fonts/tree/patching-strategy)
 
-It looks like it's gone... Oh wait nah, it's still here...
+## Font Maps
+Referring to glyphs by codepints (eg. `\uf00c`) in your scripts or shell configuration it's not recommended because icon fonts like [Font Awesome](http://fontawesome.io/) use [code points ranges](https://en.wikipedia.org/wiki/Private_Use_Areas) those ranges are not disciplined by the unicode consortium, every font can associate every glyphs to those codepoints. This means that [Font Awesome](http://fontawesome.io/) can choose to move glyphs around freely, today `\uf00c` is associated to the `check` symbol, tomorrow it can be associated to something else. Moreover, more than one icon font can use the same codepoint for different glyphs and if we want to use them both we need to move one of them. So, if you use a codepoint to refer to a glyph after an update that codepoint can point to another glyph. To avoid this situation you can use the font maps in the `./build` directory, font maps are scripts which define shell variables that give names to glyphs, by sourcing those files in your shell you can refer to glyphs by name (eg. `$CODEPOINT_OF_AWESOME_CHECK`).
 
-This should still be working, and it is!
+TLDR: don't refer to glyphs by codepoints (eg. `\uf00c`) but by name (eg. `$CODEPOINT_OF_AWESOME_CHECK`) to make your scripts and shell configurations resilient to future updates. To do that don't forget to copy font maps (`*.sh` files) in the `./build` directory in your home directory and to source them in your shell startup
+
+## Included Fonts
+In this repository you can find a bunch of fonts that I use as symbol fonts with the relative font maps
+* **Font Awesome 4.7.0**: `./fonts/fontawesome-regular.ttf`, for further informations and license see http://fortawesome.github.io/Font-Awesome
+* **Devicons 1.8.0**: `./fonts/devicons-regular.ttf`, for further informations and license see https://github.com/vorillaz/devicons
+* **Octicons 1.0.0**: `./fonts/octicons-regular.ttf`, for further informations and license see https://github.com/blog/1135-the-making-of-octicons
+* **Pomicons 1.0.0**: `./fonts/pomicons-regular.ttf`, for further informations and license see https://github.com/gabrielelana/pomicons
+
+## How to install (Linux)
+* copy all the fonts from `./build` directory to `~/.fonts` directory
+* copy all the font maps (all `*.sh` files) from `./build` directory to `~/.fonts` directory
+* run `fc-cache -fv ~/.fonts` to let freetype2 know of those fonts
+* customize the configuration file `./config/10-symbols.conf` replacing `PragmataPro` with the name of the font you want to use in the terminal (I will add more fonts in the future so that this step could be skippable)
+* copy the above configuration file to `~/.config/fontconfig/conf.d` directory
+* source the font maps (`source ~/.fonts/*.sh`) in your shell startup script (eg. `~/.bashrc` or `~/.zshrc`)
+
+### Arch Linux
+We have been included in the [official repositories](https://www.archlinux.org/packages/community/any/awesome-terminal-fonts/), so if you are running an Arch Linux
+* run `pacman -Syu awesome-terminal-fonts`
+
+## How to install (OSX)
+* follow [this detailed instructions](https://github.com/gabrielelana/awesome-terminal-fonts/wiki/OS-X) contributed by [@inkrement](https://github.com/inkrement)
+* copy all the fonts maps (all `*.sh` files) from `./build` directory to `~/.fonts` directory
+* source the font maps (`source ~/.fonts/*.sh`) in your shell startup script (eg. `~/.bashrc` or `~/.zshrc`)
+* If it still doesn't work, consider to use the [patching strategy](#patching-vs-fallback)
+
+## How to install (Windows)
+* make sure you have permissions to execute Powershell scripts in your machine. To do so, open Windows Powershell as Administrator and paste & run the following command `Set-ExecutionPolicy RemoteSigned`
+* then run the install script `./install.ps1`
+
+## License
+[MIT](https://github.com/gabrielelana/awesome-terminal-fonts/blob/master/LICENSE)

markdown2html.py

@@ -5,6 +5,8 @@ and makes it a lot easier to think about, and for anyone who would want to, test
 markdown2html is just a pure function
 """
 
+import io
+import struct
 import os.path
 import concurrent.futures
 import urllib.request
@@ -17,20 +19,13 @@ from .lib.markdown2 import Markdown
 
 __all__ = ("markdown2html",)
 
-markdowner = Markdown(extras=["fenced-code-blocks"])
+markdowner = Markdown(extras=["fenced-code-blocks", "cuddled-lists"])
 
 # FIXME: how do I choose how many workers I want? Does thread pool reuse threads or
 #        does it stupidly throw them out? (we could implement something of our own)
 executor = concurrent.futures.ThreadPoolExecutor(max_workers=5)
 
-images_cache = {}
-
-
-class LoadingError(Exception):
-    pass
-
-
-def markdown2html(markdown, basepath, re_render, resources):
+def markdown2html(markdown, basepath, re_render, resources, viewport_width):
     """ converts the markdown to html, loads the images and puts in base64 for sublime
     to understand them correctly. That means that we are responsible for loading the
     images from the internet. Hence, we take in re_render, which is just a function we 
@@ -57,14 +52,12 @@ def markdown2html(markdown, basepath, re_render, resources):
             # realpath: simplify that paths so that we don't have duplicated caches
             path = os.path.realpath(os.path.expanduser(os.path.join(basepath, src)))
 
-        try:
-            base64 = get_base64_image(path, re_render)
-        except FileNotFoundError as e:
-            base64 = resources["base64_404_image"]
-        except LoadingError:
-            base64 = resources["base64_loading_image"]
+        base64, (width, height) = get_base64_image(path, re_render, resources)
 
         img_element["src"] = base64
+        if width > viewport_width:
+            img_element["width"] = viewport_width
+            img_element["height"] = viewport_width * (height / width)
 
     # remove comments, because they pollute the console with error messages
     for comment_element in soup.find_all(
@@ -95,20 +88,31 @@ def markdown2html(markdown, basepath, re_render, resources):
         "<br/>", "<br />"
     )
 
+images_cache = {}
+images_loading = []
 
-def get_base64_image(path, re_render):
+def get_base64_image(path, re_render, resources):
     """ Gets the base64 for the image (local and remote images). re_render is a
     callback which is called when we finish loading an image from the internet
     to trigger an update of the preview (the image will then be loaded from the cache)
+
+    return base64_data, (width, height)
     """
 
-    def callback(path, future):
-        # altering image_cache is "safe" to do because callback is called in the same
+    def callback(path, resources, future):
+        # altering images_cache is "safe" to do because callback is called in the same
         # thread as add_done_callback:
         # > Added callables are called in the order that they were added and are always
         # > called in a thread belonging to the process that added them
         # > --- Python docs
+        try:
             images_cache[path] = future.result()
+        except urllib.error.HTTPError as e:
+            images_cache[path] = resources['base64_404_image']
+            print("Error loading {!r}: {!r}".format(path, e))
+
+        images_loading.remove(path)
+
         # we render, which means this function will be called again, but this time, we
         # will read from the cache
         re_render()
@@ -117,17 +121,29 @@ def get_base64_image(path, re_render):
         return images_cache[path]
 
     if path.startswith("http://") or path.startswith("https://"):
-        executor.submit(load_image, path).add_done_callback(partial(callback, path))
-        raise LoadingError()
+        # FIXME: submiting a load of loaders, we should only have one
+        if path not in images_loading:
+            executor.submit(load_image, path).add_done_callback(partial(callback, path, resources))
+            images_loading.append(path)
+        return resources['base64_loading_image']
 
-    with open(path, "rb") as fp:
-        image = "data:image/png;base64," + base64.b64encode(fp.read()).decode("utf-8")
-        images_cache[path] = image
-        return image
+    with open(path, "rb") as fhandle:
+        image_content = fhandle.read()
+        width, height = get_image_size(io.BytesIO(image_content), path)
+
+        image = "data:image/png;base64," + base64.b64encode(image_content).decode(
+            "utf-8"
+        )
+        images_cache[path] = image, (width, height)
+        return images_cache[path]
 
 
 def load_image(url):
     with urllib.request.urlopen(url, timeout=60) as conn:
+
+        image_content = conn.read()
+        width, height = get_image_size(io.BytesIO(image_content), url)
+
         content_type = conn.info().get_content_type()
         if "image" not in content_type:
             raise ValueError(
@@ -135,4 +151,71 @@ def load_image(url):
                     url, content_type
                 )
             )
-        return "data:image/png;base64," + base64.b64encode(conn.read()).decode("utf-8")
+        return (
+            "data:image/png;base64," + base64.b64encode(image_content).decode("utf-8"),
+            (width, height),
+        )
+
+
+def get_image_size(fhandle, pathlike):
+    """ Thanks to https://stackoverflow.com/a/20380514/6164984 for providing the basis
+        of a working solution.
+
+    fhandle should be a seekable stream. It's not the best for non-seekable streams,
+    but in our case, we have to load the whole stream into memory anyway because base64
+    library only accepts bytes-like objects, and not streams.
+
+    pathlike is the filename/path/url of the image so that we can guess the file format
+    """
+
+    format_ = os.path.splitext(os.path.basename(pathlike))[1][1:]
+
+    head = fhandle.read(24)
+    if len(head) != 24:
+        return "invalid head"
+    if format_ == "png":
+        check = struct.unpack(">i", head[4:8])[0]
+        if check != 0x0D0A1A0A:
+            return
+        width, height = struct.unpack(">ii", head[16:24])
+    elif format_ == "gif":
+        width, height = struct.unpack("<HH", head[6:10])
+    elif format_ == "jpeg":
+        try:
+            fhandle.seek(0)  # Read 0xff next
+
+            size = 2
+            ftype = 0
+            while not 0xC0 <= ftype <= 0xCF:
+                fhandle.seek(size, 1)
+                byte = fhandle.read(1)
+                if byte == b"":
+                    fhandle = end
+                    byte = fhandle.read(1)
+
+                while ord(byte) == 0xFF:
+                    byte = fhandle.read(1)
+                ftype = ord(byte)
+                size = struct.unpack(">H", fhandle.read(2))[0] - 2
+            # We are at a SOFn block
+            fhandle.seek(1, 1)  # Skip `precision' byte.
+            height, width = struct.unpack(">HH", fhandle.read(4))
+        except Exception as e:  # IGNORE:W0703
+            raise e
+    else:
+        return "unknown format {!r}".format(format_)
+    return width, height
+
+
+def independent_markdown2html(markdown):
+    return markdown2html(
+        markdown,
+        ".",
+        lambda: None,
+        {
+            "base64_404_image": ("", (0, 0)),
+            "base64_loading_image": ("", (0, 0)),
+            "stylesheet": "",
+        },
+        960,
+    )

resources/convertresources.py

@@ -1,9 +1,34 @@
 """ A small script to convert the images into base64 data """
 
+import struct
 from base64 import b64encode
 
-with open("404.png", "rb") as png, open("404.base64", "wb") as base64:
+
+def get_image_size(fhandle):
+    """https://stackoverflow.com/a/20380514/6164984"""
+    head = fhandle.read(24)
+    if len(head) != 24:
+        return
+
+    # always going to be png
+    check = struct.unpack(">i", head[4:8])[0]
+    if check != 0x0D0A1A0A:
+        raise ValueError("invalid check (?)")
+
+    width, height = struct.unpack(">ii", head[16:24])
+    return width, height
+
+
+def make_cache(image_name):
+    with open("{}.png".format(image_name), "rb") as png, open(
+        "{}.base64".format(image_name), "wb"
+    ) as base64:
+        width, height = get_image_size(png)
+        png.seek(0)
+        base64.write(bytes("{}\n{}\n".format(width, height), encoding="utf-8"))
+        base64.write(b'data:image/png;base64,')
         base64.write(b64encode(png.read()))
 
-with open("loading.png", "rb") as png, open("loading.base64", "wb") as base64:
-    base64.write(b64encode(png.read()))
+
+make_cache("404")
+make_cache("loading")

resources/stylesheet.css

@@ -17,6 +17,7 @@ blockquote {
 pre {
     display: block;
     background-color: var(--very-light-bg);
+    margin: 10px 0;
 }
 
 code {

utils.py

@@ -1,27 +0,0 @@
-# import sublime
-import time
-
-
-def get_settings():
-    return sublime.get_settings("MarkdownLivePreview.sublime-settings")
-
-
-def min_time_between_call(timeout, on_block=lambda *args, **kwargs: None):
-    """ Enforces a timeout between each call to the function
-    timeout is in seconds
-    """
-    last_call = 0
-
-    def outer(func):
-        def wrapper(*args, **kwargs):
-            nonlocal last_call
-
-            if time.time() - last_call < timeout:
-                time.sleep(timeout - (time.time() - last_call))
-
-            last_call = time.time()
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    return outer