tashwiki 0.1.1__tar.gz

tashwiki-0.1.1/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2025 Alexey Ryabov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

tashwiki-0.1.1/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.3
+Name: tashwiki
+Version: 0.1.1
+Summary: Wiki-like static site generator
+License: MIT
+Keywords: wiki,git,markdown
+Author: Alexey Ryabov
+Author-email: alex@b00bl1k.ru
+Requires-Python: >=3.12,<4.0
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Dist: click (>=8.2.1,<9.0.0)
+Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
+Requires-Dist: livereload (>=2.7.1,<3.0.0)
+Requires-Dist: markdown (>=3.8.2,<4.0.0)
+Requires-Dist: termcolor (>=3.1.0,<4.0.0)
+Project-URL: Issues, https://github.com/b00bl1k/tashwiki/issues
+Project-URL: Repository, https://github.com/b00bl1k/tashwiki
+Description-Content-Type: text/markdown
+
+# TashWiki
+
+TashWiki is a wiki-like static site generator. It can be used to make your own
+digital garden or simple personal wiki.
+
+## Features
+
+- Converts your Markdown notes into static HTML pages
+- Wiki-style links between pages
+- Simple and lightweight
+- Easy to deploy
+
+## Installation
+
+```bash
+pip install git+https://github.com/b00bl1k/tashwiki.git
+```
+
+## Usage
+
+```bash
+tashwiki build
+```
+
+This will take your source files from ./content and generate a static site
+into ./output.
+
+## Example
+
+Here is a minimal note:
+
+```markdown
+# Welcome to TashWiki
+
+This is my digital garden.
+
+See also [[Another note]].
+```
+
+## Roadmap
+
+- [x] Categories
+- [ ] Themes
+- [ ] Search
+
+## Status
+
+TashWiki is still in early development. Expect breaking changes.
+
+## License
+
+MIT
+
+## Credits
+
+- [[Rock icons created by Freepik - Flaticon]](https://www.flaticon.com/free-icons/rock)
+

tashwiki-0.1.1/README.md

@@ -0,0 +1,56 @@
+# TashWiki
+
+TashWiki is a wiki-like static site generator. It can be used to make your own
+digital garden or simple personal wiki.
+
+## Features
+
+- Converts your Markdown notes into static HTML pages
+- Wiki-style links between pages
+- Simple and lightweight
+- Easy to deploy
+
+## Installation
+
+```bash
+pip install git+https://github.com/b00bl1k/tashwiki.git
+```
+
+## Usage
+
+```bash
+tashwiki build
+```
+
+This will take your source files from ./content and generate a static site
+into ./output.
+
+## Example
+
+Here is a minimal note:
+
+```markdown
+# Welcome to TashWiki
+
+This is my digital garden.
+
+See also [[Another note]].
+```
+
+## Roadmap
+
+- [x] Categories
+- [ ] Themes
+- [ ] Search
+
+## Status
+
+TashWiki is still in early development. Expect breaking changes.
+
+## License
+
+MIT
+
+## Credits
+
+- [[Rock icons created by Freepik - Flaticon]](https://www.flaticon.com/free-icons/rock)

tashwiki-0.1.1/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "tashwiki"
+version = "0.1.1"
+description = "Wiki-like static site generator"
+authors = [
+    {name = "Alexey Ryabov", email = "alex@b00bl1k.ru"}
+]
+requires-python = ">=3.12,<4.0"
+dependencies = [
+    "markdown (>=3.8.2,<4.0.0)",
+    "jinja2 (>=3.1.6,<4.0.0)",
+    "click (>=8.2.1,<9.0.0)",
+    "livereload (>=2.7.1,<3.0.0)",
+    "termcolor (>=3.1.0,<4.0.0)"
+]
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+keywords = ["wiki", "git", "markdown"]
+classifiers = [
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Text Processing :: Markup",
+    "Topic :: Text Processing :: Markup :: Markdown",
+]
+
+[project.scripts]
+tashwiki = "tashwiki:cli.main"
+
+[project.urls]
+Repository = "https://github.com/b00bl1k/tashwiki"
+Issues = "https://github.com/b00bl1k/tashwiki/issues"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

tashwiki-0.1.1/tashwiki/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__= version(__package__)

tashwiki-0.1.1/tashwiki/builder.py

@@ -0,0 +1,168 @@
+
+import logging
+from pathlib import Path
+from shutil import copytree
+from importlib import resources
+
+from markdown import Markdown
+from jinja2 import Environment, PackageLoader, TemplateNotFound
+from termcolor import cprint
+
+from tashwiki.categories import Categories, Category
+from tashwiki.config import Config
+from tashwiki.utils import page_name_to_label, label_to_page_name
+from tashwiki.wikilinks import WikiLinkExtension
+
+logger = logging.getLogger()
+
+
+class Builder:
+    DEFAULT_PAGE_TEMPLATE = "page.html"
+    CATEGORIES_PAGE_TEMPLATE = "categories.html"
+    CATEGORY_TEMPLATE = "category.html"
+
+    def __init__(self, config: Config):
+        self.conf = config
+        self.source_dir = Path(config.site_source_dir)
+        self.output_dir = Path(config.site_output_dir)
+        self.glob_context = self._prepare_context()
+        self.env = Environment(
+            loader=PackageLoader("tashwiki"),
+        )
+        self.categories = Categories(config.site_category_page)
+        self.md = Markdown(extensions=[
+            "meta",
+            "fenced_code",
+            WikiLinkExtension(
+                base_url=config.site_baseurl,
+                end_url=".html",
+                html_class=self._build_link_class,
+            )
+        ])
+
+    def _prepare_context(self) -> dict:
+        return {
+            "site_author": self.conf.site_author,
+            "site_name": self.conf.site_name,
+            "baseurl": self.conf.site_baseurl,
+            "language": self.conf.site_language,
+            "main_page": self.conf.site_main_page,
+            "categories_page": self.conf.site_categories_page,
+            "categories_url": label_to_page_name(self.conf.site_categories_page) + ".html",
+            "category_page": self.conf.site_categories_page,
+            "category_url": label_to_page_name(self.conf.site_categories_page) + ".html",
+        }
+
+    def _build_link_class(self, page: str):
+        """Return css class for link."""
+
+        page_name = label_to_page_name(page)
+        page_path = (self.source_dir / page_name).with_suffix(".md")
+        if not page_path.exists():
+            cprint(f"Missing page '{page_name}'", color="red")
+            return "notfound"
+        return ""
+
+    def _render_html_page(self, out_path: Path, template: str, context: dict):
+        """Render page using Jinja template engine and write to output file."""
+
+        template = self.env.get_template(template)
+        html = template.render(context)
+        out_path.write_text(html, encoding="utf-8")
+
+    def _validate_meta(self, meta: dict) -> dict:
+        """Validate meta information from Markdown document."""
+
+        for key, value in meta.items():
+            if key in ("title", "author"):
+                meta[key] = value[0]
+            elif key == "template":
+                tpl = value[0]
+                try:
+                    env.get_template(tpl)
+                    meta[key] = tpl
+                except TemplateNotFound:
+                    raise ValueError(f"Template '{tpl}' not found.")
+            elif key == "categories":
+                pass
+            else:
+                raise ValueError(f"Unknown meta field '{key}'.")
+        return meta
+
+    def _copy_static(self):
+        with resources.as_file(resources.files("tashwiki.static")) as src_path:
+            copytree(src_path, self.output_dir, dirs_exist_ok=True)
+
+        static_dir = Path(self.conf.site_static_dir)
+        if static_dir.exists():
+            copytree(static_dir, self.output_dir, dirs_exist_ok=True)
+
+    def build(self):
+        """Build site to output folder."""
+
+        print(f"Building site to folder '{self.output_dir}'...")
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        for md_file in self.source_dir.rglob("*.md"):
+            print(f"Rendering '{md_file.stem}'...")
+            self.render_page(md_file)
+
+        for category in self.categories:
+            print(f"Rendering category page '{category.name}'...")
+            self.render_category_page(category)
+
+        print("Rendering categories index page...")
+        self.render_categories_index()
+
+        print("Copying static files...")
+        self._copy_static()
+
+    def render_page(self, md_file: Path):
+        """Convert Markdown document to HTML page."""
+
+        page_content = self.md.convert(md_file.read_text(encoding="utf-8"))
+        page_name = md_file.stem
+        page_title = page_name_to_label(page_name)
+
+        # prepare context for rendering
+        page_context = {
+            "page_content": page_content,
+            "title": page_title,
+        }
+        page_context.update(self.glob_context)
+
+        # document can contain some meta information
+        meta = self._validate_meta(self.md.Meta)
+        page_template = meta.pop("template", self.DEFAULT_PAGE_TEMPLATE)
+        category_names = meta.pop("categories", [])
+        page_context.update(meta)
+
+        # extract categories from meta and update context
+        page_categories = []
+        for category_name in category_names:
+            category = self.categories.get_or_create(category_name)
+            category.add_page(page_title)
+            page_categories.append(category)
+        page_context.update({"categories": page_categories})
+
+        # actual render to a file
+        out_path = self.output_dir / md_file.with_suffix(".html").name
+        self._render_html_page(out_path, page_template, page_context)
+
+    def render_categories_index(self):
+        categories_context = {
+            "categories": list(self.categories),
+            "title": self.conf.site_categories_page,
+        }
+        categories_context.update(self.glob_context)
+        out_path = (self.output_dir / self.conf.site_categories_page).with_suffix(".html")
+        self._render_html_page(out_path, self.CATEGORIES_PAGE_TEMPLATE, categories_context)
+
+    def render_category_page(self, category: Category):
+        category_context = {
+            "category": category,
+            "title": f"{self.conf.site_category_page}: {category.name}"
+        }
+        category_context.update(self.glob_context)
+        out_path = self.output_dir / category.url
+        self._render_html_page(out_path, self.CATEGORY_TEMPLATE, category_context)

tashwiki-0.1.1/tashwiki/categories.py

@@ -0,0 +1,54 @@
+from tashwiki.utils import label_to_page_name
+
+
+class Category:
+
+    def __init__(self, categories, name):
+        self.categories = categories
+        self.name = name
+        self.url = "{}_{}.html".format(
+            self.categories.basename,
+            label_to_page_name(name),
+        )
+        self.pages = {}
+
+    @property
+    def pages_count(self):
+        return len(self.pages)
+
+    def add_page(self, name):
+        if name not in self.pages:
+            self.pages[name] = label_to_page_name(name) + ".html"
+
+    def __iter__(self):
+        for name, url in self.pages.items():
+            yield {"name": name, "url": url}
+
+    def __repr__(self):
+        return f"Category<{self.name}, {self.pages_count}>"
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+
+class Categories:
+
+    def __init__(self, basename):
+        self.basename = basename
+        self.categories = []
+
+    def get_or_create(self, name) -> Category:
+        for cat in self.categories:
+            if cat.name == name:
+                return cat
+        cat = Category(self, name)
+        self.categories.append(cat)
+        return cat
+
+    def __iter__(self):
+        for category in sorted(self.categories):
+            yield category
+
+    def __repr__(self):
+        return f"Categories<{self.categories}>"
+

tashwiki-0.1.1/tashwiki/cli.py

@@ -0,0 +1,62 @@
+import logging
+from pathlib import Path
+
+import click
+from livereload import Server
+
+from tashwiki import __version__
+from tashwiki.config import Config
+from tashwiki.builder import Builder
+
+logger = logging.getLogger()
+def_conf = Path("config.cfg")
+
+
+@click.group("tashwiki")
+@click.option(
+    "--config",
+    type=click.Path(),
+    help="Path to the configuration file."
+)
+@click.pass_context
+def cli(ctx, config):
+    print(f"TashWiki v{__version__}")
+    if not config and def_conf.exists():
+        config = def_conf
+    if config:
+        conf = Config.from_file(config)
+    else:
+        conf = Config.default()
+    ctx.obj = {
+        "config": conf,
+    }
+
+
+@cli.command()
+@click.pass_context
+def build(ctx):
+    """Build the website."""
+    config = ctx.obj["config"]
+    Builder(config).build()
+
+
+@cli.command()
+@click.option("--reload", is_flag=True, help="Enable automatic reloading.")
+@click.option("--port", type=int, default=8080, help="Webserver port.")
+@click.pass_context
+def serve(ctx, reload, port):
+    """Run development web server"""
+    config = ctx.obj["config"]
+
+    def rebuild():
+        Builder(config).build()
+
+    server = Server()
+    if reload:
+        rebuild()
+        server.watch(config.site_source_dir, func=rebuild)
+    server.serve(port=port, root=config.site_output_dir)
+
+
+def main():
+    cli()

tashwiki-0.1.1/tashwiki/config.py

@@ -0,0 +1,64 @@
+import os
+from configparser import ConfigParser, Error
+
+
+class Config:
+
+    def __init__(self, config: ConfigParser):
+        self.conf = config
+
+    @classmethod
+    def from_file(cls, file: str):
+        if not os.path.exists(file):
+            raise ValueError("Config file not found.")
+        try:
+            config_parser = ConfigParser()
+            config_parser.read(file)
+            return cls(config_parser)
+        except Error:
+            raise ValueError("Config file is invalid.")
+
+    @classmethod
+    def default(cls):
+        config_parser = ConfigParser()
+        return cls(config_parser)
+
+    @property
+    def site_author(self):
+        return self.conf.get("site", "author", fallback="")
+
+    @property
+    def site_name(self):
+        return self.conf.get("site", "name", fallback="TashWiki")
+
+    @property
+    def site_language(self):
+        return self.conf.get("site", "language", fallback="en")
+
+    @property
+    def site_baseurl(self):
+        return self.conf.get("site", "baseurl", fallback="/")
+
+    @property
+    def site_source_dir(self):
+        return self.conf.get("site", "source_dir", fallback="content")
+
+    @property
+    def site_static_dir(self):
+        return self.conf.get("site", "static_dir", fallback="content/static")
+
+    @property
+    def site_output_dir(self):
+        return self.conf.get("site", "output_dir", fallback="output")
+
+    @property
+    def site_main_page(self):
+        return self.conf.get("site", "main_page", fallback="Main page")
+
+    @property
+    def site_categories_page(self):
+        return self.conf.get("site", "categories_page", fallback="Categories")
+
+    @property
+    def site_category_page(self):
+        return self.conf.get("site", "category_page", fallback="Category")

tashwiki-0.1.1/tashwiki/static/css/style.css

@@ -0,0 +1,84 @@
+body {
+  font-family: sans-serif;
+  font-size: 16px;
+}
+
+main {
+  margin: 40px auto;
+  max-width: 750px;
+  line-height: 1.2;
+  color: #222;
+  padding: 0 10px;
+  hyphens: auto;
+  -moz-hyphens: auto;
+  -webkit-hyphens: auto;
+  -ms-hyphens: auto;
+}
+
+header {
+  display: flex;
+  flex-direction: row;
+  justify-content: flex-start;
+  align-items: center;
+}
+
+header .menu-item img {
+  margin: 0;
+  max-width: 100%;
+}
+
+header .menu-item {
+  margin-right: 10px;
+}
+
+pre code {
+  color: #111;
+  background: lightgray;
+  border: 1px solid #999;
+  border-radius: 4px;
+  display: block;
+  padding: 10px;
+  overflow: auto;
+}
+
+code {
+  color: #111;
+  background: lightgray;
+  border-style: solid;
+  border-width: 1px;
+  border: 1px solid #999;
+  border-radius: 4px;
+  padding: 1px;
+}
+
+img {
+  display: block;
+  margin: 0 auto;
+  max-width: 90%;
+}
+
+a {
+  color: #36c;
+  text-decoration: none;
+}
+
+a:visited {
+  color: #6a60b0;
+}
+
+a:hover {
+  text-decoration: underline;
+}
+
+a.notfound {
+  color: #bf3c2c;
+}
+
+footer {
+  clear: both;
+  padding-top: 1rem;
+  margin-top: 2rem;
+  text-align: center;
+  font-size: 0.8rem;
+  color: #333;
+}

tashwiki-0.1.1/tashwiki/templates/base.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="{{ language }}">
+<head>
+  <meta charset="utf-8">
+  <meta name="author" content="{{ site_author }}">
+  <meta name="generator" content="tashwiki">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link rel="stylesheet" href="{{ baseurl }}css/style.css">
+  <link rel="icon" type="image/png" sizes="32x32" href="{{ baseurl }}icons/rocks-32px.png">
+  <link rel="icon" type="image/png" sizes="16x16" href="{{ baseurl }}icons/rocks-16px.png">
+  <title>{{ title }}</title>
+</head>
+<body>
+  <main>
+    <header>
+      <div class="menu-item"><img src="{{ baseurl }}icons/rocks-32px.png"></div>
+      <div class="menu-item"><a href="{{ baseurl }}">{{ main_page }}</a></div>
+      <div class="menu-item"><a href="{{ categories_url }}">{{ categories_page }}</a></div>
+    </header>
+    <hr>
+    <h1>{{ title }}</h1>
+    {% block content %}{% endblock %}
+    <footer>Generated by <a href="https://github.com/b00bl1k/tashwiki">TashWiki</a>.</footer>
+  </main>
+</body>
+</html>

tashwiki-0.1.1/tashwiki/templates/categories.html

@@ -0,0 +1,10 @@
+{% extends "base.html" %}
+
+{% block content %}
+  <ul>
+  {% for category in categories %}
+    <li><a href="{{ baseurl }}{{ category.url }}">{{ category.name }}</a></li>
+  {% endfor %}
+  </ul>
+  <hr>
+{% endblock %}

tashwiki-0.1.1/tashwiki/templates/category.html

@@ -0,0 +1,10 @@
+{% extends "base.html" %}
+
+{% block content %}
+  <ul>
+  {% for page in category %}
+    <li><a href="{{ baseurl }}{{ page.url }}">{{ page.name }}</a></li>
+  {% endfor %}
+  </ul>
+  <hr>
+{% endblock %}

tashwiki-0.1.1/tashwiki/templates/page.html

@@ -0,0 +1,13 @@
+{% extends "base.html" %}
+
+{% block content %}
+  {{ page_content }}
+  <hr>
+  {% if categories %}
+    <p>[ {{ categories_page }}:
+    {% for category in categories %}
+      <a href="{{ baseurl }}{{ category.url }}">{{ category.name }}</a></li>{% if not loop.last %}, {% endif %}
+    {% endfor %}
+    ]</p>
+  {% endif %}
+{% endblock %}

tashwiki-0.1.1/tashwiki/utils.py

@@ -0,0 +1,9 @@
+import re
+
+
+def page_name_to_label(page_name):
+    return re.sub(r"_+", " ", page_name)
+
+
+def label_to_page_name(label):
+    return re.sub(r"([ ]+_)|(_[ ]+)|([ ]+)", "_", label)

tashwiki-0.1.1/tashwiki/wikilinks.py

@@ -0,0 +1,68 @@
+""" Customised wikilinks extension
+
+Based on markdown.extensions.wikilinks
+"""
+
+import re
+import xml.etree.ElementTree as etree
+from typing import Any
+
+from markdown.extensions import Extension
+from markdown.inlinepatterns import InlineProcessor
+
+from tashwiki.utils import label_to_page_name
+
+
+def build_html_class(page):
+    return ""
+
+
+class WikiLinkExtension(Extension):
+    """ Add inline processor to Markdown. """
+
+    def __init__(self, **kwargs):
+        """ Default configuration options. """
+        self.config = {
+            "base_url": ["/", "String to append to beginning or URL."],
+            "end_url": ["/", "String to append to end of URL."],
+            "html_class": [build_html_class, "Callback to return actual html class"],
+        }
+        super().__init__(**kwargs)
+
+    def extendMarkdown(self, md):
+        self.md = md
+
+        # append to end of inline patterns
+        WIKILINK_RE = r"\[\[([\(\)\w0-9_ -]+?)(?:\|([^\]]+?))?\]\]"
+        wikilinkPattern = WikiLinksInlineProcessor(WIKILINK_RE, self.getConfigs())
+        wikilinkPattern.md = md
+        md.inlinePatterns.register(wikilinkPattern, "wikilink", 75)
+
+
+class WikiLinksInlineProcessor(InlineProcessor):
+    """ Build link from `wikilink`. """
+
+    def __init__(self, pattern: str, config: dict[str, Any]):
+        super().__init__(pattern)
+        self.config = config
+
+    def build_url(self, label: str) -> str:
+        return "{}{}{}".format(
+            self.config["base_url"],
+            label,
+            self.config["end_url"],
+        )
+
+    def handleMatch(self, m: re.Match[str], data: str) -> tuple[etree.Element | str, int, int]:
+        if page := m.group(1).strip():
+            label = m.group(2).strip() if m.group(2) else page
+            url = self.build_url(label_to_page_name(page))
+            a = etree.Element("a")
+            a.text = label
+            a.set("href", url)
+            html_class = self.config["html_class"]
+            if html_class:
+                a.set("class", html_class(page))
+        else:
+            a = ""
+        return a, m.start(0), m.end(0)