Free option software for linux

options is a small and simple library for parsing commandline options. It is not intended to rival popt or the like, so if you need really fancy option parsing `options is not for you.
Installation:
./configure
make install
Main features:
- long and short options
- options that take no argument are `counters by default; these start from zero and are incremented each time theyre specified
- default values for all types of options
- interpret option values as integer or string, or both
- print table of options and help messages (with default values)

Tk::Optionmenu will let the user select one of some predefined options values.

SYNOPSIS

use Optionmenu;

$opt = $w->Optionmenu(
-options => REFERENCE_to_OPTIONLIST,
-command => CALLBACK,
-variable => SCALAR_REF,
);

$opt->addOptions( OPTIONLIST );

# OPTION LIST is
# a) $val1, $val2, $val3,...
# b) [ $lab1=>$val1], [$lab2=>val2], ... ]
# c) combination of a) and b), e.g.,
# val1, [$lab2=>val2], val3, val4, [...], ...

The Optionmenu widget allows the user chose between a given set of options.

If the user should be able to change the available option have a look at Tk::BrowseEntry.

OPTIONS

-options

(Re)sets the list of options presented.

-command

Defines the callback that is invokes when a new option is selected.

-variable

Reference to a scalar that contains the current value of the selected option.

-textvariable

Reference to a scalar that contains the text label of the current value of the selected option.

METHODS

addOptions

Adds OPTION_LIST to the already available options.

EXAMPLE

use Tk;
my $mw = MainWindow->new();

my ($var, $tvar);
my $opt = $mw->Optionmenu(
-options => [[jan=>1], [feb=>2], [mar=>3], [apr=>4]],
-command => sub { print "got: ", shift, "n" },
-variable => $var,
-textvariable => $tvar
)->pack;

$opt->addOptions([may=>5],[jun=>6],[jul=>7],[aug=>8]);

my $f = $mw->Frame(-relief=>groove, -borderwidth => 2)->pack;
$f->Label(-textvariable=>$tvar)->pack(-side => left);
$f->Label(-text => " -> ")->pack(-side => left);
$f->Label(-textvariable=>$var)->pack(-side => left);

$mw->Button(-text=>Exit, -command=>sub{$mw->destroy})->pack;

MainLoop;

Options Toolbar Button provides a button which opens the options menu.

This is a small devision of Toolbar Buttons and one of the most popular on my web site.

This one adds a toolbar button to open Options.

You must add the button to your toolbar by right clicking the toolbar selecting "customize" and dragging this new button to the toolbar.

Getopt::OO is an object oriented command line parser. It handles short, long and multi (--x ... -) value options. Getopt::OO module also incorporates help for options to simplify generation of usage statements.

SYNOPSIS

use Getopt::OO qw(Debug Verbose);

my ($handle) = Getopt::OO->new(@ARGV,
-d => {
help => turn on debug output,
callback => sub {Debug(1); 0},
},
-o => {
help => another option.,
},
-f => {
help => option that expects one more value.,
n_values => 1,
},
--long {
help => long option
},
--multiple_ => {
help => [
"Everything between --multiple_values and - is",
"an value for this options",
],
multi_value => 1,
multiple= => 1, # Can happen more than once on command line.
},
other_values => {
help => file_1 ... file_n,
multi_value => 1,
},
);
if ($handle->Values()) {
Debug("You will get output if -d was on command line");
if (my $f = handle->Values(-f)) {
print "Got $f with the -f value.n";
}
}
else {
print "No options found on command line.n";
}

Getopt::OO is an object oriented tool for parsing command line arguments. It expects a reference to the input arguments and uses a perl hash to describe how the command line arguments should be parsed. Note that by parsed, we mean what options expect values, etc. We check to make sure values exist on the command line as necessary -- nothing else. The caller is responsible for making sure that a value that he knows should be a file exists, is writable, or whatever.

Command line arguments can be broken into two distinct types: options and values that are associated with these options. In windows, options often start with a / but sometimes with a -, but in unix they almost universally start with a -. For this module options start with a -. We support two types of options: the short single dashed options and the long double dashed options.

The difference between these two is that with this module the short options can be combined into a single option, but the long options can not. For example, most of us will be familiar with the tar -xvf file command which can also be expressed as -x -v -f file. Long options can not be combined this way, so --help for example must always stand by itself.

The input template expects the option names as its keys. For instance if you were expecting -xv --hello as possible command line options, the keys for your template hash would be -x, -v, and --hello.

mirmon project monitors the state of mirrors.
Every hour the root site writes a fresh timestamp somewhere in the archive; mirror sites copy this timestamp when they update the mirror archive. Mirmon periodically retrieves these timestamps from the mirror sites. It generates a html report and a flat state file.
Mirmons actions and report are directed by a config file. There are many configuration parameters, but most have acceptable defaults. Only a few project specific items need to be specified. Once configured, mirmon can be run by cron every hour.
Mirror sites are probed at certain (user defined) intervals (default every 4 hours). Sites that are (temporarily) unreachable are probed more often (by default hourly) until a probe is successful.
The state file has a simple format and can be used for other administrative purposes (mailing admins of stale mirrors, directing users to fresh mirrors, etc).
Options:
option v : be verbose
option q : be quiet
option t : set timeout [ default 300 ] ;
option get : all : probe all sites
: update : probe a selection of the sites
option c : configuration file ; default list : ./mirmon.conf $HOME/.mirmon.conf etc/mirmon.conf
Enhancements:
- Some averages were added to the reports that mirmon generates.

Getopt::Lucid is a clear, readable syntax for command line processing.
SYNOPSIS
use Getopt::Lucid qw( :all );
# basic option specifications with aliases
@specs = (
Switch("version|V"),
Counter("verbose|v"),
Param("config|C"),
List("lib|l|I"),
Keypair("define"),
Switch("help|h")
);
$opt = Getopt::Lucid->getopt( @specs );
$verbosity = $opt->get_verbose;
@libs = $opt->get_lib;
%defs = $opt->get_define;
%all_options = $opt->options;
# advanced option specifications
@adv_spec = (
Param("input")->required, # required
Param("mode")->default("tcp"), # defaults
Param("host")->needs("port"), # dependencies
Param("port", qr/d+/ )->required, # regex validation
Param("config", sub { -r } ), # custom validation
Param("help")->anycase, # case insensitivity
);
# example with a config file
use Config::Std;
if ( -r $opt->get_config ) {
read_config( $opt->get_config() => my %config_hash );
$opt->merge_defaults( $config_hash{} );
}
The goal of this module is providing good code readability and clarity of intent for command-line option processing. While readability is a subjective standard, Getopt::Lucid relies on a more verbose, plain-English option specification as compared against the more symbolic approach of Getopt::Long.
Main features:
- Five option types: switches, counters, parameters, lists, and keypairs
- Three option styles: long, short (including bundled), and bare (without dashes)
- Specification of defaults, required options and option dependencies
- Validation of options with regexes or subroutines
- Negation of options on the command line
- Support for parsing any array, not just the default @ARGV
- Incorporation of external defaults (e.g. from a config file) with user control of precedence

Tiny.pl is a Firefox extension that allows to shorten a current page URL or any Link on a webpage by right clicking and choosing an option from pop-up menu.