Free text program software for linux

Text::Roman is a Perl module that converts roman algarism in integer numbers and the contrary, recognize algarisms.

SYNOPSIS

use Text::Roman;

print roman(123);

Text::Roman::roman() is a very simple algarism converter. It converts a single integer (in arabic algarisms) at a time to its roman correspondent. The conventional roman numbers goes from 1 up to 3999. MROMANS (milhar romans) range is 1 up to 3999*1000+3999=4002999.

Up to these number we will found symbols as:??????but they do not concern this specific package. There is no concern for mix cases, like Xv, XiiI, as legal roman algarism numbers.

roman($int): return string containing the roman corresponding to the given integer, or if the integer is out of domain...

roman2int($str): return if $str is not roman or return integer if it is.

isroman($str): verify whether the given string is a conventional roman number, if it is return 1; if it is not return 0...

Quite same follows for mroman2int($str) and ismroman($str), except that these functions treat milhar romans.

Text::Graphics is a text graphics rendering toolkit.

This is a toolkit for rendering plain text via an API like that used for graphics rendering in GUI toolkits. This package might be used when you want to do sophisticated rendering of plain text, e.g., for graphing, creating of complex forms for email and fax, and so on.

SYNOPSIS

use Text::Graphics;
my $text = "A text graphics rendering toolkit.n";
my $page = Text::Graphics::Page->new( 20, 10);
my $panel0 = Text::Graphics::BorderedPanel->new( 20, 10);
my $panel1 =
Text::Graphics::FilledBorderedTextPanel->new($text x 3, 25, 12);
$panel0->setBackground("#");
$panel1->setBackground(" ");
$page->add($panel0);
$page->add($panel1, 5, 2);
$page->render();

+-------------------+
|###################|
|####+--------------+
|####|A text graphic|
|####|rendering tool|
|####|text graphics |
|####|toolkit. A tex|
|####|graphics rende|
|####|toolkit. |
|####| |
+----+--------------+

Text::Refer can parse Unix "refer" files.

SYNOPSIS

Pull in the module:

use Text::Refer;

Parse a refer stream from a filehandle:

while ($ref = input Text::Refer *FH) {
# ...do stuff with $ref...
}
defined($ref) or die "error parsing input";

Same, but using a parser object for more control:

# Create a new parser:
$parser = new Text::Refer::Parser LeadWhite=>KEEP;

# Parse:
while ($ref = $parser->input(*FH)) {
# ...do stuff with $ref...
}
defined($ref) or die "error parsing input";

Manipulating reference objects, using high-level methods:

# Get the title, author, etc.:
$title = $ref->title;
@authors = $ref->author; # list context
$lastAuthor = $ref->author; # scalar context

# Set the title and authors:
$ref->title("Cyberiad");
$ref->author(["S. Trurl", "C. Klapaucius"]); # arrayref for >1 value!

# Delete the abstract:
$ref->abstract(undef);

Same, using low-level methods:

# Get the title, author, etc.:
$title = $ref->get(T);
@authors = $ref->get(A); # list context
$lastAuthor = $ref->get(A); # scalar context

# Set the title and authors:
$ref->set(T, "Cyberiad");
$ref->set(A, "S. Trurl", "C. Klapaucius");

# Delete the abstract:
$ref->set(X); # sets to empty array of values

Output:

print $ref->as_string;

Text::MacroScript is a macro pre-processor with embedded perl capability.

SYNOPSIS

use Text::MacroScript ;

# new() for macro processing

my $Macro = Text::MacroScript->new ;
while( ) {
print $Macro->expand( $_ ) if $_ ;
}

# Canonical use (the filename improves error messages):
my $Macro = Text::MacroScript->new ;
while( ) {
print $Macro->expand( $_, $ARGV ) if $_ ;
}

# new() for embedded macro processing

