nele

package module
v0.8.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 14, 2019 License: GPL-3.0 Imports: 29 Imported by: 0

README

Nele Blog

Golang GoDoc Go Report Issues Size Tag License View examples

Purpose

The purpose of this package was twofold initially. On one hand I needed a project to learn the (then to me new) Go language, and on the other hand I wanted a project, that lead me into different domains, like user authentication, configuration, data formats, error handling, filesystem access, data logging, os, network, regex, templating etc. – And, I wanted no external dependencies (like databases etc.). – And, I didn't care for Windows(tm) compatibility since I left the MS-platform about 25 years ago after using it in the 80s and early 90s of the last century. (But who, in his right mind, would want to run a web-service on such a platform anyway?)

That's how I ended up with this little blog-system (for lack of a better word; or: diary, notes, …). It's a system that lets you write and add articles from both the command line and a web-interface. It provides options to add, modify and delete entries using a user/password list for authentication when accessing certain URLs in this system. Articles can be added, edited (e.g. for correcting typos etc.), or removed altogether. If you don't like the styles coming with the package you can, of course, change them acoording to your preferences in your own installation.

The articles you write are then available on the net as web-pages.

It is not, however, a discussion platform. It's supposed to be used as a publication platform, not some kind of social media. So I intentionally didn't bother with comments or discussion threading.

Features

  • Markdown support
  • Multiple user accounts supported
  • No database (like SQLite, MariaDB, etc.) required
  • No JavaScript dependency
  • No cookies needed
  • Privacy aware
  • Simplicity of use

Installation

You can use Go to install this package for you:

go get -u github.com/mwat56/Nele

Usage

After downloading this package you go to its directory and compile

go build app/nele.go

which should produce an executable binary. On my system it looked (at a certain point in time) like this:

$ ls -l
total 11420
drwxrwxr-x 12 matthias matthias     4096 Mai 23 18:35 .
drwxrwxr-x 12 matthias matthias     4096 Mai 23 17:58 ..
-rw-rw-r--  1 matthias matthias      474 Apr 27 00:21 addTest.md
-rw-rw-r--  1 matthias matthias     1458 Mai 23 17:58 blog.ini
drwxrwxr-x  2 matthias matthias     4096 Mai 23 18:14 certs
-rw-rw-r--  1 matthias matthias     6583 Mai 23 18:14 cmdline.go
-rw-rw-r--  1 matthias matthias    10149 Mai 23 18:20 config.go
-rw-rw-r--  1 matthias matthias     1846 Mai 23 18:14 config_test.go
drwxrwxr-x  2 matthias matthias     4096 Mai 23 18:14 css
drwxrwxr-x  3 matthias matthias     4096 Mai 23 18:14 _demo
-rw-rw-r--  1 matthias matthias      823 Mai 23 18:14 doc.go
drwxrwxr-x  2 matthias matthias     4096 Mai 23 18:14 fonts
drwxrwxr-x  8 matthias matthias     4096 Mai 23 18:10 .git
drwxrwxr-x  3 matthias matthias     4096 Mai 23 17:58 .github
-rw-rw-r--  1 matthias matthias      123 Mai 23 17:58 .gitignore
-rw-------  1 matthias matthias      507 Mai 23 18:11 go.mod
-rw-------  1 matthias matthias     4004 Mai 23 18:11 go.sum
-rw-rw-r--  1 matthias matthias     5010 Mai 23 18:18 hashfile.db
drwxrwxr-x  2 matthias matthias     4096 Mai 23 18:14 img
-rw-rw-r--  1 matthias matthias       84 Apr 12 15:46 intl.ini
-rw-rw-r--  1 matthias matthias    32474 Mai 23 17:58 LICENSE
-rwxrwxr-x  1 matthias matthias 11149115 Mai 23 18:19 nele
-rw-rw-r--  1 matthias matthias    21803 Mai 23 18:14 pagehandler.go
-rw-rw-r--  1 matthias matthias      619 Mai 23 18:22 pagehandler_test.go
-rw-rw-r--  1 matthias matthias     9313 Mai 23 18:14 posting.go
drwxrwxr-x  8 matthias matthias     4096 Mai 23 18:01 postings
-rw-rw-r--  1 matthias matthias    15319 Mai 23 18:14 posting_test.go
-rw-rw-r--  1 matthias matthias     8240 Mai 23 18:14 postlist.go
-rw-rw-r--  1 matthias matthias     7279 Mai 23 18:23 postlist_test.go
-rw-rw-r--  1 matthias matthias       70 Mai 23 18:19 pwaccess.db
-rw-rw-r--  1 matthias matthias    22792 Mai 23 18:35 README.md
-rw-rw-r--  1 matthias matthias    10435 Mai 23 18:24 regex.go
-rw-rw-r--  1 matthias matthias     8190 Mai 23 18:14 regex_test.go
drwxrwxr-x  2 matthias matthias     4096 Mai 23 17:58 static
-rw-rw-r--  1 matthias matthias     3656 Mai 23 18:14 tags.go
-rw-rw-r--  1 matthias matthias     3811 Mai 23 17:58 template_vars.md
-rw-rw-r--  2 matthias matthias     3109 Mai 23 18:16 TODO.md
drwxrwxr-x  3 matthias matthias     4096 Mai 23 18:14 views
-rw-rw-r--  1 matthias matthias     6787 Mai 23 18:14 views.go
-rw-rw-r--  1 matthias matthias     6009 Mai 23 18:14 views_test.go
$ _

