no bug - reformat all the code using the new perltidy rules

5 files changed, 200 insertions, 199 deletions

diff --git a/Bugzilla/Template/Context.pm b/Bugzilla/Template/Context.pm
index 21e2b7ec8..f2db23702 100644
--- a/Bugzilla/Template/Context.pm
+++ b/Bugzilla/Template/Context.pm
@@ -18,23 +18,24 @@ use Bugzilla::Hook;
 use Scalar::Util qw(blessed);
 
 sub process {
-    my $self = shift;
-    # We don't want to run the template_before_process hook for
-    # template hooks (but we do want it to run if a hook calls
-    # PROCESS inside itself). The problem is that the {component}->{name} of
-    # hooks is unreliable--sometimes it starts with ./ and it's the
-    # full path to the hook template, and sometimes it's just the relative
-    # name (like hook/global/field-descs-end.none.tmpl). Also, calling
-    # template_before_process for hook templates doesn't seem too useful,
-    # because that's already part of the extension and they should be able
-    # to modify their hook if they want (or just modify the variables in the
-    # calling template).
-    if (not delete $self->{bz_in_hook}) {
-        $self->{bz_in_process} = 1;
-    }
-    my $result = $self->SUPER::process(@_);
-    delete $self->{bz_in_process};
-    return $result;
+  my $self = shift;
+
+  # We don't want to run the template_before_process hook for
+  # template hooks (but we do want it to run if a hook calls
+  # PROCESS inside itself). The problem is that the {component}->{name} of
+  # hooks is unreliable--sometimes it starts with ./ and it's the
+  # full path to the hook template, and sometimes it's just the relative
+  # name (like hook/global/field-descs-end.none.tmpl). Also, calling
+  # template_before_process for hook templates doesn't seem too useful,
+  # because that's already part of the extension and they should be able
+  # to modify their hook if they want (or just modify the variables in the
+  # calling template).
+  if (not delete $self->{bz_in_hook}) {
+    $self->{bz_in_process} = 1;
+  }
+  my $result = $self->SUPER::process(@_);
+  delete $self->{bz_in_process};
+  return $result;
 }
 
 # This method is called by Template-Toolkit exactly once per template or
