Free democratic national convention software for linux

Gem to rpm converter creates an RPM spec file from a Ruby gem. The project uses the gem metadata to fill out most of the information needed for building an RPM containing the gem.

Usage:

Run gem2rpm --help for options

At its simplest, download a gem (lets call that file GEM) and run

gem2rpm $GEM

This will print an rpm spec file based on the information contained in the gems spec file. In general, it is necessary to edit the generated spec file because the gem is missing some important information that is customarily provided in rpms, most notably the license and the changelog.

Rather than editing the generated specfile, edit the template from which the specfile is generated. This will make it easier to update the RPM when a new version of the Gem becomes available.

To support this process, it is recommended to first save the default template somewhere:

gem2rpm -T > rubygem-GEM.spec.template

Now, edit the template and then run gem2rpm to generate the spec file using the edited template:

gem2rpm -t rubygem-GEM.spec.template > rubygem-GEM.spec

With that, you can now build your RPM as ususal. When a new version of the gem becomes available, you should edit the saved template and rerun gem2rpm over it.

Template Details:

The template is a standard erb file; there are three main variables available in the template file:

format - The Gem::Format for the gem
spec - The Gem::Specification for the gem (the same as format.spec)

Conventions:

A typical source RPM for a gem should consist of three files: the gem file itself, the template for the spec file and the spec file. To ensure that the template will be included in the source RPM, it must be listed as one of the sources in the spec file.

The resulting rpms should follow the naming convention rubygem-$GEM where GEM is the name of the packaged gem. The default template also makes sure that the resulting package provides ruby($GEM), according to general packaging conventions for scripting languages

CGI::Application::Plugin::ValidateRM is a Perl module to help validate CGI::Application run modes using Data::FormValidator.

SYNOPSIS

use CGI::Application::Plugin::ValidateRM;

my $results = $self->check_rm(form_display,_form_profile) || return $self->check_rm_error_page;


# Optionally, you can pass additional options to HTML::FillInForm->fill()

my $results = $self->check_rm(form_display,_form_profile, { fill_password => 0 })
|| return $self->check_rm_error_page;

CGI::Application::Plugin::ValidateRM helps to validate web forms when using the CGI::Application framework and the Data::FormValidator module.
check_rm()

Validates a form displayed in a run mode with a Data::FormValidator profile, returning the results and possibly an a version of the form page with errors marked on the page.

In scalar context, it returns simply the Data::FormValidator::Results object which conveniently evaluates to false in a boolean context if there were any missing or invalide fields. This is the recommended calling convention.

DemoWave is a Web application for conducting referendums that:

allows anyone to propose a new referendum
minimizes the negative effects of people "spamming" the system with bogus referendums
makes referendums where people disagree a lot take longer to go through.

In addition, it can manage a set of laws and referendums on changes to those laws.

DemoWave is intended for democratic organizations that need to decrease the bureaucratic load and increase the participation of their members in the decision-making process.

Cable Modem Counter is a cable modem (or any Ethernet connection) IP byte logger. It is not a packet sniffer, it just gathers network statistics.

It is composed of two parts:

A daemon, which logs all the incoming/outgoing connections and creates pairs of source/destination IP addresses with a byte counter and direction of traffic (inbound or outbound) attached. It stores it periodically on a file (or files).It also accepts network connections to gather the statistics and can also run users scripts which can send commands to the daemon and receive information.
An user application, which can be run on console or X (wmaker/kde bar?) and connects to the daemon and collects the statistics, and then making the separation between national/international , inbound/outbound , etc (not done yet)

Wombat Linux Server is a port of Linux that runs as an application on top of L4/Iguana.

This package is not really intended to be used standalone. It is best to download it as part of the Iguana project.

