Free 2.1.0 software for linux

Text::Template::Inline allows easy formatting of hierarchical data.

SYNOPSIS

# you can import any name you want instead of "render"
use Text::Template::Inline render;

# yields "Replace things and stuff."
render {
foo => things,
bar => stuff,
}, q ;

# yields "Three Two One Zero"
render [qw/ Zero One Two Three /], {3} {2} {1} {0};

# for a blessed $obj that has id and name accessors:
render $obj, {id} {name};

# a "fat comma" can be used as syntactic sugar:
render $obj => {id} {name};

# its also possible to traverse heirarchies of data,
# even of different types.
# the following yields "one two three"
render {
a => { d => one },
b => { e => two },
c => { f => [qw/ zero one two three /], },
} => {a.d} {b.e} {c.f.3};

# theres also an automatic unindent feature that
# lines up to the least-indented line in the template:
render {
a => { d => one },
b => { e => two },
c => { f => [qw/ zero one two three /], },
} => q{
{a.d}
{b.e}
{c.f.3}
};
# the above results in this:
one
two
three

Webswell Connect is an e-business integration framework based on the ebXML standard. Webswell Connect allows easy, interactive and user-friendly installation.
It consists of an ebXML registry/repository server and client, a messaging system for secure and reliable messaging and user interface similar to popular email clients for sending/handling ebXML messages.
It supports HTTP, HTTPS, and email communication while keeping it safe and reliable by implementing digital signatures, encryption, acknowledgment mechanisms, duplication elimination, etc.
Enhancements:
- This version can be used as an SOA, ebxml, and AS2 integration tool.
- It includes HSQLDB as a default database system.
- It includes an interactive installer with supporting software.
- It includes Webswell Dispatcher 1.1.22, with improved handling of AS2 and ebxml Registry Repository messages.
- It is able to load Ebxml collaboration profiles agreements with hundreds of partnerships.

Pidgin, previously known as Gaim, is a multi-protocol instant messaging client for Linux, BSD, MacOS X, and Windows. Pidgin messenger is compatible with AIM and ICQ (Oscar protocol), MSN Messenger, Yahoo!, IRC, Jabber, SILC, Gadu-Gadu, GroupWise Messenger, and Zephyr networks.
Pidgin users can log in to multiple accounts on multiple IM networks simultaneously. This means that you can be chatting with friends on AOL Instant Messenger, talking to a friend on Yahoo Messenger, and sitting in an IRC channel all at the same time.
Pidgin supports many features of the various networks, such as file transfer, away messages, typing notification, and MSN window closing notification. It also goes beyond that and provides many unique features.
A few popular features are Buddy Pounces, which give the ability to notify you, send a message, play a sound, or run a program when a specific buddy goes away, signs online, or returns from idle; and plugins, consisting of text replacement, a buddy ticker, extended message notification, iconify on away, spell checking, tabbed conversations, and more.
Pidgin runs on a number of platforms, including Windows, Linux, and Qtopia (Sharp Zaurus and iPaq).
Pidgin integrates well with GNOME 2 and KDE 3.1s system tray, as well as Windowss own system tray. This allows you to work with Pidgin without requiring the buddy list window to be up at all times.
Pidgin is under constant development, and releases are usually frequent. The latest news regarding Pidgin can be found on the news page.
Enhancements:
- libpurple:
- Core changes to allow UIs to use second-granularity for scheduling. Pidgin and Finch, which use the glib event loop, were changed to use g_timeout_add_seconds() on glib >= 2.14 when possible. This allows glib to better group our longer timers to increase power efficiency. (Arjan van de Ven with Intel Corporation)
- No longer linkifies screennames containing @ signs in join/part notifications in chats
- With the HTML logger, images in conversations are now saved. NOTE: Saved images are not yet displayed when loading logs.
- Added support for QIP logs to the Log Reader plugin (Michael Shkutkov)
Pidgin:
- Ensure only one copy of Pidgin is running with a given configuration directory. The net effect of this is that trying to start Pidgin a second time will raise the buddy list. (Gabriel Schulhof)
- Undo capability in the conversation window
- The formatting toolbar has been reorganized to be more concise.
- A new status area has been added to the top of conversations to provide additional detail about the buddy, including buddy icon, protocol and status message.
- Show idle times in the buddy list as days, hours, seconds
Finch:
- Theres support for workspaces now (details in the manpage)
- Theres a new custom window manager, Irssi
- Some improvements for tab-completion, tooltip and the password entries
- Some bugs regarding search results fixed
- A new DBus-script to create a docklet for finch
- Support for showing empty groups in the buddy list (Eric Polino)

Sort::Key::Top is a Perl module that can select and sort top n elements.

SYNOPSIS

use Sort::Key::Top (nkeytop top);

# select 5 first numbers by absolute value:
@top = nkeytop { abs $_ } 5 => 1, 2, 7, 5, 5, 1, 78, 0, -2, -8, 2;
# ==> @top = (1, 2, 1, 0, -2)

# select 5 first words by lexicographic order:
@a = qw(cat fish bird leon penguin horse rat elephant squirrel dog);
@top = top 5 => @a;
# ==> @top = qw(cat fish bird elephant dog);

The functions available from this module select the top n elements from a list using several common orderings and custom key extraction procedures.

They are all variations around

keytopsort { CALC_KEY($_) } $n => @data;

This function calculates the ordering key for every element in @data using the expression inside the block. Then it selects and orders the $n elements with the lower keys when compared lexicographically.