@@ -46,57 +47,58 @@ sub process {
 # in the PROCESS or INCLUDE directive haven't been set, and if we're
 # in an INCLUDE, the stash is not yet localized during process().
 sub stash {
-    my $self = shift;
-    my $stash = $self->SUPER::stash(@_);
+  my $self  = shift;
+  my $stash = $self->SUPER::stash(@_);
 
-    my $name = $stash->{component}->{name};
-    my $pre_process = $self->config->{PRE_PROCESS};
+  my $name        = $stash->{component}->{name};
+  my $pre_process = $self->config->{PRE_PROCESS};
 
-    # Checking bz_in_process tells us that we were indeed called as part of a
-    # Context::process, and not at some other point.
-    #
-    # Checking $name makes sure that we're processing a file, and not just a
-    # block, by checking that the name has a period in it. We don't allow
-    # blocks because their names are too unreliable--an extension could have
-    # a block with the same name, or multiple files could have a same-named
-    # block, and then your extension would malfunction.
-    #
-    # We also make sure that we don't run, ever, during the PRE_PROCESS
-    # templates, because if somebody calls Throw*Error globally inside of
-    # template_before_process, that causes an infinite recursion into
-    # the PRE_PROCESS templates (because Bugzilla, while inside
-    # global/intialize.none.tmpl, loads the template again to create the
-    # template object for Throw*Error).
-    #
-    # Checking Bugzilla::Hook::in prevents infinite recursion on this hook.
-    if ($self->{bz_in_process} and $name =~ /\./
-        and !grep($_ eq $name, @$pre_process)
-        and !Bugzilla::Hook::in('template_before_process'))
-    {
-        Bugzilla::Hook::process("template_before_process",
-                                { vars => $stash, context => $self,
-                                  file => $name });
-    }
+  # Checking bz_in_process tells us that we were indeed called as part of a
+  # Context::process, and not at some other point.
+  #
+  # Checking $name makes sure that we're processing a file, and not just a
+  # block, by checking that the name has a period in it. We don't allow
+  # blocks because their names are too unreliable--an extension could have
+  # a block with the same name, or multiple files could have a same-named
+  # block, and then your extension would malfunction.
+  #
+  # We also make sure that we don't run, ever, during the PRE_PROCESS
+  # templates, because if somebody calls Throw*Error globally inside of
+  # template_before_process, that causes an infinite recursion into
+  # the PRE_PROCESS templates (because Bugzilla, while inside
+  # global/intialize.none.tmpl, loads the template again to create the
+  # template object for Throw*Error).
+  #
+  # Checking Bugzilla::Hook::in prevents infinite recursion on this hook.
+  if (  $self->{bz_in_process}
+    and $name =~ /\./
+    and !grep($_ eq $name, @$pre_process)
+    and !Bugzilla::Hook::in('template_before_process'))
+  {
+    Bugzilla::Hook::process("template_before_process",
+      {vars => $stash, context => $self, file => $name});
+  }
 
-    # This prevents other calls to stash() that might somehow happen
-    # later in the file from also triggering the hook.
-    delete $self->{bz_in_process};
+  # This prevents other calls to stash() that might somehow happen
+  # later in the file from also triggering the hook.
+  delete $self->{bz_in_process};
 
-    return $stash;
+  return $stash;
 }
 
 sub filter {
-    my ($self, $name, $args) = @_;
-    # If we pass an alias for the filter name, the filter code is cached
-    # instead of looking for it at each call.
-    # If the filter has arguments, then we can't cache it.
-    $self->SUPER::filter($name, $args, $args ? undef : $name);
+  my ($self, $name, $args) = @_;
+
+  # If we pass an alias for the filter name, the filter code is cached
+  # instead of looking for it at each call.
+  # If the filter has arguments, then we can't cache it.
+  $self->SUPER::filter($name, $args, $args ? undef : $name);
 }
 
 # We need a DESTROY sub for the same reason that Bugzilla::CGI does.
 sub DESTROY {
-    my $self = shift;
-    $self->SUPER::DESTROY(@_);
-};
+  my $self = shift;
+  $self->SUPER::DESTROY(@_);
+}
 
 1;
diff --git a/Bugzilla/Template/Plugin/Bugzilla.pm b/Bugzilla/Template/Plugin/Bugzilla.pm
index 752aa9dfa..110d3d352 100644
--- a/Bugzilla/Template/Plugin/Bugzilla.pm
+++ b/Bugzilla/Template/Plugin/Bugzilla.pm
@@ -16,20 +16,20 @@ use base qw(Template::Plugin);
 use Bugzilla;
 
 sub new {
-    my ($class, $context) = @_;
+  my ($class, $context) = @_;
 
-    return bless {}, $class;
+  return bless {}, $class;
 }
 
 sub AUTOLOAD {
-    my $class = shift;
-    our $AUTOLOAD;
+  my $class = shift;
+  our $AUTOLOAD;
 
-    $AUTOLOAD =~ s/^.*:://;
+  $AUTOLOAD =~ s/^.*:://;
 
-    return if $AUTOLOAD eq 'DESTROY';
+  return if $AUTOLOAD eq 'DESTROY';
 
-    return Bugzilla->$AUTOLOAD(@_);
+  return Bugzilla->$AUTOLOAD(@_);
 }
 
 1;
