---
name: "Jifty::View::Declare::CoreTemplates"
section: "3pm"
platform: "linux"
package: "libjifty-perl"
version: "1.10518+dfsg-2"
release: "Debian 7 (Wheezy)"
platforms: ["linux"]
url: "https://new.carta.tech/Jifty::View::Declare::CoreTemplates"
---

# Jifty::View::Declare::CoreTemplates(3pm)

Templates Jifty can't function without

## NAME

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

## 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 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 } ) ); };