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
Jifty::View::Declare::CoreTemplates(3) User Contributed Perl Documentation Jifty::View::Declare::CoreTemplates(3)

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

This library contains templates that Jifty can't function without:
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/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 don't have a good way to serialize
        # Jifty::DBI::Record's 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 } ) ); };

2013-02-19 perl v5.32.1

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

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