* inline: Add copyright/license info on a per-post basis to atom
[ikiwiki.git] / IkiWiki / Plugin / meta.pm
1 #!/usr/bin/perl
2 # Ikiwiki metadata plugin.
3 package IkiWiki::Plugin::meta;
4
5 use warnings;
6 use strict;
7 use IkiWiki 2.00;
8
9 my %meta;
10 my %title;
11 my %permalink;
12 my %author;
13 my %authorurl;
14 my %license;
15 my %copyright;
16
17 sub import { #{{{
18         hook(type => "needsbuild", id => "meta", call => \&needsbuild);
19         hook(type => "preprocess", id => "meta", call => \&preprocess);
20         hook(type => "pagetemplate", id => "meta", call => \&pagetemplate);
21 } # }}}
22
23 sub needsbuild (@) { #{{{
24         my $needsbuild=shift;
25         foreach my $page (keys %pagestate) {
26                 if (exists $pagestate{$page}{meta}) {
27                         if (grep { $_ eq $pagesources{$page} } @$needsbuild) {
28                                 # remove state, it will be re-added
29                                 # if the preprocessor directive is still
30                                 # there during the rebuild
31                                 delete $pagestate{$page}{meta};
32                         }
33                 }
34         }
35 }
36
37 sub scrub ($) { #{{{
38         if (IkiWiki::Plugin::htmlscrubber->can("sanitize")) {
39                 return IkiWiki::Plugin::htmlscrubber::sanitize(content => shift);
40         }
41         else {
42                 return shift;
43         }
44 } #}}}
45
46 sub htmlize ($$$) { #{{{
47         my $page = shift;
48         my $destpage = shift;
49         my $text = shift;
50
51         $text=IkiWiki::htmlize($page, pagetype($pagesources{$page}),
52                 IkiWiki::linkify($page, $destpage,
53                 IkiWiki::preprocess($page, $destpage, $text)));
54
55         # hack to get rid of enclosing junk added by markdown
56         $text=~s!^<p>!!;
57         $text=~s!</p>$!!;
58         chomp $text;
59
60         return $text;
61 }
62
63 sub preprocess (@) { #{{{
64         return "" unless @_;
65         my %params=@_;
66         my $key=shift;
67         my $value=$params{$key};
68         delete $params{$key};
69         my $page=$params{page};
70         delete $params{page};
71         my $destpage=$params{destpage};
72         delete $params{destpage};
73         delete $params{preview};
74
75         eval q{use HTML::Entities};
76         # Always decode, even if encoding later, since it might not be
77         # fully encoded.
78         $value=decode_entities($value);
79
80         if ($key eq 'title') {
81                 $title{$page}=HTML::Entities::encode_numeric($value);
82         }
83         elsif ($key eq 'permalink') {
84                 $permalink{$page}=$value;
85                 push @{$meta{$page}}, scrub('<link rel="bookmark" href="'.encode_entities($value).'" />');
86         }
87         elsif ($key eq 'date') {
88                 eval q{use Date::Parse};
89                 if (! $@) {
90                         my $time = str2time($value);
91                         $IkiWiki::pagectime{$page}=$time if defined $time;
92                 }
93         }
94         elsif ($key eq 'stylesheet') {
95                 my $rel=exists $params{rel} ? $params{rel} : "alternate stylesheet";
96                 my $title=exists $params{title} ? $params{title} : $value;
97                 # adding .css to the value prevents using any old web
98                 # editable page as a stylesheet
99                 my $stylesheet=bestlink($page, $value.".css");
100                 if (! length $stylesheet) {
101                         return "[[meta ".gettext("stylesheet not found")."]]";
102                 }
103                 push @{$meta{$page}}, '<link href="'.urlto($stylesheet, $page).
104                         '" rel="'.encode_entities($rel).
105                         '" title="'.encode_entities($title).
106                         "\" type=\"text/css\" />";
107         }
108         elsif ($key eq 'openid') {
109                 if (exists $params{server}) {
110                         push @{$meta{$page}}, '<link href="'.encode_entities($params{server}).
111                                 '" rel="openid.server" />';
112                 }
113                 push @{$meta{$page}}, '<link href="'.encode_entities($value).
114                         '" rel="openid.delegate" />';
115         }
116         elsif ($key eq 'license') {
117                 push @{$meta{$page}}, '<link rel="license" href="#page_license" />';
118                 $license{$page}=$value;
119         }
120         elsif ($key eq 'copyright') {
121                 push @{$meta{$page}}, '<link rel="copyright" href="#page_copyright" />';
122                 $copyright{$page}=$value;
123         }
124         elsif ($key eq 'redir') {
125                 return "" if $page ne $destpage;
126                 my $safe=0;
127                 if ($value !~ /^\w+:\/\//) {
128                         my ($redir_page, $redir_anchor) = split /\#/, $value;
129
130                         add_depends($page, $redir_page);
131                         my $link=bestlink($page, $redir_page);
132                         if (! length $link) {
133                                 return "[[meta ".gettext("redir page not found")."]]";
134                         }
135
136                         $value=urlto($link, $page);
137                         $value.='#'.$redir_anchor if defined $redir_anchor;
138                         $safe=1;
139
140                         # redir cycle detection
141                         $pagestate{$page}{meta}{redir}=$link;
142                         my $at=$page;
143                         my %seen;
144                         while (exists $pagestate{$at}{meta}{redir}) {
145                                 if ($seen{$at}) {
146                                         return "[[meta ".gettext("redir cycle is not allowed")."]]";
147                                 }
148                                 $seen{$at}=1;
149                                 $at=$pagestate{$at}{meta}{redir};
150                         }
151                 }
152                 else {
153                         $value=encode_entities($value);
154                 }
155                 my $delay=int(exists $params{delay} ? $params{delay} : 0);
156                 my $redir="<meta http-equiv=\"refresh\" content=\"$delay; URL=$value\">";
157                 if (! $safe) {
158                         $redir=scrub($redir);
159                 }
160                 push @{$meta{$page}}, $redir;
161         }
162         elsif ($key eq 'link') {
163                 return "[[meta ".gettext("link is no longer supported")."]]";
164         }
165         else {
166                 push @{$meta{$page}}, scrub('<meta name="'.encode_entities($key).
167                         '" content="'.encode_entities($value).'" />');
168                 if ($key eq 'author') {
169                         $author{$page}=$value;
170                 }
171                 elsif ($key eq 'authorurl') {
172                         $authorurl{$page}=$value;
173                 }
174         }
175
176         return "";
177 } # }}}
178
179 sub pagetemplate (@) { #{{{
180         my %params=@_;
181         my $page=$params{page};
182         my $destpage=$params{destpage};
183         my $template=$params{template};
184
185         if (exists $meta{$page} && $template->query(name => "meta")) {
186                 # avoid duplicate meta lines
187                 my %seen;
188                 $template->param(meta => join("\n", grep { (! $seen{$_}) && ($seen{$_}=1) } @{$meta{$page}}));
189         }
190         if (exists $title{$page} && $template->query(name => "title")) {
191                 $template->param(title => $title{$page});
192                 $template->param(title_overridden => 1);
193         }
194         $template->param(permalink => $permalink{$page})
195                 if exists $permalink{$page} && $template->query(name => "permalink");
196         $template->param(author => $author{$page})
197                 if exists $author{$page} && $template->query(name => "author");
198         $template->param(authorurl => $authorurl{$page})
199                 if exists $authorurl{$page} && $template->query(name => "authorurl");
200                 
201         if ($page ne $destpage &&
202             ((exists $license{$page}   && ! exists $license{$destpage}) ||
203              (exists $copyright{$page} && ! exists $copyright{$destpage}))) {
204                 # Force a scan of the destpage to get its copyright/license
205                 # info. If the info is declared after an inline, it will
206                 # otherwise not be available at this point.
207                 IkiWiki::scan($pagesources{$destpage});
208         }
209
210         if (exists $license{$page} && $template->query(name => "license") &&
211             ($page eq $destpage || ! exists $license{$destpage} ||
212              $license{$page} ne $license{$destpage})) {
213                 $template->param(license => htmlize($page, $destpage, $license{$page}));
214         }
215         if (exists $copyright{$page} && $template->query(name => "copyright") &&
216             ($page eq $destpage || ! exists $copyright{$destpage} ||
217              $copyright{$page} ne $copyright{$destpage})) {
218                 $template->param(copyright => htmlize($page, $destpage, $copyright{$page}));
219         }
220 } # }}}
221
222 1