A decompiler takes as input an executable file, and attempts to create a high level, compilable, possibly even maintainable source file that does the same thing.
It is therefore the opposite of a compiler, which takes a source file and makes an executable. However, a general decompiler does not attempt to reverse every action of the decompiler, rather it transforms the input program repeatedly until the result is high level source code. It therefore wont recreate the original source file; probably nothing like it.
It does not matter if the executable file has symbols or not, or was compiled from any particular language. (However, declarative languages like ML are not considered.)
The intent is to create a retargetable decompiler (i.e. one that can decompile different types of machine code files with modest effort, e.g. X86-windows, sparc-solaris, etc). It was also intended to be highly modular, so that different parts of the decompiler can be replaced with experimental modules. It was intended to eventually become interactive, a la IDA Pro, because some things (not just variable names and comments, though these are obviously very important) require expert intervention. Whether the interactivity belongs in the decompiler or in a separate tool remains unclear.
By transforming the semantics of individual instructions, and using powerful techniques such as Static Single Assignment dataflow analysis, Boomerang should be (largely) independent of the exact behaviour of the compiler that happened to be used. Optimisation should not affect the results. Hence, the goal is a general decompiler.
Version restrictions:
- In case you want to try Boomerang as it is as a decompiler (as opposed to experimenting with it, or improving it), be aware of its severe limitations. As of early 2004, Boomerang will only decompile X86 (Linux/X86 or Windows PE), SPARC (Solaris, or presumably Linux/SPARC), or Power PC (Linux/PPC or Mac OS/X) programs. In particular, note that it will not decompile DOS or NE (Windows 3.1) programs. Adding another processor is a large (several month) undertaking.
- It will only generate C, not C++. It will decompile C++ programs of course, (and any sorts of programs, including assembler). You may be able to hand edit some C++ programs into usable C++ source code. For MSVC compiled programs, at present you have to spoonfeed the decompiler and tell it that there is one register parameter (thiscall calling convention). The switches to handle this are complex; see using the -sf switch.

DocPerl provides a web-based interface to Perls Plain Old Documentation (POD). DocPerl project is a graphical easy to use interface to POD, automatically listing all installed modules on the local host, and any other nominated directories containing Perl files.
Main features:
- Easily navigable list of all modules installed as well as other nominated directories containing perl files
- Limited capability of searching for modules by name
- Displays POD as HTML for each listed file (eg YAML.pm)
- Displays the API for each listed file (eg YAML.pm)
- The functions are hyperlinked to their definition line number in the code page so that a function can be viewed in context
- The functions are further subdivided into class methods, object methods and general subroutines (by convention/best guess)
- Modules are listed by whether they are useed or required or inherited
- Other packages defined in the file are also listed
- A graphical view of the module inheritance is also displayed
- Displays the Code for each listed file with some syntax highlighting (eg YAML.pm)
- Provides access to description of the API files defined and display code in limited syntax highlighting.
- Pages can be cached for increased performance and the cache is auto-updated when original file changes
Enhancements:
- Issues with IE6 and Konqueror were fixed, as well as some potential Javascript problems.
- Work was also done on improving the documentation.

Catalyst::Enzyme is a CRUD framework for Catalyst.

SYNOPSIS

#Create app
catalyst BookShelf
cd BookShelf

#Create View
scriptbookshelf_create.pl view TT Enzyme::TT

#Create database
... left as an exercise for the reader (actually, see the tutorial) ...

#Create Models for all tables
scriptbookshelf_create.pl model BookShelfDB Enzyme::CDBI dbi:SQLite:dbname=db/bookshelf.db

#Create Controller
scriptbookshelf_create.pl controller Book Enzyme::CRUD BookShelfDB::Book

Browse to http://localhost:3000/book and see what it looks like without any configuration.

See the "DEMO APPLICATION" below for a ready-to-run example of the BookDB.

See the "TUTORIAL" below for a detailed example of how to create an application from the BookDB schema.

Catalyst::Enzyme is a layer on top of the Catalyst framework providing CRUD functionality for Class::DBI models.

Enzyme uses convention and configuration to provide e.g. extensible CRUD out-of-the-box, and a common way of dealing with error handling etc.

Its not completely unlike Maypole in this regard. However, at this point Enzyme isnt as feature-rich as Maypole.

Enzyme is one way of bringing many Catalyst modules and concepts together into a unified whole. There are other ways to do this (obviously. This is, like... uh, Perl).