Gruta/Template/Artemus.pm

   1 package Gruta::Template::Artemus;
   2
   3 use strict;
   4 use warnings;
   5
   6 use base 'Gruta::Template::BASE';
   7
   8 use Artemus;
   9 use Gruta::Data;
  10
  11 sub new {
  12         my $class       = shift;
  13         my %args        = @_;
  14
  15         my $a = bless( {}, $class );
  16
  17         $a->{_artemus} = undef;
  18         $a->{path} = $args{path};
  19
  20         return $a;
  21 }
  22
  23
  24 sub _artemus {
  25         my $self        = shift;
  26
  27         if (not $self->{_artemus}) {
  28                 my $data = $self->data();
  29
  30                 my %f = ();
  31                 my %v = ();
  32
  33                 $f{l} = sub {
  34                         my $t = shift;
  35
  36                         return '?t=' . $t . ';' . join(';', @_);
  37                 };
  38
  39                 $f{'add'} = sub { $_[0] + $_[1]; };
  40                 $f{'sub'} = sub { $_[0] - $_[1]; };
  41                 $f{'gt'} = sub { $_[0] > $_[1]; };
  42                 $f{'lt'} = sub { $_[0] < $_[1]; };
  43                 $f{'eq'} = sub { $_[0] eq $_[1] ? 1 : 0; };
  44
  45                 $f{date} = sub { $data->today(); };
  46                 $f{random} = sub { $_[rand(scalar(@_))]; };
  47
  48                 foreach my $p (Gruta::Data::Topic->new->afields()) {
  49                         $f{'topic_' . $p} = sub {
  50                                 return $data->topic($_[0])->get($p);
  51                         };
  52                 }
  53
  54                 foreach my $p (Gruta::Data::Story->new->afields()) {
  55                         $f{'story_' . $p} = sub {
  56                                 return $data->story($_[0], $_[1])->get($p);
  57                         };
  58                 }
  59
  60                 $f{story_body} = sub {
  61                         my $story = $data->story($_[0], $_[1]);
  62                         my $ret = $story->get('body');
  63
  64                         if (not $data->auth()) {
  65                                 $story->touch();
  66                         }
  67
  68                         return $ret;
  69                 };
  70
  71                 $f{story_date} = sub {
  72                         return $data->story($_[1], $_[2])->date($_[0]);
  73                 };
  74
  75                 foreach my $p (Gruta::Data::User->new->afields()) {
  76                         $f{'user_' . $p} = sub {
  77                                 return $data->user($_[0])->get($p);
  78                         };
  79                 }
  80
  81                 $f{template} = sub {
  82                         my $t = $data->template->template($_[0]);
  83                         return $self->{_artemus}->armor($t);
  84                 };
  85
  86                 $f{save_template} = sub {
  87                         return $data->template->save_template($_[0], $_[1]);
  88                 };
  89
  90                 $f{loop_topics} = sub {
  91                         my $template    = shift;
  92                         my $sep         = shift;
  93
  94                         return join($sep, map {
  95                                 my $t = $data->topic($_);
  96                                 sprintf('{-%s|%s|%s}',
  97                                         $template, $t->get('name'),
  98                                         $t->get('id')
  99                                 );
 100                         } $data->topics());
 101                 };
 102
 103                 $f{loop_users} = sub {
 104                         return join($_[1], map { "{-$_[0]|$_}" } $data->users());
 105                 };
 106
 107                 $f{loop_renderers} = sub {
 108                         return join($_[1], map { "{-$_[0]|$_}" }
 109                                 sort(keys(%{$data->{renderers_h}})));
 110                 };
 111
 112                 $f{loop_templates} = sub {
 113                         return join($_[1], map { "{-$_[0]|$_}" }
 114                                 $data->template->templates());
 115                 };
 116
 117                 $f{story_loop_by_date} = sub {
 118                         my $topic       = shift;
 119                         my $num         = shift;
 120                         my $offset      = shift;
 121                         my $template    = shift;
 122                         my $sep         = shift;
 123                         my $from        = shift;
 124                         my $to          = shift;
 125                         my $future      = shift;
 126
 127                         return join($sep, map { "{-$template|$topic|$_}" }
 128                                 $data->stories_by_date(
 129                                         $topic,
 130                                         num     => $num,
 131                                         offset  => $offset,
 132                                         from    => $from,
 133                                         to      => $to,
 134                                         future  => $future
 135                                 )
 136                         );
 137                 };
 138
 139                 $f{is_logged_in} = sub {
 140                         return $data->auth() ? 1 : 0;
 141                 };
 142
 143                 $f{is_admin} = sub {
 144                         if ($data->auth() and $data->auth->get('is_admin')) {
 145                                 return 1;
 146                         }
 147                         return 0;
 148                 };
 149
 150                 $f{is_topic_editor} = sub {
 151                         my $auth;
 152
 153                         if (not $auth = $data->auth()) {
 154                                 return 0;
 155                         }
 156
 157                         if ($auth->get('is_admin')) {
 158                                 return 1;
 159                         }
 160
 161                         my $topic;
 162
 163                         if (not $topic = $data->topic($_[0])) {
 164                                 return 0;
 165                         }
 166
 167                         if (my $editors = $topic->get('editors') and
 168                                 my $user_id = $auth->get('id')) {
 169                                 return 1 if $editors =~/\b$user_id\b/;
 170                         }
 171
 172                         return 0;
 173                 };
 174
 175                 $f{login} = sub {
 176                         my $user_id     = shift;
 177                         my $password    = shift;
 178                         my $error_msg   = shift;
 179
 180                         if ($user_id eq '' || $user_id eq 'cgi-userid') {
 181                                 $error_msg = '{-login_box}';
 182                         }
 183                         elsif (my $sid = $data->login($user_id, $password)) {
 184                                 $data->cgi->cookie("sid=$sid");
 185                                 $data->cgi->redirect('?t=INDEX');
 186                                 $self->{abort} = 1;
 187                         }
 188
 189                         return $error_msg || 'Login incorrect.';
 190                 };
 191
 192                 $f{logout} = sub {
 193                         $data->logout();
 194                         $data->cgi->redirect('?t=INDEX');
 195                         $self->{abort} = 1;
 196                 };
 197
 198                 $f{assert_logged_in} = sub {
 199                         if (not $data->auth()) {
 200                                 $data->cgi->redirect('?t=LOGIN');
 201                                 $self->{abort} = 1;
 202                         }
 203
 204                         return '';
 205                 };
 206
 207                 $f{assert_admin} = sub {
 208                         if ($data->auth() and $data->auth->get('is_admin')) {
 209                                 return '';
 210                         }
 211
 212                         $data->cgi->redirect('?t=LOGIN');
 213                         $self->{abort} = 1;
 214                 };
 215
 216                 $f{username} = sub {
 217                         my $ret = '';
 218
 219                         if ($data->auth()) {
 220                                 $ret = $data->auth->get('username');
 221                         }
 222
 223                         return $ret;
 224                 };
 225
 226                 $f{search_stories} = sub {
 227                         my $topic_id    = shift;
 228                         my $query       = shift;
 229
 230                         return "search_stories: FIXME";
 231                 };
 232
 233                 $f{story_loop_top_ten} = sub {
 234                         my $num         = shift;
 235                         my $internal    = shift; # ignored
 236                         my $template    = shift;
 237                         my $sep         = shift;
 238
 239                         return join($sep, map { "{-$template|$_->[1]|$_->[2]}" }
 240                                 $data->stories_top_ten($num)
 241                         );
 242                 };
 243
 244                 $f{assert_visible_story} = sub {
 245                         my $story = $data->story($_[0], $_[1]);
 246                         my $ret = '';
 247
 248                         if (!$data->auth() && $story->get('date') > $data->today()) {
 249                                 $data->cgi->redirect('?t=404');
 250                                 $self->{abort} = 1;
 251                         }
 252
 253                         return $ret;
 254                 };
 255
 256                 $f{redir_if_archived} = sub {
 257                         my $template    = shift;
 258                         my $topic_id    = shift;
 259                         my $id          = shift;
 260
 261                         if ($topic_id =~ /-arch$/) {
 262                                 return '';
 263                         }
 264
 265                         my $story = $data->story($topic_id, $id);
 266
 267                         if ($story->get('topic_id') =~ /-arch$/) {
 268                                 $data->cgi->redirect(
 269                                         sprintf('?t=%s;topic=%s;id=%s',
 270                                         $template,
 271                                         $story->get('topic_id'),
 272                                         $id)
 273                                 );
 274                                 $self->{abort} = 1;
 275                         }
 276
 277                         return '';
 278                 };
 279
 280                 $f{topic_has_archive} = sub {
 281                         return $data->topic($_[0] . '-arch') ? 1 : 0;
 282                 };
 283
 284                 $self->{abort}          = 0;
 285                 $self->{unresolved}     = [];
 286
 287                 $self->{_artemus} = Artemus->new(
 288                         'include-path'  =>      $self->{path},
 289                         'funcs'         =>      \%f,
 290                         'vars'          =>      \%v,
 291                         'unresolved'    =>      $self->{unresolved},
 292                         'abort'         =>      \$self->{abort},
 293                 );
 294
 295                 if ($self->{cgi_vars}) {
 296                         foreach my $k (keys(%{ $self->{cgi_vars} })) {
 297                                 $v{"cgi-${k}"} =
 298                                         $self->{_artemus}->armor($self->{cgi_vars}->{$k});
 299                         }
 300                 }
 301         }
 302
 303         return $self->{_artemus};
 304 }
 305
 306
 307 sub data {
 308         my $self        = shift;
 309         my $data        = shift;
 310
 311         if (defined($data)) {
 312                 $self->{data} = $data;
 313                 $self->{_artemus} = undef;
 314         }
 315
 316         return $self->{data};
 317 }
 318
 319
 320 sub cgi_vars {
 321         my $self        = shift;
 322
 323         if (@_) {
 324                 $self->{cgi_vars} = shift;
 325                 $self->{_artemus} = undef;
 326         }
 327
 328         return $self->{cgi_vars};
 329 }
 330
 331
 332 sub process { $_[0]->_artemus->process('{-' . $_[1] . '}'); }
 333
 334 1;