Free class software for linux

TagCloud Maker Class is a class that takes a single dimensional array of terms and outputs a piece of HTML with each term wrapped in a span tag with an ID that you can define in your CSS.

TagCloud Maker Class script can be called either as an object or as a static class.

Check out the example page. The keywords from the sample page come from the last 30 entries of my blog. Ill admit I cheated and just open the database and pull them from there instead of trying to call my blog w/curl or fopen and parse it. (Although that would have been cooler.) I then ran each blog entry against Yahoos Term Extraction API to get the terms. Then I pumped that array into my new TagCloud maker. The important code you cant see from the index.php is below.


require_once(TagCloud.php);
$x = TagCloud::fetch_cloud($thisArray,...,tagcloud_,http://www.technorati.com/tags/%s);
$o = new TagCloud($thisArray,...,tagcloud_,http://www.technorati.com/tags/%s,10,weight,2);
$o->get_cloud();
$y = $o->output_cloud;

As you can see, I used 2 different methods of creating the 2 lists. The first is just calling the object::method statically with all the necessary parameters. This is by far the easiest way to use this class and unless you need something special, its the way I recommend. The second way it to instantiate an object. I pass all the variables into the constructor but you could just as easily use the setters to set them all. (dont know why you would but hey, I spent an extra 15 minutes creating getters and setters so use them, by all means use them!)

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.

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.

Class::DBI::ConceptSearch is a Perl module to retrieve Class::DBI aggregates from high-level conceptual searches.

SYNOPSIS

my $cs = Class::DBI::ConceptSearch->new(xml => $config); #see CONFIGURATION
$cs->use_wildcards(1);
$cs->use_implicit_wildcards(1);
$cs->use_search_ilike(1);
$cs->use_search_lower(1);

my(@tracks) = $cs->search( albums => Britney );

Given the example Class::DBI classes (Music::CD, Music::Artist, Music::Track), lets add another one, Music::Dbxref, which contains external database accessions outside our control. Music::Dbxref includes things like UPC IDs, ASIN and ISBN numbers, vendor and manufacturer part numbers, person IDs (for artists), etc.