jdresolve resolves IP addresses to hostnames. Any file format is
supported, including those where the line does not begin with the IP
address. One of the strongest features of the program is the support
for recursion, which can drastically reduce the number of unresolved
hosts by faking a hostname based on the network that the IP belongs
to. DNS queries are sent in parallel, which means that you can
decrease run time by increasing the number of simultaneous sockets
used (given a fast enough machine and available bandwidth). By using
the database support, performance can be increased even further, by
using cached data from previous runs.
Included is a tiny shell script called rhost to interface with
jdresolve when resolving a single IP address. Think of it as a smart
replacement for the 'host' utility that comes with bind-utils.
Nevow (pronounced as the French "nouveau", or "noo-voh") is a web application
construction kit written in Python. It is designed to allow the programmer to
express as much of the view logic as desired in Python, and includes a pure
Python XML expression syntax named stan to facilitate this. However it also
provides rich support for designer-edited templates, using a very small XML
attribute language to provide bi-directional template manipulation capability.
Nevow also includes formless, a declarative syntax for specifying the types of
method parameters and exposing these methods to the web. Forms can be rendered
automatically, and form posts will be validated and input coerced, rendering
error pages if appropriate. Once a form post has validated successfully, the
method will be called with the coerced values.
Bigtop is a language for describing the data of a web application.
Usually this data will be stored in a relational database. Once you
have a description of your data, you can generate a web application
from it. This includes all the pieces you need like: the sql
statements ready for feeding to your database command line tool, the
httpd.conf you need to Include in the httpd.conf on your system, the
modules that will handle the web requests, the models that make the
database tables look like classes, etc.
If you need to alter the data model in the future, you can change your
original description to match the new reality, then regenerate the
application without fear of losing hand written code (though you may
have to modify some of it to reflect the new reality).
This plugin provides a way to stream a file back to the user.
This is useful if you are creating a PDF or Spreadsheet document
dynamically to deliver to the user.
The file is read and printed in small chunks to keep memory
consumption down.
This plugin is a consumer, as in your runmode shouldn't try to do any
output or anything afterwards. This plugin affects the HTTP response
headers, so anything you do afterwards will probably not work. If you
pass along a filehandle, we'll make sure to close it for you.
It's recommended that you increment $| (or set it to 1), which will
autoflush the buffer as your application is streaming out the file.
Ruby on Rails has a nice feature to create nested parameters that help
with the organization of data in a form - parameters can be an
arbitrarily deep nested structure.
The way this structure is denoted is that when you construct a form the
field names have a special syntax which is parsed.
This plugin supports two syntaxes:
dot notation
<input name="foo.bar.gorch" />
subscript notation
<input name="foo[bar][gorch]" />
When reading query parameters from $c->req you can now access all the
items starting with "foo" as one entity using $c->req->param('foo');.
Each subitem, denoted by either the dot or the square brackets, will be
returned as a further deeper hashref.
The majority of the web pages of the internet today are much larger than they
need to be. The reason for this is that HTML tends to be stored in a human
readable format, with indenting, newlines and comments.
However, all of these comments, whitespace etc. are ignored by the browser, and
needlessly lengthen download times.
Second, many people are using WYSIWYG HTML editors these days. This makes
creating content easy. However these editors can cause a number of compatibility
problems by tying themselves to a particular browser or operating system.
The HTML::Clean module encapsulates a number of HTML optimizations and cleanups.
The end result is HTML that loads faster, displays properly in more browsers.
Think of it as a compiler that translates HTML input into optimized machine
readable code.
MasonX::WebApp works with Mason to let you do processing before Mason is ever
invoked. There are a number of things that one might want to do:
* Argument munging
You might want to make sure all incoming arguments are UTF-8 encoded.
Or you might want to create some objects which Mason will see as
incoming arguments. For example, a "user_id" parameter could be turned
into a user object.
* Handle requests without Mason
If you're not generating output for the browser other than a redirect,
then there's no reason to use Mason. You can use a MasonX::WebApp
subclass to handle all form submissions, for example.
This has the added benefit of making it easier to preload this code
once during server startup.
* And others ...
Template Toolkit is the best Perl template framework. The only problem
with it is that using it for simple stuff is a little bit cumbersome.
Also there is no good utility for using it from the command line.
This module is a simple wrapper around Template Toolkit. It exports a
function called tt which returns a new Template::Toolkit::Simple object.
The object supports method calls for setting all the Template Toolkit
options.
This module also installs a program called tt-render which you can use
from the command line to render templates with all the power of the Perl
object. All of the object methods become command line arguments in the
command line version.
HTMLgen is a class library for the generation of HTML documents with
Python scripts. It's used when you want to create HTML pages
containing information which changes from time to time. For example
you might want to have a page which provides an overall system summary
of data collected nightly. Or maybe you have a catalog of data and
images that you would like formed into a spiffy set of web pages for
the world to browse. Python is a great scripting language for these
tasks and with HTMLgen it's very straightforward to construct objects
which are rendered into consistently structured web pages. Of course,
CGI scripts written in Python can take advantage of these classes as
well.
Tclwebtest is a tool to write automated tests for web applications.
It provides a simple API for issuing http requests, dealing with the
result and assume specific response values, while taking care of the
details such as redirects and cookies.
It has some basic html parsing functionality, to provide access to
elements of the result html page that are needed for testing.
TclWebtest should be suitable for testing larger chains of user
interaction on a web application, for example a full ecommerce
ordering session.
Tclwebtest could visit an ecommerce site as
anonymous user, add some products to its shopping cart, check out
the cart, register itself as user and enter a test address etc.
The test script could also include the administration part of the
interaction, by explicitely logging in as site admin, reviewing and
processing the order, nuking the test user etc.