my $Macro = Text::MacroScript->new( -embedded => 1 ) ;
# Delimiters default to
# or
my $Macro = Text::MacroScript->new( -opendelim => [[, -closedelim => ]] ) ;
while( ) {
print $Macro->expand_delimited( $_, $ARGV ) if $_ ;
}

# Create a macro object and create initial macros/scripts from the file(s)
# given:
my $Macro = Text::MacroScript->new(
-file => [ local.macro, ~/.macro/global.macro ]
) ;

# Create a macro object and create initial macros/scripts from the
# definition(s) given:
my $Macro = Text::MacroScript->new(
-macro => [
[ MAX_INT => 32767 ],
],
-script => [
[ DHM2S =>
[
my $s = (#0*24*60*60)+(#1*60*60)+(#2*60) ;
"#0 days, #1 hrs, #2 mins = $s secs"
],
],
-variable => [ *MARKER* => 0 ],
) ;

# We may of course use any combination of the options.

my $Macro = Text::MacroScript->new( -comment => 1 ) ; # Create the %%[] macro.

# define()

$Macro->define( -macro, $macroname, $macrobody ) ;

$Macro->define( -script, $scriptname, $scriptbody ) ;

$Macro->define( -variable, $variablename, $variablebody ) ;

# undefine()

$Macro->undefine( -macro, $macroname ) ;

$Macro->undefine( -script, $scriptname ) ;

$Macro->undefine( -variable, $variablename ) ;

# undefine_all()

$Macro->undefine( -macro ) ;

$Macro->undefine( -script ) ;

$Macro->undefine( -variable ) ;

# list()

@macros = $Macro->list( -macro ) ;
@macros = $Macro->list( -macro, -namesonly ) ;

@scripts = $Macro->list( -script ) ;
@scripts = $Macro->list( -script, -namesonly ) ;

@variables = $Macro->list( -variable ) ;
@variables = $Macro->list( -variable, -namesonly ) ;

# load_file() - always treats the contents as within delimiters if we are
# doing embedded processing.

$Macro->load_file( $filename ) ;

# expand_file() - calls expand_embedded() if we are doing embedded
# processing otherwise calls expand().

$Macro->expand_file( $filename ) ;
@expanded = $Macro->expand_file( $filename ) ;


# expand()

$expanded = $Macro->expand( $unexpanded ) ;
$expanded = $Macro->expand( $unexpanded, $filename ) ;

# expand_embedded()

$expanded = $Macro->expand_embedded( $unexpanded ) ;
$expanded = $Macro->expand_embedded( $unexpanded, $filename ) ;

This bundle also includes the macro and macrodir scripts which allows us to expand macros without having to use/understand Text::MacroScript.pm, although you will have to learn the handful of macro commands available and which are documented here and in macro. macro provides more documentation on the embedded approach.

The macroutil.pl library supplied provides some functions which you may choose to use in HTML work for example.

Text::Replace is a Perl module to replace variables from a hash.

SYNOPSIS

#######
# Subroutine Interface
#
use Text::Replace qw(&replace_variables);
$success = replace_variables($template, %variable_hash, @variable);

########
# Class Interface
#
use Text::Replace;
$success = Text::Replace->replace_variables($template, %variable_hash, @variable);

The Text::Replace program module is simple and plain by design. The Text::Replace program module mimics the built-in Perl double quote, ", literal scalar that replaces Perl scalar variables named with a leading $. The Text::Replace program module stays in the background, just like John Williams movie scores.

There is no large manual thicker than the Bible with tricks and tips and gyrations to learn and to distract. The module is plain, simple with no expressiveness. The Text::Replace program module does only one thing: substitute a value for a variable. It is amazing how many times, just a simple double quote literal replacement in a small string or even a large text string gets the job done.

Does Text::Replace solve all variable replacement, template problems? Definitely not. There is no capabilities for inserting graphs, text wrap plug-ins, GD interface. If an application needs something this sophisticated, there are many fine template program modules in CPAN such as the highly rated Template program module.

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.