Free cgi software for linux

CGI::Application::Magic is a template based framework for CGI applications.

SYNOPSIS

package WebApp ;
use base CGI::Application::Magic ;

# optional runmethod
sub RM_myRunMmode
{
... do_something_useful ...
... no_need_to_set_page ...
... returned_value_will_be_ignored ...
}

# package where Template::Magic will looks up
package WebApp::Lookups ;

# this value will be substituted to each
# app_name label in each template that include it
our $app_name = WebApp 1.0 ;

# same for each Time label
sub Time { scalar localtime }

# and same for each ENV_table block
sub ENV_table
{
my ($self, # $self is your WebApp object
$zone) = @_ ; # $zone is the Template::Magic::Zone object
my @table ;
while (my @line = each %ENV)
{
push @table, @line
}
@table ;
}

CGI::AppBuilder::Table module contains a configuration initializer.



SYNOPSIS

use CGI::AppBuilder::Table;

my $ab = CGI::AppBuilder::Table->new(
ifn, my_init.cfg, opt, vhS:a:);
my ($q, $ar, $ar_log) = $ab->start_app($0, %ARGV);
print $ab->disp_form($q, $ar);

This class provides methods for reading and parsing configuration files.

new (ifn => file.cfg, opt => hvS:)

This is a inherited method from CGI::AppBuilder. See the same method in CGI::AppBuilder for more details.

html_table($arf, $cns, $br)

Input variables:

$arf - array ref containing the content of the table
$cns - column names separated by comma or
AUTO|AH|HASH - use $k in AH Array ${$arf}[$i]{$k}
$br - hash array ref for table format, it contains
css_table - CSS class name for < TABLE>
atr_table - attribute parameters for < TABLE>
css_tr - CSS class name for < TR>
atr_tr - attribute parameters for < TR>
atr_tr_odd - attribute parameters for ODD < TR>
atr_tr_even - attribute parameters for EVEN < TR>
css_tr_odd - CSS class name for ODD < TR>
css_tr_even - CSS class name for EVEN < TR>
css_select - CSS class name for < SELECT ...>
css_input - CSS class name for < INPUT type=input ...>
atr_sel - attributes for itemized < SELECT ...> for instance:
atr_sel = {
var1 => style="display:none",
var2 => style="display:block",
var3 => class="FormSel",
}
atr_inp - attributes for itemized < INPUT type=input ...>
css_td - CSS class name for < TD>
atr_td - attribute parameters for < TD>
atr_cell - an array ref to attribute parameters for each cell
${$br}{atr_cell}[$i][$j]
esc_vars - a list of escaped variables separated by comma.
fh_out - output file handler
cns_desc - hash ref containing column name description
tab_caption - table caption/header
tab_footer - table footer/notes

CGI::kSession is a sessions manager for CGI.
This module can be used anywhere you need sessions. As a session management module, it uses files with a configurable lifetime to handle your session data. For those of you familiar with PHP, you will notice that the session syntax is a little bit similar.
METHODS
The following public methods are availible:
$s = new CGI::kSession();
The constructor, this starts the ball rolling. It can take the following hash-style parameters:
lifetime - how long the session lasts, in seconds
path - the directory where you want to store your session files
id - if you want to give the session a non-random name, use this parameter as well
$s->start();
This creates a session or resumes an old one (could be used in conjunction with something like HTTP::Cookie). This will return 1 if this is a new session, and 0 if its resuming an old one. If you defined no values in the new() call, then the session will start with a default lifetime of 600 seconds, a path of /var/tmp, and a random string for an id.
$s->save_path();
Save the session path or, without an argument, return the current session path. Used with an argument, this performs the same thing as the path parameter in the constructor.
$s->id();
If the session id exists, this will return the current session id - useful if you want to maintain state with a cookie! If you pass a parameter, it acts the same as new( id => some_session_name), i.e., it creates a session with that id.
$s->register();
This takes a string as an arguement and basically tells the session object this: "Hey, this is a variable Im thinking about associating with some data down the road. Hang onto it for me, and Ill let you know what Im going to do with it". Once you register a variable name here, you can use it in set() and get().
$s->is_registered();
Check to see if the function is registered. Returns 1 for true, 0 for false.
$s->unregister();
Tell the session jinn that you no longer want to use this variable, and it can go back in the bottle (the variable, not the jinn... you still want the jinn around until you call destroy()).
$s->set();
This is where you actually define your variables (once you have "reserved" them using register()). This method takes two arguments: the first is the name of the variable that you registerd, and the second is the info you want to store in the variable.
$s->get();
This method allows you to access the data that you have saved in a session - just pass it the name of the variable that you set().
$s->unset();
Calling this method will wipe all the variables stored in your session.
$s->destroy();
This method deletes the session file, destroys all the evidence, and skips bail.
Enhancements:
- updated the documentation

CGI::WML is a Perl module with subclass LDSs "CGI.pm" for WML output and WML methods.

SYNOPSIS

