Free discard software for linux

Games::Cards is a Perl module for writing and playing card games.

SYNOPSIS

use Games::Cards;
my $Rummy = new Games::Cards::Game;

# Create the correct deck for a game of Rummy.
my $Deck = new Games::Cards::Deck ($Rummy, "Deck");

# shuffle the deck and create the discard pile
$Deck->shuffle;
my $Discard = new Games::Cards::Queue "Discard Pile";

# Deal out the hands
foreach my $i (1 .. 3) {
my $hand = new Games::Cards::Hand "Player $i" ;
$Deck->give_cards($hand, 7);
$hand->sort_by_value;
push @Hands, $hand;
}

# print hands (e.g. "Player 1: AS 2C 3C 3H 10D QS KH")
foreach (@Hands) { print ($_->print("short"), "n") }

$Hands[1]->give_a_card ($Discard, "8D"); # discard 8 of diamonds

This module creates objects and methods to allow easier programming of card games in Perl. It allows you to do things like create decks of cards, have piles of cards, hands, and other sets of cards, turn cards face-up or face-down, and move cards from one set to another. Which is pretty much all you need for most card games.

KardsGT is a card game programme that has many of your favourite card games. Each game comes with an exhaustive manual on how to play the game.
In addition to the many wonderful games to play, we also have amazing characters to play against. Each character has their own history and sense of play, giving you a fun challenge as you play.
path is the path to where you want to store your game profile information. This is typically /home/username
Main features:
- Graphical base library
- Card logic base library
Enhancements:
- Bug fix: In Cribbage, a run or pairs would not be counted if the resulting score was 31.
- Bug fix: In Cribbage, if a special run was in the hand and if the pair was able to make a combination of 15, it would remove the pair for 15 from the sequence of listed point counting hands.
- Bug Fix: When in Go, if the Go Player made 31, it would continue to remain his turn.
- Added check to verify proper crib selection.
- Bug fix: Abigail, Jack, Norman, Sally failed to check if their card was a legal card to play in a special point situation on the board.
- Bug fix: Abigail, Jack, Norman incorrectly would select the same card twice when discarding to their opponents crib if only one non-valuable card was present.

listadmin is a command-line alternative to Mailmans Web interface for administering mailing lists.
Mailman has a friendly but rather awkward web interface for manipulating the queue of messages held for moderator approval. Since I maintain a couple of dozen lists, some of which receive 50+ spams per day, I needed a way to reduce the time taken to process all the junk e-mail.
The result was listadmin. It is designed to keep user interaction to a minimum, in theory you could run it from cron to prune the queue. It can use the score from a header added by SpamAssassin to filter, or it can match specific senders, subjects, or reasons. The configuration file is Notepad.exe friendly. A sample configuration file:
password "Geheim"
# action to take when pressing just Return default discard
# discard automatically anything with SA score higher than 6 spamlevel 6
discard_if_from ^(postmaster|mailer(-daemon)?|listproc|no-reply)@
my-favourite-band@ifi.uio.no
spectroscopy-discuss@lister.ping.uio.no
You cant make a screenshot of a program like this, but a sample session may be instructive. See the manual page for the whole story. The script is written in Perl and requires a few modules, but AFAIK they are all bundled with Perl 5.8.0.
Enhancements:
- This release fixes the use of proxies for HTTP, adds the capability of turning nomail on or off from the command line, and improves interoperability with Mailman 2.1.x.
- Unknown character encodings are also handled more gracefully.

mod_xsendfile is a small Apache2 module that processes X-SENDFILE headers registered by the original output handler.
If it encounters the presence of such header it will discard all output and send the file specified by that header instead using Apache internals including all optimizations like caching-headers and sendfile or mmap if configured.
mod_xsendfile is useful for processing script-output of e.g. php, perl or any cgi.
- Some applications require checking for special privileges.
- Other have to lookup values first (e.g.. from a DB) in order to correctly process a download request.
- Or store values (download-counters come into mind).
Benefits
- Uses apache internals
- Optimal delivery through senfile and mmap (if available).
- Sets correct cache headers such as Etag and If-Modified-Since as if the file was statically served.
- Processes cache headers such as If-None-Match or If-Modified-Since.
Installation:
- Grab the source.
- Compile and install
apxs -cia mod_xsendfile.c
- Restart apache

