Free class maker software for linux

Patch Maker helps you manage multiple in-progress source code patches to software. Patch Maker remembers which files are part of which patch, and keeps them disentangled during the development process.
It speeds up common operations and housekeeping tasks, allowing you to focus on writing code. It is a command-line tool written in Perl, and so is usable on (at least) Windows, Linux and Mac OS X.
Enhancements:
- Initial SVN support was added to go with CVS.
- The configuration was moved to the .pmrc file in the home directory.
- Message and error printing were tidied up and standardized.

Config Maker is a tool to automatically create C++ classes that parse configuration files.

Only a few lines of text that describe the possible entries in the configuration file are needed, and the complete class will be generated ready for use.

Basic usage

The input files for Config Maker have a very simple structure (in ANTLR/grep like notation):

objectname (configentry)+
Each configentry looks like this
type entryname defaultvalue (comment)?

type

Type of the entry, can be int, double, string or bool. If the basic type is followed by any number, the corresponding c++object variable will be of type vector < basic type > The number is the initial number of elements that are allocated for the vector, but the actual configuration file can contain more components. These are added using the push_back method.

If there are less elements specified in the configuration file, the object variable will still contain the number of elements specified here. No warning will be issued.
configentry

Name of the entry and corresponding variable. Has to be at least two characters long and can contain characters and numbers. Case insensitive.

defaultvalue

Default value for the entry. This is optional.

comment

Each comment starts with // and is completely ignored

Class::Meta is a Perl class automation, introspection, and data validation.

SYNOPSIS

Generate a class:
package MyApp::Thingy;
use strict;
use Class::Meta;
use Class::Meta::Types::String;
use Class::Meta::Types::Numeric;

BEGIN {

# Create a Class::Meta object for this class.
my $cm = Class::Meta->new( key => thingy );

# Add a constructor.
$cm->add_constructor(
name => new,
create => 1,
);

# Add a couple of attributes with generated methods.
$cm->add_attribute(
name => uuid,
authz => Class::Meta::READ,
type => string,
required => 1,
default => sub { Data::UUID->new->create_str },
);
$cm->add_attribute(
name => name,
is => string,
required => 1,
default => undef,
);
$cm->add_attribute(
name => age,
is => integer,
default => undef,
);

# Add a custom method.
$cm->add_method(
name => chk_pass,
view => Class::Meta::PUBLIC,
);
$cm->build;
}
Then use the class:
use MyApp::Thingy;

my $thingy = MyApp::Thingy->new;
print "ID: ", $thingy->id, $/;
$thingy->name(Larry);
print "Name: ", $thingy->name, $/;
$thingy->age(42);
print "Age: ", $thingy->age, $/;
Or make use of the introspection API:
use MyApp::Thingy;

my $class = MyApp::Thingy->my_class;
my $thingy;

print "Examining object of class ", $class->package, $/;

print "nConstructors:n";
for my $ctor ($class->constructors) {
print " o ", $ctor->name, $/;
$thingy = $ctor->call($class->package);
}

print "nAttributes:n";
for my $attr ($class->attributes) {
print " o ", $attr->name, " => ", $attr->get($thingy), $/;
if ($attr->authz >= Class::Meta::SET && $attr->type eq string) {
$attr->get($thingy, hey there!);
print " Changed to: ", $attr->get($thingy), $/;
}
}

print "nMethods:n";
for my $meth ($class->methods) {
print " o ", $meth->name, $/;
$meth->call($thingy);
}

Class::Meta provides an interface for automating the creation of Perl classes with attribute data type validation. It differs from other such modules in that it includes an introspection API that can be used as a unified interface for all Class::Meta-generated classes. In this sense, it is an implementation of the "Facade" design pattern.

Class::Date is a perl module, which provides a simple date type for perl.
You can create new Class::Date objects with a constructor from different scalar formats, array refs, and hash refs, and then you can easily manipulate it by the builtin "+" and "-" operators (e.g., $date=date([2001,03,15])+3Y 1s). Relative date types also available.
Enhancements:
- This release adds "ampm" and "meridiam" methods.

El Jay Icon Maker is a Firefox extension that allows you to right click on any image and create an icon for use with livejournal.com There are two options to choose from when making an icon "Create Icon Instantly" and "Create Icon With Options".

Selecting either link redirects you to the El Jay icon maker home page where you can rotate, crop, add text and borders to the image. The El Jay icon maker was made for use with llivejournal.com, but can be used on any site that requires an image smaller than 100x100 for an icon.

This is not a support forum, if you have questions or problems please go here: http://www.livejournal.com/users/lechatron/407511.html?mode=reply

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!)

Class::CGI is a Perl module to fetch objects from your CGI object.

SYNOPSIS

use Class::CGI
handlers => {
customer_id => My::Customer::Handler
};

my $cgi = Class::CGI->new;
my $customer = $cgi->param(customer_id);
my $name = $customer->name;
my $email = $cgi->param(email); # behaves like normal

if ( my %errors = $cgi->errors ) {
# do error handling
}

For small CGI scripts, its common to get a parameter, untaint it, pass it to an object constructor and get the object back. This module would allow one to to build Class::CGI handler classes which take the parameter value, automatically perform those steps and just return the object. Much grunt work goes away and you can get back to merely pretending to work.