use CGI::WML;

$query = new CGI::WML;

$content = $query->p("Hello WAP world");

print
$query->header(),
$query->start_wml(),
$query->template(-content=>$query->prev()),
$query->card(-id=>"first_card",
-title=>"First card",
-content=>$content),
$query->end_wml();

print
$query->wml_to_wmlc(-wml=>$wml_buffer,
-errorcontext=>2);

($page_title,$content) = $query->html_to_wml($buffer);

This is a library of perl functions to allow CGI.pm-style programming to be applied to WAP/WML. Since this is a subclass of Lincoln Steins CGI.pm all the normal CGI.pm methods are available. See perldoc CGI if you are not familiar with CGI.pm

CGI::Kwiki::New is the default new wiki generator for CGI::Kwiki.

A Wiki is a website that allows its users to add pages, and edit any existing pages. It is one of the most popular forms of web collaboration. If you are new to wiki, visit http://c2.com/cgi/wiki?WelcomeVisitors which is possibly the oldest wiki, and has lots of information about how wikis work.

There are dozens of wiki implementations in the world, and many of those are written in Perl. As is common with many Perl hacks, they are rarely modular, and almost never released on CPAN. One major exception is CGI::Wiki. This is a wiki framework that is extensible and is actively maintained.

Another exception is this module, CGI::Kwiki. CGI::Kwiki focuses on simplicity and extensibility. You can create a new kwiki website with a single command. The module has no prerequisite modules, except the ones that ship with Perl. It doesnt require a database backend, although it could be made to use one. The default kwiki behaviour is fairly full featured, and includes support for html tables. Any behaviour of the kwiki can be customized, without much trouble.

SPECIAL FEATURES

CGI::Kwiki will come with some fancy addons not found in most wiki implementations. This comes with the promise that they will not interfere with the sheer simplicity of the default kwiki interface.

Check http://http://www.kwiki.org/index.cgi?KwikiFeatures from time to time to see what hot features have been added.

Kwiki Slide Show

You can create an entire PowerPoint-like slideshow, in a single kwiki page. There is Javascript magic for advancing slides, etc. See the sample page KwikiSlideShow.

EXTENDING

CGI::Kwiki is completely Object Oriented. You can easily override every last behaviour by subclassing one of its class modules and overriding one or more methods. This is generally accomplished in just a few lines of Perl.

The best way to describe this is with an example. Start with the config file. The default config file is called "config.yaml". It contains a set of lines like this:

config_class: CGI::Kwiki::Config
driver_class: CGI::Kwiki::Driver
cgi_class: CGI::Kwiki::CGI
cookie_class: CGI::Kwiki::Cookie
database_class: CGI::Kwiki::Database
metadata_class: CGI::Kwiki::Metadata
display_class: CGI::Kwiki::Display
edit_class: CGI::Kwiki::Edit
formatter_class: CGI::Kwiki::Formatter
template_class: CGI::Kwiki::Template
search_class: CGI::Kwiki::Search
changes_class: CGI::Kwiki::Changes
prefs_class: CGI::Kwiki::Prefs
pages_class: CGI::Kwiki::Pages
slides_class: CGI::Kwiki::Slides
javascript_class: CGI::Kwiki::Javascript
style_class: CGI::Kwiki::Style
scripts_class: CGI::Kwiki::Scripts

This is a list of all the classes that make up the kwiki. You can change anyone of them to be a class of your own.

Lets say that you wanted to change the BOLD format indicator from "*bold*" to bold. You just need to override the "bold()" method of the Formatter class. Start by changing "config.yaml".

formatter_class: MyKwikiFormatter

Then write a module called "MyKwikiFormatter.pm". You can put this module right in your kwiki installation directory if you want. The module might look like this:

package MyKwikiFormatter;
use base CGI::Kwiki::Formatter;

sub bold {
my ($self, $text) = @_;
$text =~ s!(.*?)!$1!g;
return $text;
}

1;

Not too hard, eh? You can change all aspects of CGI::Kwiki like this, from the database storage to the search engine, to the main driver code. If you come up with a set of classes that you want to share with the world, just package them up as a distribution and put them on CPAN.

By the way, you can even change the configuration file format from the YAML default. If you wanted to use say, XML, just call the file "config.xml" and write a module called "CGI::Kwiki::Config_xml".

CGI::XMLForm is a Perl extension of CGI.pm which reads/generates formated XML. NB: This is a subclass of CGI.pm, so can be used in its place.

SYNOPSIS

use CGI::XMLForm;

my $cgi = new CGI::XMLForm;

if ($cgi->param) {
print $cgi->header, $cgi->pre($cgi->escapeHTML($cgi->toXML));
}
else {
open(FILE, "test.xml") or die "Cant open: $!";
my @queries = (/a, /a/b*, /a/b/c*, /a/d);
print $cgi->header,
$cgi->pre($cgi->escapeHTML(
join "n", $cgi->readXML(*FILE, @queries)));
}