DBIx::HTML::ClientDB is a Perl module to convert sql into a client-side db with keyed access.

Synopsis

use DBIx::HTML::ClientDB;

my($object) = DBIx::HTML::ClientDB -> new
(
dbh => $dbh,
row_headings => Unit code,Unit code,Campus name,Unit name,
sql => select unit_code, unit_code, campus_name, unit_name .
from unit, campus where unit_campus_id = campus_id .
order by unit_code,
);

print $object -> javascript_for_client_db();
print $object -> table();
print $object -> javascript_for_client_init();

This module takes a db handle, an SQL statement and a specially-formatted row_headings parameter, and builds an array of rows as returned by the SQL.

Then you ask for that array in HTML, ie as a table.

After a call to the table() method, you can call the size() method if you need to check how many rows were returned by the SQL you used.

Neither the module CGI.pm, nor any of that kidney, are used by this module. We simply output pure HTML.

However, for simplicity, this document pretends you are using CGI.pm rather than an alternative. The sentences would become too convoluted otherwise.

The output table is formatted as N rows of 2 columns:

First column

The first column contains the row headings you supply in the row_headings parameter. row_headings is a comma-separated list of strings you want to appear in the first column of the table.

There must be one string in row_headings for each column mentioned in the SQL.

Second column

The second column contains the current record in the database.

Now for the rows:

First row

The first row contains the first prompt string in the first column.

The first row contains a HTML popup menu in the second column.

This menu is what you use to choose the current record in the database.
Since two (2) SQL columns are used to build this menu, two (2) strings from the row_headings parameter are consumed building the first row. The first of these 2 strings appears in the first column, as explained above. The second of these 2 strings is, much to your amazement, discarded!

This way of doing things makes it easy for you to count row_heading strings and their corresponding SQL columns, and makes it easy for me to cross-check your ability to count to 2.

Other rows

Each other row contains a field in the current record. The value in the first column comes from the row_headings parameter, and the value in the second column comes from the database.

The sum result is menu-driven access to the data returned by the SQL. All this is downloaded from your CGI script to the web client. Since changing the current menu item updates the other fields in this table using JavaScript, no message is sent to the web server, and hence you have maximum speed of access.

The whole point of the exercise is to give you simple code for simple access to simple data.

See examples/test-clientdb.cgi for an example which will make all this clear.

Pod::Compiler can compile POD into an object tree.

This package, based on Pod::Parser, compiles a given POD document into an object tree (based on Tree::DAG_Node). It prints errors and warnings about the POD it reads. The result can be used to conveniently convert the POD into any other format.

The resulting objects have a variety of methods to ease the subsequent conversion.

There are two script based on this package, namely podchecker2, an enhanced POD syntax checker and podlint, which beautifies the POD of a given file.

This package is object-oriented, which means that you can quite easily build a derived package and override some methods in case the given behaviour does not exactly suit your needs.

Package Functions

The following functions can be imported and called from a script, e.g. like this:

use Pod::Compiler qw(pod_compile);
my $root = pod_compile(myfile.pod);

pod_compile( { %options } , $file )
pod_compile( $file )

Compile the given $file using some %options and return the root of the object tree representing the POD in $file. The return value is either undef if some fatal error occured or an object of type Pod::root. See below for methods applicable to this class and for the options.

The special option -compiler => class lets you specify an alternate (derived) compiler class rather than Pod::Compiler.

Compiler Object Interface

The following section describes the OO interface of Pod::Compiler.

$c = Pod::Compiler->new( %options )

Set up a new compiler object. Options (see below) can be passed as a hash, e.g.

$c = Pod::Compiler->new( -warnings => 0 ); # dont be silly

Pod::Compiler inherits from Pod::Parser. See Pod::Parser for additional methods.

$c->initialize()

