Free text files software for linux

Text::vFile::toXML can convert vFiles into equivalent XML.

SYNOPSIS

This module converts iCalendar (iCal : generically, vFile) files into their (equivalent) XML (xCalendar / xCal) representation, according to Royers IETF Draft (http://tools.ietf.org/html/draft-royer-calsch-xcal-03).

# Enable functional interface
use Text::vFile::toXML qw(to_xml);

# Input filename
my $arg = "input.file";
my $a = Text::vFile::toXML->new(filename => $arg)->to_xml;
my $b = Text::vFile::toXML->new(filehandle =>
do { open my $fh, $arg or die "cant open ics: $!"; $fh }
)->to_xml;

use Text::vFile::asData; # to make the functional example work
my $data =
Text::vFile::asData->new->parse(
do {
open my $fh, $arg
or die "Cant open vFile: $!"; $fh
}
);
my $c = Text::vFile::toXML->new(data => $data)->to_xml;

# Use functional interface
my $d = to_xml($data);

# Now ($a, $b, $c, $d) all contain the same XML string.

TxtView is a script that shows the text files from the same directory of the song. TxtView script is mostly used to check the information contained in an album directory.
When starting the script, you can right click on a song in your playlist and go to "TxtView -> Open".
Enhancements:
- Option Wrap/No Wrap and Fixed/non fixed chars in the menu
- Using the built-in functions from Python unlike the QDir/file/etc...
- Open With ... in /usr/bin by default
- Use of mimetypes + filename to guess whatever it is a text file or not (I tried magic, but my first note was that it created a new dependence and second.. it didnt do well the job, my default /etc/magic file was empty, at the opposite mimetypes is builtin and does a good job)

TextSearch is a program that helps you search through a set of text files which are in a hierarchical structure, i.e. a directory structure. Each document is searched using a regular expression and an overview of the results is shown as a tree structure. By clicking on a file, it can be viewed, with matches being highlighted.

As opposed to other programs out there, focus is not so much on statistics, i.e. how often a word would occur in an entire corpus of files, but rather on occurrences in single files.

TextSearch is published as open source under the GPL.

Why do I need it?

a) Youre writing your diploma thesis about the occurences of certain terms in publications by various political parties, and you need a way to quickly look for a certain term in many files.
b) Youre a programmer, you have a large code tree, and youd just like to know where youve used sprintf() instead of snprintf().

Text::VimColor is a syntax color text in HTML or XML using Vim.

SYNOPSIS

use Text::VimColor;
my $syntax = Text::VimColor->new(
file => $0,
filetype => perl,
);

print $syntax->html;
print $syntax->xml;

This module tries to markup text files according to their syntax. It can be used to produce web pages with pretty-printed colourful source code samples. It can produce output in the following formats:

HTML

Valid XHTML 1.0, with the exact colouring and style left to a CSS stylesheet

XML

Pieces of text are marked with XML elements in a simple vocabulary, which can be converted to other formats, for example, using XSLT

Perl array

A simple Perl data structure, so that Perl code can be used to turn it into whatever is needed

This module works by running the Vim text editor and getting it to apply its excellent syntax highlighting (aka font-locking) to an input file, and mark pieces of text according to whether it thinks they are comments, keywords, strings, etc. The Perl code then reads back this markup and converts it to the desired output format.

This is an object-oriented module. To use it, create an object with the new function (as shown above in the SYNOPSIS) and then call methods to get the markup out.

File::SmartNL is a slurp text files no matter the New Line (NL) sequence.

SYNOPSIS

#####
# Subroutine Interface
#
use File::SmartNL qw(config fin fout smartnl);

$old_value = config( $option );
$old_value = config( $option => $new_value);
(@all_options) = config( );

$data = smart_nl($data);
$data = fin( $file_name, @options );
$char_count = fout($file_name, $data, @options);

######
# Object Interface
#
use File::SmartNL;

$default_options = File::SmartNL->default(@options);

$old_value = $default_options->config( $option );
$old_value = $default_options->config( $option => $new_value);
(@all_options) = $default_options->config( );

$data = File::SmartNL->smart_nl($data);
$data = File::SmartNL->fin( $file_name, @options );
$char_count = File::SmartNL->fout($file_name, $data, @options);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

Different operating systems have different sequences for new-lines. Historically when computers where first being born, one of the mainstays was the teletype. The teletype understood ASCII. The teletype was an automated typewriter that would perform a carriage return when it received an ASCII Carriage Return (CR), 15, character and a new line when it received a Line Feed (LF), 12 character.

After some time came Unix. Unix had a tty driver that had a raw mode that sent data unprocessed to a teletype and a cooked mode that performed all kinds of translations and manipulations. Unix stored data internally using a single NL character at the ends of lines. The tty driver in the cooked mode would translate the New Line (NL) character to a CR,LF sequence. When driving a teletype, the physicall action of performing a carriage return took some time. By always putting the CR before the LF, the teletype would actually still be performing a carriage return when it received the LF and started a line feed.

After some time came DOS. Since the tty driver is actually one of the largest peices of code for UNIX and DOS needed to run in very cramp space, the DOS designers decided, that instead of writing a tailored down tty driver, they would stored a CR,LF in the internal memory. Data internally would be either text data or binary data.

Needless to say, after many years and many operating systems about every conceivable method of storing new lines may be found amoung the various operating systems. This greatly complicates moving files from one operating system to another operating system.

The smart NL methods in this package are designed to take any combination of CR and NL and translate it into the special NL seqeunce used on the site operating system. Thus, by using these methods, the messy problem of moving files between operating systems is mostly hidden in these methods. By using the fin and fout methods, text files may be freely exchanged between operating systems without any other processing.

The one thing not hidden is that the methods need to know if the data is text data or binary data. Normally, the assume the data is text and are overriden by setting the binary option.

Perl 5.6 introduced a built-in smart nl functionality as an IO discipline :crlf. See Programming Perl by Larry Wall, Tom Christiansen and Jon Orwant, page 754, Chapter 29: Functions, open function. For Perl 5.6 or above, the :crlf IO discipline my be preferable over the smart_nl method of this program module.

Text::MetaText is a Perl extension implementing meta-language for processing "template" text files.

SYNOPSIS

use Text::MetaText;

my $mt = Text::MetaText->new();

# process file content or text string
print $mt->process_file($filename, %vardefs);
print $mt->process_text($textstring, %vardefs);

# pre-declare a BLOCK for subsequent INCLUDE
$mt->declare($textstring, $blockname);
$mt->declare(@content, $blockname);

SUMMARY OF METATEXT DIRECTIVES

%% DEFINE
variable1 = value # define variable(s)
variable2 = "quoted value"
%%

%% SUBST variable %% # insert variable value
%% variable %% # short form of above

%% BLOCK blockname %% # define a block blockname
block text...
%% ENDBLOCK %%

%% INCLUDE blockname %% # include blockname block text
%% INCLUDE filename %% # include external file filename

%% INCLUDE file_or_block # a more complete example...
variable = value # additional variable definition(s)
if = condition # conditional inclusion
unless = condition # conditional exclusion
format = format_string # printf-like format string with %s
filter = fltname(params) # post-process filter
%%

%% TIME # current system time, as per time(2)
format = format_string # display format, as per strftime(3C)
%%

Text::Emoticon::GoogleTalk is a Perl module emoticon filter of GoogleTalk.

SYNOPSIS

use Text::Emoticon::GoogleTalk;
my $emoticon = Text::Emoticon::GoogleTalk->new;

my $text = "I<<less