Free your page software for linux

Free Link Page is a project that allows visitors to add links to your page in a specified category.

This script allows visitors to add links to your page in a specified category. It is quite easy to install.

The administration module supports deleting of existing links.

Installation:

1.Open links.pl with a text editor.
Change the url in line one, to the Perl program at your server.
Usually it is: - /usr/bin/perl or /usr/local/bin/perl for Unix.
- C:/Perl/Perl.exe for Windows (use slash "/")
Set the correct paths and required urls.

2.Upload links.pl in ASCII-mode to your cgi-bin directory
and change mode it to 755 (-rwxr-xr-x).

3.Open addlink.html with a text editor.
Change the line

to the correct location of links.pl

Thats all.

g-page is a client/server application for Unix designed to send text messages to alphanumeric pagers or PCS phones with short messaging, SMS, capabilities.

It supports the SNPP, WCTP, and SMTP (email) protocols, and works on a stand-alone workstation or across a network.

C++ Server Pages is a partial Java server pages and servlet implementation in C++. C++ Server Pages is written as Apache 2.0 modules, with the focus on performance.

Data::Page is a Perl module that helps when paging through sets of results.

SYNOPSIS

use Data::Page;

my $page = Data::Page->new();
$page->total_entries($total_entries);
$page->entries_per_page($entries_per_page);
$page->current_page($current_page);

print " First page: ", $page->first_page, "n";
print " Last page: ", $page->last_page, "n";
print "First entry on page: ", $page->first, "n";
print " Last entry on page: ", $page->last, "n";

When searching through large amounts of data, it is often the case that a result set is returned that is larger than we want to display on one page. This results in wanting to page through various pages of data. The maths behind this is unfortunately fiddly, hence this module.

The main concept is that you pass in the number of total entries, the number of entries per page, and the current page number. You can then call methods to find out how many pages of information there are, and what number the first and last entries on the current page really are.

For example, say we wished to page through the integers from 1 to 100 with 20 entries per page. The first page would consist of 1-20, the second page from 21-40, the third page from 41-60, the fourth page from 61-80 and the fifth page from 81-100. This module would help you work this out.

WWW::Mixi::OO::Page is a WWW::Mixi::OOs Pages base class.

SYNOPSIS

package WWW::Mixi::OO::Foo;
use base qw(WWW::Mixi::OO::Page);
sub uri {
shift->absolute_uri(foo.pl);
}
# some implementations...

METHODS

new
# subclass
sub new {
my $this = shift->SUPER::new(@_);
# some initializations...
}

# call
my $page = $pkg->new($session);

constructor of page. please override if you need some initializations.

uri
# subclass
sub uri {
my ($this, %options) = @_;
$this->SUPER::uri(_path => foo,
_params => {
a => b,
},
%options);
}

# call
my $uri = $page->uri([opt => val], ...);
return URI of page.

parse_uri
# subclass
sub parse_uri {
my ($this, $data, %options) = @_;
$this->copy_hash_val($data->{params}, %options, page);
if ($data->{path} eq "show_friend") {
# blah...
}
if ($data->{uri}->...) {
# maybe you wont use this
}
$this->SUPER::uri($data, %options);
}

# call
my %options = $page->analyze_uri($uri);
return page information of URI.

parse
# subclass
sub parse {
my ($this, %options) = @_;
# parse...
my $part = $this->parse_extract_parts(qw/.../);
return () unless defined $part;
# return
return ({ a => b, c => d }, { a => e, c => f }, ...);
}

# call
my @datas = $page->parse;
page parser. please return hashref array.

parse_banner
my $data = $page->parse_banner;
parse banner. structure:
link: link to ad page.
subject: subject of ad(banners alt text).
image: image of banner
height: height of image
width: width of image
parse_mainmenu
my @data = $page->parse_mainmenu;
parse mainmenu. structure:
link: link to page
subject: subject of page
parse_tool_bar
my @data = $page->parse_tool_bar;
parse toolbar. structure:
link: link to page
subject: subject of page
image: image of toolbar.
height: height of image
width: width of image
get
$page->get([opt => val], ...);
handy method. call ->set_content and ->parse.
set_content
$page->set_content($uri);
or
$page->set_content(%options);
set content to specified by uri or options.

Rails Page Cache Test Plugin adds two assertions to the Test::Units::TestCase class of Ruby on Rails to check the caching and expiring of pages in integration tests.
Installation:
Unpack into the vendor/plugin and that should be it.
Usage:
First create an integration test. Then, to test caching of the "/pages/about" and "/pages/contact" pages, add a method like this:
def test_caching
assert_cache("/pages/about", "/pages/contact")
end
The assert_cache method will
- first make sure that the urls are not cached,
- execute a get on each request,
- assert that the corresponding cache files have been created.
You can also give a block to the assert_cache method. Instead of executing a get on each url, it will yield the urls. For example:
def test_caching
assert_cache("/pages/about",
"/pages/contact") do |url_about, url_contact|
post url_about
post url_contact
end
end
You will also certainly want (and thats really the most interesting part) to check if your cached pages expires when the user is doing some action. For that, here is the assert_expire method:
def test_expiring
assert_expire("/news/list", "/news/show/1") do |*urls|
post "/news/delete/1"
end
end
Here the assert_expire method will
- check that the urls are cached,
- execute the post request,
- and assert that the urls are no more cached.
This is great for testing your cache sweepers logic.
Enhancements:
- This release adds a test for action and fragment caching.
- The plugin does not look at the filesystem anymore to see if page are cached or not.
- It hijacks the ActionController::Base page caching methods to store which pages are cached and expired, and uses that information for the assertions.

ViewMyCurrency allows you to view the web in the currency you want.

This extension automatically converts all foreign currencies on a web page into your currency using live exchange rates.

No right-clicking or seperate applications required.