Free flaming text software for linux

XML From Plain Text (xfpt) is a program that reads a file of plain text that contains relatively simple markup, and outputs an XML file. It is intended to simplify the management of XML data.
The project is not a program that attempts to turn a plain text document into XML. Markup within text is introduced by ampersand characters, but is otherwise "soft". You can define what follows the ampersand, for example, &" to generate a "quote" element. There is also a macro facility that allows for higher level concepts such as chapters, displays, tables, etc.
Enhancements:
- The macro library has been extended to include preface, appendix, colophon, footnote, figure, and table.
- The program has one new directive to enable it to handle "nested" sections such as footnotes.

Fractal Flames are algorithmically generated images and animations. The software was originally written in 1992 and released as open source, aka free software. Since then it has developed a lot.

Flames has been incorporated into many graphics programs and ported to most operating systems. The shape of each image is specified by a long string of numbers - a genetic code of sorts.

You can create your own flames with the Apophysis interactive designer (for windows) or with the gimps flame plug-in (for linux and OSX). Or you can use the Electric Sheep distributed screen saver to join the collective evolution of animated fractal flames.

Tartan is a text parsing engine targeted at wiki text. The syntax specification is defined in YAML in the form of regex-based rules.

It supports layering and multiple output types. Rules for Markdown to HTML are included, with optional layered extensions for tables. Tartan text parser is implemented in Ruby, but looking to have implementations in other languages.

Edit by Text Editors allows you to open a file with Kate, Kwrite, Kedit, Khexedit by a KDE service menu.

To install the service menu you must copy editby.desktop in ~/.kde/share/apps/konqueror/servicemenus

EP3 Perl module is the Extensible Perl PreProcessor.

SYNOPSIS

# Use options and files from command-line
use Text::EP3;
[use Text::EP3::{Extension}] # Language Specific Modules
# create the PreProcessor object
my $preprocessor = new Text::EP3 file;
# do the preprocessing, using command-line options from @ARGV
$preprocessor->ep3_execute;

# Set options and files from the Perl script
use Text::EP3;
[use Text::EP3::{Extension}] # Language Specific Modules
# create the PreProcessor object
my $preprocessor = new Text::EP3 file;
# configure the PreProcessor object (optional)
$preprocessor->ep3_output_file([$filename]);
$preprocessor->ep3_modules([@modules]);
$preprocessor->ep3_includes([@include_directories]);
$preprocessor->ep3_reset;
$preprocessor->ep3_start_comment([$string]);
$preprocessor->ep3_end_comment([$string]);
$preprocessor->ep3_line_comment([$string]);
$preprocessor->ep3_delimiter([$string]);
$preprocessor->ep3_gen_depend_list([$value]);
$preprocessor->ep3_keep_comments([$value]);
$preprocessor->ep3_protect_comments([$value]);
$preprocessor->ep3_defines($string1=$string2);
# do the preprocessing
$preprocessor->ep3_process([$filename, [$condition]]);

EP3 is a Perl5 program that preprocesses STDIN or some set of input files and produces an output file. EP3 only works on input files and produces output files. It seems to me that if you want to preprocess arrays or somesuch, you should be using perl. EP3 was first developed to provide a flexible preprocessor for the Verilog hardware description language.

Verilog presents some problems that were not easily solved by using cpp or m4. I wanted to be able to use a normal preprocessor, but extend its functionality. So I wrote EP3 - the Extensible Perl PreProcessor. The main difference between EP3 and other preprocessors is its built-in extensibility. Every directive in EP3 is really a method defined in EP3, one of its submodules, or embedded in the file that is being processed. By linking the directive name to the associated methods, other methods could be added, thus extending the preprocessor.

Text::Yats is Yet Another Template System.

SYNOPSIS

use Text::Yats;

my $template = < < ENDHTML;
< html >
< head >
< title >$title - $version< /title >
< /head >
< body >
< form >
< select name="names" >< !--{1}-- >
< option $selected >$list< /option >
< !--{2}-- >< /select >
< /form >
< /body >
< /html >
ENDHTML

my $result = "";
my $tpl = Text::Yats- >new(
level = > 1,
text = > $template);

$result .= $tpl- >section- >[0]- >replace(
title = > "Yats",
version = > "Development", );

$result .= $tpl- >section- >[1]- >replace(
list = > [hdias,anita,cubitos],
selected = > { value = > "selected",
array = > "list",
match = > "anita", } );

$result .= $tpl- >section- >[2]- >text;
print $result;

Text::Diff can perform diffs on files and record sets.

SYNOPSIS

use Text::Diff;

## Mix and match filenames, strings, file handles, producer subs,
## or arrays of records; returns diff in a string.
## WARNING: can return B diffs for large files.
my $diff = diff "file1.txt", "file2.txt", { STYLE => "Context" };
my $diff = diff $string1, $string2, %options;
my $diff = diff *FH1, *FH2;
my $diff = diff &reader1, &reader2;
my $diff = diff @records1, @records2;

## May also mix input types:
my $diff = diff @records1, "file_B.txt";

diff() provides a basic set of services akin to the GNU diff utility. It is not anywhere near as feature complete as GNU diff, but it is better integrated with Perl and available on all platforms. It is often faster than shelling out to a systems diff executable for small files, and generally slower on larger files.

Relies on Algorithm::Diff for, well, the algorithm. This may not produce the same exact diff as a systems local diff executable, but it will be a valid diff and comprehensible by patch. We havent seen any differences between Algorithm::Diffs logic and GNU diffs, but we have not examined them to make sure they are indeed identical.

Note: If you dont want to import the diff function, do one of the following:

use Text::Diff ();

require Text::Diff;

Thats a pretty rare occurence, so diff() is exported by default.

Palm::Progect::Converter::Text is a Perl module to convert between Progect databases and Text files.

SYNOPSIS

my $converter = Palm::Progect::Converter->new(
format => Text,
# ... other args ...
);

$converter->load_records();

# ... do stuff with records

$converter->save_records();

This converts between Text files and Palm::Progect records and preferences.
The Text format used for import/export looks something like this:
[x] Level 1 Todo item
[10%] Child (progress)
. Child of Child (informational)

[80%] (31/12/2001) Progress item
[ ] Unticked action item
Here is a summary of the various types of records:
[ ] action type
[x] completed action type
< > action type with todo link
completed action type with todo link

[80%] progress type
[4/5] numeric type

. info type

[ ] [5] action type with priority
[ ] (15/7/2001) action type with date

[80%] [5] (15/7/2001) {category} progress type with priority and date and category

[80%] [5] (15/7/2001) {category} progress type with priority and date and category >