You can reduce the binary's size by stripping it:

$ strip nele
$ ls -l nele
-rwxrwxr-x 1 matthias matthias 8146912 Mai 23 18:38 nele
$ _

As you can see the binary lost about 3MB of its weight.

Let's start with the command line:

$ ./nele -h

Usage: bin/nele-linux-amd64 [OPTIONS]

-blogname string
	Name of this Blog (shown on every page)
	(default "Meine Güte, was für'n Blah!")
-certKey string
	<fileName> the name of the TLS certificate's private key
	(default "/home/matthias/devel/Go/src/github.com/mwat56/Nele/certs/server.key")
-certPem string
	<fileName> the name of the TLS certificate PEM
	(default "/home/matthias/devel/Go/src/github.com/mwat56/Nele/certs/server.pem")
-datadir string
	<dirName> the directory with CSS, IMG, JS, POSTINGS, STATIC, VIEWS sub-directories
	(default "/home/matthias/devel/Go/src/github.com/mwat56/Nele")
-gzip
	(optional) use gzip compression for server responses (default true)
-hashfile string
	<fileName> (optional) the name of a file storing #hashtags and @mentions
	(default "/home/matthias/devel/Go/src/github.com/mwat56/Nele/hashfile.db")
-ini string
	<fileName> the path/filename of the INI file to use
	(default "/home/matthias/devel/Go/src/github.com/mwat56/Nele/nele.ini")
-lang string
	(optional) the default language to use  (default "de")
-listen string
	the host's IP to listen at  (default "127.0.0.1")
-log string
	(optional) name of the logfile to write to
	(default "/dev/stdout")
-logStack
	<boolean> Log a stack trace for recovered runtime errors  (default true)
-maxfilesize string
	max. accepted size of uploaded files (default "10MB")
-pa
	(optional) posting add: write a posting from the commandline
-pf string
	<fileName> (optional) post file: name of a file to add as new posting
-port int
	<portNumber> the IP port to listen to  (default 8181)
-realm string
	(optional) <hostName> name of host/domain to secure by BasicAuth
	(default "This Host")
-theme string
	<name> the display theme to use ('light' or 'dark')
	(default "dark")
-ua string
	<userName> (optional) user add: add a username to the password file
-uc string
	<userName> (optional) user check: check a username in the password file
-ud string
	<userName> (optional) user delete: remove a username from the password file
-uf string
	<fileName> (optional) user passwords file storing user/passwords for BasicAuth
	(default "/home/matthias/devel/Go/src/github.com/mwat56/Nele/pwaccess.db")
-ul
	(optional) user list: show all users in the password file
-uu string
	<userName> (optional) user update: update a username in the password file

Most options can be set in an INI file to keep the command-line short ;-)

$ _

However, to just run the program you'll usually don't need any of those options to input on the commandline. There is an INI file called nele.ini coming with the package, where you can store the most common settings:

$ cat nele.ini
# Default configuration file

[Default]

# Name of this Blog (shown on every page).
blogname = "Meine Güte, was für'n Blah!"

# path-/filename of the TLS certificate's private key to enable
# TLS/HTTPS (if empty standard HTTP is used).
# NOTE: A relative path/name will be combined with `datadir` (below).
certKey = ./certs/server.key

# path-/filename of TLS (server) certificate to enable TLS/HTTPS
# (if empty standard HTTP is used).
# NOTE: A relative path/name will be combined with `datadir` (below).
certPem = ./certs/server.pem

# The directory root for the "css", "fonts", "img", "postings",
# "static", and "views" sub-directories.
# NOTE: This should be an _absolute_ path name.
datadir = ./

# Use gzip compression for server responses.
gzip = true

# The file to store #hashtags and @mentions.
# NOTE: A relative path/name will be combined with `datadir` (above).
hashfile = ./hashfile.db

# The default UI language to use ("de" or "en").
lang = de

# The host's IP number to listen at.
listen = 127.0.0.1

# Whether or not log a stack trace for recovered runtime errors.
# NOTE: This is merely a debugging aid and should normally be `false`.
logStack = true

