Free class file software for linux

Validate_fields Class is an easy-to-use form field validation PHP script. This class can be used to validate database inputs or mail forms.
It can validate simple text, numbers, dates, urls, email addresses, and the presence of HTML tags. Invalid form fields will be reported inside a detailed error message.
Enhancements:
- A small improvement in the create_msg() method makes it possible to switch between the XHTML version and the simple HTML version.
- In the fields array one key was named "name", and it has been renamed to "value" to make it more clear.
- The variable declarations at the beginning of the validation method was removed.
- Because the value of a checkbox (radio) type field is only available if the element is checked, there are new functions to validate this elements.

PHP Advanced Graphing Class is a PHP class that can be used to generate line, bar, and 2D/3D pie graphs from multiple data sets. PHP Advanced Graphing Class offers many style and data formatting options.
The graphs can be built from data defined with PHP code or with data imported from XML or CSV files. It can use custom colors, custom data point shapes or images, custom end arrows, an optional inline format, a custom graph scale, etc.
The graphs can be generated in PNG format either to a file or served as the current script output.
Enhancements:
- Bar charts and 2D/3D pie charts were added.

Cgiapp.class.php is a port of CGI::Application to PHP. Cgiapp.class.php utilizes Smarty as its default templating engine, much as CGI::Application uses HTML::Template, due to its prevalence and acceptance in the PHP community.

Due to PHPs built-in session support, it also adds two methods, s_param() and s_delete(), to handle session parameters.

A number of static methods have also been included to facilitate error handling and array/hash conversion.

PHP Client Sniffer is a PHP class file that allows one to quickly determine the clients browser and system information based on the HTTP_USER_AGENT string. The class can be used to generate browser specific html marks and other client side scripting.
Enhancements:
- add k-meleon support
- add camino support
- add mozilla firebird support
- add amiga support
- fixed issues with netscape and gecko browsers

DBIx::Class::FormTools is a utility module for building forms with multiple related DBIx::Class objects.

SYNOPSIS

In the examples I use 3 objects, a Film, an Actor and a Role. Role is a many to many relation between Film and Actor.

package MySchema;
use base DBIx::Class::Schema;
__PACKAGE__->load_classes(qw[
Film
Actor
Role
]);

package MySchema::Film;
__PACKAGE__->table(films);
__PACKAGE__->add_columns(qw[
id
title
]);
__PACKAGE__->set_primary_key(id);
__PACKAGE__->has_many(roles => MySchema::Role, film_id);


package MySchema::Actor;
__PACKAGE__->table(films);
__PACKAGE__->add_columns(qw[
id
name
]);
__PACKAGE__->set_primary_key(id);
__PACKAGE__->has_many(roles => MySchema::Role, actor_id);

package MySchema::Role;
__PACKAGE__->table(roles);
__PACKAGE__->add_columns(qw[
film_id
actor_id
]);
__PACKAGE__->set_primary_key(qw[
film_id
actor_id
]);

__PACKAGE__->belongs_to(film_id => MySchema::Film);
__PACKAGE__->belongs_to(actor_id => MySchema::Actor);
In your Model class
use base qw/DBIx::Class/;
__PACKAGE__->load_components(qw/PK::Auto::Pg Core FormTools/);
In your view - HTML::Mason example
< %init >
my $film = $schema->resultset(Film)->find(42);
my $actor = $schema->resultset(Actor)->find(24);
< /%init >
< form >
< input
name="< % $film->form_fieldname(title, o1) => Title % >"
type="text"
value="< % $film->title % >"
/ >
< input
name="< % $film->form_fieldname(length, o1) % >"
type="text"
value="< % $film->length % >"
/ >
< input
name="< % $film->form_fieldname(comment, o1) % >"
type="text"
value="< % $film->comment % >"
/ >
< input
name="< % $actor->form_fieldname(name, o2) % >"
type="text"
value="< % $actor->name % >"
/ >


In your controller (or cool helper module, used in your controller)
my @objects = DBIx::Class::FormTools->formdata_to_objects($querystring);
foreach my $object ( @objects ) {
# Assert and Manupulate $object as you like
$object->insert_or_update;
}

Class::Std::Utils is a Perl module for utility subroutines for building "inside-out" objects.

SYNOPSIS

use Class::Std::Utils;

# Constructor for anonymous scalars...
my $new_object = bless anon_scalar(), $class;

# Convert an object reference into a unique ID number...
my $ID_num = ident $new_object;

# Extract class-specific arguments from a hash reference...
my %args = extract_initializers_from($arg_ref);

This module provides three utility subroutines that simplify the creation of "inside-out" classes. See Chapters 15 and 16 of "Perl Best Practices" (OReilly, 2005) for details.

Class::XML is a Perl module for simple XML Abstraction.

SYNOPSIS

package Foo;

use base qw/Class::XML/;

__PACKAGE__->has_attributes(qw/length colour/);
__PACKAGE__->has_child(bar => Bar);

package Bar;

use base qw/Class::XML/;

__PACKAGE__->has_parent(foo);
__PACKAGE__->has_attribute(counter);

# Meanwhile, in another piece of code -

my $foo = Foo->new( xml => # Or filename or ioref or parser
qq!< foo length="3m" colour="pink" >< bar / >< /foo >! );

$foo->length; # Returns "3m"
$foo->colour("purple"); # Sets colour to purple

print $foo; # Outputs

my $new_bar = new Bar; # Creates empty Bar node

$new_bar->counter("formica");

$foo->bar($new_bar); # Replaces child

$new_bar->foo->colour; # Returns "purple"

$foo->colour(undef); # Deletes colour attribute

print $foo; # Outputs < foo length="3m" >< bar counter="formica" / >< /foo >

Class::XML is designed to make it reasonably easy to create, consume or modify XML from Perl while thinking in terms of Perl objects rather than the available XML APIs; it was written out of a mixture of frustration that JAXB (for Java) and XMLSerializer (for .Net) provided programming capabilities that simply werent easy to do in Perl with the existing modules, and the sheer pleasure that Ive had using Class::DBI.

The aim is to provide a convenient abstraction layer that allows you to put as much of your logic as you like into methods on a class tree, then throw some XML at that tree and get back a tree of objects to work with. It should also be easy to get started with for anybody familiar with Class::DBI (although I doubt you could simply switch them due to the impedance mismatch between XML and relational data) and be pleasant to use from the Template Toolkit.

Finally, all Class::XML objects are also XML::XPath nodes so the full power of XPath is available to you if Class::XML doesnt provide a shortcut to what youre trying to do (but if you find it doesnt on a regular basis, contact me and Ill see if I can fix that.