GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  JIFTY::VIEW::DECLARE::CORETEMPLATES (3)

.ds Aq ’

NAME

Jifty::View::Declare::CoreTemplates - Templates Jifty can’t function without

CONTENTS

DESCRIPTION

This library contains templates that Jifty can’t function without:
PubSub
Validate
Autocomplete
Canonicalize
YAML and XML webservice endpoints for core jifty functionality
These templates are still in Masonland. we’re doing something wrong with escaping in them

template ’__jifty/subs’ => sub {
my ($forever) = get(qw(forever)) || 1;



    Jifty->web->response->content_type("text/html; charset=utf-8");
    Jifty->web->response->header(Pragma => no-cache);
    Jifty->web->response->header(Cache-control => no-cache);

    my $writer = XML::Writer->new;
    $writer->xmlDecl( "UTF-8", "yes" );

    my $begin = <<END;
<!DOCTYPE html>
<html><head><title></title></head>
END
    chomp $begin;

    if ($forever) {
        my $whitespace = " " x ( 1024 - length $begin );
        $begin =~ s/<body>$/$whitespace/s;
    }

    Jifty->web->out($begin);
    $writer->startTag("body");

    while (1) {
        my $sent = _write_subs_once($writer);
        flush STDOUT;
        last if ( $sent && !$forever );
        sleep 1;
    }
    $writer->endTag();
    return;



};

sub _write_subs_once {
my $writer = shift;
Jifty::Subs::Render->render(
Jifty->web->session->id,
sub {
my ( $mode, $name, $content ) = @_;
$writer->startTag( pushfrag, mode => $mode );
$writer->startTag( fragment, id => $name );
$writer->dataElement( content, $content );
$writer->endTag();
$writer->endTag();
}
); }

template ’__jifty/autocomplete.xml’ => sub {



    # Note: the only point to this file is to set the content_type; the actual
    # behavior is accomplished inside the framework.  It will go away once we
    # have infrastructure for serving things of various content-types.
    Jifty->web->response->content_type(text/xml; charset=utf-8);
    my $ref = Jifty->web->response->result(autocomplete)->content;
    my @options = @{ $ref->{completions} || [] };
    body {
        ul {
            foreach my $item (@options) {
                if ( !ref($item) ) {
                    li { $item };
                }
                elsif ( exists $item->{label} ) {
                    li {
                        with( class => "informal" ), span { $item->{label} };
                        with( class => "hidden_value" ),
                          span { $item->{value} };
                    };
                }
                else {
                    li { $item->{value} };
                }
            }
        };
    };
};