# The IP port to listen to.
port = 8181

# Name of the optional logfile to write to.
# NOTE: A relative path/name will be combined with `datadir` (above).
logfile = /dev/stdout

# Accepted size of uploaded files.
maxfilesize = 10MB

# Password file for HTTP Basic Authentication.
# NOTE: a relative path/name will be combined with `datadir` (above).
passfile = ./pwaccess.db

# Name of host/domain to secure by BasicAuth.
realm = "This Host"

# Web/display theme ("dark" or "light").
theme = dark

# _EoF_
$ _

The program, when started, will first look for the INI file in five different places:

  1. in your (i.e. the current user's) directory (./nele.ini),
  2. in the computer's main config directory (/etc/nele.ini"),
  3. in the current user's home directory (e.g. $HOME/.nele.ini),
  4. in the current user's configuration directory (e.g. $HOME/.config/nele.ini),
  5. in the -ini <filename> commandline option (if given).

All these files (if they exist) are read in the given order at startup before finally parsing the commandline options shown earlier. So each step overwrites the previous one, the commandline options having the highest priority. – But let's look at some of the commandline options more closely.

Commandline postings

You can post an article directly from the commandline.

./nele -pa allows you to write an article/posting directly on the commandline.

$ ./nele -pa
This is
a test
posting directly
from the commandline.
<Ctrl-D>
2019/05/06 14:57:30 ./nele wrote 54 bytes in a new posting
$ _

./nele -pf <fileName> allows you to include an already existing text file (with possibly some Markdown markup) into the system.

$ ./nele -pf addTest.md
2019/05/06 15:09:27 ./nele stored 474 bytes in a new posting
$ _

These two options (-pa and -pf) are only usable from the commandline.

Authentication

Why, you may ask, would you need an username/password file anyway? Well, you remember me mentioning that you can add, edit and delete articles? You wouldn't want anyone on the net being able to do that, now, would you? For that reason, whenever there's no password file given (either in the INI file or the command-line) all functionality requiring authentication will be disabled. (Better safe than sorry, right?)

Note that the password file generated and used by this system resembles the htpasswd used by the Apache web-server, but both files are not interchangeable because the actual encryption algorithms used by both are different.

User/password file & handling

Only usable from the commandline are the -uXX options, most of which need a username and the name of the password file to use. – Note that whenever you're prompted to input a password this will not be echoed to the console.

The -ua option allows you to add an user/password pair:

$ ./nele -ua testuser1 -uf pwaccess.db

 password:
repeat pw:
    added 'testuser1' to list
$ _

Again: The password input is not echoed to the console, therefor you don't see it.

Since we have the passfile setting already in our INI file (see above) we can forget the -uf option for the next options.

With -uc you can check a user's password:

$ ./nele -uc testuser1

 password:
    'testuser1' password check successful
$ _

This -uc you'll probably never actually use, it was just easy to implement.

If you want to remove an user account the -ud will do the trick (i.e. delete a user):

$ ./nele -ud testuser1
    removed 'testuser1' from list
$ _

When you want to know which users are stored in your password file -ul is your friend:

$ ./nele -ul
matthias

$ _

Since we deleted the testuser1 before only one entry remains.

That only leaves -uu to update (change) a user's password.

$ ./nele -ua testuser2

 password:
repeat pw:
    added 'testuser2' to list

$ ./nele -uu testuser2

 password:
repeat pw:
    updated user 'testuser2' in list

$ ./nele -ul
matthias
testuser2

$ _

First we added (-ua) a new user, then we updated the password (-uu), and finally we asked for the list of users (-ul).

Configuration

The system's configuration takes two steps:

  1. Prepare the required files and directories.
  2. Customise the INI file and/or prepare a script with all needed commandline arguments.
  3. You most probably want to customise the files ./views/imprint.gohtml, ./views/licence.gohtml, and ./views/privacy.gohtml according to your personal reqirements.

URLs

The system uses a number of slightly different URL groups.

First, there are the static files served from the css, img, and static directories. The actual location of which you can configure with the datadir INI entry and/or commandline option.

Second, are the URLs any normal user might see and use:

  • / defines the logical root of the presentation; it's effectivily the same as /n/ (see below).
  • /faq, /imprint, /licence, and /privacy serve static files which have to be filled with content according to your personal and legal needs.
  • /hl/tagname allows you to search for #tagname (but you'll input it without the number sign # because that has a special meaning in an URL). Provided the given #tagname was actually used in one or more of your articles a list of the respective articles will be shown.
  • /m/ shows the articles of the current month. You can, however, specify the month you're interested in by adding a data part defining the month you want to see (/m/yyyy-mm), like /m/2019-04 to see the acticles from April 2019.
  • /ml/mentionedname allows you to search for @mentionedname (but you'll input it without the at sign @ because that has a special meaning in an URL). Provided the given @mentionedname was actually used in one or more of your articles a list of the respective articles will be shown.
  • /n/ gives you the newest 20 articles. The number of articles to show can be added to the URL like /n/5 to see only five articles, or /n/100 to see a hundred. If you want to see the articles in slices of, say, 10 per page (instead of the default 20/page) you could use the URL /n/10,10 and to see the secong slice user /n/10,20, the third with /n/10,30 and so on. However, as long as there are more articles available, there will be a »» link at the bottom of the page to ease the navigation for you.
  • /p/1234567890abcdef shows you a single article/posting (the ID is automatically generated). This kind of URL your users will see when they choose on another page to see the single article per page by selecting the leading [*] link.
  • /s/searchterm can be used to search for articles containing a certain word. All existing articles will be searched for the given searchterm.
  • /w/ shows the articles of the current week. You can, however, specify the week you're interested in by adding a data part defining the week you want to see (/w/yyyy-mm-dd), like /w/2019-04-13 to see the acticles from the week in April 2019 containing the 13th.

And, third, there's a group of URLs your users won't usually see or use, because by design they are reserved for you. These URLs are protected by an authentication mechanism called BasicAuth (which is supported by browsers for at least twenty years); this is where the username/password files comes in. Only users whose credentials (i.e. username and password) are stored in the password file will be given access to the following URLs. So don't forget to setup an appropriate password file. If you forget that (or the file is not accessible for the program) everybody on the net could read, modify, or delete your articles, or add new ones – which you might not like and therefor the system disables all options that might modify your system.

  • /a add a new posting. A simple Web form will allow you to input whatever's on your mind.
  • /d/234567890abcdef1 lets you change an article/posting's date/time if you feel the need for cosmetic or other reasons. Since you don't usually know/remember the article ID you'll first go to show the article/posting on a single page (/p/234567890abcdef1) by selectiing the respective [*] link on the index page and then just replace in the URL the p by a d.
  • /e/34567890abcdef12 lets you edit the article/posting's text identified by 34567890abcdef12. The procedure is the same: go to /p/34567890abcdef12 and replace the p by an e.
  • /r/4567890abcdef123 lets you remove (delete) the article/posting identified by 4567890abcdef123 altogether. Note that there's no undo feature: Once you've deleted an article/posting it's gone.
  • /si (store image): This shows you a simple HTML form by which you can upload image files into your /img/ directory. Once the upload is done you (i.e. the user) will be presented an edit page in which the uploaded image is used.
  • /share/https://some.host.domain/somepage lets you share another page URL. Whatever you write after the initial /share/ is considered a remote URL, and a new article will be created and shown to edit.
  • /ss (store static): This shows you a simple HTML form by which you can upload static files into your /static/ directory. Once the upload is done you (i.e. the user) will be presented an edit page in which the uploaded file is used.

Files

Right at the start I mentioned that I wanted to avoid external dependencies – like databases for example. Well, that's not exactly true (or even possible), because there is one database that's always already there, regardless of the operating system: the filesystem. The trick is to figure out how to best use it for our own purposes. The solution I came up with here is to use sort of a timestamp as ID and filename for the arcticles, and use part of that very timestamp as ID and name for the directory names as well.

Both directory- and file-names are automatically handled by the system. Each directory can hold up to 52 days worth of articles. After extensive experimentation – with hundreds of thousands of automatically generated (and deleted) test files – that number seemed to be a reasonable compromise between directories not growing too big (search times) and keeping the number of directories used low (about seven per year).

All this data (files and directories) will be created under the directory you configure either in the INI file (entry datadir) or on the commandline (option -datadir). Under that directory the program expects several sub-directories:

  • css/ for stylesheet files,
  • fonts/ for font files,
  • img/ for image files,
  • postings/ directory root for the articles,
  • static/ for static files (like e.g. PDF files),
  • views/ for page templates

Apart from setting that datadir option to your liking you don't have to worry about it anymore.

As mentioned before, it's always advisable to use absolute pathnames, not relative one. The latter are converted into absolute ones (based on datadir) by the system, but they depend on where you are in the filesystem when you start the program or write the commandline options. You can use ./nele -h to see which directories the program will use (see the example above).

CSS

In the CSS directory (datadir/css) there are currently four files that are used automatically (i.a. hardcoded) by the system: stylesheet.css with some basic styling rules and dark.css and light.css with different settings for mainly colours, thus implementing two different themes for the web-presentation, and there's the fonts.css file setting up the custom fonts to use. The theme INI setting and the -theme commandline option determine which of the two dark and light styles to actually use.

Fonts

The datadir/fonts directory contains some freely available fonts used by the CSS files.

Images

The datadir//img/ directory can be used to store, well, images to which you then can link in your articles. You can put there whatever images you like either form the command-line or by using the system's /si URL.

Postings

The datadir// directory is the base for storing all the articles. The system creates subdirectories as needed to store new articles. This directory structure is not accessed via a direct URL but used internally by the system.

Static

The datadir//static/ directory can be used to store, well, static files to which you then can link in your articles. You can put there whatever file you like either form the command-line or by using the system's /ss URL.

Views

The datadir//views/ directory holds the templates with which the final HTML pages are generated. Provided that you feel at home working with Go templates you might change them as you seem fit. I will, however, not provide any support for you changing the default template structure.

An concise overview of the used templates and which variables they use you'll find in the file template_vars.md

Contents

For all the article you write – either on the commandline or with the web-interface – you can use Markdown to enrich the plain text. In fact, the system expects the postings to be using MarkDown syntax if any markup at all.

Libraries

The following external libraries were used building Nele:

Licence

Copyright © 2019 M.Watermann, 10247 Berlin, Germany
                All rights reserved
            EMail : <support@mwat.de>

This program 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.

This software 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.

You should have received a copy of the GNU General Public License along with this program. If not, see the GNU General Public License for details.

Documentation

Overview

Package nele implements a simple blog-server. 

Copyright © 2019 M.Watermann, 10247 Berlin, Germany
               All rights reserved
           EMail : <support@mwat.de>

This program 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.

This software 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.

You should have received a copy of the GNU General Public License along with this program. If not, see the [GNU General Public License](http://www.gnu.org/licenses/gpl.html) for details.

Index

Constants

This section is empty.

Variables

View Source 
var (
	// AppArguments is the list for the cmdline arguments and INI values.
	AppArguments tAguments
)

Functions

func AddConsolePost 

func AddConsolePost() (int64, error)

AddConsolePost reads data from `StdIn` and saves it as a new posting, returning the number of bytes written and a possible I/O error.

func AddFilePost 

func AddFilePost(aFilename string) (int64, error)

AddFilePost reads `aFilename` and adds it as a new posting, returning the number of bytes written and a possible I/O error.

func AddTagID added in v0.8.0 

func AddTagID(aList *hashtags.THashList, aPosting *TPosting)

AddTagID checks a newly added `aPosting` for #hashtags and @mentions. 

`aList` The hashlist to use (update).
`aPosting` The new posting to handle.

func AddUser 

func AddUser(aUser, aFilename string)

AddUser reads a password for `aUser` from the commandline and adds it to `aFilename`.

NOTE: This function does not return but terminates the program with error code `0` (zero) if successful, or `1` (one) otherwise. 

`aUser` the username to add to the password file.

`aFilename` name of the password file to use.

func CheckUser 

func CheckUser(aUser, aFilename string)

CheckUser reads a password for `aUser` from the commandline and compares it with the one stored in `aFilename`.

NOTE: This function does not return but terminates the program with error code `0` (zero) if successful, or `1` (one) otherwise. 

`aUser` the username to check in the password file.

`aFilename` name of the password file to use.

func DeleteUser 

func DeleteUser(aUser, aFilename string)

DeleteUser removes the entry for `aUser` from the password list `aFilename`.

NOTE: This function does not return but terminates the program with error code `0` (zero) if successful, or `1` (one) otherwise. 

`aUser` the username to remove from the password file.

`aFilename` name of the password file to use.

func InitConfig added in v0.2.0 

func InitConfig()

InitConfig reads the commandline arguments into a list structure merging it with key-value pairs read from INI file(s).

The steps here are: (1) read the INI file(s), (2) merge the commandline arguments the INI values into the global `AppArguments` variable.

This function is meant to be called first thing in the program's `main()`.

func InitHashlist added in v0.7.0 

func InitHashlist(aList *hashtags.THashList)

InitHashlist initialises the hash list. 

`aList` The list of #hashtags/@mentions to update.

func ListUsers added in v0.3.0 

func ListUsers(aFilename string)

ListUsers reads `aFilename` and lists all users stored in there.

NOTE: This function does not return but terminates the program with error code `0` (zero) if successful, or `1` (one) otherwise.

`aFilename` name of the password file to use.

func MDtoHTML 

func MDtoHTML(aMarkdown []byte) []byte

MDtoHTML converts the `aMarkdown` data returning HTML data.

`aMarkdown` the raw Markdown text to convert.

func MarkupCloud added in v0.7.0 

func MarkupCloud(aList *hashtags.THashList) []template.HTML

MarkupCloud returns a list with the markup of all existing #hashtags/@mentions. 

`aList` The list of #hashtags/@mentions to use.

func MarkupTags added in v0.7.0 

func MarkupTags(aPage []byte) []byte

MarkupTags returns `aPage` with all #hashtags/@mentions marked up as a HREF links. 

`aPage` The HTML page to process.

func NewID 

func NewID() string

NewID returns a new article ID. It is based on the current date/time and given in hexadecimal notation. It's assumend that no more than one ID per nanosecond is required.

func PostingBaseDirectory 

func PostingBaseDirectory() string

PostingBaseDirectory returns the base directory used for storing articles/postings.

func PrepareLinkPreviews added in v0.8.0 

func PrepareLinkPreviews(aPosting *TPosting, aImageURLdir string)

PrepareLinkPreviews updates the external link(s) in `aPosting` to include page preview image(s) (if available). 

`aPosting` is the posting the text of which is going to be processed.
`aImageURLdir` is the URL directory for page preview images.

func RemoveIDTags added in v0.8.0 

func RemoveIDTags(aList *hashtags.THashList, aID string)

RemoveIDTags removes `aID` from `aList's` items. 

`aList` The hashlist to update.
`aID` The ID of the posting to remove.

func RemovePagePreviews added in v0.8.0 

func RemovePagePreviews(aPosting *TPosting)

RemovePagePreviews deletes the images used in `aPosting`. 

`aPosting` The posting the image(s) of which are going to be deleted.

func RemoveWhiteSpace 

func RemoveWhiteSpace(aPage []byte) []byte

RemoveWhiteSpace removes HTML comments and unnecessary whitespace.

This function removes all unneeded/redundant whitespace and HTML comments from the given <tt>aPage</tt>. This can reduce significantly the amount of data to send to the remote user agent thus saving bandwidth.

func RenameIDTags added in v0.8.0 

func RenameIDTags(aList *hashtags.THashList, aOldID, aNewID string)

RenameIDTags renames all references of `aOldID` to `aNewID`. 

`aList` The hashlist to update.
`aOldID` The posting's old ID.
`aNewID` The posting's new ID.

func ReplaceTag added in v0.8.0 

func ReplaceTag(aList *hashtags.THashList, aSearchTag, aReplaceTag string)

ReplaceTag replaces the #tags/@mentions in `aList`. 

`aList` The hashlist to update.
`aSearchTag` The old #tag/@mention to find.
`aReplaceTag` The new #tag/@mention to use.

func SetPostingBaseDirectory 

func SetPostingBaseDirectory(aBaseDir string)

SetPostingBaseDirectory sets the base directory used for storing articles/postings. 

`aBaseDir` The base directory to use for storing articles/postings.

func ShowHelp 

func ShowHelp()

ShowHelp lists the commandline options to `Stderr`.

func URLparts 

func URLparts(aURL string) (rDir, rPath string)

URLparts returns two parts: `rDir` holds the base-directory of `aURL`, `rPath` holds the remaining part of `aURL`.

Depending on the actual value of `aURL` both return values may be empty or both may be filled; none of both will hold a leading slash.

func UpdatePreviews added in v0.8.0 

func UpdatePreviews(aPostingBaseDir, aImgURLdir string)

UpdatePreviews starts the process to update the preview images in all postings. 

`aPostingBaseDir` is the base directory used for storing

articles/postings. 

`aImageURLdir` is the URL directory for page preview images.

func UpdateTags added in v0.8.0 

func UpdateTags(aList *hashtags.THashList, aPosting *TPosting)

UpdateTags updates the #hashtag/@mention references of `aPosting`. 

`aList` The hashlist to update.
`aPosting` The new posting to process.

func UpdateUser 

func UpdateUser(aUser, aFilename string)

UpdateUser reads a password for `aUser` from the commandline and updates the entry in the password list `aFilename`.

NOTE: This function does not return but terminates the program with error code `0` (zero) if successful, or `1` (one) otherwise.

`aUser` the username to remove from the password file.

`aFilename` name of the password file to use.

Types

type TDataList 

type TDataList map[string]interface{}

TDataList is a list of values to be injected into a template.

func NewDataList 

func NewDataList() *TDataList

NewDataList returns a new (empty) TDataList instance.

func (*TDataList) Set 

func (dl *TDataList) Set(aKey string, aValue interface{}) *TDataList

Set inserts `aValue` identified by `aKey` to the list.

If there's already a list entry with `aKey` its current value gets replaced by `aValue`.

`aKey` is the values's identifier (as used as placeholder in the template).

`aValue` contains the data entry's value.

type TPageHandler 

type TPageHandler struct {
	// contains filtered or unexported fields
}

TPageHandler provides the handling of HTTP request/response.

func NewPageHandler 

func NewPageHandler() (*TPageHandler, error)

NewPageHandler returns a new `TPageHandler` instance.

func (*TPageHandler) Address 

func (ph *TPageHandler) Address() string

Address returns the configured `IP:Port` address to use for listening.

func (*TPageHandler) GetErrorPage 

func (ph *TPageHandler) GetErrorPage(aData []byte, aStatus int) []byte

GetErrorPage returns an error page for `aStatus`, implementing the `TErrorPager` interface.

func (*TPageHandler) Len 

func (ph *TPageHandler) Len() int

Len returns the length of the internal views list.

func (*TPageHandler) NeedAuthentication 

func (ph *TPageHandler) NeedAuthentication(aRequest *http.Request) bool

NeedAuthentication returns `true` if authentication is needed, or `false` otherwise. 

`aRequest` is the request to check.

func (*TPageHandler) ServeHTTP 

func (ph *TPageHandler) ServeHTTP(aWriter http.ResponseWriter, aRequest *http.Request)

ServeHTTP handles the incoming HTTP requests.

type TPostList 

type TPostList []TPosting

TPostList is a list of postings to be injected into a template/view.

func NewPostList 

func NewPostList() *TPostList

NewPostList returns a new (empty) TPostList instance.

func SearchPostings 

func SearchPostings(aText string) *TPostList

SearchPostings traverses the sub-directories of `aBaseDir` looking for `aText` in all posting files.

The returned `TPostList` can be empty because (a) `aText` could not be compiled into a regular expression, (b) no files to search were found, or (c) no files matched `aText`.

`aText` is the text to look for in the postings.

func (*TPostList) Add 

func (pl *TPostList) Add(aPosting *TPosting) *TPostList

Add appends `aPosting` to the list. 

`aPosting` contains the actual posting's text.

func (*TPostList) Article 

func (pl *TPostList) Article(aID string) *TPostList

Article adds the posting identified by `aID` to the list. 

`aID` is the ID of the posting to add to this list.

func (*TPostList) Day 

func (pl *TPostList) Day() *TPostList

Day adds all postings of the current day to the list.

func (*TPostList) Delete 

func (pl *TPostList) Delete(aPosting *TPosting) (*TPostList, bool)

Delete removes `aPosting` from the list, returning the (possibly modified) list and whether the operation war successful. 

`aPosting` is the posting o remove from this list.

func (*TPostList) Index 

func (pl *TPostList) Index(aPosting *TPosting) int

Index returns the 0-based list index of `aPosting`. In case `aPosting` was not found in list the return value will be `-1`. 

`aPosting` is the posting to lookup in this list.

func (*TPostList) IsSorted 

func (pl *TPostList) IsSorted() bool

IsSorted returns `true` if the list is sorted (in descending order), or `false` otherwise.

func (*TPostList) Len 

func (pl *TPostList) Len() int

Len returns the number of postings stored in this list.

func (*TPostList) Month 

func (pl *TPostList) Month(aYear int, aMonth time.Month) *TPostList

Month adds all postings of `aMonth` to the list. 

`aYear` the year to lookup; if `0` (zero) the current year

is used. 

`aMonth` the year's month to lookup; if `0` (zero) the

current month is used.

func (*TPostList) Newest 

func (pl *TPostList) Newest(aNumber, aStart int) error

Newest adds the last `aNumber` of postings to the list.

The resulting list is sorted in descending order (newest first) with at most `aNumber` posts. 

`aNumber` The number of articles to show.

`aStart` The start number to use.

func (*TPostList) Sort 

func (pl *TPostList) Sort() *TPostList

Sort returns the list sorted by posting IDs (i.e. date/time) in descending order.

func (*TPostList) Week 

func (pl *TPostList) Week(aYear int, aMonth time.Month, aDay int) *TPostList

Week adds all postings of the current week to the list. 

`aYear` the year to lookup; if `0` (zero) the current year

is used. 

`aMonth` the year's month to lookup; if `0` (zero) the current

month is used. 

`aDay` the month's day to lookup; if `0` (zero) the current day is used.

type TPosting 

type TPosting struct {
	// contains filtered or unexported fields
}

TPosting is a single article/posting to be used by a template.

func NewPosting 

func NewPosting(aID string) *TPosting

NewPosting returns a new posting structure with an empty article text. 

`aID` if an empty string the `NewID()` function is called

to provide a new article ID.

func (*TPosting) After 

func (p *TPosting) After(aID string) bool

After reports whether this posting is younger than the one identified by `aID`. 

`aID` is the ID of another posting to compare.

func (*TPosting) Before 

func (p *TPosting) Before(aID string) bool

Before reports whether this posting is older than the one identified by `aID`. 

`aID` is the ID of another posting to compare.

func (*TPosting) Clear 

func (p *TPosting) Clear() *TPosting

Clear resets the internal fields to their respective zero values.

This method does NOT remove the file (if any) associated with this posting/article; for that call the `Delete()` method.

func (*TPosting) Date 

func (p *TPosting) Date() string

Date returns the posting's date as a formatted string (`yyy-mm-dd`).

func (*TPosting) Delete 

func (p *TPosting) Delete() error

Delete removes the posting/article from the filesystem returning a possible I/O error.

This method does NOT empty the markdown text of the object; for that call the `Clear()` method.

func (*TPosting) Equal 

func (p *TPosting) Equal(aID string) bool

Equal reports whether this posting is of the same time as `aID`. 

`aID` The ID of the posting to compare with this one.

func (*TPosting) Exists 

func (p *TPosting) Exists() bool

Exists returns whether there is a file with more than zero bytes.

func (*TPosting) ID 

func (p *TPosting) ID() string

ID returns the article's identifier.

The identifier is based on the article's creation time and given in hexadecimal notation.

This method allows the template to validate and use the placeholder `.ID`

func (*TPosting) Len 

func (p *TPosting) Len() int

Len returns the current length of the posting's Markdown text.

If the markup is not already in memory this methods calls `TPosting.Load()` to read the text data from the filesystem.

func (*TPosting) Load 

func (p *TPosting) Load() error

Load reads the Markdown from disk, returning a possible I/O error.

func (*TPosting) Markdown 

func (p *TPosting) Markdown() []byte

Markdown returns the Markdown of this article.

If the markup is not already in memory this methods calls `TPosting.Load()` to read the text data from the filesystem.

func (*TPosting) PathFileName 

func (p *TPosting) PathFileName() string

PathFileName returns the article's complete path-/filename.

func (*TPosting) Post 

func (p *TPosting) Post() template.HTML

Post returns the article's HTML markup.

func (*TPosting) Set 

func (p *TPosting) Set(aMarkdown []byte) *TPosting

Set assigns the article's Markdown text. 

`aMarkdown` is the actual Markdown text of the article to assign.

func (*TPosting) Store 

func (p *TPosting) Store() (int64, error)

Store writes the article's Markdown to disk returning the number of bytes written and a possible I/O error.

The file is created on disk with mode `0640` (`-rw-r-----`).

func (*TPosting) String added in v0.8.0 

func (p *TPosting) String() string

String returns a stringified version of the posting object.

Note: This is mainly for debugging purposes and has no real life use.

func (*TPosting) Time 

func (p *TPosting) Time() time.Time

Time returns the posting's date/time.

type TView 

type TView struct {
	// contains filtered or unexported fields
}

TView combines a template and its logical name.

func NewView 

func NewView(aBaseDir, aName string) (*TView, error)

NewView returns a new `TView` with `aName`.

`aBaseDir` is the path to the directory storing the template files.

`aName` is the name of the template file providing the page's main body without the filename extension (i.e. w/o ".gohtml"). `aName` serves as both the main template's name as well as the view's name.

func (*TView) Render 

func (v *TView) Render(aWriter http.ResponseWriter, aData *TDataList) error

Render executes the template using the TView's properties.

`aWriter` is a http.ResponseWriter, or e.g. `os.Stdout` in console apps.

`aData` is a list of data to be injected into the template.

If an error occurs executing the template or writing its output, execution stops, and the method returns without writing anything to the output `aWriter`.

func (*TView) RenderedPage 

func (v *TView) RenderedPage(aData *TDataList) (rBytes []byte, rErr error)

RenderedPage returns the rendered template/page and a possible Error executing the template.

`aData` is a list of data to be injected into the template.

type TViewList 

type TViewList tViewList

TViewList is a list of `TView` instances (to be used as a template pool).

func NewViewList 

func NewViewList() *TViewList

NewViewList returns a new (empty) `TViewList` instance.

func (*TViewList) Add 

func (vl *TViewList) Add(aView *TView) *TViewList

Add appends `aView` to the list.

`aView` is the view to add to this list.

The view's name (as specified in the `NewView()` function call) is used as the view's key in this list.

func (*TViewList) Get 

func (vl *TViewList) Get(aName string) (*TView, bool)

Get returns the view with `aName`.

`aName` is the name (key) of the `TView` object to retrieve.

If `aName` doesn't exist, the return value is `nil`. The second value (ok) is a `bool` that is `true` if `aName` exists in the list, and `false` if not.

func (*TViewList) Render 

func (vl *TViewList) Render(aName string, aWriter http.ResponseWriter, aData *TDataList) error

Render executes the template with the key `aName`.

`aName` is the name of the template/view to use.

`aWriter` is a `http.ResponseWriter` to handle the executed template.

`aData` is a list of data to be injected into the template.

If an error occurs executing the template or writing its output, execution stops, and the method returns without writing anything to the output `aWriter`.

func (*TViewList) RenderedPage 

func (vl *TViewList) RenderedPage(aName string, aData *TDataList) (rBytes []byte, rErr error)

RenderedPage returns the rendered template/page with the key `aName`.

`aName` is the name of the template/view to use.

`aData` is a list of data to be injected into the template.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.