Free rose html objects 0.547 software for linux

HTML Objects is a Perl module library for turning HTML tags into Perl objects. HTML Objects allows Web pages to be manipulated as a data structure rather than text.

Once manipulation is done, the entire page is generated via depth-first recursion.

Rose::HTML::Form is a HTML form base class.

SYNOPSIS

package PersonForm;

use Rose::HTML::Form;
our @ISA = qw(Rose::HTML::Form);

use Person;

sub build_form
{
my($self) = shift;

$self->add_fields
(
name => { type => text, size => 25, required => 1 },
email => { type => email, size => 50, required => 1 },
phone => { type => phone },
);
}

sub validate
{
my($self) = shift;

# Base class will validate individual fields in isolation,
# confirming that all required fields are filled in, and that
# the email address and phone number are formatted correctly.
my $ok = $self->SUPER::validate(@_);
return $ok unless($ok);

# Inter-field validation goes here
if($self->field(name)->internal_value ne John Doe &&
$self->field(phone)->internal_value =~ /^555/)
{
$self->error(Only John Doe can have a 555 phone number.);
return 0;
}

return 1;
}

sub init_with_person # give a friendlier name to a base-class method
{
my($self, $person) = @_;
$self->init_with_object($person);
}

sub person_from_form
{
my($self) = shift;

# Base class method does most of the work
my $person = $self->object_from_form(class => Person);

# Now fill in the non-obvious details...
# e.g., set alt phone to be the same as the regular phone
$person->alt_phone($self->field(phone)->internal_value);

return $person;
}

...

#
# Sample usage in a hypothetical web application
#

$form = PersonForm->new;

if(...)
{
# Get query parameters in a hash ref and pass to the form
my $params = MyWebServer->get_query_params();
$form->params($params);

# ...or initialize form params from a CGI object
# $form->params_from_cgi($cgi); # $cgi "isa" CGI

# ...or initialize params from an Apache request object
# (mod_perl 1 and 2 both supported)
# $form->params_from_apache($r);

# Initialize the fields based on params
$form->init_fields();

unless($form->validate)
{
return error_page(error => $form->error);
}

$person = $form->person_from_form; # $person is a Person object

do_something_with($person);
...
}
else
{
$person = ...; # Get or create a Person object somehow

# Initialize the form with the Person object
$form->init_with_person($person);

# Pass the initialized form object to the template
display_page(form => $form);
}
...

Rose::HTML::Form is more than just an object representation of the HTML tag. It is meant to be a base class for custom form classes that can be initialized with and return "rich" values such as objects, or collections of objects.

Building up a reusable library of form classes is extremely helpful when building large web applications with forms that may appear in many different places. Similar forms can inherit from a common subclass, and forms may be nested.

This class inherits from, and follows the conventions of, Rose::HTML::Object. Inherited methods that are not overridden will not be documented a second time here. See the Rose::HTML::Object documentation for more information.

Pod::HTML_Elements is a Perl module to convert POD to tree of LWPs HTML::Element and hence HTML or PostScript.

SYNOPSIS

use Pod::HTML_Elements;

my $parser = new Pod::HTML_Elements;
$parser->parse_from_file($pod,foo.html);

my $parser = new Pod::HTML_Elements PostScript => 1;
$parser->parse_from_file($pod,foo.ps);

Pod::HTML_Elements is subclass of Pod::Parser. As the pod is parsed a tree of HTML::Element objects is built to represent HTML for the pod.

At the end of each pod HTML or PostScript representation is written to the output file.

Rose::DB::Object::Tutorial is a guided tour of the basics of Rose::DB::Object.

INTRODUCTION

This document provides a step-by-step introduction to the Rose::DB::Object module distribution. It demonstrates all of the important features using a semi-realistic example database. This tutorial does not replace the actual documentation for each module, however. The "reference" documentation found in each ".pm" file is still essential, and contains some good examples of its own.

This tutorial provides a gradual introduction to Rose::DB::Object. It also describes "best practices" for using Rose::DB::Object in the most robust, maintainable manner. If youre just trying to get a feel for whats possible, you can skip to the end and take a look at the completed example database and associated Perl code. But I recommend reading the tutorial from start to finish at least once.

The examples will start simple and get progressively more complex. You, the developer, have to decide which level of complexity or abstraction is appropriate for your particular task.

CONVENTIONS

