The convert menu may be confusing and dangerous without first becoming familiar with its purposes, and how each item works. Therefore, I’m writing up this help file to help you understand.

The first set of menu items pertains to counting systems, such as Roman numerals, and the system used to count columns in most spreadsheet software. Some of these items also pertain to creating your own counting systems and to using custom counting systems to encode or decode text.

Although you may have other purposes for some of them, the second and third sets of menu items are used for formatting plaintext e-books (such as the .txt files you might find at Project Gutenberg) in certain ways, including as HTML.

^
Convert to/from column letters:

This treats ASCII alphabet letters (in a case-insensitive fashion) as if they are numbers in a special counting system, and it converts them into decimal. Furthermore, it will treat numbers as decimal numbers to be converted into this counting system. There is no zero in this system. A is 1, B is 2, C is 3, and so on to Z being 26. However, because there is no zero, it wraps around to A instead of 0. So, after Z (26), we get AA (27).

This system is nice because it can turn basically any English word into a unique number. The system may have originated with the concept of spreadsheets.
$

^
Convert to/from Roman numberals:

This converts decimal numbers and Roman numerals to and from each other. Be warned that Roman numerals do have some limitations that decimal lacks.
$

^
Set counting system:

This allows you to determine how your custom counting system is represented. The first character entered corresponds with 0 (or 1 as with the column letters, if you want that). The second character is the next number, and so on until the last. Do not enter the same character multiple times.
$

^
To decimal from counting system:

This takes the custom counting sytem you created (or the default, if you didn't create one), and converts it to decimal.
$

^
To counting system from decimal:

This takes something in decimal and converts it to the custom counting system you created (or the default, if you didn't create one).
$

^
Numbers to password text:

I actually removed this feature; so, it's not in the convert menu. But here's what it did in Shule 0.10.0 and before, if you're curious:

This allows you to select numbers written out in your text editor and enter a password. The password text is used to create a new counting system, and the numbers are converted to this new system.

In theory, maybe you could convert words to decimal numbers with the column letters thing (or another method). Then you could enter a password for the numbers with this feature; the numbers would be transformed into something else by the aforementioned counting system.
$

^
Counting system encrypt:

This is encrypts a document with an encryption algorithm that I invented (without trying to emulate, or even know much about, any existing encryption methods).

You should use at least two iterations.

The way it works is it does this:
• Gets a set of all the unique characters used in the document, and randomizes their order (this randomization matters). This is used as the decryption key (how it is used is explained later).
• It divides your text into chunks of a random size.
• It uses the decryption key as a counting system to convert each chunk of text into a decimal number.
• It puts each number on its own line.
• It includes the hash of the encrypted content and the key after all the numbers.
• The next iteration does use the hash characters as part of the next key (which is why it's important to do at least two iterations).

If you do very many iterations, the result will be huge, just so you're warned. A few iterations should be plenty. After you've encrypted it, remove the key and probably the hash, and save them where you want, and then use the numbers as the encrypted text. The document has to be exactly as generated to convert back within Shule, though. So you if you add an extra line or space, it won't work. Keys normally do have spaces in them (so if there is a space at the beginning or ending of a key, it actually matters).

Here's an example, with one iteration to demonstrate:

The original document just says:
this is a test

The encrypted document says this (for me):

469551516074
**Key**
 esthia
**Hash**
a68bf14c14f2f81a3ed31a849cc104555834af7dd7cc586829debd330641d9f799d5f261201a54802157f40aa3435b495f2f060831c28edd79cf0bf43938a3ac

So, ' esthia' is a base seven counting system. Spaces represent 1 (not 0; we're using the column letters style here), e represents two, s represents three, t represents four (the fact that the first and last digits of 469551516074 are 4 is entirely coincidental and irrelevant), h represents five, i represents six and a represents seven. Two spaces in a row represents eight. A space followed by e represents nine. And so on and so forth. Mind you, this isn't simple cipher: you actually have to count to 469551516074 in the ` esthia` base-seven counting system to get to `this is a test`. You're not going to do that without a computer, I'm pretty sure, even if you have the key (the counting system) to crack it.

The document was pretty short, so it looks like we randomly only got one chunk (469551516074). So, `469551516074` is decimal for `this is a test` (and `this is a test` is a single number in a base seven counting system represented by the digits ` esthia` (nevermind that `this is a test` looks like words and spaces; it is actually comprised of digits belonging to a single number); we could have used 1234567 instead (with 11 being 8, 12 being 9, and so on), but then it wouldn't be encryption).

Anyway, I'd love to hear about it if you think you have an algorithm to crack this without knowing the key beforehand, without a brute force algorithm. :) Of course, it's a lot more complex with more iterations, thanks to the hash (or you could just armor the text before encryption and do one iteration), but I'd love to know if you could even do it with one iteration. Keep in mind, all you have is the number. You don't know the base for the counting system. You don't know what characters (and what order of them) are used in the counting system.

The hash is used to verify that decryption of each iteration was successful, and to make the key more complex.

You do not get to choose the key. It is random. Thus, using the same key on multiple documents isn't a thing.

Anyway, I just thought I'd share this with the world. It could stand to be spruced up and modified to be more serious, though.

Here's an example of what it could look like with one iteration if you armor the document first:

6398401295782221036617977221643
59655848746053667033988120685606
56878793130905204564606437381128
32753756085149295633483294686145
29925238004050022771973420357800
23703580546404656362812717967979
58687598632084971859118622003508
258
**Key**
MN"y-roBlacHph gIQti:S\neZmAuEsDkOCUXF3fPd9=LnGR
**Hash**
b48acb6289fa357c403f94ac38d4bd0cfc0c022f09013c36db31deb945d7c41546fabe1569cca4bfc68cf6b18064bdc24626227e25ac46ca0ebb7be88f5455fb

And then here's with two iterations:

61250881186810682202399393768321
62107271073468523568213242224800
23459469865799070588626673293474
34071439116433362156364140709038
12443194564381210300462153891655
6563780348883246514753945277100
23890512635822389831619013762888
62050352832843213676850167739140
54336931267608752085153870244204
54552448785767351553776802345126
61267295556137588868010311691464
34116152175030427385235586107992
4824671516706701316523469701197
38818423810154585254728111448225
40299790625325668462583332084594
25933536975539517801553013236307
16382605983707755587832614113810
61517853478602043645634549660266
12030073480754953827990346129486
54418845490460872461875128146637
39621130153432249409447426503001
34570989154235363738818819571760
11218745381692810045735757537765
2882464695567194733136685
**Key**
Ig9:7Dy43fXG=Zplk5Mu2E- A8b"a*cKheCtmOFHn0rPL1Q6NBR\nsoSUi\\d
**Hash**
e93ace9ce4b9eb893d829e52afd27d8670823e2b3304f4b28cc2e80a326a9bb4bb717e9e934ffcb6d6f34bd679a8ae02f34a6d2ed0182342146045523db64250
$

^
Counting system decrypt:

This is used to decrypt what `Counting system encrypt` produces (exactly as it produced it).
$

^
Convert all, HTML:

This converts a plaintext book or some such into HTML with formatted characters and stuff.

None that if the document contains some ambiguous hyphens, apostrophes, single quote characters, this will ask you about their context (like if it belongs to a zipcode or a telephone number, or not, so it can know whether to use a figure dash, an en dash, or whatever).
$

^
Convert all, TXT:

This removes hard returns and replaces ASCII text with formatted non-ASCII text.

None that if the document contains some ambiguous hyphens, apostrophes, single quote characters, this will ask you about their context (like if it belongs to a zipcode or a telephone number, or not, so it can know whether to use a figure dash, an en dash, or whatever).
$

^
Format special:

This formats dashes, ellipses, and section signs and removes repeated punctuation that isn't proper English!!! It also removes unnecessary punctuation before em dashes and spaced en dashes. (Keeping question marks and exclamation marks.)
$

^
Fix punctuation:

This removes repeated punctuation, punctuation before em dashes, and punctuation before spaced en dashes (`Fix punctuation` is called by `Format special`; so, you don't need to use both on the same text).
$

^
Format dashes:

This replaces hyphens with em dashes, en dashes, and figure dashes. In ambiguous cases, it will ask you questions about how to proceed.
$

^
Format section marks:

This does a very complicated regular expression substitution to put the `§` character where different kinds of manual ASCII section marks might appear. I made it a while ago, so I don't really have an explanation for its logic. However, and I could be wrong, but if memory serves me, it basically should change things like this:

----------------------------

or

===========================

or

**********************

or

whatever

Into

§
$

^
Format ellipses:

This changes the various incarnations of repeated periods into actual ellipses with this regex substitution:

    text=re.sub(r"( ?\. ?){2,}", r" … ", text);
$

^
Format Quotes:

This exchanges ASCII quotes for formatted quotes. In ambiguous cases, it may prompt you as to how to proceed.
$

^
Pre-format blockquotes:

This attempts to exchange ASCII blockquote formatting for some certain abstract Unicode characters. The purpose of this is to make conversion to HTML tags easier later. You don't want to leave a text like this after you do it.
$

^
Remove hard returns:

This removes hard returns! I mean, so if you have like several lines per paragraph, it will turn them all into one line (so you have to use word wrap if you want it spread over multiple lines).
$

^
Convert selection to entity names:

Convert characters in the selecte text to HTML entity names, and escape characters necessary to do so. For example, it will change all instances of `ŵ` within the selection into `&wcirc;`.
$

^
Convert symbolic text styles to HTML …:

This takes you through a series of prompts, which allow you to replace ASCII text styles (e.g. /italic/) with HTML tags (e.g. <i>italic</i>).

It just does bold and italic currently, apparently! I should definitely add underline and overstrike. It does not do CSS. Just simple HTML tags.
$

^
Convert to HTML with entity names:

This converts the document to HTML, using entity names instead of the actual characters.

No, evidently this does not convert the pre-formatted blockquotes to HTML. But it should.
$

^
Format HTML horizontal rules:

This formats section marks and exchanges them for `<hr />`.
$

^
Format HTML blockquotes:

This converts plaintext (not HTML) blockquotes, or and preformatted blockquotes into HTML blockquotes (with line breaks and paragraph tags where appropriate).
$

^
Format HTML paragraphs:

This adds HTML paragraph tags around paragraphs.

Only use when there are no hard returns and spaces at the beginning of paragraphs have been removed.
$

^
Remove HTML tags:

This attempts to remove HTML tags from the document. It's not super successful with modern obfuscated HTML, but for HTML code that actually makes sense to an actual human reading it, it probably works. It provides you with two ways of doing it, lest one doesn't work.
$