It is equivalent to the pure Perl expression:

(sort { CALC_KEY($a) cmp CALC_KEY($b) } @data)[0 .. $n-1];

Variations allow to:

- use the own values as the ordering keys
topsort 5 => qw(a b ab t uu g h aa aac);

==> a aa aac ab b
- return the selected values in the original order
top 5 => qw(a b ab t uu g h aa aac);

==> a b ab aa aac
- use a different ordering
For instance comparing the keys as numbers, using the locale configuration or in reverse order:
rnkeytop { length $_ } 3 => qw(a ab aa aac b t uu g h);

==> ab aa aac

rnkeytopsort { length $_ } 3 => qw(a ab aa aac b t uu g h);

==> aac ab aa

A prefix is used to indicate the required ordering:

(no prefix)

lexicographical ascending order

r

lexicographical descending order

l

lexicographical ascending order obeying locale configuration

r

lexicographical descending order obeying locale configuration

n

numerical ascending order

rn

numerical descending order

i

numerical ascending order but converting the keys to integers first

ri

numerical descending order but converting the keys to integers first

u

numerical ascending order but converting the keys to unsigned integers first

ru

numerical descending order but converting the keys to unsigned integers first

The full list of available functions is:

top ltop ntop itop utop rtop rltop rntop ritop rutop

keytop lkeytop nkeytop ikeytop ukeytop rkeytop rlkeytop rnkeytop
rikeytop rukeytop

topsort ltopsort ntopsort itopsort utopsort rtopsort rltopsort
rntopsort ritopsort rutopsort

keytopsort lkeytopsort nkeytopsort ikeytopsort ukeytopsort
rkeytopsort rlkeytopsort rnkeytopsort rikeytopsort rukeytopsort

XML::XPathToXML is a Perl module that generates XML document from XPath expressions.

SYNOPSIS

my @data = (
/project/name => The Ultimate Question,
/project/comment() => generated by XPathToXML ,
/project/start => 2002-09-08,
/project/end => 7002002-09-08,
/project/@id => 42,
/project/temp/pre => 41,
/project/temp/pre[position()=6] => 46,
/project/temp/pre[3] => 43,
/project/temp/pre[2] => XML::LibXML->new->parse_xml_chunk(q(arbitrary < b>XML< /b> chunk)),
);

my $xpx = new XML::XPathToXML( debug=>1 );

$xpx->parse( @data );

$xpx->parse( /project/temp/pre[last()]/@guess, tooHigh );

print $xpx->documentElement->toString(1)."n";

Result:

< project id="42">
< !-- generated by XPathToXML -->
< name>The Ultimate Question< /name>
< start>2002-09-08< /start>
< end>7002002-09-08< /end>
< temp>
< pre>41< /pre>
< pre>arbitrary < b>XML< /b> chunk< /pre>
< pre>43< /pre>
< pre/>
< pre/>
< pre guess="tooHigh">46< /pre>
< /temp>
< /project>

Generates an XML document or node tree from one or more XPath expressions. Returnes an XML::LibXML::Document or XML::LibXML::Element.
Only a limited subset of XPath is currently supported. Namely, the XPath expression must be a location path consisting of a /-separated sequence of one or more location steps along the child, sibling, or attribute axes. The node-test part of the expression cannot be neither a wildcard (*, @*, prefix:*, ...), nor the node() function. If a namespace prefix is used, then either the namespace must already be declared in the document or registered with an XPathContext object. Location steps may contain arbitrary predicates (filters), but see the details below.

The parser processes the location path as follows:

For an absolute location path (starting with /) the evaluation starts on the document node. For relative location path the evaluation starts on a specified initial context node. The parser evaluates the location path from left to right, one location step at a time, starting either on the document node (in case of absolute location path) or on a specified initial context node (in case of relative location paths). If the location step (including filters) matches a child node or an attribute of the current node, then the parser moves to the first node matched and to the next location step. If no nodes are matched by the location step, then the parser creates an element or attribute with the name (and possibly namespace) specified in the node-test part of the location step and tries again.

If still no nodes are matched, the parser repeats the procedure until the location step matches or the number of sibling nodes created in this way reaches the limit specified in maximumAutoSiblings. In the first case the parser moves to the first matching node. In the latter case the parser fails (removing all sibling-nodes created for the failed location-step from the tree).

Hence, if a filter predicate of a location step specifies a position of a node (e.g. with [4], or [position3], etc), then the parser tries to automatically create empty siblings nodes until it finally creates one with for which the predicate is true.
Note, that because the parser only processes one location step at a time and always picks the first matching node, expressions like /root/a/b are treated as /root/a[1]/b[1]. So, in case of the document

< root>
< a/>
< a>
< b/>
< /a>
< /root>
$xpx->parse(q(/root/a/b),foo) will result in
< root>
< a>< b>foo< /b>< /a>
< a>
< b/>
< /a>
< /root>

although an element matching /root/a/b was already present in the document. To prevent this, either explicitly state that b must exist with /root/a[b]/b or set the second element a as the context node and use a relative location path such as b:

$xpx->setContextNode($xpc->document->find(/root/a[2])->get_node(1)) $xpx->parse("b","foo"); # "./b" is also ok

or simply

$xpx->createNode("b","foo",$xpc->document->find(/root/a[2])->get_node(1));

In the tradition of XML::LibXML errors must be trapped with eval() (the parser dies on error).