Some of the examples in this tutorial will use the fictional My:: namespace prefix. Some will use no prefix at all. Your code should use whatever namespace you deem appropriate. Usually, it will be something like MyCorp::MyProject:: (i.e., your corporation, organization, and/or project). Ive chosen to use My:: or to omit the prefix entirely simply because this produces shorter class names, which will help this tutorial stay within an 80-column width.

For the sake of brevity, the use strict directive and associated "my" declarations have also been omitted from the example code. Needless to say, you should always use strict in your actual code.

Similarly, the traditional "1;" true value used at the end of each ".pm" file has been omitted from the examples. Dont forget to add this to the end of your actual Perl module files.

Although most of the examples in this tutorial use the base.pm module to set up inheritance, directly modifying the @ISA package variable usually works just as well. In situations where there are circular relationships between classes, the use base ... form may be preferable because it runs at compile-time, whereas @ISA modification happens at run-time. In either case, its a good idea to set up inheritance as early as possible in each module.

package Product;

# Set up inheritance first
use base qw(Rose::DB::Object);

# Then do other stuff...
...

HTML::Tree::AboutObjects is an article: "Users View of Object-Oriented Modules".

SYNOPSIS

# This an article, not a module.

The following article by Sean M. Burke first appeared in The Perl Journal #17 and is copyright 2000 The Perl Journal. It appears courtesy of Jon Orwant and The Perl Journal. This document may be distributed under the same terms as Perl itself.

Rose::Object::MakeMethods::Generic is a Perl module that can create simple object methods.

SYNOPSIS

package MyObject;

use Rose::Object::MakeMethods::Generic
(
scalar =>
[
power,
error,
],

scalar --get_set_init => name,

boolean --get_set_init => is_tall,

boolean =>
[
is_red,
is_happy => { default => 1 },
],

array =>
[
jobs => {},
job => { interface => get_set_item, hash_key => jobs },
clear_jobs => { interface => clear, hash_key => jobs },
reset_jobs => { interface => reset, hash_key => jobs },
],

hash =>
[
param => { hash_key => params },
params => { interface => get_set_all },
param_names => { interface => keys, hash_key => params },
param_values => { interface => values, hash_key => params },
param_exists => { interface => exists, hash_key => params },
delete_param => { interface => delete, hash_key => params },

clear_params => { interface => clear, hash_key => params },
reset_params => { interface => reset, hash_key => params },
],
);

sub init_name { Fred }
sub init_is_tall { 1 }
...

$obj = MyObject->new(power => 5);

print $obj->name; # Fred

$obj->do_something or die $obj->error;

$obj->is_tall; # true
$obj->is_tall(undef); # false (but defined)
$obj->is_tall; # false (but defined)

$obj->is_red; # undef
$obj->is_red(1234); # true
$obj->is_red(); # false (but defined)
$obj->is_red; # false (but defined)

$obj->is_happy; # true

$obj->params(a => 1, b => 2); # add pairs
$val = $obj->param(b); # 2
$obj->param_exists(x); # false

$obj->jobs(butcher, baker); # add values
$obj->job(0 => sailor); # set value
$job = $obj->job(0); # sailor

Rose::DB::Object::QueryBuilder is a Perl module that can build SQL queries on behalf of Rose::DB::Object::Manager.

SYNOPSIS

use Rose::DB::Object::QueryBuilder qw(build_select);

# Build simple query
$sql = build_select
(
dbh => $dbh,
select => COUNT(*),
tables => [ articles ],
columns => { articles => [ qw(id category type title date) ] },
query =>
[
category => [ sports, science ],
type => news,
title => { like => [ %million%,
%resident% ] },
],
query_is_sql => 1);

$sth = $dbh->prepare($sql);
$dbh->execute;
$count = $sth->fetchrow_array;

...

# Return query with placeholders, plus bind values
($sql, $bind) = build_select
(
dbh => $dbh,
tables => [ articles ],
columns => { articles => [ qw(id category type title date) ] },
query =>
[
category => [ sports, science ],
type => news,
title => { like => [ %million%,
%resident% ] },
],
query_is_sql => 1,
sort_by => title DESC, category,
limit => 5);

$sth = $dbh->prepare($sql);
$dbh->execute(@$bind);

while($row = $sth->fetchrow_hashref) { ... }

...

# Coerce query values into the right format
($sql, $bind) = build_select
(
db => $db,
tables => [ articles ],
columns => { articles => [ qw(id category type title date) ] },
classes => { articles => Article },
query =>
[
type => news,
date => { lt => now },
date => { gt => DateTime->new(...) },
],
sort_by => title DESC, category,
limit => 5);

$sth = $dbh->prepare($sql);
$dbh->execute(@$bind);