diff --git a/Bugzilla/Template/Plugin/Hook.pm b/Bugzilla/Template/Plugin/Hook.pm
index a2b76a80f..e20ca1016 100644
--- a/Bugzilla/Template/Plugin/Hook.pm
+++ b/Bugzilla/Template/Plugin/Hook.pm
@@ -21,74 +21,73 @@ use Bugzilla::Error;
 use File::Spec;
 
 sub new {
-    my ($class, $context) = @_;
-    return bless { _CONTEXT => $context }, $class;
+  my ($class, $context) = @_;
+  return bless {_CONTEXT => $context}, $class;
 }
 
 sub _context { return $_[0]->{_CONTEXT} }
 
 sub process {
-    my ($self, $hook_name, $template) = @_;
-    my $context = $self->_context();
-    $template ||= $context->stash->{component}->{name};
-
-    # sanity check:
-    if (!$template =~ /[\w\.\/\-_\\]+/) {
-        ThrowCodeError('template_invalid', { name => $template });
-    }
-
-    my (undef, $path, $filename) = File::Spec->splitpath($template);
-    $path ||= '';
-    $filename =~ m/(.+)\.(.+)\.tmpl$/;
-    my $template_name = $1;
-    my $type = $2;
-
-    # Hooks are named like this:
-    my $extension_template = "$path$template_name-$hook_name.$type.tmpl";
-
-    # Get the hooks out of the cache if they exist. Otherwise, read them
-    # from the disk.
-    my $cache = Bugzilla->request_cache->{template_plugin_hook_cache} ||= {};
-    my $lang = $context->{bz_language} || '';
-    $cache->{"${lang}__$extension_template"}
-        ||= $self->_get_hooks($extension_template);
-
-    # process() accepts an arrayref of templates, so we just pass the whole
-    # arrayref.
-    $context->{bz_in_hook} = 1; # See Bugzilla::Template::Context
-    return $context->process($cache->{"${lang}__$extension_template"});
+  my ($self, $hook_name, $template) = @_;
+  my $context = $self->_context();
+  $template ||= $context->stash->{component}->{name};
+
+  # sanity check:
+  if (!$template =~ /[\w\.\/\-_\\]+/) {
+    ThrowCodeError('template_invalid', {name => $template});
+  }
+
+  my (undef, $path, $filename) = File::Spec->splitpath($template);
+  $path ||= '';
+  $filename =~ m/(.+)\.(.+)\.tmpl$/;
+  my $template_name = $1;
+  my $type          = $2;
+
+  # Hooks are named like this:
+  my $extension_template = "$path$template_name-$hook_name.$type.tmpl";
+
+  # Get the hooks out of the cache if they exist. Otherwise, read them
+  # from the disk.
+  my $cache = Bugzilla->request_cache->{template_plugin_hook_cache} ||= {};
+  my $lang = $context->{bz_language} || '';
+  $cache->{"${lang}__$extension_template"}
+    ||= $self->_get_hooks($extension_template);
+
+  # process() accepts an arrayref of templates, so we just pass the whole
+  # arrayref.
+  $context->{bz_in_hook} = 1;    # See Bugzilla::Template::Context
+  return $context->process($cache->{"${lang}__$extension_template"});
 }
 
 sub _get_hooks {
-    my ($self, $extension_template) = @_;
-
-    my $template_sets = $self->_template_hook_include_path();
-    my @hooks;
-    foreach my $dir_set (@$template_sets) {
-        foreach my $template_dir (@$dir_set) {
-            my $file = "$template_dir/hook/$extension_template";
-            if (-e $file) {
-                my $template = $self->_context->template($file);
-                push(@hooks, $template);
-                # Don't run the hook for more than one language.
-                last;
-            }
-        }
+  my ($self, $extension_template) = @_;
+
+  my $template_sets = $self->_template_hook_include_path();
+  my @hooks;
+  foreach my $dir_set (@$template_sets) {
+    foreach my $template_dir (@$dir_set) {
+      my $file = "$template_dir/hook/$extension_template";
+      if (-e $file) {
+        my $template = $self->_context->template($file);
+        push(@hooks, $template);
+
+        # Don't run the hook for more than one language.
+        last;
+      }
     }
+  }
 
-    return \@hooks;
+  return \@hooks;
 }
 
 sub _template_hook_include_path {
-    my $self = shift;
-    my $cache = Bugzilla->request_cache;
-    my $language = $self->_context->{bz_language} || '';
-    my $cache_key = "template_plugin_hook_include_path_$language";
-    $cache->{$cache_key} ||= template_include_path({
-        language => $language,
-        hook     => 1,
-    });
-    return $cache->{$cache_key};
+  my $self      = shift;
+  my $cache     = Bugzilla->request_cache;
+  my $language  = $self->_context->{bz_language} || '';
+  my $cache_key = "template_plugin_hook_include_path_$language";
+  $cache->{$cache_key}
+    ||= template_include_path({language => $language, hook => 1,});
+  return $cache->{$cache_key};
 }
 
 1;
diff --git a/Bugzilla/Template/Plugin/User.pm b/Bugzilla/Template/Plugin/User.pm
index 09452d899..ac22f0861 100644
--- a/Bugzilla/Template/Plugin/User.pm
+++ b/Bugzilla/Template/Plugin/User.pm
@@ -31,20 +31,20 @@ use base qw(Template::Plugin);
 use Bugzilla::User;
 
 sub new {
-    my ($class, $context) = @_;
+  my ($class, $context) = @_;
 
-    return bless {}, $class;
+  return bless {}, $class;
 }
 
 sub AUTOLOAD {
-    my $class = shift;
-    our $AUTOLOAD;
+  my $class = shift;
+  our $AUTOLOAD;
 
-    $AUTOLOAD =~ s/^.*:://;
+  $AUTOLOAD =~ s/^.*:://;
 
-    return if $AUTOLOAD eq 'DESTROY';
+  return if $AUTOLOAD eq 'DESTROY';
 
-    return Bugzilla::User->$AUTOLOAD(@_);
+  return Bugzilla::User->$AUTOLOAD(@_);
 }
 
 1;
diff --git a/Bugzilla/Template/PreloadProvider.pm b/Bugzilla/Template/PreloadProvider.pm
index bddabfa2e..6d963f31f 100644
--- a/Bugzilla/Template/PreloadProvider.pm
+++ b/Bugzilla/Template/PreloadProvider.pm
@@ -15,7 +15,7 @@ use warnings;
 use base qw(Template::Provider);
 
 use File::Find ();
-use Cwd ();
+use Cwd        ();
 use File::Spec;
 use Template::Constants qw( STATUS_ERROR );
 use Template::Document;
@@ -24,88 +24,88 @@ use Template::Config;
 use Bugzilla::Util qw(trick_taint);
 
 sub _init {
-    my $self = shift;
-    $self->SUPER::_init(@_);
-
-    my $path   = $self->{INCLUDE_PATH};
-    my $cache  = $self->{_BZ_CACHE} = {};
-    my $search = $self->{_BZ_SEARCH} = {};
-
-    foreach my $template_dir (@$path) {
-        $template_dir = Cwd::realpath($template_dir);
-        my $wanted = sub {
-            my ( $name, $dir ) = ($File::Find::name, $File::Find::dir);
-            if ( $name =~ /\.tmpl$/ ) {
-                my $key = $name;
-                $key =~ s/^\Q$template_dir\///;
-                unless ($search->{$key}) {
-                    $search->{$key} = $name;
-                }
-                trick_taint($name);
-                my $data = {
-                    path => $name,
-                    name => $key,
-                    text => do {
-                        open my $fh, '<:utf8', $name or die "cannot open $name";
-                        local $/ = undef;
-                        scalar <$fh>; # $fh is closed it goes out of scope
-                    },
-                    time => (stat($name))[9],
-                };
-                trick_taint($data->{text}) if $data->{text};
-                $cache->{$name} = $self->_bz_compile($data) or die "compile error: $name";
-            }
+  my $self = shift;
+  $self->SUPER::_init(@_);
+
+  my $path   = $self->{INCLUDE_PATH};
+  my $cache  = $self->{_BZ_CACHE} = {};
+  my $search = $self->{_BZ_SEARCH} = {};
+
+  foreach my $template_dir (@$path) {
+    $template_dir = Cwd::realpath($template_dir);
+    my $wanted = sub {
+      my ($name, $dir) = ($File::Find::name, $File::Find::dir);
+      if ($name =~ /\.tmpl$/) {
+        my $key = $name;
+        $key =~ s/^\Q$template_dir\///;
+        unless ($search->{$key}) {
+          $search->{$key} = $name;
+        }
+        trick_taint($name);
+        my $data = {
+          path => $name,
+          name => $key,
+          text => do {
+            open my $fh, '<:utf8', $name or die "cannot open $name";
+            local $/ = undef;
+            scalar <$fh>;    # $fh is closed it goes out of scope
+          },
+          time => (stat($name))[9],
         };
-        File::Find::find( { wanted => $wanted, no_chdir => 1 }, $template_dir );
-    }
-
-    return $self;
+        trick_taint($data->{text}) if $data->{text};
+        $cache->{$name} = $self->_bz_compile($data) or die "compile error: $name";
+      }
+    };
+    File::Find::find({wanted => $wanted, no_chdir => 1}, $template_dir);
+  }
+
+  return $self;
 }
 
 sub fetch {
-    my ($self, $name, $prefix) = @_;
-    my $file;
-    if (File::Spec->file_name_is_absolute($name)) {
-        $file = $name;
-    }
-    elsif ($name =~ m#^\./#) {
-        $file = File::Spec->rel2abs($name);
-    }
-    else {
-        $file = $self->{_BZ_SEARCH}{$name};
-    }
-
-    if (not $file) {
-        return ("cannot find file - $name ($file)", STATUS_ERROR);
-    }
-
-    if ($self->{_BZ_CACHE}{$file}) {
-        return ($self->{_BZ_CACHE}{$file}, undef);
-    }
-    else {
-        return ("unknown file - $file", STATUS_ERROR);
-    }
+  my ($self, $name, $prefix) = @_;
+  my $file;
+  if (File::Spec->file_name_is_absolute($name)) {
+    $file = $name;
+  }
+  elsif ($name =~ m#^\./#) {
+    $file = File::Spec->rel2abs($name);
+  }
+  else {
+    $file = $self->{_BZ_SEARCH}{$name};
+  }
+
+  if (not $file) {
+    return ("cannot find file - $name ($file)", STATUS_ERROR);
+  }
+
+  if ($self->{_BZ_CACHE}{$file}) {
+    return ($self->{_BZ_CACHE}{$file}, undef);
+  }
+  else {
+    return ("unknown file - $file", STATUS_ERROR);
+  }
 }
 
 sub _bz_compile {
-    my ($self, $data) = @_;
+  my ($self, $data) = @_;
 
-    my $parser = $self->{PARSER} ||= Template::Config->parser( $self->{PARAMS} )
-        || return ( Template::Config->error(), STATUS_ERROR );
+  my $parser = $self->{PARSER} ||= Template::Config->parser($self->{PARAMS})
+    || return (Template::Config->error(), STATUS_ERROR);
 
-    # discard the template text - we don't need it any more
-    my $text = delete $data->{text};
+  # discard the template text - we don't need it any more
+  my $text = delete $data->{text};
 
-    # call parser to compile template into Perl code
-    if (my $parsedoc = $parser->parse($text, $data)) {
-        $parsedoc->{METADATA} = {
-            'name' => $data->{name},
-            'modtime' => $data->{time},
-            %{ $parsedoc->{METADATA} },
-        };
+  # call parser to compile template into Perl code
+  if (my $parsedoc = $parser->parse($text, $data)) {
+    $parsedoc->{METADATA} = {
+      'name'    => $data->{name},
+      'modtime' => $data->{time},
+      %{$parsedoc->{METADATA}},
+    };
 
-        return Template::Document->new($parsedoc);
-    }
+    return Template::Document->new($parsedoc);
+  }
 }
 
 1;