Initalize, set defaults. The following options are set to the given defaults unless they have been defined at object creation:

-errors => 1

Print POD syntax errors (using messagehandler) if option value is true.

-warnings => 1

Print POD syntax warnings (using messagehandler) if option value is true.

-idlength => 20

Pod::Compiler creates a unique node id for each =head, =item and X, consisting only of w characters. The option value specifies how many characters from the original node text are used for the node id by the built-in make_unique_node_id method. See below for more information.

-ignore => BCFS

This option specifies which interior sequences (e.g. B< ... >) are ignored when nested in itself, e.g. B< ...B< ... >... >. The inner B is simply discarded if the corresponding letter appears in the option value string.

-unwrap => I

This option specifies which interior sequences (e.g. I< ... >) are unwrapped when nested in itself, e.g. I< ...I< ... >... > is turned into I< ... >...I< ... >. While some destination formats may handle such nestings appropriately, other might have problems. This option solves it right away. By the way, from a typographical point of view, italics are often used for emphasis. In order to emphasize something within an emphasis, one reverts to the non-italic font.

name =>

This is used to store the (logical) name of the POD, i.e. for example the module name as it appears in use module;. It is used internally only to detect internal links pointing to the explicit page name. Example: You compile the file Compiler.pm which contains the package Pod::Compiler. You set name to Pod::Compiler (there is no safe automatic way to do so). Thus if the file includes a link like L< Pod::Compiler/messagehandler > it is recognized as an internal link and it is checked whether it resolves. Of course you should have written the link as L< /messagehandler >...

-perlcode => 0

If set to true, the compiler will also return the Perl code blocks as objects Pod::perlcode, rather than only the POD embedded in the file. This is used e.g. by podlint.

$c->option( $name , $value )

Get or set the compile option (see above) given by $name. If $value is defined, the option is set to this value. The resulting (or unchanged) value is returned.

$c->messagehandler( $severity , $message )

This method is called every time a warning or error occurs. $severity is one of ERROR or WARNING, $message is a one-line string. The built-in method simply does

warn "$severity: $messagen";
$c->name( [ $name ] )

Set/retrieve the name property, i.e. the canonical Pod name (e.g. Pod::HTML). See above for more details.

$c->root()

Return the root element (instance of class Pod::root) representing the compiled POD document. See below for more info about its methods.

$c->make_unique_node_id($string)

Turn given text string into a document unique node id. Can be overridden to adapt this to specific formatter needs. Basically this method takes a string and must return something (more or less dependent on the string) that is unique for this POD document. The built-in method maps all consecutive non-word characters and underlines to a single underline and truncates the result to -idlength (see options above). If the result already exists, a suffix _n is appended, where n is a number starting with 1. A different method could e.g. just return ascending numbers, but if you think of HTML output, a node id that resembles the text and has a fair chance to remain constant over subsequent compiles of the same document gives the opportunity to link to such anchors from external documents.

XML::Filter::Dispatcher::AsStructHandler Perl module can help you convert SAX stream in to simple, data-oriented structure.

SYNOPSIS

## Ordinarily used via the XML::Filter::Dispatchers as_data_struct()
## built-in extension function for XPath

This SAX2 handler builds a simple hash from XML. Text from each element and attribute is stored in the hash with a key of a relative path from the root down to the current element.

The goal is to produce a usable structure as simply and quickly as possible; use XML::Simple for more sophisticated applications.

The resulting data structure has one hash per element, one scalar per attribute, and one scalar per text string in each leaf element.

Warnings are emitted if any content other than whitespace is discarded.

The root element name is discarded.

If you are using namespaces, you must pass in the Namespaces option, otherwise not. Using namespaces without a Namespaces option or vice versa will not work.

Only start_document(), start_element(), characters(), end_element(), and end_document() are provided; so all comments, processing instructions etc., are discarded.