template ’__jifty/validator.xml’ => sub {
Jifty->web->response->content_type(’text/xml; charset=utf-8’);
my $output = ";
use XML::Writer;
my $writer = XML::Writer->new( OUTPUT => \$output );
$writer->xmlDecl( UTF-8, yes );
$writer->startTag(validation);
for my $ra ( Jifty->web->request->actions ) {
my $action = Jifty->web->new_action_from_request($ra);
$writer->startTag( validationaction, id => $action->register_name );
for my $arg ( $action->argument_names ) {
if ( not $action->arguments->{$arg}->{ajax_validates} ) {
$writer->emptyTag( ignored,
id => $action->error_div_id($arg) );
$writer->emptyTag( ignored,
id => $action->warning_div_id($arg) );
}
elsif ( not defined $action->argument_value($arg)
or length $action->argument_value($arg) == 0 )
{
$writer->emptyTag( blank, id => $action->error_div_id($arg) );
$writer->emptyTag( blank,
id => $action->warning_div_id($arg) );
}
elsif ( $action->result->field_error($arg) ) {
$writer->dataElement(
error,
$action->result->field_error($arg),
id => $action->error_div_id($arg)
);
$writer->emptyTag( ok, id => $action->warning_div_id($arg) );
}
elsif ( $action->result->field_warning($arg) ) {
$writer->dataElement(
warning,
$action->result->field_warning($arg),
id => $action->warning_div_id($arg)
);
$writer->emptyTag( ok, id => $action->error_div_id($arg) );
}
else {
$writer->emptyTag( ok, id => $action->error_div_id($arg) );
$writer->emptyTag( ok, id => $action->warning_div_id($arg) );
}
}
$writer->endTag();
$writer->startTag( canonicalizeaction", id => $action->register_name );
for my $arg ( $action->argument_names ) {
no warnings ’uninitialized’;
if ( $ra->arguments->{$arg} eq $action->argument_value($arg) ) {



                # if the value doesn t change, it can be ignored .



# canonicalizers can change other parts of the action, so we want to send all changes
$writer->emptyTag( ignored,
name => $action->form_field_name($arg) );
}
elsif ( not defined $action->argument_value($arg)
or length $action->argument_value($arg) == 0 )
{
$writer->emptyTag( blank,
name => $action->form_field_name($arg) );
}
else {
if ( $action->result->field_canonicalization_note($arg) ) {
$writer->dataElement(
canonicalization_note,
$action->result->field_canonicalization_note($arg),
id => $action->canonicalization_note_div_id($arg)
);
}
$writer->dataElement(
update,
$action->argument_value($arg),
name => $action->form_field_name($arg)
);
}
}
$writer->endTag();
}
$writer->endTag();
Jifty->web->out($output); };

template ’__jifty/webservices/xml’ => sub {
my $output = ";
my $writer = XML::Writer->new(
OUTPUT => \$output,
UNSAFE => 1
);
$writer->xmlDecl( UTF-8, yes );
$writer->startTag(response");
for my $f ( Jifty->web->request->fragments ) {



        # Set up the region stack
        local Jifty->web->{region_stack} = [];
        my @regions;
        do {
            push @regions, $f;
        } while ( $f = $f->parent );

        for $f ( reverse @regions ) {
            my $new =
              Jifty->web->get_region( join -,
                grep { $_ } Jifty->web->qualified_region, $f->name );

            # Arguments can be complex mapped hash values.  Get their
            # real values by mapping.
            my %defaults = %{ $f->arguments || {} };
            for ( keys %defaults ) {
                my ( $key, $value ) = Jifty::Request::Mapper->map(
                    destination => $_,
                    source      => $defaults{$_}
                );
                delete $defaults{$_};
                $defaults{$key} = $value;
            }

            $new ||= Jifty::Web::PageRegion->new(
                name           => $f->name,
                path           => $f->path,
                region_wrapper => $f->wrapper,
                parent         => Jifty->web->current_region,
                defaults       => \%defaults,
            );
            $new->enter;
        }

        # Stuff the rendered region into the XML
        $writer->startTag( "fragment",
            id => Jifty->web->current_region->qualified_name );
        my %args = %{ Jifty->web->current_region->arguments };
        $writer->dataElement( "argument", $args{$_}, name => $_ )
          for sort keys %args;
        $writer->cdataElement( "content",
            Jifty->web->current_region->as_string );
        $writer->endTag();

        Jifty->web->current_region->exit while Jifty->web->current_region;
    }

    my %results = Jifty->web->response->results;
    for ( keys %results ) {
        $writer->startTag(
            "result",
            moniker => $_,
            class   => $results{$_}->action_class
        );
        $writer->dataElement( "success", $results{$_}->success );

        $writer->dataElement( "message", $results{$_}->message )
          if $results{$_}->message;
        $writer->dataElement( "error", $results{$_}->error )
          if $results{$_}->error;

        my %warnings = $results{$_}->field_warnings;
        my %errors   = $results{$_}->field_errors;
        my %fields;
        $fields{$_}++ for keys(%warnings), keys(%errors);
        for ( sort keys %fields ) {
            next unless $warnings{$_} or $errors{$_};
            $writer->startTag( "field", name => $_ );
            $writer->dataElement( "warning", $warnings{$_} )
              if $warnings{$_};
            $writer->dataElement( "error", $errors{$_} )
              if $errors{$_};
            $writer->endTag();
        }

        # XXX TODO: Hack because we dont have a good way to serialize
        # Jifty::DBI::Records yet, which are technically circular data
        # structures at some level (current_user of a
        # current_user->user_object is itself)
        use Scalar::Util qw(blessed);
        my $content = $results{$_}->content;


        $content = _stripkids($content);
        use XML::Simple;
        $writer->raw(
            XML::Simple::XMLout(
                $content,
                NoAttr   => 1,
                RootName => "content",
                NoIndent => 1
            )
        ) if keys %{$content};

        $writer->endTag();
    }

    $writer->endTag();
    Jifty->web->response->content_type(text/xml; charset=utf-8);

    # For some reason, this line is needed, lest we end up outputting ISO-8859-1 text
    utf8::decode($output);

    outs_raw($output);
};

        sub _stripkids {
            my $top = shift;
            if ( not ref $top ) { return $top }
            elsif (
                blessed($top)
                and (  $top->isa("Jifty::DBI::Record")
                    or $top->isa("Jifty::DBI::Collection") )
              )
            {
                return undef;
            }
            elsif ( ref $top eq HASH ) {
                foreach my $item ( keys %$top ) {
                    $top->{$item} = _stripkids( $top->{$item} );
                }
            }
            elsif ( ref $top eq ARRAY ) {
                for ( 0 .. $#{$top} ) {
                    $top->[$_] = _stripkids( $top->[$_] );
                }
            }
            return $top;
        }



template ’__jifty/webservices/yaml’ => sub {
Jifty->web->response->content_type(text/x-yaml);
outs( Jifty::YAML::Dump( { Jifty->web->response->results } ) ); };

Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 JIFTY::VIEW::DECLARE::CORETEMPLATES (3) 2011-02-08

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.