Fetchmail is a full-featured, robust, well-documented remote-mail retrieval and forwarding utility intended to be used over on-demand TCP/IP links (such as SLIP or PPP connections). Fetchmail supports every remote-mail protocol now in use on the Internet: POP2, POP3, RPOP, APOP, KPOP, all flavors of IMAP, ETRN, and ODMR. It can even support IPv6 and IPSEC.
Fetchmail retrieves mail from remote mail servers and forwards it via SMTP, so it can then be read by normal mail user agents such as mutt, elm(1) or BSD Mail. It allows all your system MTAs filtering, forwarding, and aliasing facilities to work just as they would on normal mail.
Fetchmail offers better security than any other Unix remote-mail client. It supports APOP, KPOP, OTP, Compuserve RPA, Microsoft NTLM, and IMAP RFC1731 encrypted authentication methods including CRAM-MD5 to avoid sending passwords en clair. It can be configured to support end-to-end encryption via tunneling with ssh, the Secure Shell.
Fetchmail can be used as a POP/IMAP-to-SMTP gateway for an entire DNS domain, collecting mail from a single drop box on an ISP and SMTP-forwarding it based on header addresses. (We dont really recommend this, though, as it may lose important envelope-header information. ETRN or a UUCP connection is better.)
Fetchmail can be started automatically and silently as a system daemon at boot time. When running in this mode with a short poll interval, it is pretty hard for anyone to tell that the incoming mail link is not a full-time "push" connection.
Fetchmail is easy to configure. You can edit its dotfile directly, or use the interactive GUI configurator (fetchmailconf) supplied with the fetchmail distribution. It is also directly supported in linuxconf versions 1.16r8 and later.
Fetchmail is fast and lightweight. It packs all its standard features (POP3, IMAP, and ETRN support) in 196K of core on a Pentium under Linux.
Fetchmail is open-source software. The openness of the sources is your strongest possible assurance of quality and reliability.
Main features:
- STARTTLS is supported in both POP and IMAP.
- ESMTP AUTH (RFC 2554) is supported.
- Has the capability of adding trace information to the Received header to faciliate mail filtering by mailserver and remote account.
- Fetchmail now has options to handle SSL certificate validation.
- Fetchmail can be told to fall back to delivering via local sendmail if it cant open port 25.
- Support for AUTH=CRAM-MD5 under POP3, a la RFC2195.
- Support for ODMR (On-Demand Mail Relay), RFC 2645.
- Its now easy to deliver mail to a local LMTP socket.
- The interface option now checks both local and remote interface IPs.
- The plugin facility has been enhanced; %h and %p options are now available to pass in the hostname and service port number.
- Added a dropdelivered option to discard Delivered-To headers. This addresses a problem with using fetchmail and postfix as a relay inside a domain; when postfix sees incoming messages with delivered-to headers looking exactly the same as the ones it adds himself, it bounces the message.
- Added --smtpname to set username and domain portion of SMTP "RCPT TO" command. - Added "from" servers IP address to inserted Received line.
- Fetchmail now runs on BeOS, thanks to David Reid .
- In IMAP, unseen-message counting and indexing is now done by SEARCH UNSEEN at the beginning of each poll or re-poll (rather than with the UNSEEN and RECENT responses and FLAGS queries on individual messages). This significantly cuts down on traffic to and from the server, and gives more reliable results.
- The aka option now matches hostname suffixes, so (for example) saying `aka netaxs.com will match not just netaxs.com but also (say) pop3.netaxs.com and mail.netaxs.com.
- Fetchmail can optionally use the RFC 2177 IDLE extension on an IMAP server that supports it. On IMAP servers that dont, it can simulate it using periodic NOOP commands.
- Fetchmail now recognizes the RFC 2449 extended responses [IN-USE] and [LOGIN-DELAY].
- Fetchmail running in daemon mode now restarts itself quietly when the rc file is touched.
- Following recent court decisions and changes in U.S. federal regulatory policy, hooks for Secure Sockets Layer (SSL) are now part of the main fetchmail distribution. The distribution still contains no actual cryptographic code.
- NTLM support under IMAP, so fetchmail can query Microsoft Exchange servers.
- Expunge option can now be used to break POP3 retrieval into subsessions.
- Support for AUTH=CRAM-MD5 under IMAP, a la RFC2195.